summaryrefslogtreecommitdiff
path: root/src/ipa/libipa
diff options
context:
space:
mode:
Diffstat (limited to 'src/ipa/libipa')
-rw-r--r--src/ipa/libipa/agc_mean_luminance.cpp53
-rw-r--r--src/ipa/libipa/agc_mean_luminance.h2
-rw-r--r--src/ipa/libipa/exposure_mode_helper.cpp152
-rw-r--r--src/ipa/libipa/exposure_mode_helper.h14
4 files changed, 111 insertions, 110 deletions
diff --git a/src/ipa/libipa/agc_mean_luminance.cpp b/src/ipa/libipa/agc_mean_luminance.cpp
index f97ef117..cd175708 100644
--- a/src/ipa/libipa/agc_mean_luminance.cpp
+++ b/src/ipa/libipa/agc_mean_luminance.cpp
@@ -89,10 +89,10 @@ static constexpr double kDefaultRelativeLuminanceTarget = 0.16;
* \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.
+ * This algorithm calculates an exposure 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 the entire image against a target,
@@ -109,7 +109,7 @@ static constexpr double kDefaultRelativeLuminanceTarget = 0.16;
* 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
+ * and that new exposure value is divided into exposure time, analogue gain and
* digital gain according to the selected AeExposureMode. This class uses 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
@@ -247,27 +247,27 @@ int AgcMeanLuminance::parseExposureModes(const YamlObject &tuningData)
return -EINVAL;
}
- std::vector<uint32_t> shutters =
- modeValues["shutter"].getList<uint32_t>().value_or(std::vector<uint32_t>{});
+ std::vector<uint32_t> exposureTimes =
+ modeValues["exposure-time"].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()) {
+ if (exposureTimes.size() != gains.size()) {
LOG(AgcMeanLuminance, Error)
- << "Shutter and gain array sizes unequal";
+ << "Exposure time and gain array sizes unequal";
return -EINVAL;
}
- if (shutters.empty()) {
+ if (exposureTimes.empty()) {
LOG(AgcMeanLuminance, Error)
- << "Shutter and gain arrays are empty";
+ << "Exposure time and gain arrays are empty";
return -EINVAL;
}
std::vector<std::pair<utils::Duration, double>> stages;
- for (unsigned int i = 0; i < shutters.size(); i++) {
+ for (unsigned int i = 0; i < exposureTimes.size(); i++) {
stages.push_back({
- std::chrono::microseconds(shutters[i]),
+ std::chrono::microseconds(exposureTimes[i]),
gains[i]
});
}
@@ -283,7 +283,7 @@ int AgcMeanLuminance::parseExposureModes(const YamlObject &tuningData)
/*
* 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
+ * in the ExposureModeHelper simply driving the exposure time as high as
* possible before touching gain.
*/
if (availableExposureModes.empty()) {
@@ -338,18 +338,18 @@ int AgcMeanLuminance::parseExposureModes(const YamlObject &tuningData)
* 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:
+ * contain an array of exposure times with the key "exposure-time" 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 ]
+ * exposure-time: [ 100, 10000, 30000, 60000, 120000 ]
* gain: [ 2.0, 4.0, 6.0, 8.0, 10.0 ]
* ExposureShort:
- * shutter: [ 100, 10000, 30000, 60000, 120000 ]
+ * exposure-time: [ 100, 10000, 30000, 60000, 120000 ]
* gain: [ 2.0, 4.0, 6.0, 8.0, 10.0 ]
*
* \endcode
@@ -371,20 +371,20 @@ int AgcMeanLuminance::parseTuningData(const YamlObject &tuningData)
/**
* \brief Set the ExposureModeHelper limits for this class
- * \param[in] minShutter Minimum shutter time to allow
- * \param[in] maxShutter Maximum shutter time to allow
+ * \param[in] minExposureTime Minimum exposure time to allow
+ * \param[in] maxExposureTime Maximum ewposure time to allow
* \param[in] minGain Minimum gain to allow
* \param[in] maxGain Maximum gain to allow
*
* This function calls \ref ExposureModeHelper::setLimits() for each
* ExposureModeHelper that has been created for this class.
*/
-void AgcMeanLuminance::setLimits(utils::Duration minShutter,
- utils::Duration maxShutter,
+void AgcMeanLuminance::setLimits(utils::Duration minExposureTime,
+ utils::Duration maxExposureTime,
double minGain, double maxGain)
{
for (auto &[id, helper] : exposureModeHelpers_)
- helper->setLimits(minShutter, maxShutter, minGain, maxGain);
+ helper->setLimits(minExposureTime, maxExposureTime, minGain, maxGain);
}
/**
@@ -513,7 +513,8 @@ utils::Duration AgcMeanLuminance::filterExposure(utils::Duration exposureValue)
}
/**
- * \brief Calculate the new exposure value and splut it between shutter time and gain
+ * \brief Calculate the new exposure value and splut it between exposure time
+ * and gain
* \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
@@ -523,9 +524,9 @@ utils::Duration AgcMeanLuminance::filterExposure(utils::Duration exposureValue)
*
* 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.
+ * divided into exposure time, analogue and digital gain.
*
- * \return Tuple of shutter time, analogue gain, and digital gain
+ * \return Tuple of exposure time, analogue gain, and digital gain
*/
std::tuple<utils::Duration, double, double>
AgcMeanLuminance::calculateNewEv(uint32_t constraintModeIndex,
diff --git a/src/ipa/libipa/agc_mean_luminance.h b/src/ipa/libipa/agc_mean_luminance.h
index 576d28be..c41391cb 100644
--- a/src/ipa/libipa/agc_mean_luminance.h
+++ b/src/ipa/libipa/agc_mean_luminance.h
@@ -44,7 +44,7 @@ public:
int parseTuningData(const YamlObject &tuningData);
- void setLimits(utils::Duration minShutter, utils::Duration maxShutter,
+ void setLimits(utils::Duration minExposureTime, utils::Duration maxExposureTime,
double minGain, double maxGain);
std::map<int32_t, std::vector<AgcConstraint>> constraintModes()
diff --git a/src/ipa/libipa/exposure_mode_helper.cpp b/src/ipa/libipa/exposure_mode_helper.cpp
index 30da0c89..f235316d 100644
--- a/src/ipa/libipa/exposure_mode_helper.cpp
+++ b/src/ipa/libipa/exposure_mode_helper.cpp
@@ -14,9 +14,9 @@
* \file exposure_mode_helper.h
* \brief Helper class that performs computations relating to exposure
*
- * AEGC algorithms have a need to split exposure between shutter time, analogue
+ * AEGC algorithms have a need to split exposure between exposure time, analogue
* and digital gain. Multiple implementations do so based on paired stages of
- * shutter time and gain limits; provide a helper to avoid duplicating the code.
+ * exposure time and gain limits; provide a helper to avoid duplicating the code.
*/
namespace libcamera {
@@ -29,24 +29,24 @@ namespace ipa {
/**
* \class ExposureModeHelper
- * \brief Class for splitting exposure into shutter time and total gain
+ * \brief Class for splitting exposure into exposure time and total gain
*
* The ExposureModeHelper class provides a standard interface through which an
- * AEGC algorithm can divide exposure between shutter time and gain. It is
- * configured with a set of shutter time and gain pairs and works by initially
- * fixing gain at 1.0 and increasing shutter time up to the shutter time value
+ * AEGC algorithm can divide exposure between exposure time and gain. It is
+ * configured with a set of exposure time and gain pairs and works by initially
+ * fixing gain at 1.0 and increasing exposure time up to the exposure time value
* from the first pair in the set in an attempt to meet the required exposure
* value.
*
- * If the required exposure is not achievable by the first shutter time value
+ * If the required exposure is not achievable by the first exposure time value
* alone it ramps gain up to the value from the first pair in the set. If the
- * required exposure is still not met it then allows shutter time to ramp up to
- * the shutter time value from the second pair in the set, and continues in this
+ * required exposure is still not met it then allows exposure time to ramp up to
+ * the exposure time value from the second pair in the set, and continues in this
* vein until either the required exposure time is met, or else the hardware's
- * shutter time or gain limits are reached.
+ * exposure time or gain limits are reached.
*
* This method allows users to strike a balance between a well-exposed image and
- * an acceptable frame-rate, as opposed to simply maximising shutter time
+ * an acceptable frame-rate, as opposed to simply maximising exposure time
* followed by gain. The same helpers can be used to perform the latter
* operation if needed by passing an empty set of pairs to the initialisation
* function.
@@ -61,9 +61,9 @@ namespace ipa {
/**
* \brief Construct an ExposureModeHelper instance
- * \param[in] stages The vector of paired shutter time and gain limits
+ * \param[in] stages The vector of paired exposure time and gain limits
*
- * The input stages are shutter time and _total_ gain pairs; the gain
+ * The input stages are exposure time and _total_ gain pairs; the gain
* encompasses both analogue and digital gain.
*
* The vector of stages may be empty. In that case, the helper will simply use
@@ -71,46 +71,46 @@ namespace ipa {
*/
ExposureModeHelper::ExposureModeHelper(const Span<std::pair<utils::Duration, double>> stages)
{
- minShutter_ = 0us;
- maxShutter_ = 0us;
+ minExposureTime_ = 0us;
+ maxExposureTime_ = 0us;
minGain_ = 0;
maxGain_ = 0;
for (const auto &[s, g] : stages) {
- shutters_.push_back(s);
+ exposureTimes_.push_back(s);
gains_.push_back(g);
}
}
/**
- * \brief Set the shutter time and gain limits
- * \param[in] minShutter The minimum shutter time supported
- * \param[in] maxShutter The maximum shutter time supported
+ * \brief Set the exposure time and gain limits
+ * \param[in] minExposureTime The minimum exposure time supported
+ * \param[in] maxExposureTime The maximum exposure time supported
* \param[in] minGain The minimum analogue gain supported
* \param[in] maxGain The maximum analogue gain supported
*
- * This function configures the shutter time and analogue gain limits that need
+ * This function configures the exposure time and analogue gain limits that need
* to be adhered to as the helper divides up exposure. Note that this function
* *must* be called whenever those limits change and before splitExposure() is
* used.
*
- * If the algorithm using the helpers needs to indicate that either shutter time
+ * If the algorithm using the helpers needs to indicate that either exposure time
* or analogue gain or both should be fixed it can do so by setting both the
* minima and maxima to the same value.
*/
-void ExposureModeHelper::setLimits(utils::Duration minShutter,
- utils::Duration maxShutter,
+void ExposureModeHelper::setLimits(utils::Duration minExposureTime,
+ utils::Duration maxExposureTime,
double minGain, double maxGain)
{
- minShutter_ = minShutter;
- maxShutter_ = maxShutter;
+ minExposureTime_ = minExposureTime;
+ maxExposureTime_ = maxExposureTime;
minGain_ = minGain;
maxGain_ = maxGain;
}
-utils::Duration ExposureModeHelper::clampShutter(utils::Duration shutter) const
+utils::Duration ExposureModeHelper::clampExposureTime(utils::Duration exposureTime) const
{
- return std::clamp(shutter, minShutter_, maxShutter_);
+ return std::clamp(exposureTime, minExposureTime_, maxExposureTime_);
}
double ExposureModeHelper::clampGain(double gain) const
@@ -119,108 +119,108 @@ double ExposureModeHelper::clampGain(double gain) const
}
/**
- * \brief Split exposure time into shutter time and gain
- * \param[in] exposure Exposure time
+ * \brief Split exposure into exposure time and gain
+ * \param[in] exposure Exposure value
*
- * This function divides a given exposure time into shutter time, analogue and
- * digital gain by iterating through stages of shutter time and gain limits. At
- * each stage the current stage's shutter time limit is multiplied by the
+ * This function divides a given exposure into exposure time, analogue and
+ * digital gain by iterating through stages of exposure time and gain limits.
+ * At each stage the current stage's exposure time limit is multiplied by the
* previous stage's gain limit (or 1.0 initially) to see if the combination of
- * the two can meet the required exposure time. If they cannot then the current
- * stage's shutter time limit is multiplied by the same stage's gain limit to
+ * the two can meet the required exposure. If they cannot then the current
+ * stage's exposure time limit is multiplied by the same stage's gain limit to
* see if that combination can meet the required exposure time. If they cannot
* then the function moves to consider the next stage.
*
- * When a combination of shutter time and gain _stage_ limits are found that are
- * sufficient to meet the required exposure time, the function attempts to
- * reduce shutter time as much as possible whilst fixing gain and still meeting
- * the exposure time. If a _runtime_ limit prevents shutter time from being
- * lowered enough to meet the exposure time with gain fixed at the stage limit,
- * gain is also lowered to compensate.
+ * When a combination of exposure time and gain _stage_ limits are found that
+ * are sufficient to meet the required exposure, the function attempts to reduce
+ * exposure time as much as possible whilst fixing gain and still meeting the
+ * exposure. If a _runtime_ limit prevents exposure time from being lowered
+ * enough to meet the exposure with gain fixed at the stage limit, gain is also
+ * lowered to compensate.
*
- * Once the shutter time and gain values are ascertained, gain is assigned as
+ * Once the exposure time and gain values are ascertained, gain is assigned as
* analogue gain as much as possible, with digital gain only in use if the
* maximum analogue gain runtime limit is unable to accommodate the exposure
* value.
*
- * If no combination of shutter time and gain limits is found that meets the
- * required exposure time, the helper falls-back to simply maximising the
- * shutter time first, followed by analogue gain, followed by digital gain.
+ * If no combination of exposure time and gain limits is found that meets the
+ * required exposure, the helper falls-back to simply maximising the exposure
+ * time first, followed by analogue gain, followed by digital gain.
*
- * \return Tuple of shutter time, analogue gain, and digital gain
+ * \return Tuple of exposure time, analogue gain, and digital gain
*/
std::tuple<utils::Duration, double, double>
ExposureModeHelper::splitExposure(utils::Duration exposure) const
{
- ASSERT(maxShutter_);
+ ASSERT(maxExposureTime_);
ASSERT(maxGain_);
bool gainFixed = minGain_ == maxGain_;
- bool shutterFixed = minShutter_ == maxShutter_;
+ bool exposureTimeFixed = minExposureTime_ == maxExposureTime_;
/*
* There's no point entering the loop if we cannot change either gain
- * nor shutter anyway.
+ * nor exposure time anyway.
*/
- if (shutterFixed && gainFixed)
- return { minShutter_, minGain_, exposure / (minShutter_ * minGain_) };
+ if (exposureTimeFixed && gainFixed)
+ return { minExposureTime_, minGain_, exposure / (minExposureTime_ * minGain_) };
- utils::Duration shutter;
+ utils::Duration exposureTime;
double stageGain = 1.0;
double gain;
for (unsigned int stage = 0; stage < gains_.size(); stage++) {
double lastStageGain = stage == 0 ? 1.0 : clampGain(gains_[stage - 1]);
- utils::Duration stageShutter = clampShutter(shutters_[stage]);
+ utils::Duration stageExposureTime = clampExposureTime(exposureTimes_[stage]);
stageGain = clampGain(gains_[stage]);
/*
- * We perform the clamping on both shutter and gain in case the
- * helper has had limits set that prevent those values being
- * lowered beyond a certain minimum...this can happen at runtime
- * for various reasons and so would not be known when the stage
- * limits are initialised.
+ * We perform the clamping on both exposure time and gain in
+ * case the helper has had limits set that prevent those values
+ * being lowered beyond a certain minimum...this can happen at
+ * runtime for various reasons and so would not be known when
+ * the stage limits are initialised.
*/
- if (stageShutter * lastStageGain >= exposure) {
- shutter = clampShutter(exposure / clampGain(lastStageGain));
- gain = clampGain(exposure / shutter);
+ if (stageExposureTime * lastStageGain >= exposure) {
+ exposureTime = clampExposureTime(exposure / clampGain(lastStageGain));
+ gain = clampGain(exposure / exposureTime);
- return { shutter, gain, exposure / (shutter * gain) };
+ return { exposureTime, gain, exposure / (exposureTime * gain) };
}
- if (stageShutter * stageGain >= exposure) {
- shutter = clampShutter(exposure / clampGain(stageGain));
- gain = clampGain(exposure / shutter);
+ if (stageExposureTime * stageGain >= exposure) {
+ exposureTime = clampExposureTime(exposure / clampGain(stageGain));
+ gain = clampGain(exposure / exposureTime);
- return { shutter, gain, exposure / (shutter * gain) };
+ return { exposureTime, gain, exposure / (exposureTime * gain) };
}
}
/*
- * From here on all we can do is max out the shutter time, followed by
+ * From here on all we can do is max out the exposure time, followed by
* the analogue gain. If we still haven't achieved the target we send
* the rest of the exposure time to digital gain. If we were given no
* stages to use then the default stageGain of 1.0 is used so that
- * shutter time is maxed before gain is touched at all.
+ * exposure time is maxed before gain is touched at all.
*/
- shutter = clampShutter(exposure / clampGain(stageGain));
- gain = clampGain(exposure / shutter);
+ exposureTime = clampExposureTime(exposure / clampGain(stageGain));
+ gain = clampGain(exposure / exposureTime);
- return { shutter, gain, exposure / (shutter * gain) };
+ return { exposureTime, gain, exposure / (exposureTime * gain) };
}
/**
- * \fn ExposureModeHelper::minShutter()
- * \brief Retrieve the configured minimum shutter time limit set through
+ * \fn ExposureModeHelper::minExposureTime()
+ * \brief Retrieve the configured minimum exposure time limit set through
* setLimits()
- * \return The minShutter_ value
+ * \return The minExposureTime_ value
*/
/**
- * \fn ExposureModeHelper::maxShutter()
- * \brief Retrieve the configured maximum shutter time set through setLimits()
- * \return The maxShutter_ value
+ * \fn ExposureModeHelper::maxExposureTime()
+ * \brief Retrieve the configured maximum exposure time set through setLimits()
+ * \return The maxExposureTime_ value
*/
/**
diff --git a/src/ipa/libipa/exposure_mode_helper.h b/src/ipa/libipa/exposure_mode_helper.h
index 85c665d7..c5be1b67 100644
--- a/src/ipa/libipa/exposure_mode_helper.h
+++ b/src/ipa/libipa/exposure_mode_helper.h
@@ -24,26 +24,26 @@ public:
ExposureModeHelper(const Span<std::pair<utils::Duration, double>> stages);
~ExposureModeHelper() = default;
- void setLimits(utils::Duration minShutter, utils::Duration maxShutter,
+ void setLimits(utils::Duration minExposureTime, utils::Duration maxExposureTime,
double minGain, double maxGain);
std::tuple<utils::Duration, double, double>
splitExposure(utils::Duration exposure) const;
- utils::Duration minShutter() const { return minShutter_; }
- utils::Duration maxShutter() const { return maxShutter_; }
+ utils::Duration minExposureTime() const { return minExposureTime_; }
+ utils::Duration maxExposureTime() const { return maxExposureTime_; }
double minGain() const { return minGain_; }
double maxGain() const { return maxGain_; }
private:
- utils::Duration clampShutter(utils::Duration shutter) const;
+ utils::Duration clampExposureTime(utils::Duration exposureTime) const;
double clampGain(double gain) const;
- std::vector<utils::Duration> shutters_;
+ std::vector<utils::Duration> exposureTimes_;
std::vector<double> gains_;
- utils::Duration minShutter_;
- utils::Duration maxShutter_;
+ utils::Duration minExposureTime_;
+ utils::Duration maxExposureTime_;
double minGain_;
double maxGain_;
};
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-14 02:51:26 +0000