libcamera/libcamera.git - libcamera official repository

diff options

author	Jacopo Mondi <jacopo.mondi@ideasonboard.com>	2024-12-05 11:00:29 +0100
committer	Jacopo Mondi <jacopo.mondi@ideasonboard.com>	2024-12-11 15:39:05 +0100
commit	88456ab55adb5593826afc073448aab50665631c (patch)
tree	aa09504611b00e8e097cab210c87272d67a36649 /package
parent	229667606e4d30e03d530341baf1ee528e7f2e95 (diff)

libcamera: stream: Add operator<<(StreamConfiguration)

The StreamConfiguration class only implements toString() but doesn't offer an overload of operator<<() which is more convenient to use. Add an overload for operator<<(StreamConfiguration) and re-implement StreamConfiguration::toString() on top of it. Signed-off-by: Jacopo Mondi <jacopo.mondi@ideasonboard.com> Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com> Reviewed-by: Stefan Klug <stefan.klug@ideasonboard.com> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

Diffstat (limited to 'package')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2024 Ideas on Board Oy * * 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. These constraints are expressed as a pair of quantile * boundaries for a histogram, along with a luminance target and a bounds-type. * The algorithm uses the constraints by ensuring that the defined portion of a * luminance histogram (I.E. lying between the two quantiles) is above or below * the given luminance value. */ /** * \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 the 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 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 * format described in \ref parseTuningData(). * * In order to be able to use this algorithm an IPA module 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. * * IPA modules that want to use this class to implement their AEGC algorithm * should derive it and provide an overriding estimateLuminance() function for * this class to use. They must call parseTuningData() in init(), and must also * call setLimits() and resetFrameCounter() in configure(). They may then use * calculateNewEv() in process(). If the limits passed to setLimits() change for * any reason (for example, in response to a FrameDurationLimit control being * passed in queueRequest()) then setLimits() must be called again with the new * values. */ AgcMeanLuminance::AgcMeanLuminance() : frameCount_(0), filteredExposure_(0s), relativeLuminanceTarget_(0) { } AgcMeanLuminance::~AgcMeanLuminance() = default; void AgcMeanLuminance::parseRelativeLuminanceTarget(const YamlObject &tuningData) { relativeLuminanceTarget_ = tuningData["relativeLuminanceTarget"].get<double>(kDefaultRelativeLuminanceTarget); } 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 IPU3/RkISP1 Agc algorithms were adhering * to anyway before centralisation; this constraint forces the top 2% of * the histogram to be at least 0.5. */ 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()) {


context:
space:
mode: