libcamera/vivid.git - libcamera pipeline handler for VIVID

diff options

author	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2019-10-27 23:51:02 +0200
committer	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2019-11-20 21:47:42 +0200
commit	7cbd88fec72643ff2bbe8c2ea43b25ad7bd31ca9 (patch)
tree	085d03f819289492385fbb1a571a8e33dbdc7432 /test/stream
parent	cdc68bf7f775538bcc58ff85a14cf89fc6c8668e (diff)

libcamera: controls: Catch type mismatch in ControlInfoMap

ControlInfoMap requires the ControlId and ControlRange of each entry to have identical types. Check for this and log an error if a mismatch is detected. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>

Diffstat (limited to 'test/stream')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2021-2022, Ideas On Board * * AGC/AEC mean-based control algorithm */ #include "agc.h" #include <algorithm> #include <chrono> #include <cmath> #include <tuple> #include <vector> #include <libcamera/base/log.h> #include <libcamera/base/utils.h> #include <libcamera/control_ids.h> #include <libcamera/ipa/core_ipa_interface.h> #include "libcamera/internal/yaml_parser.h" #include "libipa/histogram.h" /** * \file agc.h */ namespace libcamera { using namespace std::literals::chrono_literals; namespace ipa::rkisp1::algorithms { /** * \class Agc * \brief A mean-based auto-exposure algorithm */ LOG_DEFINE_CATEGORY(RkISP1Agc) int Agc::parseMeteringModes(IPAContext &context, const YamlObject &tuningData) { if (!tuningData.isDictionary()) LOG(RkISP1Agc, Warning) << "'AeMeteringMode' parameter not found in tuning file"; for (const auto &[key, value] : tuningData.asDict()) { if (controls::AeMeteringModeNameValueMap.find(key) == controls::AeMeteringModeNameValueMap.end()) { LOG(RkISP1Agc, Warning) << "Skipping unknown metering mode '" << key << "'"; continue; } std::vector<uint8_t> weights = value.getList<uint8_t>().value_or(std::vector<uint8_t>{}); if (weights.size() != context.hw->numHistogramWeights) { LOG(RkISP1Agc, Warning) << "Failed to read metering mode'" << key << "'"; continue; } meteringModes_[controls::AeMeteringModeNameValueMap.at(key)] = weights; } if (meteringModes_.empty()) { LOG(RkISP1Agc, Warning) << "No metering modes read from tuning file; defaulting to matrix"; int32_t meteringModeId = controls::AeMeteringModeNameValueMap.at("MeteringMatrix"); std::vector<uint8_t> weights(context.hw->numHistogramWeights, 1); meteringModes_[meteringModeId] = weights; } std::vector<ControlValue> meteringModes; std::vector<int> meteringModeKeys = utils::map_keys(meteringModes_); std::transform(meteringModeKeys.begin(), meteringModeKeys.end(), std::back_inserter(meteringModes), [](int x) { return ControlValue(x); }); context.ctrlMap[&controls::AeMeteringMode] = ControlInfo(meteringModes); return 0; } uint8_t Agc::computeHistogramPredivider(const Size &size, enum rkisp1_cif_isp_histogram_mode mode) { /* * The maximum number of pixels that could potentially be in one bin is * if all the pixels of the image are in it, multiplied by 3 for the * three color channels. The counter for each bin is 16 bits wide, so * `factor` thus contains the number of times we'd wrap around. This is * obviously the number of pixels that we need to skip to make sure * that we don't wrap around, but we compute the square root of it * instead, as the skip that we need to program is for both the x and y * directions. * * Even though it looks like dividing into a counter of 65536 would * overflow by 1, this is apparently fine according to the hardware * documentation, and this successfully gets the expected documented * predivider size for cases where: * (width / predivider) * (height / predivider) * 3 == 65536. * * There's a bit of extra rounding math to make sure the rounding goes * the correct direction so that the square of the step is big enough * to encompass the `factor` number of pixels that we need to skip. * * \todo Take into account weights. That is, if the weights are low * enough we can potentially reduce the predivider to increase * precision. This needs some investigation however, as this hardware * behavior is undocumented and is only an educated guess. */ int count = mode == RKISP1_CIF_ISP_HISTOGRAM_MODE_RGB_COMBINED ? 3 : 1; double factor = size.width * size.height * count / 65536.0; double root = std::sqrt(factor); uint8_t predivider = static_cast<uint8_t>(std::ceil(root)); return std::clamp<uint8_t>(predivider, 3, 127); } Agc::Agc() { supportsRaw_ = true; } /** * \brief Initialise the AGC algorithm from tuning files * \param[in] context The shared IPA context * \param[in] tuningData The YamlObject containing Agc tuning data * * This function calls the base class' tuningData parsers to discover which * control values are supported. * * \return 0 on success or errors from the base class */ int Agc::init(IPAContext &context, const YamlObject &tuningData) { int ret; ret = parseTuningData(tuningData); if (ret) return ret; const YamlObject &yamlMeteringModes = tuningData["AeMeteringMode"]; ret = parseMeteringModes(context, yamlMeteringModes); if (ret) return ret; context.ctrlMap[&controls::AeEnable] = ControlInfo(false, true); context.ctrlMap.merge(controls()); return 0; } /** * \brief Configure the AGC given a configInfo * \param[in] context The shared IPA context * \param[in] configInfo The IPA configuration data * * \return 0 */ int Agc::configure(IPAContext &context, const IPACameraSensorInfo &configInfo) { /* Configure the default exposure and gain. */ context.activeState.agc.automatic.gain = context.configuration.sensor.minAnalogueGain; context.activeState.agc.automatic.exposure = 10ms / context.configuration.sensor.lineDuration; context.activeState.agc.manual.gain = context.activeState.agc.automatic.gain; context.activeState.agc.manual.exposure = context.activeState.agc.automatic.exposure; context.activeState.agc.autoEnabled = !context.configuration.raw; context.activeState.agc.constraintMode = static_cast<controls::AeConstraintModeEnum>(constraintModes().begin()->first); context.activeState.agc.exposureMode = static_cast<controls::AeExposureModeEnum>(exposureModeHelpers().begin()->first); context.activeState.agc.meteringMode = static_cast<controls::AeMeteringModeEnum>(meteringModes_.begin()->first); /* * \todo This should probably come from FrameDurationLimits instead, * except it's computed in the IPA and not here so we'd have to * recompute it. */ context.activeState.agc.maxFrameDuration = context.configuration.sensor.maxShutterSpeed; /* * Define the measurement window for AGC as a centered rectangle * covering 3/4 of the image width and height. */ context.configuration.agc.measureWindow.h_offs = configInfo.outputSize.width / 8; context.configuration.agc.measureWindow.v_offs = configInfo.outputSize.height / 8; context.configuration.agc.measureWindow.h_size = 3 * configInfo.outputSize.width / 4; context.configuration.agc.measureWindow.v_size = 3 * configInfo.outputSize.height / 4; setLimits(context.configuration.sensor.minShutterSpeed, context.configuration.sensor.maxShutterSpeed, context.configuration.sensor.minAnalogueGain, context.configuration.sensor.maxAnalogueGain); resetFrameCount(); return 0; } /** * \copydoc libcamera::ipa::Algorithm::queueRequest */ void Agc::queueRequest(IPAContext &context, [[maybe_unused]] const uint32_t frame, IPAFrameContext &frameContext, const ControlList &controls) { auto &agc = context.activeState.agc; if (!context.configuration.raw) { const auto &agcEnable = controls.get(controls::AeEnable); if (agcEnable && *agcEnable != agc.autoEnabled) { agc.autoEnabled = *agcEnable; LOG(RkISP1Agc, Debug) << (agc.autoEnabled ? "Enabling" : "Disabling") << " AGC"; } } const auto &exposure = controls.get(controls::ExposureTime); if (exposure && !agc.autoEnabled) { agc.manual.exposure = *exposure * 1.0us / context.configuration.sensor.lineDuration; LOG(RkISP1Agc, Debug) << "Set exposure to " << agc.manual.exposure; } const auto &gain = controls.get(controls::AnalogueGain); if (gain && !agc.autoEnabled) { agc.manual.gain = *gain; LOG(RkISP1Agc, Debug) << "Set gain to " << agc.manual.gain; } frameContext.agc.autoEnabled = agc.autoEnabled; if (!frameContext.agc.autoEnabled) { frameContext.agc.exposure = agc.manual.exposure; frameContext.agc.gain = agc.manual.gain; } const auto &meteringMode = controls.get(controls::AeMeteringMode); if (meteringMode) { frameContext.agc.updateMetering = agc.meteringMode != *meteringMode; agc.meteringMode = static_cast<controls::AeMeteringModeEnum>(*meteringMode); } frameContext.agc.meteringMode = agc.meteringMode; const auto &exposureMode = controls.get(controls::AeExposureMode); if (exposureMode) agc.exposureMode = static_cast<controls::AeExposureModeEnum>(*exposureMode); frameContext.agc.exposureMode = agc.exposureMode; const auto &constraintMode = controls.get(controls::AeConstraintMode); if (constraintMode) agc.constraintMode = static_cast<controls::AeConstraintModeEnum>(*constraintMode); frameContext.agc.constraintMode = agc.constraintMode; const auto &frameDurationLimits = controls.get(controls::FrameDurationLimits); if (frameDurationLimits) { utils::Duration maxFrameDuration = std::chrono::milliseconds((*frameDurationLimits).back()); agc.maxFrameDuration = maxFrameDuration; } frameContext.agc.maxFrameDuration = agc.maxFrameDuration; } /** * \copydoc libcamera::ipa::Algorithm::prepare */ void Agc::prepare(IPAContext &context, const uint32_t frame, IPAFrameContext &frameContext, RkISP1Params *params) { if (frameContext.agc.autoEnabled) { frameContext.agc.exposure = context.activeState.agc.automatic.exposure; frameContext.agc.gain = context.activeState.agc.automatic.gain; } if (frame > 0 && !frameContext.agc.updateMetering) return; /* * Configure the AEC measurements. Set the window, measure * continuously, and estimate Y as (R + G + B) x (85/256). */ auto aecConfig = params->block<BlockType::Aec>(); aecConfig.setEnabled(true); aecConfig->meas_window = context.configuration.agc.measureWindow; aecConfig->autostop = RKISP1_CIF_ISP_EXP_CTRL_AUTOSTOP_0; aecConfig->mode = RKISP1_CIF_ISP_EXP_MEASURING_MODE_1; /* * Configure the histogram measurement. Set the window, produce a * luminance histogram, and set the weights and predivider. */ auto hstConfig = params->block<BlockType::Hst>(); hstConfig.setEnabled(true); hstConfig->meas_window = context.configuration.agc.measureWindow; hstConfig->mode = RKISP1_CIF_ISP_HISTOGRAM_MODE_Y_HISTOGRAM; Span<uint8_t> weights{ hstConfig->hist_weight, context.hw->numHistogramWeights }; std::vector<uint8_t> &modeWeights = meteringModes_.at(frameContext.agc.meteringMode); std::copy(modeWeights.begin(), modeWeights.end(), weights.begin()); struct rkisp1_cif_isp_window window = hstConfig->meas_window; Size windowSize = { window.h_size, window.v_size }; hstConfig->histogram_predivider = computeHistogramPredivider(windowSize, static_cast<rkisp1_cif_isp_histogram_mode>(hstConfig->mode)); } void Agc::fillMetadata(IPAContext &context, IPAFrameContext &frameContext, ControlList &metadata) { utils::Duration exposureTime = context.configuration.sensor.lineDuration * frameContext.sensor.exposure; metadata.set(controls::AnalogueGain, frameContext.sensor.gain); metadata.set(controls::ExposureTime, exposureTime.get<std::micro>()); metadata.set(controls::AeEnable, frameContext.agc.autoEnabled); /* \todo Use VBlank value calculated from each frame exposure. */ uint32_t vTotal = context.configuration.sensor.size.height + context.configuration.sensor.defVBlank; utils::Duration frameDuration = context.configuration.sensor.lineDuration * vTotal; metadata.set(controls::FrameDuration, frameDuration.get<std::micro>()); metadata.set(controls::AeMeteringMode, frameContext.agc.meteringMode); metadata.set(controls::AeExposureMode, frameContext.agc.exposureMode); metadata.set(controls::AeConstraintMode, frameContext.agc.constraintMode); } /** * \brief Estimate the relative luminance of the frame with a given gain * \param[in] gain The gain to apply to the frame *


context:
space:
mode: