2761 lines
96 KiB
C++
2761 lines
96 KiB
C++
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
/*
|
|
* Copyright (C) 2019, Google Inc.
|
|
*
|
|
* controls ID list
|
|
*
|
|
* This file is auto-generated. Do not edit.
|
|
*/
|
|
|
|
#include <libcamera/control_ids.h>
|
|
#include <libcamera/controls.h>
|
|
|
|
/**
|
|
* \file control_ids.h
|
|
* \brief Camera controls identifiers
|
|
*/
|
|
|
|
namespace libcamera {
|
|
|
|
/**
|
|
* \brief Namespace for libcamera controls
|
|
*/
|
|
namespace controls {
|
|
|
|
/**
|
|
* \var AeEnable
|
|
* \brief Enable or disable the AEGC algorithm. When this control is set to true,
|
|
* both ExposureTimeMode and AnalogueGainMode are set to auto, and if this
|
|
* control is set to false then both are set to manual.
|
|
*
|
|
* If ExposureTimeMode or AnalogueGainMode are also set in the same
|
|
* request as AeEnable, then the modes supplied by ExposureTimeMode or
|
|
* AnalogueGainMode will take precedence.
|
|
*
|
|
* \sa ExposureTimeMode AnalogueGainMode
|
|
*/
|
|
|
|
/**
|
|
* \enum AeStateEnum
|
|
* \brief Supported AeState values
|
|
*
|
|
* \var AeStateIdle
|
|
* \brief The AEGC algorithm is inactive.
|
|
*
|
|
* This state is returned when both AnalogueGainMode and
|
|
* ExposureTimeMode are set to Manual and the algorithm is not
|
|
* actively computing any value.
|
|
*
|
|
* \var AeStateSearching
|
|
* \brief The AEGC algorithm is actively computing new values, for either the
|
|
* exposure time or the analogue gain, but has not converged to a
|
|
* stable result yet.
|
|
*
|
|
* This state is returned if at least one of AnalogueGainMode or
|
|
* ExposureTimeMode is auto and the algorithm hasn't converged yet.
|
|
*
|
|
* The AEGC algorithm converges once stable values are computed for
|
|
* all of the controls set to be computed in Auto mode. Once the
|
|
* algorithm converges the state is moved to AeStateConverged.
|
|
*
|
|
* \var AeStateConverged
|
|
* \brief The AEGC algorithm has converged.
|
|
*
|
|
* This state is returned if at least one of AnalogueGainMode or
|
|
* ExposureTimeMode is Auto, and the AEGC algorithm has converged to a
|
|
* stable value.
|
|
*
|
|
* If the measurements move too far away from the convergence point
|
|
* then the AEGC algorithm might start adjusting again, in which case
|
|
* the state is moved to AeStateSearching.
|
|
*/
|
|
|
|
/**
|
|
* \var AeStateValues
|
|
* \brief List of all AeState supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AeStateNameValueMap
|
|
* \brief Map of all AeState supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AeState
|
|
* \brief Report the AEGC algorithm state.
|
|
*
|
|
* The AEGC algorithm computes the exposure time and the analogue gain
|
|
* to be applied to the image sensor.
|
|
*
|
|
* The AEGC algorithm behaviour is controlled by the ExposureTimeMode and
|
|
* AnalogueGainMode controls, which allow applications to decide how
|
|
* the exposure time and gain are computed, in Auto or Manual mode,
|
|
* independently from one another.
|
|
*
|
|
* The AeState control reports the AEGC algorithm state through a single
|
|
* value and describes it as a single computation block which computes
|
|
* both the exposure time and the analogue gain values.
|
|
*
|
|
* When both the exposure time and analogue gain values are configured to
|
|
* be in Manual mode, the AEGC algorithm is quiescent and does not actively
|
|
* compute any value and the AeState control will report AeStateIdle.
|
|
*
|
|
* When at least the exposure time or analogue gain are configured to be
|
|
* computed by the AEGC algorithm, the AeState control will report if the
|
|
* algorithm has converged to stable values for all of the controls set
|
|
* to be computed in Auto mode.
|
|
*
|
|
* \sa AnalogueGainMode
|
|
* \sa ExposureTimeMode
|
|
*/
|
|
|
|
/**
|
|
* \enum AeMeteringModeEnum
|
|
* \brief Supported AeMeteringMode values
|
|
*
|
|
* \var MeteringCentreWeighted
|
|
* \brief Centre-weighted metering mode.
|
|
*
|
|
* \var MeteringSpot
|
|
* \brief Spot metering mode.
|
|
*
|
|
* \var MeteringMatrix
|
|
* \brief Matrix metering mode.
|
|
*
|
|
* \var MeteringCustom
|
|
* \brief Custom metering mode.
|
|
*/
|
|
|
|
/**
|
|
* \var AeMeteringModeValues
|
|
* \brief List of all AeMeteringMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AeMeteringModeNameValueMap
|
|
* \brief Map of all AeMeteringMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AeMeteringMode
|
|
* \brief Specify a metering mode for the AE algorithm to use.
|
|
*
|
|
* The metering modes determine which parts of the image are used to
|
|
* determine the scene brightness. Metering modes may be platform specific
|
|
* and not all metering modes may be supported.
|
|
*/
|
|
|
|
/**
|
|
* \enum AeConstraintModeEnum
|
|
* \brief Supported AeConstraintMode values
|
|
*
|
|
* \var ConstraintNormal
|
|
* \brief Default constraint mode.
|
|
*
|
|
* This mode aims to balance the exposure of different parts of the
|
|
* image so as to reach a reasonable average level. However, highlights
|
|
* in the image may appear over-exposed and lowlights may appear
|
|
* under-exposed.
|
|
*
|
|
* \var ConstraintHighlight
|
|
* \brief Highlight constraint mode.
|
|
*
|
|
* This mode adjusts the exposure levels in order to try and avoid
|
|
* over-exposing the brightest parts (highlights) of an image.
|
|
* Other non-highlight parts of the image may appear under-exposed.
|
|
*
|
|
* \var ConstraintShadows
|
|
* \brief Shadows constraint mode.
|
|
*
|
|
* This mode adjusts the exposure levels in order to try and avoid
|
|
* under-exposing the dark parts (shadows) of an image. Other normally
|
|
* exposed parts of the image may appear over-exposed.
|
|
*
|
|
* \var ConstraintCustom
|
|
* \brief Custom constraint mode.
|
|
*/
|
|
|
|
/**
|
|
* \var AeConstraintModeValues
|
|
* \brief List of all AeConstraintMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AeConstraintModeNameValueMap
|
|
* \brief Map of all AeConstraintMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AeConstraintMode
|
|
* \brief Specify a constraint mode for the AE algorithm to use.
|
|
*
|
|
* The constraint modes determine how the measured scene brightness is
|
|
* adjusted to reach the desired target exposure. Constraint modes may be
|
|
* platform specific, and not all constraint modes may be supported.
|
|
*/
|
|
|
|
/**
|
|
* \enum AeExposureModeEnum
|
|
* \brief Supported AeExposureMode values
|
|
*
|
|
* \var ExposureNormal
|
|
* \brief Default exposure mode.
|
|
*
|
|
* \var ExposureShort
|
|
* \brief Exposure mode allowing only short exposure times.
|
|
*
|
|
* \var ExposureLong
|
|
* \brief Exposure mode allowing long exposure times.
|
|
*
|
|
* \var ExposureCustom
|
|
* \brief Custom exposure mode.
|
|
*/
|
|
|
|
/**
|
|
* \var AeExposureModeValues
|
|
* \brief List of all AeExposureMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AeExposureModeNameValueMap
|
|
* \brief Map of all AeExposureMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AeExposureMode
|
|
* \brief Specify an exposure mode for the AE algorithm to use.
|
|
*
|
|
* The exposure modes specify how the desired total exposure is divided
|
|
* between the exposure time and the sensor's analogue gain. They are
|
|
* platform specific, and not all exposure modes may be supported.
|
|
*
|
|
* When one of AnalogueGainMode or ExposureTimeMode is set to Manual,
|
|
* the fixed values will override any choices made by AeExposureMode.
|
|
*
|
|
* \sa AnalogueGainMode
|
|
* \sa ExposureTimeMode
|
|
*/
|
|
|
|
/**
|
|
* \var ExposureValue
|
|
* \brief Specify an Exposure Value (EV) parameter.
|
|
*
|
|
* The EV parameter will only be applied if the AE algorithm is currently
|
|
* enabled, that is, at least one of AnalogueGainMode and ExposureTimeMode
|
|
* are in Auto mode.
|
|
*
|
|
* By convention EV adjusts the exposure as log2. For example
|
|
* EV = [-2, -1, -0.5, 0, 0.5, 1, 2] results in an exposure adjustment
|
|
* of [1/4x, 1/2x, 1/sqrt(2)x, 1x, sqrt(2)x, 2x, 4x].
|
|
*
|
|
* \sa AnalogueGainMode
|
|
* \sa ExposureTimeMode
|
|
*/
|
|
|
|
/**
|
|
* \var ExposureTime
|
|
* \brief Exposure time for the frame applied in the sensor device.
|
|
*
|
|
* This value is specified in microseconds.
|
|
*
|
|
* This control will only take effect if ExposureTimeMode is Manual. If
|
|
* this control is set when ExposureTimeMode is Auto, the value will be
|
|
* ignored and will not be retained.
|
|
*
|
|
* When reported in metadata, this control indicates what exposure time
|
|
* was used for the current frame, regardless of ExposureTimeMode.
|
|
* ExposureTimeMode will indicate the source of the exposure time value,
|
|
* whether it came from the AE algorithm or not.
|
|
*
|
|
* \sa AnalogueGain
|
|
* \sa ExposureTimeMode
|
|
*/
|
|
|
|
/**
|
|
* \enum ExposureTimeModeEnum
|
|
* \brief Supported ExposureTimeMode values
|
|
*
|
|
* \var ExposureTimeModeAuto
|
|
* \brief The exposure time will be calculated automatically and set by the
|
|
* AE algorithm.
|
|
*
|
|
* If ExposureTime is set while this mode is active, it will be
|
|
* ignored, and its value will not be retained.
|
|
*
|
|
* When transitioning from Manual to Auto mode, the AEGC should start
|
|
* its adjustments based on the last set manual ExposureTime value.
|
|
*
|
|
* \var ExposureTimeModeManual
|
|
* \brief The exposure time will not be updated by the AE algorithm.
|
|
*
|
|
* When transitioning from Auto to Manual mode, the last computed
|
|
* exposure value is used until a new value is specified through the
|
|
* ExposureTime control. If an ExposureTime value is specified in the
|
|
* same request where the ExposureTimeMode is changed from Auto to
|
|
* Manual, the provided ExposureTime is applied immediately.
|
|
*/
|
|
|
|
/**
|
|
* \var ExposureTimeModeValues
|
|
* \brief List of all ExposureTimeMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var ExposureTimeModeNameValueMap
|
|
* \brief Map of all ExposureTimeMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var ExposureTimeMode
|
|
* \brief Controls the source of the exposure time that is applied to the image
|
|
* sensor.
|
|
*
|
|
* When set to Auto, the AE algorithm computes the exposure time and
|
|
* configures the image sensor accordingly. When set to Manual, the value
|
|
* of the ExposureTime control is used.
|
|
*
|
|
* When transitioning from Auto to Manual mode and no ExposureTime control
|
|
* is provided by the application, the last value computed by the AE
|
|
* algorithm when the mode was Auto will be used. If the ExposureTimeMode
|
|
* was never set to Auto (either because the camera started in Manual mode,
|
|
* or Auto is not supported by the camera), the camera should use a
|
|
* best-effort default value.
|
|
*
|
|
* If ExposureTimeModeManual is supported, the ExposureTime control must
|
|
* also be supported.
|
|
*
|
|
* Cameras that support manual control of the sensor shall support manual
|
|
* mode for both ExposureTimeMode and AnalogueGainMode, and shall expose
|
|
* the ExposureTime and AnalogueGain controls. If the camera also has an
|
|
* AEGC implementation, both ExposureTimeMode and AnalogueGainMode shall
|
|
* support both manual and auto mode. If auto mode is available, it shall
|
|
* be the default mode. These rules do not apply to black box cameras
|
|
* such as UVC cameras, where the available gain and exposure modes are
|
|
* completely dependent on what the device exposes.
|
|
*
|
|
* \par Flickerless exposure mode transitions
|
|
*
|
|
* Applications that wish to transition from ExposureTimeModeAuto to direct
|
|
* control of the exposure time without causing extra flicker can do so by
|
|
* selecting an ExposureTime value as close as possible to the last value
|
|
* computed by the auto exposure algorithm in order to avoid any visible
|
|
* flickering.
|
|
*
|
|
* To select the correct value to use as ExposureTime value, applications
|
|
* should accommodate the natural delay in applying controls caused by the
|
|
* capture pipeline frame depth.
|
|
*
|
|
* When switching to manual exposure mode, applications should not
|
|
* immediately specify an ExposureTime value in the same request where
|
|
* ExposureTimeMode is set to Manual. They should instead wait for the
|
|
* first Request where ExposureTimeMode is reported as
|
|
* ExposureTimeModeManual in the Request metadata, and use the reported
|
|
* ExposureTime to populate the control value in the next Request to be
|
|
* queued to the Camera.
|
|
*
|
|
* The implementation of the auto-exposure algorithm should equally try to
|
|
* minimize flickering and when transitioning from manual exposure mode to
|
|
* auto exposure use the last value provided by the application as starting
|
|
* point.
|
|
*
|
|
* 1. Start with ExposureTimeMode set to Auto
|
|
*
|
|
* 2. Set ExposureTimeMode to Manual
|
|
*
|
|
* 3. Wait for the first completed request that has ExposureTimeMode
|
|
* set to Manual
|
|
*
|
|
* 4. Copy the value reported in ExposureTime into a new request, and
|
|
* submit it
|
|
*
|
|
* 5. Proceed to run manual exposure time as desired
|
|
*
|
|
* \sa ExposureTime
|
|
*/
|
|
|
|
/**
|
|
* \var AnalogueGain
|
|
* \brief Analogue gain value applied in the sensor device.
|
|
*
|
|
* The value of the control specifies the gain multiplier applied to all
|
|
* colour channels. This value cannot be lower than 1.0.
|
|
*
|
|
* This control will only take effect if AnalogueGainMode is Manual. If
|
|
* this control is set when AnalogueGainMode is Auto, the value will be
|
|
* ignored and will not be retained.
|
|
*
|
|
* When reported in metadata, this control indicates what analogue gain
|
|
* was used for the current request, regardless of AnalogueGainMode.
|
|
* AnalogueGainMode will indicate the source of the analogue gain value,
|
|
* whether it came from the AEGC algorithm or not.
|
|
*
|
|
* \sa ExposureTime
|
|
* \sa AnalogueGainMode
|
|
*/
|
|
|
|
/**
|
|
* \enum AnalogueGainModeEnum
|
|
* \brief Supported AnalogueGainMode values
|
|
*
|
|
* \var AnalogueGainModeAuto
|
|
* \brief The analogue gain will be calculated automatically and set by the
|
|
* AEGC algorithm.
|
|
*
|
|
* If AnalogueGain is set while this mode is active, it will be
|
|
* ignored, and it will also not be retained.
|
|
*
|
|
* When transitioning from Manual to Auto mode, the AEGC should start
|
|
* its adjustments based on the last set manual AnalogueGain value.
|
|
*
|
|
* \var AnalogueGainModeManual
|
|
* \brief The analogue gain will not be updated by the AEGC algorithm.
|
|
*
|
|
* When transitioning from Auto to Manual mode, the last computed
|
|
* gain value is used until a new value is specified through the
|
|
* AnalogueGain control. If an AnalogueGain value is specified in the
|
|
* same request where the AnalogueGainMode is changed from Auto to
|
|
* Manual, the provided AnalogueGain is applied immediately.
|
|
*/
|
|
|
|
/**
|
|
* \var AnalogueGainModeValues
|
|
* \brief List of all AnalogueGainMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AnalogueGainModeNameValueMap
|
|
* \brief Map of all AnalogueGainMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AnalogueGainMode
|
|
* \brief Controls the source of the analogue gain that is applied to the image
|
|
* sensor.
|
|
*
|
|
* When set to Auto, the AEGC algorithm computes the analogue gain and
|
|
* configures the image sensor accordingly. When set to Manual, the value
|
|
* of the AnalogueGain control is used.
|
|
*
|
|
* When transitioning from Auto to Manual mode and no AnalogueGain control
|
|
* is provided by the application, the last value computed by the AEGC
|
|
* algorithm when the mode was Auto will be used. If the AnalogueGainMode
|
|
* was never set to Auto (either because the camera started in Manual mode,
|
|
* or Auto is not supported by the camera), the camera should use a
|
|
* best-effort default value.
|
|
*
|
|
* If AnalogueGainModeManual is supported, the AnalogueGain control must
|
|
* also be supported.
|
|
*
|
|
* For cameras where we have control over the ISP, both ExposureTimeMode
|
|
* and AnalogueGainMode are expected to support manual mode, and both
|
|
* controls (as well as ExposureTimeMode and AnalogueGain) are expected to
|
|
* be present. If the camera also has an AEGC implementation, both
|
|
* ExposureTimeMode and AnalogueGainMode shall support both manual and
|
|
* auto mode. If auto mode is available, it shall be the default mode.
|
|
* These rules do not apply to black box cameras such as UVC cameras,
|
|
* where the available gain and exposure modes are completely dependent on
|
|
* what the hardware exposes.
|
|
*
|
|
* The same procedure described for performing flickerless transitions in
|
|
* the ExposureTimeMode control documentation can be applied to analogue
|
|
* gain.
|
|
*
|
|
* \sa ExposureTimeMode
|
|
* \sa AnalogueGain
|
|
*/
|
|
|
|
/**
|
|
* \enum AeFlickerModeEnum
|
|
* \brief Supported AeFlickerMode values
|
|
*
|
|
* \var FlickerOff
|
|
* \brief No flicker avoidance is performed.
|
|
*
|
|
* \var FlickerManual
|
|
* \brief Manual flicker avoidance.
|
|
*
|
|
* Suppress flicker effects caused by lighting running with a period
|
|
* specified by the AeFlickerPeriod control.
|
|
* \sa AeFlickerPeriod
|
|
*
|
|
* \var FlickerAuto
|
|
* \brief Automatic flicker period detection and avoidance.
|
|
*
|
|
* The system will automatically determine the most likely value of
|
|
* flicker period, and avoid flicker of this frequency. Once flicker
|
|
* is being corrected, it is implementation dependent whether the
|
|
* system is still able to detect a change in the flicker period.
|
|
* \sa AeFlickerDetected
|
|
*/
|
|
|
|
/**
|
|
* \var AeFlickerModeValues
|
|
* \brief List of all AeFlickerMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AeFlickerModeNameValueMap
|
|
* \brief Map of all AeFlickerMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AeFlickerMode
|
|
* \brief Set the flicker avoidance mode for AGC/AEC.
|
|
*
|
|
* The flicker mode determines whether, and how, the AGC/AEC algorithm
|
|
* attempts to hide flicker effects caused by the duty cycle of artificial
|
|
* lighting.
|
|
*
|
|
* Although implementation dependent, many algorithms for "flicker
|
|
* avoidance" work by restricting this exposure time to integer multiples
|
|
* of the cycle period, wherever possible.
|
|
*
|
|
* Implementations may not support all of the flicker modes listed below.
|
|
*
|
|
* By default the system will start in FlickerAuto mode if this is
|
|
* supported, otherwise the flicker mode will be set to FlickerOff.
|
|
*/
|
|
|
|
/**
|
|
* \var AeFlickerPeriod
|
|
* \brief Manual flicker period in microseconds.
|
|
*
|
|
* This value sets the current flicker period to avoid. It is used when
|
|
* AeFlickerMode is set to FlickerManual.
|
|
*
|
|
* To cancel 50Hz mains flicker, this should be set to 10000 (corresponding
|
|
* to 100Hz), or 8333 (120Hz) for 60Hz mains.
|
|
*
|
|
* Setting the mode to FlickerManual when no AeFlickerPeriod has ever been
|
|
* set means that no flicker cancellation occurs (until the value of this
|
|
* control is updated).
|
|
*
|
|
* Switching to modes other than FlickerManual has no effect on the
|
|
* value of the AeFlickerPeriod control.
|
|
*
|
|
* \sa AeFlickerMode
|
|
*/
|
|
|
|
/**
|
|
* \var AeFlickerDetected
|
|
* \brief Flicker period detected in microseconds.
|
|
*
|
|
* The value reported here indicates the currently detected flicker
|
|
* period, or zero if no flicker at all is detected.
|
|
*
|
|
* When AeFlickerMode is set to FlickerAuto, there may be a period during
|
|
* which the value reported here remains zero. Once a non-zero value is
|
|
* reported, then this is the flicker period that has been detected and is
|
|
* now being cancelled.
|
|
*
|
|
* In the case of 50Hz mains flicker, the value would be 10000
|
|
* (corresponding to 100Hz), or 8333 (120Hz) for 60Hz mains flicker.
|
|
*
|
|
* It is implementation dependent whether the system can continue to detect
|
|
* flicker of different periods when another frequency is already being
|
|
* cancelled.
|
|
*
|
|
* \sa AeFlickerMode
|
|
*/
|
|
|
|
/**
|
|
* \var Brightness
|
|
* \brief Specify a fixed brightness parameter.
|
|
*
|
|
* Positive values (up to 1.0) produce brighter images; negative values
|
|
* (up to -1.0) produce darker images and 0.0 leaves pixels unchanged.
|
|
*/
|
|
|
|
/**
|
|
* \var Contrast
|
|
* \brief Specify a fixed contrast parameter.
|
|
*
|
|
* Normal contrast is given by the value 1.0; larger values produce images
|
|
* with more contrast.
|
|
*/
|
|
|
|
/**
|
|
* \var Lux
|
|
* \brief Report an estimate of the current illuminance level in lux.
|
|
*
|
|
* The Lux control can only be returned in metadata.
|
|
*/
|
|
|
|
/**
|
|
* \var AwbEnable
|
|
* \brief Enable or disable the AWB.
|
|
*
|
|
* When AWB is enabled, the algorithm estimates the colour temperature of
|
|
* the scene and computes colour gains and the colour correction matrix
|
|
* automatically. The computed colour temperature, gains and correction
|
|
* matrix are reported in metadata. The corresponding controls are ignored
|
|
* if set in a request.
|
|
*
|
|
* When AWB is disabled, the colour temperature, gains and correction
|
|
* matrix are not updated automatically and can be set manually in
|
|
* requests.
|
|
*
|
|
* \sa ColourCorrectionMatrix
|
|
* \sa ColourGains
|
|
* \sa ColourTemperature
|
|
*/
|
|
|
|
/**
|
|
* \enum AwbModeEnum
|
|
* \brief Supported AwbMode values
|
|
*
|
|
* \var AwbAuto
|
|
* \brief Search over the whole colour temperature range.
|
|
*
|
|
* \var AwbIncandescent
|
|
* \brief Incandescent AWB lamp mode.
|
|
*
|
|
* \var AwbTungsten
|
|
* \brief Tungsten AWB lamp mode.
|
|
*
|
|
* \var AwbFluorescent
|
|
* \brief Fluorescent AWB lamp mode.
|
|
*
|
|
* \var AwbIndoor
|
|
* \brief Indoor AWB lighting mode.
|
|
*
|
|
* \var AwbDaylight
|
|
* \brief Daylight AWB lighting mode.
|
|
*
|
|
* \var AwbCloudy
|
|
* \brief Cloudy AWB lighting mode.
|
|
*
|
|
* \var AwbCustom
|
|
* \brief Custom AWB mode.
|
|
*/
|
|
|
|
/**
|
|
* \var AwbModeValues
|
|
* \brief List of all AwbMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AwbModeNameValueMap
|
|
* \brief Map of all AwbMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AwbMode
|
|
* \brief Specify the range of illuminants to use for the AWB algorithm.
|
|
*
|
|
* The modes supported are platform specific, and not all modes may be
|
|
* supported.
|
|
*/
|
|
|
|
/**
|
|
* \var AwbLocked
|
|
* \brief Report the lock status of a running AWB algorithm.
|
|
*
|
|
* If the AWB algorithm is locked the value shall be set to true, if it's
|
|
* converging it shall be set to false. If the AWB algorithm is not
|
|
* running the control shall not be present in the metadata control list.
|
|
*
|
|
* \sa AwbEnable
|
|
*/
|
|
|
|
/**
|
|
* \var ColourGains
|
|
* \brief Pair of gain values for the Red and Blue colour channels, in that
|
|
* order.
|
|
*
|
|
* ColourGains can only be applied in a Request when the AWB is disabled.
|
|
* If ColourGains is set in a request but ColourTemperature is not, the
|
|
* implementation shall calculate and set the ColourTemperature based on
|
|
* the ColourGains.
|
|
*
|
|
* \sa AwbEnable
|
|
* \sa ColourTemperature
|
|
*/
|
|
|
|
/**
|
|
* \var ColourTemperature
|
|
* \brief ColourTemperature of the frame, in kelvin.
|
|
*
|
|
* ColourTemperature can only be applied in a Request when the AWB is
|
|
* disabled.
|
|
*
|
|
* If ColourTemperature is set in a request but ColourGains is not, the
|
|
* implementation shall calculate and set the ColourGains based on the
|
|
* given ColourTemperature. If ColourTemperature is set (either directly,
|
|
* or indirectly by setting ColourGains) but ColourCorrectionMatrix is not,
|
|
* the ColourCorrectionMatrix is updated based on the ColourTemperature.
|
|
*
|
|
* The ColourTemperature used to process the frame is reported in metadata.
|
|
*
|
|
* \sa AwbEnable
|
|
* \sa ColourCorrectionMatrix
|
|
* \sa ColourGains
|
|
*/
|
|
|
|
/**
|
|
* \var Saturation
|
|
* \brief Specify a fixed saturation parameter.
|
|
*
|
|
* Normal saturation is given by the value 1.0; larger values produce more
|
|
* saturated colours; 0.0 produces a greyscale image.
|
|
*/
|
|
|
|
/**
|
|
* \var SensorBlackLevels
|
|
* \brief Reports the sensor black levels used for processing a frame.
|
|
*
|
|
* The values are in the order R, Gr, Gb, B. They are returned as numbers
|
|
* out of a 16-bit pixel range (as if pixels ranged from 0 to 65535). The
|
|
* SensorBlackLevels control can only be returned in metadata.
|
|
*/
|
|
|
|
/**
|
|
* \var Sharpness
|
|
* \brief Intensity of the sharpening applied to the image.
|
|
*
|
|
* A value of 0.0 means no sharpening. The minimum value means
|
|
* minimal sharpening, and shall be 0.0 unless the camera can't
|
|
* disable sharpening completely. The default value shall give a
|
|
* "reasonable" level of sharpening, suitable for most use cases.
|
|
* The maximum value may apply extremely high levels of sharpening,
|
|
* higher than anyone could reasonably want. Negative values are
|
|
* not allowed. Note also that sharpening is not applied to raw
|
|
* streams.
|
|
*/
|
|
|
|
/**
|
|
* \var FocusFoM
|
|
* \brief Reports a Figure of Merit (FoM) to indicate how in-focus the frame is.
|
|
*
|
|
* A larger FocusFoM value indicates a more in-focus frame. This singular
|
|
* value may be based on a combination of statistics gathered from
|
|
* multiple focus regions within an image. The number of focus regions and
|
|
* method of combination is platform dependent. In this respect, it is not
|
|
* necessarily aimed at providing a way to implement a focus algorithm by
|
|
* the application, rather an indication of how in-focus a frame is.
|
|
*/
|
|
|
|
/**
|
|
* \var ColourCorrectionMatrix
|
|
* \brief The 3x3 matrix that converts camera RGB to sRGB within the imaging
|
|
* pipeline.
|
|
*
|
|
* This should describe the matrix that is used after pixels have been
|
|
* white-balanced, but before any gamma transformation. The 3x3 matrix is
|
|
* stored in conventional reading order in an array of 9 floating point
|
|
* values.
|
|
*
|
|
* ColourCorrectionMatrix can only be applied in a Request when the AWB is
|
|
* disabled.
|
|
*
|
|
* \sa AwbEnable
|
|
* \sa ColourTemperature
|
|
*/
|
|
|
|
/**
|
|
* \var ScalerCrop
|
|
* \brief Sets the image portion that will be scaled to form the whole of
|
|
* the final output image.
|
|
*
|
|
* The (x,y) location of this rectangle is relative to the
|
|
* PixelArrayActiveAreas that is being used. The units remain native
|
|
* sensor pixels, even if the sensor is being used in a binning or
|
|
* skipping mode.
|
|
*
|
|
* This control is only present when the pipeline supports scaling. Its
|
|
* maximum valid value is given by the properties::ScalerCropMaximum
|
|
* property, and the two can be used to implement digital zoom.
|
|
*/
|
|
|
|
/**
|
|
* \var DigitalGain
|
|
* \brief Digital gain value applied during the processing steps applied
|
|
* to the image as captured from the sensor.
|
|
*
|
|
* The global digital gain factor is applied to all the colour channels
|
|
* of the RAW image. Different pipeline models are free to
|
|
* specify how the global gain factor applies to each separate
|
|
* channel.
|
|
*
|
|
* If an imaging pipeline applies digital gain in distinct
|
|
* processing steps, this value indicates their total sum.
|
|
* Pipelines are free to decide how to adjust each processing
|
|
* step to respect the received gain factor and shall report
|
|
* their total value in the request metadata.
|
|
*/
|
|
|
|
/**
|
|
* \var FrameDuration
|
|
* \brief The instantaneous frame duration from start of frame exposure to start
|
|
* of next exposure, expressed in microseconds.
|
|
*
|
|
* This control is meant to be returned in metadata.
|
|
*/
|
|
|
|
/**
|
|
* \var FrameDurationLimits
|
|
* \brief The minimum and maximum (in that order) frame duration, expressed in
|
|
* microseconds.
|
|
*
|
|
* When provided by applications, the control specifies the sensor frame
|
|
* duration interval the pipeline has to use. This limits the largest
|
|
* exposure time the sensor can use. For example, if a maximum frame
|
|
* duration of 33ms is requested (corresponding to 30 frames per second),
|
|
* the sensor will not be able to raise the exposure time above 33ms.
|
|
* A fixed frame duration is achieved by setting the minimum and maximum
|
|
* values to be the same. Setting both values to 0 reverts to using the
|
|
* camera defaults.
|
|
*
|
|
* The maximum frame duration provides the absolute limit to the exposure
|
|
* time computed by the AE algorithm and it overrides any exposure mode
|
|
* setting specified with controls::AeExposureMode. Similarly, when a
|
|
* manual exposure time is set through controls::ExposureTime, it also
|
|
* gets clipped to the limits set by this control. When reported in
|
|
* metadata, the control expresses the minimum and maximum frame durations
|
|
* used after being clipped to the sensor provided frame duration limits.
|
|
*
|
|
* \sa AeExposureMode
|
|
* \sa ExposureTime
|
|
*
|
|
* \todo Define how to calculate the capture frame rate by
|
|
* defining controls to report additional delays introduced by
|
|
* the capture pipeline or post-processing stages (ie JPEG
|
|
* conversion, frame scaling).
|
|
*
|
|
* \todo Provide an explicit definition of default control values, for
|
|
* this and all other controls.
|
|
*/
|
|
|
|
/**
|
|
* \var SensorTemperature
|
|
* \brief Temperature measure from the camera sensor in Celsius.
|
|
*
|
|
* This value is typically obtained by a thermal sensor present on-die or
|
|
* in the camera module. The range of reported temperatures is device
|
|
* dependent.
|
|
*
|
|
* The SensorTemperature control will only be returned in metadata if a
|
|
* thermal sensor is present.
|
|
*/
|
|
|
|
/**
|
|
* \var SensorTimestamp
|
|
* \brief The time when the first row of the image sensor active array is exposed.
|
|
*
|
|
* The timestamp, expressed in nanoseconds, represents a monotonically
|
|
* increasing counter since the system boot time, as defined by the
|
|
* Linux-specific CLOCK_BOOTTIME clock id.
|
|
*
|
|
* The SensorTimestamp control can only be returned in metadata.
|
|
*
|
|
* \todo Define how the sensor timestamp has to be used in the reprocessing
|
|
* use case.
|
|
*/
|
|
|
|
/**
|
|
* \enum AfModeEnum
|
|
* \brief Supported AfMode values
|
|
*
|
|
* \var AfModeManual
|
|
* \brief The AF algorithm is in manual mode.
|
|
*
|
|
* In this mode it will never perform any action nor move the lens of
|
|
* its own accord, but an application can specify the desired lens
|
|
* position using the LensPosition control. The AfState will always
|
|
* report AfStateIdle.
|
|
*
|
|
* If the camera is started in AfModeManual, it will move the focus
|
|
* lens to the position specified by the LensPosition control.
|
|
*
|
|
* This mode is the recommended default value for the AfMode control.
|
|
* External cameras (as reported by the Location property set to
|
|
* CameraLocationExternal) may use a different default value.
|
|
*
|
|
* \var AfModeAuto
|
|
* \brief The AF algorithm is in auto mode.
|
|
*
|
|
* In this mode the algorithm will never move the lens or change state
|
|
* unless the AfTrigger control is used. The AfTrigger control can be
|
|
* used to initiate a focus scan, the results of which will be
|
|
* reported by AfState.
|
|
*
|
|
* If the autofocus algorithm is moved from AfModeAuto to another mode
|
|
* while a scan is in progress, the scan is cancelled immediately,
|
|
* without waiting for the scan to finish.
|
|
*
|
|
* When first entering this mode the AfState will report AfStateIdle.
|
|
* When a trigger control is sent, AfState will report AfStateScanning
|
|
* for a period before spontaneously changing to AfStateFocused or
|
|
* AfStateFailed, depending on the outcome of the scan. It will remain
|
|
* in this state until another scan is initiated by the AfTrigger
|
|
* control. If a scan is cancelled (without changing to another mode),
|
|
* AfState will return to AfStateIdle.
|
|
*
|
|
* \var AfModeContinuous
|
|
* \brief The AF algorithm is in continuous mode.
|
|
*
|
|
* In this mode the lens can re-start a scan spontaneously at any
|
|
* moment, without any user intervention. The AfState still reports
|
|
* whether the algorithm is currently scanning or not, though the
|
|
* application has no ability to initiate or cancel scans, nor to move
|
|
* the lens for itself.
|
|
*
|
|
* However, applications can pause the AF algorithm from continuously
|
|
* scanning by using the AfPause control. This allows video or still
|
|
* images to be captured whilst guaranteeing that the focus is fixed.
|
|
*
|
|
* When set to AfModeContinuous, the system will immediately initiate a
|
|
* scan so AfState will report AfStateScanning, and will settle on one
|
|
* of AfStateFocused or AfStateFailed, depending on the scan result.
|
|
*/
|
|
|
|
/**
|
|
* \var AfModeValues
|
|
* \brief List of all AfMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AfModeNameValueMap
|
|
* \brief Map of all AfMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AfMode
|
|
* \brief The mode of the AF (autofocus) algorithm.
|
|
*
|
|
* An implementation may choose not to implement all the modes.
|
|
*/
|
|
|
|
/**
|
|
* \enum AfRangeEnum
|
|
* \brief Supported AfRange values
|
|
*
|
|
* \var AfRangeNormal
|
|
* \brief A wide range of focus distances is scanned.
|
|
*
|
|
* Scanned distances cover all the way from infinity down to close
|
|
* distances, though depending on the implementation, possibly not
|
|
* including the very closest macro positions.
|
|
*
|
|
* \var AfRangeMacro
|
|
* \brief Only close distances are scanned.
|
|
*
|
|
* \var AfRangeFull
|
|
* \brief The full range of focus distances is scanned.
|
|
*
|
|
* This range is similar to AfRangeNormal but includes the very
|
|
* closest macro positions.
|
|
*/
|
|
|
|
/**
|
|
* \var AfRangeValues
|
|
* \brief List of all AfRange supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AfRangeNameValueMap
|
|
* \brief Map of all AfRange supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AfRange
|
|
* \brief The range of focus distances that is scanned.
|
|
*
|
|
* An implementation may choose not to implement all the options here.
|
|
*/
|
|
|
|
/**
|
|
* \enum AfSpeedEnum
|
|
* \brief Supported AfSpeed values
|
|
*
|
|
* \var AfSpeedNormal
|
|
* \brief Move the lens at its usual speed.
|
|
*
|
|
* \var AfSpeedFast
|
|
* \brief Move the lens more quickly.
|
|
*/
|
|
|
|
/**
|
|
* \var AfSpeedValues
|
|
* \brief List of all AfSpeed supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AfSpeedNameValueMap
|
|
* \brief Map of all AfSpeed supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AfSpeed
|
|
* \brief Determine whether the AF is to move the lens as quickly as possible or
|
|
* more steadily.
|
|
*
|
|
* For example, during video recording it may be desirable not to move the
|
|
* lens too abruptly, but when in a preview mode (waiting for a still
|
|
* capture) it may be helpful to move the lens as quickly as is reasonably
|
|
* possible.
|
|
*/
|
|
|
|
/**
|
|
* \enum AfMeteringEnum
|
|
* \brief Supported AfMetering values
|
|
*
|
|
* \var AfMeteringAuto
|
|
* \brief Let the AF algorithm decide for itself where it will measure focus.
|
|
*
|
|
* \var AfMeteringWindows
|
|
* \brief Use the rectangles defined by the AfWindows control to measure focus.
|
|
*
|
|
* If no windows are specified the behaviour is platform dependent.
|
|
*/
|
|
|
|
/**
|
|
* \var AfMeteringValues
|
|
* \brief List of all AfMetering supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AfMeteringNameValueMap
|
|
* \brief Map of all AfMetering supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AfMetering
|
|
* \brief The parts of the image used by the AF algorithm to measure focus.
|
|
*/
|
|
|
|
/**
|
|
* \var AfWindows
|
|
* \brief The focus windows used by the AF algorithm when AfMetering is set to
|
|
* AfMeteringWindows.
|
|
*
|
|
* The units used are pixels within the rectangle returned by the
|
|
* ScalerCropMaximum property.
|
|
*
|
|
* In order to be activated, a rectangle must be programmed with non-zero
|
|
* width and height. Internally, these rectangles are intersected with the
|
|
* ScalerCropMaximum rectangle. If the window becomes empty after this
|
|
* operation, then the window is ignored. If all the windows end up being
|
|
* ignored, then the behaviour is platform dependent.
|
|
*
|
|
* On platforms that support the ScalerCrop control (for implementing
|
|
* digital zoom, for example), no automatic recalculation or adjustment of
|
|
* AF windows is performed internally if the ScalerCrop is changed. If any
|
|
* window lies outside the output image after the scaler crop has been
|
|
* applied, it is up to the application to recalculate them.
|
|
*
|
|
* The details of how the windows are used are platform dependent. We note
|
|
* that when there is more than one AF window, a typical implementation
|
|
* might find the optimal focus position for each one and finally select
|
|
* the window where the focal distance for the objects shown in that part
|
|
* of the image are closest to the camera.
|
|
*/
|
|
|
|
/**
|
|
* \enum AfTriggerEnum
|
|
* \brief Supported AfTrigger values
|
|
*
|
|
* \var AfTriggerStart
|
|
* \brief Start an AF scan.
|
|
*
|
|
* Setting the control to AfTriggerStart is ignored if a scan is in
|
|
* progress.
|
|
*
|
|
* \var AfTriggerCancel
|
|
* \brief Cancel an AF scan.
|
|
*
|
|
* This does not cause the lens to move anywhere else. Ignored if no
|
|
* scan is in progress.
|
|
*/
|
|
|
|
/**
|
|
* \var AfTriggerValues
|
|
* \brief List of all AfTrigger supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AfTriggerNameValueMap
|
|
* \brief Map of all AfTrigger supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AfTrigger
|
|
* \brief Start an autofocus scan.
|
|
*
|
|
* This control starts an autofocus scan when AfMode is set to AfModeAuto,
|
|
* and is ignored if AfMode is set to AfModeManual or AfModeContinuous. It
|
|
* can also be used to terminate a scan early.
|
|
*/
|
|
|
|
/**
|
|
* \enum AfPauseEnum
|
|
* \brief Supported AfPause values
|
|
*
|
|
* \var AfPauseImmediate
|
|
* \brief Pause the continuous autofocus algorithm immediately.
|
|
*
|
|
* The autofocus algorithm is paused whether or not any kind of scan
|
|
* is underway. AfPauseState will subsequently report
|
|
* AfPauseStatePaused. AfState may report any of AfStateScanning,
|
|
* AfStateFocused or AfStateFailed, depending on the algorithm's state
|
|
* when it received this control.
|
|
*
|
|
* \var AfPauseDeferred
|
|
* \brief Pause the continuous autofocus algorithm at the end of the scan.
|
|
*
|
|
* This is similar to AfPauseImmediate, and if the AfState is
|
|
* currently reporting AfStateFocused or AfStateFailed it will remain
|
|
* in that state and AfPauseState will report AfPauseStatePaused.
|
|
*
|
|
* However, if the algorithm is scanning (AfStateScanning),
|
|
* AfPauseState will report AfPauseStatePausing until the scan is
|
|
* finished, at which point AfState will report one of AfStateFocused
|
|
* or AfStateFailed, and AfPauseState will change to
|
|
* AfPauseStatePaused.
|
|
*
|
|
* \var AfPauseResume
|
|
* \brief Resume continuous autofocus operation.
|
|
*
|
|
* The algorithm starts again from exactly where it left off, and
|
|
* AfPauseState will report AfPauseStateRunning.
|
|
*/
|
|
|
|
/**
|
|
* \var AfPauseValues
|
|
* \brief List of all AfPause supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AfPauseNameValueMap
|
|
* \brief Map of all AfPause supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AfPause
|
|
* \brief Pause lens movements when in continuous autofocus mode.
|
|
*
|
|
* This control has no effect except when in continuous autofocus mode
|
|
* (AfModeContinuous). It can be used to pause any lens movements while
|
|
* (for example) images are captured. The algorithm remains inactive
|
|
* until it is instructed to resume.
|
|
*/
|
|
|
|
/**
|
|
* \var LensPosition
|
|
* \brief Set and report the focus lens position.
|
|
*
|
|
* This control instructs the lens to move to a particular position and
|
|
* also reports back the position of the lens for each frame.
|
|
*
|
|
* The LensPosition control is ignored unless the AfMode is set to
|
|
* AfModeManual, though the value is reported back unconditionally in all
|
|
* modes.
|
|
*
|
|
* This value, which is generally a non-integer, is the reciprocal of the
|
|
* focal distance in metres, also known as dioptres. That is, to set a
|
|
* focal distance D, the lens position LP is given by
|
|
*
|
|
* \f$LP = \frac{1\mathrm{m}}{D}\f$
|
|
*
|
|
* For example:
|
|
*
|
|
* - 0 moves the lens to infinity.
|
|
* - 0.5 moves the lens to focus on objects 2m away.
|
|
* - 2 moves the lens to focus on objects 50cm away.
|
|
* - And larger values will focus the lens closer.
|
|
*
|
|
* The default value of the control should indicate a good general
|
|
* position for the lens, often corresponding to the hyperfocal distance
|
|
* (the closest position for which objects at infinity are still
|
|
* acceptably sharp). The minimum will often be zero (meaning infinity),
|
|
* and the maximum value defines the closest focus position.
|
|
*
|
|
* \todo Define a property to report the Hyperfocal distance of calibrated
|
|
* lenses.
|
|
*/
|
|
|
|
/**
|
|
* \enum AfStateEnum
|
|
* \brief Supported AfState values
|
|
*
|
|
* \var AfStateIdle
|
|
* \brief The AF algorithm is in manual mode (AfModeManual) or in auto mode
|
|
* (AfModeAuto) and a scan has not yet been triggered, or an
|
|
* in-progress scan was cancelled.
|
|
*
|
|
* \var AfStateScanning
|
|
* \brief The AF algorithm is in auto mode (AfModeAuto), and a scan has been
|
|
* started using the AfTrigger control.
|
|
*
|
|
* The scan can be cancelled by sending AfTriggerCancel at which point
|
|
* the algorithm will either move back to AfStateIdle or, if the scan
|
|
* actually completes before the cancel request is processed, to one
|
|
* of AfStateFocused or AfStateFailed.
|
|
*
|
|
* Alternatively the AF algorithm could be in continuous mode
|
|
* (AfModeContinuous) at which point it may enter this state
|
|
* spontaneously whenever it determines that a rescan is needed.
|
|
*
|
|
* \var AfStateFocused
|
|
* \brief The AF algorithm is in auto (AfModeAuto) or continuous
|
|
* (AfModeContinuous) mode and a scan has completed with the result
|
|
* that the algorithm believes the image is now in focus.
|
|
*
|
|
* \var AfStateFailed
|
|
* \brief The AF algorithm is in auto (AfModeAuto) or continuous
|
|
* (AfModeContinuous) mode and a scan has completed with the result
|
|
* that the algorithm did not find a good focus position.
|
|
*/
|
|
|
|
/**
|
|
* \var AfStateValues
|
|
* \brief List of all AfState supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AfStateNameValueMap
|
|
* \brief Map of all AfState supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AfState
|
|
* \brief The current state of the AF algorithm.
|
|
*
|
|
* This control reports the current state of the AF algorithm in
|
|
* conjunction with the reported AfMode value and (in continuous AF mode)
|
|
* the AfPauseState value. The possible state changes are described below,
|
|
* though we note the following state transitions that occur when the
|
|
* AfMode is changed.
|
|
*
|
|
* If the AfMode is set to AfModeManual, then the AfState will always
|
|
* report AfStateIdle (even if the lens is subsequently moved). Changing
|
|
* to the AfModeManual state does not initiate any lens movement.
|
|
*
|
|
* If the AfMode is set to AfModeAuto then the AfState will report
|
|
* AfStateIdle. However, if AfModeAuto and AfTriggerStart are sent
|
|
* together then AfState will omit AfStateIdle and move straight to
|
|
* AfStateScanning (and start a scan).
|
|
*
|
|
* If the AfMode is set to AfModeContinuous then the AfState will
|
|
* initially report AfStateScanning.
|
|
*/
|
|
|
|
/**
|
|
* \enum AfPauseStateEnum
|
|
* \brief Supported AfPauseState values
|
|
*
|
|
* \var AfPauseStateRunning
|
|
* \brief Continuous AF is running and the algorithm may restart a scan
|
|
* spontaneously.
|
|
*
|
|
* \var AfPauseStatePausing
|
|
* \brief Continuous AF has been sent an AfPauseDeferred control, and will
|
|
* pause as soon as any in-progress scan completes.
|
|
*
|
|
* When the scan completes, the AfPauseState control will report
|
|
* AfPauseStatePaused. No new scans will be start spontaneously until
|
|
* the AfPauseResume control is sent.
|
|
*
|
|
* \var AfPauseStatePaused
|
|
* \brief Continuous AF is paused.
|
|
*
|
|
* No further state changes or lens movements will occur until the
|
|
* AfPauseResume control is sent.
|
|
*/
|
|
|
|
/**
|
|
* \var AfPauseStateValues
|
|
* \brief List of all AfPauseState supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AfPauseStateNameValueMap
|
|
* \brief Map of all AfPauseState supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AfPauseState
|
|
* \brief Report whether the autofocus is currently running, paused or pausing.
|
|
*
|
|
* This control is only applicable in continuous (AfModeContinuous) mode,
|
|
* and reports whether the algorithm is currently running, paused or
|
|
* pausing (that is, will pause as soon as any in-progress scan
|
|
* completes).
|
|
*
|
|
* Any change to AfMode will cause AfPauseStateRunning to be reported.
|
|
*/
|
|
|
|
/**
|
|
* \enum HdrModeEnum
|
|
* \brief Supported HdrMode values
|
|
*
|
|
* \var HdrModeOff
|
|
* \brief HDR is disabled.
|
|
*
|
|
* Metadata for this frame will not include the HdrChannel control.
|
|
*
|
|
* \var HdrModeMultiExposureUnmerged
|
|
* \brief Multiple exposures will be generated in an alternating fashion.
|
|
*
|
|
* The multiple exposures will not be merged together and will be
|
|
* returned to the application as they are. Each image will be tagged
|
|
* with the correct HDR channel, indicating what kind of exposure it
|
|
* is. The tag should be the same as in the HdrModeMultiExposure case.
|
|
*
|
|
* The expectation is that an application using this mode would merge
|
|
* the frames to create HDR images for itself if it requires them.
|
|
*
|
|
* \var HdrModeMultiExposure
|
|
* \brief Multiple exposures will be generated and merged to create HDR
|
|
* images.
|
|
*
|
|
* Each image will be tagged with the HDR channel (long, medium or
|
|
* short) that arrived and which caused this image to be output.
|
|
*
|
|
* Systems that use two channels for HDR will return images tagged
|
|
* alternately as the short and long channel. Systems that use three
|
|
* channels for HDR will cycle through the short, medium and long
|
|
* channel before repeating.
|
|
*
|
|
* \var HdrModeSingleExposure
|
|
* \brief Multiple frames all at a single exposure will be used to create HDR
|
|
* images.
|
|
*
|
|
* These images should be reported as all corresponding to the HDR
|
|
* short channel.
|
|
*
|
|
* \var HdrModeNight
|
|
* \brief Multiple frames will be combined to produce "night mode" images.
|
|
*
|
|
* It is up to the implementation exactly which HDR channels it uses,
|
|
* and the images will all be tagged accordingly with the correct HDR
|
|
* channel information.
|
|
*/
|
|
|
|
/**
|
|
* \var HdrModeValues
|
|
* \brief List of all HdrMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var HdrModeNameValueMap
|
|
* \brief Map of all HdrMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var HdrMode
|
|
* \brief Set the mode to be used for High Dynamic Range (HDR) imaging.
|
|
*
|
|
* HDR techniques typically include multiple exposure, image fusion and
|
|
* tone mapping techniques to improve the dynamic range of the resulting
|
|
* images.
|
|
*
|
|
* When using an HDR mode, images are captured with different sets of AGC
|
|
* settings called HDR channels. Channels indicate in particular the type
|
|
* of exposure (short, medium or long) used to capture the raw image,
|
|
* before fusion. Each HDR image is tagged with the corresponding channel
|
|
* using the HdrChannel control.
|
|
*
|
|
* \sa HdrChannel
|
|
*/
|
|
|
|
/**
|
|
* \enum HdrChannelEnum
|
|
* \brief Supported HdrChannel values
|
|
*
|
|
* \var HdrChannelNone
|
|
* \brief This image does not correspond to any of the captures used to create
|
|
* an HDR image.
|
|
*
|
|
* \var HdrChannelShort
|
|
* \brief This is a short exposure image.
|
|
*
|
|
* \var HdrChannelMedium
|
|
* \brief This is a medium exposure image.
|
|
*
|
|
* \var HdrChannelLong
|
|
* \brief This is a long exposure image.
|
|
*/
|
|
|
|
/**
|
|
* \var HdrChannelValues
|
|
* \brief List of all HdrChannel supported values
|
|
*/
|
|
|
|
/**
|
|
* \var HdrChannelNameValueMap
|
|
* \brief Map of all HdrChannel supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var HdrChannel
|
|
* \brief The HDR channel used to capture the frame.
|
|
*
|
|
* This value is reported back to the application so that it can discover
|
|
* whether this capture corresponds to the short or long exposure image
|
|
* (or any other image used by the HDR procedure). An application can
|
|
* monitor the HDR channel to discover when the differently exposed images
|
|
* have arrived.
|
|
*
|
|
* This metadata is only available when an HDR mode has been enabled.
|
|
*
|
|
* \sa HdrMode
|
|
*/
|
|
|
|
/**
|
|
* \var Gamma
|
|
* \brief Specify a fixed gamma value.
|
|
*
|
|
* The default gamma value must be 2.2 which closely mimics sRGB gamma.
|
|
* Note that this is camera gamma, so it is applied as 1.0/gamma.
|
|
*/
|
|
|
|
/**
|
|
* \var DebugMetadataEnable
|
|
* \brief Enable or disable the debug metadata.
|
|
*/
|
|
|
|
/**
|
|
* \var FrameWallClock
|
|
* \brief This timestamp corresponds to the same moment in time as the
|
|
* SensorTimestamp, but is represented as a wall clock time as measured by
|
|
* the CLOCK_REALTIME clock. Like SensorTimestamp, the timestamp value is
|
|
* expressed in nanoseconds.
|
|
*
|
|
* Being a wall clock measurement, it can be used to synchronise timing
|
|
* across different devices.
|
|
*
|
|
* \sa SensorTimestamp
|
|
*
|
|
* The FrameWallClock control can only be returned in metadata.
|
|
*/
|
|
|
|
/**
|
|
* \enum WdrModeEnum
|
|
* \brief Supported WdrMode values
|
|
*
|
|
* \var WdrOff
|
|
* \brief Wdr is disabled.
|
|
*
|
|
* \var WdrLinear
|
|
* \brief Apply a linear global tone mapping curve.
|
|
* A curve with two linear sections is applied. This produces good results at the expense of a slightly artificial look.
|
|
*
|
|
* \var WdrPower
|
|
* \brief Apply a power global tone mapping curve.
|
|
*
|
|
* This curve has high gain values on the dark areas of an image and
|
|
* high compression values on the bright area. It therefore tends to
|
|
* produce noticeable noise artifacts.
|
|
*
|
|
* \var WdrExponential
|
|
* \brief Apply an exponential global tone mapping curve.
|
|
*
|
|
* This curve has lower gain values in dark areas compared to the power
|
|
* curve but produces a more natural look compared to the linear curve.
|
|
* It is therefore the best choice for most scenes.
|
|
*
|
|
* \var WdrHistogramEqualization
|
|
* \brief Apply histogram equalization.
|
|
*
|
|
* This curve preserves most of the information of the image at the
|
|
* expense of a very artificial look. It is therefore best suited for
|
|
* technical analysis.
|
|
*/
|
|
|
|
/**
|
|
* \var WdrModeValues
|
|
* \brief List of all WdrMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var WdrModeNameValueMap
|
|
* \brief Map of all WdrMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var WdrMode
|
|
* \brief Set the WDR mode.
|
|
*
|
|
* The WDR mode is used to select the algorithm used for global tone
|
|
* mapping. It will automatically reduce the exposure time of the sensor
|
|
* so that there are only a small number of saturated pixels in the image.
|
|
* The algorithm then compensates for the loss of brightness by applying a
|
|
* global tone mapping curve to the image.
|
|
*/
|
|
|
|
/**
|
|
* \var WdrStrength
|
|
* \brief Specify the strength of the wdr algorithm. The exact meaning of this
|
|
* value is specific to the algorithm in use. Usually a value of 0 means no
|
|
* global tone mapping is applied. A values of 1 is the default value and
|
|
* the correct value for most scenes. A value above 1 increases the global
|
|
* tone mapping effect and can lead to unrealistic image effects.
|
|
*/
|
|
|
|
/**
|
|
* \var WdrMaxBrightPixels
|
|
* \brief Percentage of allowed (nearly) saturated pixels. The WDR algorithm
|
|
* reduces the WdrExposureValue until the amount of pixels that are close
|
|
* to saturation is lower than this value.
|
|
*/
|
|
|
|
/**
|
|
* \var LensDewarpEnable
|
|
* \brief Enable or disable lens dewarping.
|
|
*/
|
|
|
|
/**
|
|
* \var LensShadingCorrectionEnable
|
|
* \brief Enable or disable the lens shading correction.
|
|
*/
|
|
|
|
/**
|
|
* \var Hue
|
|
* \brief Adjusts the image hue (colour rotation) in degrees, as defined in
|
|
* the HSL/HSV colour model.
|
|
*
|
|
* The value represents a rotation around the hue circle in HSL/HSV space:
|
|
* positive values rotate hues clockwise (for example a +60° turns
|
|
* Red hues to Yellow hues), and negative values rotate counter-clockwise
|
|
* (a -60° turns Red hues to Magenta hues).
|
|
*
|
|
* The nominal range is [-180, 180], where 0° leaves hues unchanged and the
|
|
* range wraps around continuously, with 180° == -180°.
|
|
*/
|
|
|
|
/**
|
|
* \brief Namespace for draft controls
|
|
*/
|
|
namespace draft {
|
|
|
|
/**
|
|
* \enum AePrecaptureTriggerEnum
|
|
* \brief Supported AePrecaptureTrigger values
|
|
*
|
|
* \var AePrecaptureTriggerIdle
|
|
* \brief The trigger is idle.
|
|
*
|
|
* \var AePrecaptureTriggerStart
|
|
* \brief The pre-capture AE metering is started by the camera.
|
|
*
|
|
* \var AePrecaptureTriggerCancel
|
|
* \brief The camera will cancel any active or completed metering sequence.
|
|
* The AE algorithm is reset to its initial state.
|
|
*/
|
|
|
|
/**
|
|
* \var AePrecaptureTriggerValues
|
|
* \brief List of all AePrecaptureTrigger supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AePrecaptureTriggerNameValueMap
|
|
* \brief Map of all AePrecaptureTrigger supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AePrecaptureTrigger
|
|
* \brief Control for AE metering trigger. Currently identical to
|
|
* ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER.
|
|
*
|
|
* Whether the camera device will trigger a precapture metering sequence
|
|
* when it processes this request.
|
|
*/
|
|
|
|
/**
|
|
* \enum NoiseReductionModeEnum
|
|
* \brief Supported NoiseReductionMode values
|
|
*
|
|
* \var NoiseReductionModeOff
|
|
* \brief No noise reduction is applied
|
|
*
|
|
* \var NoiseReductionModeFast
|
|
* \brief Noise reduction is applied without reducing the frame rate.
|
|
*
|
|
* \var NoiseReductionModeHighQuality
|
|
* \brief High quality noise reduction at the expense of frame rate.
|
|
*
|
|
* \var NoiseReductionModeMinimal
|
|
* \brief Minimal noise reduction is applied without reducing the frame rate.
|
|
*
|
|
* \var NoiseReductionModeZSL
|
|
* \brief Noise reduction is applied at different levels to different streams.
|
|
*/
|
|
|
|
/**
|
|
* \var NoiseReductionModeValues
|
|
* \brief List of all NoiseReductionMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var NoiseReductionModeNameValueMap
|
|
* \brief Map of all NoiseReductionMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var NoiseReductionMode
|
|
* \brief Control to select the noise reduction algorithm mode. Currently
|
|
* identical to ANDROID_NOISE_REDUCTION_MODE.
|
|
*
|
|
* Mode of operation for the noise reduction algorithm.
|
|
*/
|
|
|
|
/**
|
|
* \enum ColorCorrectionAberrationModeEnum
|
|
* \brief Supported ColorCorrectionAberrationMode values
|
|
*
|
|
* \var ColorCorrectionAberrationOff
|
|
* \brief No aberration correction is applied.
|
|
*
|
|
* \var ColorCorrectionAberrationFast
|
|
* \brief Aberration correction will not slow down the frame rate.
|
|
*
|
|
* \var ColorCorrectionAberrationHighQuality
|
|
* \brief High quality aberration correction which might reduce the frame
|
|
* rate.
|
|
*/
|
|
|
|
/**
|
|
* \var ColorCorrectionAberrationModeValues
|
|
* \brief List of all ColorCorrectionAberrationMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var ColorCorrectionAberrationModeNameValueMap
|
|
* \brief Map of all ColorCorrectionAberrationMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var ColorCorrectionAberrationMode
|
|
* \brief Control to select the color correction aberration mode. Currently
|
|
* identical to ANDROID_COLOR_CORRECTION_ABERRATION_MODE.
|
|
*
|
|
* Mode of operation for the chromatic aberration correction algorithm.
|
|
*/
|
|
|
|
/**
|
|
* \enum AwbStateEnum
|
|
* \brief Supported AwbState values
|
|
*
|
|
* \var AwbStateInactive
|
|
* \brief The AWB algorithm is inactive.
|
|
*
|
|
* \var AwbStateSearching
|
|
* \brief The AWB algorithm has not converged yet.
|
|
*
|
|
* \var AwbConverged
|
|
* \brief The AWB algorithm has converged.
|
|
*
|
|
* \var AwbLocked
|
|
* \brief The AWB algorithm is locked.
|
|
*/
|
|
|
|
/**
|
|
* \var AwbStateValues
|
|
* \brief List of all AwbState supported values
|
|
*/
|
|
|
|
/**
|
|
* \var AwbStateNameValueMap
|
|
* \brief Map of all AwbState supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var AwbState
|
|
* \brief Control to report the current AWB algorithm state. Currently identical
|
|
* to ANDROID_CONTROL_AWB_STATE.
|
|
*
|
|
* Current state of the AWB algorithm.
|
|
*/
|
|
|
|
/**
|
|
* \var SensorRollingShutterSkew
|
|
* \brief Control to report the time between the start of exposure of the first
|
|
* row and the start of exposure of the last row. Currently identical to
|
|
* ANDROID_SENSOR_ROLLING_SHUTTER_SKEW
|
|
*/
|
|
|
|
/**
|
|
* \enum LensShadingMapModeEnum
|
|
* \brief Supported LensShadingMapMode values
|
|
*
|
|
* \var LensShadingMapModeOff
|
|
* \brief No lens shading map mode is available.
|
|
*
|
|
* \var LensShadingMapModeOn
|
|
* \brief The lens shading map mode is available.
|
|
*/
|
|
|
|
/**
|
|
* \var LensShadingMapModeValues
|
|
* \brief List of all LensShadingMapMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var LensShadingMapModeNameValueMap
|
|
* \brief Map of all LensShadingMapMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var LensShadingMapMode
|
|
* \brief Control to report if the lens shading map is available. Currently
|
|
* identical to ANDROID_STATISTICS_LENS_SHADING_MAP_MODE.
|
|
*/
|
|
|
|
/**
|
|
* \var PipelineDepth
|
|
* \brief Specifies the number of pipeline stages the frame went through from when
|
|
* it was exposed to when the final completed result was available to the
|
|
* framework. Always less than or equal to PipelineMaxDepth. Currently
|
|
* identical to ANDROID_REQUEST_PIPELINE_DEPTH.
|
|
*
|
|
* The typical value for this control is 3 as a frame is first exposed,
|
|
* captured and then processed in a single pass through the ISP. Any
|
|
* additional processing step performed after the ISP pass (in example face
|
|
* detection, additional format conversions etc) count as an additional
|
|
* pipeline stage.
|
|
*/
|
|
|
|
/**
|
|
* \var MaxLatency
|
|
* \brief The maximum number of frames that can occur after a request (different
|
|
* than the previous) has been submitted, and before the result's state
|
|
* becomes synchronized. A value of -1 indicates unknown latency, and 0
|
|
* indicates per-frame control. Currently identical to
|
|
* ANDROID_SYNC_MAX_LATENCY.
|
|
*/
|
|
|
|
/**
|
|
* \enum TestPatternModeEnum
|
|
* \brief Supported TestPatternMode values
|
|
*
|
|
* \var TestPatternModeOff
|
|
* \brief No test pattern mode is used. The camera device returns frames from
|
|
* the image sensor.
|
|
*
|
|
* \var TestPatternModeSolidColor
|
|
* \brief Each pixel in [R, G_even, G_odd, B] is replaced by its respective
|
|
* color channel provided in test pattern data.
|
|
* \todo Add control for test pattern data.
|
|
*
|
|
* \var TestPatternModeColorBars
|
|
* \brief All pixel data is replaced with an 8-bar color pattern. The vertical
|
|
* bars (left-to-right) are as follows; white, yellow, cyan, green,
|
|
* magenta, red, blue and black. Each bar should take up 1/8 of the
|
|
* sensor pixel array width. When this is not possible, the bar size
|
|
* should be rounded down to the nearest integer and the pattern can
|
|
* repeat on the right side. Each bar's height must always take up the
|
|
* full sensor pixel array height.
|
|
*
|
|
* \var TestPatternModeColorBarsFadeToGray
|
|
* \brief The test pattern is similar to TestPatternModeColorBars,
|
|
* except that each bar should start at its specified color at the top
|
|
* and fade to gray at the bottom. Furthermore each bar is further
|
|
* subdevided into a left and right half. The left half should have a
|
|
* smooth gradient, and the right half should have a quantized
|
|
* gradient. In particular, the right half's should consist of blocks
|
|
* of the same color for 1/16th active sensor pixel array width. The
|
|
* least significant bits in the quantized gradient should be copied
|
|
* from the most significant bits of the smooth gradient. The height of
|
|
* each bar should always be a multiple of 128. When this is not the
|
|
* case, the pattern should repeat at the bottom of the image.
|
|
*
|
|
* \var TestPatternModePn9
|
|
* \brief All pixel data is replaced by a pseudo-random sequence generated
|
|
* from a PN9 512-bit sequence (typically implemented in hardware with
|
|
* a linear feedback shift register). The generator should be reset at
|
|
* the beginning of each frame, and thus each subsequent raw frame with
|
|
* this test pattern should be exactly the same as the last.
|
|
*
|
|
* \var TestPatternModeCustom1
|
|
* \brief The first custom test pattern. All custom patterns that are
|
|
* available only on this camera device are at least this numeric
|
|
* value. All of the custom test patterns will be static (that is the
|
|
* raw image must not vary from frame to frame).
|
|
*/
|
|
|
|
/**
|
|
* \var TestPatternModeValues
|
|
* \brief List of all TestPatternMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var TestPatternModeNameValueMap
|
|
* \brief Map of all TestPatternMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var TestPatternMode
|
|
* \brief Control to select the test pattern mode. Currently identical to
|
|
* ANDROID_SENSOR_TEST_PATTERN_MODE.
|
|
*/
|
|
|
|
/**
|
|
* \enum FaceDetectModeEnum
|
|
* \brief Supported FaceDetectMode values
|
|
*
|
|
* \var FaceDetectModeOff
|
|
* \brief Pipeline doesn't perform face detection and doesn't report any
|
|
* control related to face detection.
|
|
*
|
|
* \var FaceDetectModeSimple
|
|
* \brief Pipeline performs face detection and reports the
|
|
* FaceDetectFaceRectangles and FaceDetectFaceScores controls for each
|
|
* detected face. FaceDetectFaceLandmarks and FaceDetectFaceIds are
|
|
* optional.
|
|
*
|
|
* \var FaceDetectModeFull
|
|
* \brief Pipeline performs face detection and reports all the controls
|
|
* related to face detection including FaceDetectFaceRectangles,
|
|
* FaceDetectFaceScores, FaceDetectFaceLandmarks, and
|
|
* FaceDeteceFaceIds for each detected face.
|
|
*/
|
|
|
|
/**
|
|
* \var FaceDetectModeValues
|
|
* \brief List of all FaceDetectMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var FaceDetectModeNameValueMap
|
|
* \brief Map of all FaceDetectMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var FaceDetectMode
|
|
* \brief Control to select the face detection mode used by the pipeline.
|
|
*
|
|
* Currently identical to ANDROID_STATISTICS_FACE_DETECT_MODE.
|
|
*
|
|
* \sa FaceDetectFaceRectangles
|
|
* \sa FaceDetectFaceScores
|
|
* \sa FaceDetectFaceLandmarks
|
|
* \sa FaceDetectFaceIds
|
|
*/
|
|
|
|
/**
|
|
* \var FaceDetectFaceRectangles
|
|
* \brief Boundary rectangles of the detected faces. The number of values is
|
|
* the number of detected faces.
|
|
*
|
|
* The FaceDetectFaceRectangles control can only be returned in metadata.
|
|
*
|
|
* Currently identical to ANDROID_STATISTICS_FACE_RECTANGLES.
|
|
*/
|
|
|
|
/**
|
|
* \var FaceDetectFaceScores
|
|
* \brief Confidence score of each of the detected faces. The range of score is
|
|
* [0, 100]. The number of values should be the number of faces reported
|
|
* in FaceDetectFaceRectangles.
|
|
*
|
|
* The FaceDetectFaceScores control can only be returned in metadata.
|
|
*
|
|
* Currently identical to ANDROID_STATISTICS_FACE_SCORES.
|
|
*/
|
|
|
|
/**
|
|
* \var FaceDetectFaceLandmarks
|
|
* \brief Array of human face landmark coordinates in format [..., left_eye_i,
|
|
* right_eye_i, mouth_i, left_eye_i+1, ...], with i = index of face. The
|
|
* number of values should be 3 * the number of faces reported in
|
|
* FaceDetectFaceRectangles.
|
|
*
|
|
* The FaceDetectFaceLandmarks control can only be returned in metadata.
|
|
*
|
|
* Currently identical to ANDROID_STATISTICS_FACE_LANDMARKS.
|
|
*/
|
|
|
|
/**
|
|
* \var FaceDetectFaceIds
|
|
* \brief Each detected face is given a unique ID that is valid for as long as the
|
|
* face is visible to the camera device. A face that leaves the field of
|
|
* view and later returns may be assigned a new ID. The number of values
|
|
* should be the number of faces reported in FaceDetectFaceRectangles.
|
|
*
|
|
* The FaceDetectFaceIds control can only be returned in metadata.
|
|
*
|
|
* Currently identical to ANDROID_STATISTICS_FACE_IDS.
|
|
*/
|
|
|
|
} /* namespace draft */
|
|
|
|
/**
|
|
* \brief Namespace for rpi controls
|
|
*/
|
|
namespace rpi {
|
|
|
|
/**
|
|
* \var StatsOutputEnable
|
|
* \brief Toggles the Raspberry Pi IPA to output the hardware generated statistics.
|
|
*
|
|
* When this control is set to true, the IPA outputs a binary dump of the
|
|
* hardware generated statistics through the Request metadata in the
|
|
* Bcm2835StatsOutput control.
|
|
*
|
|
* \sa Bcm2835StatsOutput
|
|
*/
|
|
|
|
/**
|
|
* \var Bcm2835StatsOutput
|
|
* \brief Span of the BCM2835 ISP generated statistics for the current frame.
|
|
*
|
|
* This is sent in the Request metadata if the StatsOutputEnable is set to
|
|
* true. The statistics struct definition can be found in
|
|
* include/linux/bcm2835-isp.h.
|
|
*
|
|
* \sa StatsOutputEnable
|
|
*/
|
|
|
|
/**
|
|
* \var ScalerCrops
|
|
* \brief An array of rectangles, where each singular value has identical
|
|
* functionality to the ScalerCrop control. This control allows the
|
|
* Raspberry Pi pipeline handler to control individual scaler crops per
|
|
* output stream.
|
|
*
|
|
* The order of rectangles passed into the control must match the order of
|
|
* streams configured by the application. The pipeline handler will only
|
|
* configure crop retangles up-to the number of output streams configured.
|
|
* All subsequent rectangles passed into this control are ignored by the
|
|
* pipeline handler.
|
|
*
|
|
* If both rpi::ScalerCrops and ScalerCrop controls are present in a
|
|
* ControlList, the latter is discarded, and crops are obtained from this
|
|
* control.
|
|
*
|
|
* Note that using different crop rectangles for each output stream with
|
|
* this control is only applicable on the Pi5/PiSP platform. This control
|
|
* should also be considered temporary/draft and will be replaced with
|
|
* official libcamera API support for per-stream controls in the future.
|
|
*
|
|
* \sa ScalerCrop
|
|
*/
|
|
|
|
/**
|
|
* \var PispStatsOutput
|
|
* \brief Span of the PiSP Frontend ISP generated statistics for the current
|
|
* frame. This is sent in the Request metadata if the StatsOutputEnable is
|
|
* set to true. The statistics struct definition can be found in
|
|
* https://github.com/raspberrypi/libpisp/blob/main/src/libpisp/frontend/pisp_statistics.h
|
|
*
|
|
* \sa StatsOutputEnable
|
|
*/
|
|
|
|
/**
|
|
* \enum SyncModeEnum
|
|
* \brief Supported SyncMode values
|
|
*
|
|
* \var SyncModeOff
|
|
* \brief Disable sync mode.
|
|
*
|
|
* \var SyncModeServer
|
|
* \brief Enable sync mode, act as server. The server broadcasts timing
|
|
* messages to any clients that are listening, so that the clients can
|
|
* synchronise their camera frames with the server's.
|
|
*
|
|
* \var SyncModeClient
|
|
* \brief Enable sync mode, act as client. A client listens for any server
|
|
* messages, and arranges for its camera frames to synchronise as
|
|
* closely as possible with the server's. Many clients can listen out
|
|
* for the same server. Clients can also be started ahead of any
|
|
* servers, causing them merely to wait for the server to start.
|
|
*/
|
|
|
|
/**
|
|
* \var SyncModeValues
|
|
* \brief List of all SyncMode supported values
|
|
*/
|
|
|
|
/**
|
|
* \var SyncModeNameValueMap
|
|
* \brief Map of all SyncMode supported value names (in std::string format) to value
|
|
*/
|
|
|
|
/**
|
|
* \var SyncMode
|
|
* \brief Enable or disable camera synchronisation ("sync") mode.
|
|
*
|
|
* When sync mode is enabled, a camera will synchronise frames temporally
|
|
* with other cameras, either attached to the same device or a different
|
|
* one. There should be one "server" device, which broadcasts timing
|
|
* information to one or more "clients". Communication is one-way, from
|
|
* server to clients only, and it is only clients that adjust their frame
|
|
* timings to match the server.
|
|
*
|
|
* Sync mode requires all cameras to be running at (as far as possible) the
|
|
* same fixed framerate. Clients may continue to make adjustments to keep
|
|
* their cameras synchronised with the server for the duration of the
|
|
* session, though any updates after the initial ones should remain small.
|
|
*
|
|
* \sa SyncReady
|
|
* \sa SyncTimer
|
|
* \sa SyncFrames
|
|
*/
|
|
|
|
/**
|
|
* \var SyncReady
|
|
* \brief When using the camera synchronisation algorithm, the server broadcasts
|
|
* timing information to the clients. This also includes the time (some
|
|
* number of frames in the future, called the "ready time") at which the
|
|
* server will signal its controlling application, using this control, to
|
|
* start using the image frames.
|
|
*
|
|
* The client receives the "ready time" from the server, and will signal
|
|
* its application to start using the frames at this same moment.
|
|
*
|
|
* While this control value is false, applications (on both client and
|
|
* server) should continue to wait, and not use the frames.
|
|
*
|
|
* Once this value becomes true, it means that this is the first frame
|
|
* where the server and its clients have agreed that they will both be
|
|
* synchronised and that applications should begin consuming frames.
|
|
* Thereafter, this control will continue to signal the value true for
|
|
* the rest of the session.
|
|
*
|
|
* \sa SyncMode
|
|
* \sa SyncTimer
|
|
* \sa SyncFrames
|
|
*/
|
|
|
|
/**
|
|
* \var SyncTimer
|
|
* \brief This reports the amount of time, in microseconds, until the "ready
|
|
* time", at which the server and client will signal their controlling
|
|
* applications that the frames are now synchronised and should be
|
|
* used. The value may be refined slightly over time, becoming more precise
|
|
* as the "ready time" approaches.
|
|
*
|
|
* Servers always report this value, whereas clients will omit this control
|
|
* until they have received a message from the server that enables them to
|
|
* calculate it.
|
|
*
|
|
* Normally the value will start positive (the "ready time" is in the
|
|
* future), and decrease towards zero, before becoming negative (the "ready
|
|
* time" has elapsed). So there should be just one frame where the timer
|
|
* value is, or is very close to, zero - the one for which the SyncReady
|
|
* control becomes true. At this moment, the value indicates how closely
|
|
* synchronised the client believes it is with the server.
|
|
*
|
|
* But note that if frames are being dropped, then the "near zero" valued
|
|
* frame, or indeed any other, could be skipped. In these cases the timer
|
|
* value allows an application to deduce that this has happened.
|
|
*
|
|
* \sa SyncMode
|
|
* \sa SyncReady
|
|
* \sa SyncFrames
|
|
*/
|
|
|
|
/**
|
|
* \var SyncFrames
|
|
* \brief The number of frames the server should wait, after enabling
|
|
* SyncModeServer, before signalling (via the SyncReady control) that
|
|
* frames should be used. This therefore determines the "ready time" for
|
|
* all synchronised cameras.
|
|
*
|
|
* This control value should be set only for the device that is to act as
|
|
* the server, before or at the same moment at which SyncModeServer is
|
|
* enabled.
|
|
*
|
|
* \sa SyncMode
|
|
* \sa SyncReady
|
|
* \sa SyncTimer
|
|
*/
|
|
|
|
/**
|
|
* \var CnnOutputTensor
|
|
* \brief This control returns a span of floating point values that represent the
|
|
* output tensors from a Convolutional Neural Network (CNN). The size and
|
|
* format of this array of values is entirely dependent on the neural
|
|
* network used, and further post-processing may need to be performed at
|
|
* the application level to generate the final desired output. This control
|
|
* is agnostic of the hardware or software used to generate the output
|
|
* tensors.
|
|
*
|
|
* The structure of the span is described by the CnnOutputTensorInfo
|
|
* control.
|
|
*
|
|
* \sa CnnOutputTensorInfo
|
|
*/
|
|
|
|
/**
|
|
* \var CnnOutputTensorInfo
|
|
* \brief This control returns the structure of the CnnOutputTensor. This structure
|
|
* takes the following form:
|
|
*
|
|
* constexpr unsigned int NetworkNameLen = 64;
|
|
* constexpr unsigned int MaxNumTensors = 8;
|
|
* constexpr unsigned int MaxNumDimensions = 8;
|
|
*
|
|
* struct CnnOutputTensorInfo {
|
|
* char networkName[NetworkNameLen];
|
|
* uint32_t numTensors;
|
|
* OutputTensorInfo info[MaxNumTensors];
|
|
* uint8_t frameCount;
|
|
* };
|
|
*
|
|
* with
|
|
*
|
|
* struct OutputTensorInfo {
|
|
* uint32_t tensorDataNum;
|
|
* uint32_t numDimensions;
|
|
* uint16_t size[MaxNumDimensions];
|
|
* };
|
|
*
|
|
* networkName is the name of the CNN used,
|
|
* numTensors is the number of output tensors returned,
|
|
* tensorDataNum gives the number of elements in each output tensor,
|
|
* numDimensions gives the dimensionality of each output tensor,
|
|
* size gives the size of each dimension in each output tensor.
|
|
*
|
|
* \sa CnnOutputTensor
|
|
*/
|
|
|
|
/**
|
|
* \var CnnEnableInputTensor
|
|
* \brief Boolean to control if the IPA returns the input tensor used by the CNN
|
|
* to generate the output tensors via the CnnInputTensor control. Because
|
|
* the input tensor may be relatively large, for efficiency reason avoid
|
|
* enabling input tensor output unless required for debugging purposes.
|
|
*
|
|
* \sa CnnInputTensor
|
|
*/
|
|
|
|
/**
|
|
* \var CnnInputTensor
|
|
* \brief This control returns a span of uint8_t pixel values that represent the
|
|
* input tensor for a Convolutional Neural Network (CNN). The size and
|
|
* format of this array of values is entirely dependent on the neural
|
|
* network used, and further post-processing (e.g. pixel normalisations) may
|
|
* need to be performed at the application level to generate the final input
|
|
* image.
|
|
*
|
|
* The structure of the span is described by the CnnInputTensorInfo
|
|
* control.
|
|
*
|
|
* \sa CnnInputTensorInfo
|
|
*/
|
|
|
|
/**
|
|
* \var CnnInputTensorInfo
|
|
* \brief This control returns the structure of the CnnInputTensor. This structure
|
|
* takes the following form:
|
|
*
|
|
* constexpr unsigned int NetworkNameLen = 64;
|
|
*
|
|
* struct CnnInputTensorInfo {
|
|
* char networkName[NetworkNameLen];
|
|
* uint32_t width;
|
|
* uint32_t height;
|
|
* uint32_t numChannels;
|
|
* uint8_t frameCount;
|
|
* };
|
|
*
|
|
* where
|
|
*
|
|
* networkName is the name of the CNN used,
|
|
* width and height are the input tensor image width and height in pixels,
|
|
* numChannels is the number of channels in the input tensor image.
|
|
*
|
|
* \sa CnnInputTensor
|
|
*/
|
|
|
|
/**
|
|
* \var CnnKpiInfo
|
|
* \brief This control returns performance metrics for the CNN processing stage.
|
|
* Two values are returned in this span, the runtime of the CNN/DNN stage
|
|
* and the DSP stage in milliseconds.
|
|
*/
|
|
|
|
} /* namespace rpi */
|
|
|
|
/**
|
|
* \brief Namespace for debug controls
|
|
*/
|
|
namespace debug {
|
|
|
|
} /* namespace debug */
|
|
|
|
|
|
#ifndef __DOXYGEN__
|
|
/*
|
|
* Keep the controls definitions hidden from doxygen as it incorrectly parses
|
|
* them as functions.
|
|
*/
|
|
|
|
extern const Control<bool> AeEnable(AE_ENABLE, "AeEnable", "libcamera", ControlId::Direction::In);
|
|
|
|
extern const std::array<const ControlValue, 3> AeStateValues = {
|
|
static_cast<int32_t>(AeStateIdle),
|
|
static_cast<int32_t>(AeStateSearching),
|
|
static_cast<int32_t>(AeStateConverged),
|
|
};
|
|
extern const std::map<std::string, int32_t> AeStateNameValueMap = {
|
|
{ "AeStateIdle", AeStateIdle },
|
|
{ "AeStateSearching", AeStateSearching },
|
|
{ "AeStateConverged", AeStateConverged },
|
|
};
|
|
extern const Control<int32_t> AeState(AE_STATE, "AeState", "libcamera", ControlId::Direction::Out, AeStateNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 4> AeMeteringModeValues = {
|
|
static_cast<int32_t>(MeteringCentreWeighted),
|
|
static_cast<int32_t>(MeteringSpot),
|
|
static_cast<int32_t>(MeteringMatrix),
|
|
static_cast<int32_t>(MeteringCustom),
|
|
};
|
|
extern const std::map<std::string, int32_t> AeMeteringModeNameValueMap = {
|
|
{ "MeteringCentreWeighted", MeteringCentreWeighted },
|
|
{ "MeteringSpot", MeteringSpot },
|
|
{ "MeteringMatrix", MeteringMatrix },
|
|
{ "MeteringCustom", MeteringCustom },
|
|
};
|
|
extern const Control<int32_t> AeMeteringMode(AE_METERING_MODE, "AeMeteringMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AeMeteringModeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 4> AeConstraintModeValues = {
|
|
static_cast<int32_t>(ConstraintNormal),
|
|
static_cast<int32_t>(ConstraintHighlight),
|
|
static_cast<int32_t>(ConstraintShadows),
|
|
static_cast<int32_t>(ConstraintCustom),
|
|
};
|
|
extern const std::map<std::string, int32_t> AeConstraintModeNameValueMap = {
|
|
{ "ConstraintNormal", ConstraintNormal },
|
|
{ "ConstraintHighlight", ConstraintHighlight },
|
|
{ "ConstraintShadows", ConstraintShadows },
|
|
{ "ConstraintCustom", ConstraintCustom },
|
|
};
|
|
extern const Control<int32_t> AeConstraintMode(AE_CONSTRAINT_MODE, "AeConstraintMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AeConstraintModeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 4> AeExposureModeValues = {
|
|
static_cast<int32_t>(ExposureNormal),
|
|
static_cast<int32_t>(ExposureShort),
|
|
static_cast<int32_t>(ExposureLong),
|
|
static_cast<int32_t>(ExposureCustom),
|
|
};
|
|
extern const std::map<std::string, int32_t> AeExposureModeNameValueMap = {
|
|
{ "ExposureNormal", ExposureNormal },
|
|
{ "ExposureShort", ExposureShort },
|
|
{ "ExposureLong", ExposureLong },
|
|
{ "ExposureCustom", ExposureCustom },
|
|
};
|
|
extern const Control<int32_t> AeExposureMode(AE_EXPOSURE_MODE, "AeExposureMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AeExposureModeNameValueMap);
|
|
|
|
extern const Control<float> ExposureValue(EXPOSURE_VALUE, "ExposureValue", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<int32_t> ExposureTime(EXPOSURE_TIME, "ExposureTime", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 2> ExposureTimeModeValues = {
|
|
static_cast<int32_t>(ExposureTimeModeAuto),
|
|
static_cast<int32_t>(ExposureTimeModeManual),
|
|
};
|
|
extern const std::map<std::string, int32_t> ExposureTimeModeNameValueMap = {
|
|
{ "ExposureTimeModeAuto", ExposureTimeModeAuto },
|
|
{ "ExposureTimeModeManual", ExposureTimeModeManual },
|
|
};
|
|
extern const Control<int32_t> ExposureTimeMode(EXPOSURE_TIME_MODE, "ExposureTimeMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, ExposureTimeModeNameValueMap);
|
|
|
|
extern const Control<float> AnalogueGain(ANALOGUE_GAIN, "AnalogueGain", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 2> AnalogueGainModeValues = {
|
|
static_cast<int32_t>(AnalogueGainModeAuto),
|
|
static_cast<int32_t>(AnalogueGainModeManual),
|
|
};
|
|
extern const std::map<std::string, int32_t> AnalogueGainModeNameValueMap = {
|
|
{ "AnalogueGainModeAuto", AnalogueGainModeAuto },
|
|
{ "AnalogueGainModeManual", AnalogueGainModeManual },
|
|
};
|
|
extern const Control<int32_t> AnalogueGainMode(ANALOGUE_GAIN_MODE, "AnalogueGainMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AnalogueGainModeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 3> AeFlickerModeValues = {
|
|
static_cast<int32_t>(FlickerOff),
|
|
static_cast<int32_t>(FlickerManual),
|
|
static_cast<int32_t>(FlickerAuto),
|
|
};
|
|
extern const std::map<std::string, int32_t> AeFlickerModeNameValueMap = {
|
|
{ "FlickerOff", FlickerOff },
|
|
{ "FlickerManual", FlickerManual },
|
|
{ "FlickerAuto", FlickerAuto },
|
|
};
|
|
extern const Control<int32_t> AeFlickerMode(AE_FLICKER_MODE, "AeFlickerMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AeFlickerModeNameValueMap);
|
|
|
|
extern const Control<int32_t> AeFlickerPeriod(AE_FLICKER_PERIOD, "AeFlickerPeriod", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<int32_t> AeFlickerDetected(AE_FLICKER_DETECTED, "AeFlickerDetected", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const Control<float> Brightness(BRIGHTNESS, "Brightness", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<float> Contrast(CONTRAST, "Contrast", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<float> Lux(LUX, "Lux", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const Control<bool> AwbEnable(AWB_ENABLE, "AwbEnable", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 8> AwbModeValues = {
|
|
static_cast<int32_t>(AwbAuto),
|
|
static_cast<int32_t>(AwbIncandescent),
|
|
static_cast<int32_t>(AwbTungsten),
|
|
static_cast<int32_t>(AwbFluorescent),
|
|
static_cast<int32_t>(AwbIndoor),
|
|
static_cast<int32_t>(AwbDaylight),
|
|
static_cast<int32_t>(AwbCloudy),
|
|
static_cast<int32_t>(AwbCustom),
|
|
};
|
|
extern const std::map<std::string, int32_t> AwbModeNameValueMap = {
|
|
{ "AwbAuto", AwbAuto },
|
|
{ "AwbIncandescent", AwbIncandescent },
|
|
{ "AwbTungsten", AwbTungsten },
|
|
{ "AwbFluorescent", AwbFluorescent },
|
|
{ "AwbIndoor", AwbIndoor },
|
|
{ "AwbDaylight", AwbDaylight },
|
|
{ "AwbCloudy", AwbCloudy },
|
|
{ "AwbCustom", AwbCustom },
|
|
};
|
|
extern const Control<int32_t> AwbMode(AWB_MODE, "AwbMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AwbModeNameValueMap);
|
|
|
|
extern const Control<bool> AwbLocked(AWB_LOCKED, "AwbLocked", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const float, 2>> ColourGains(COLOUR_GAINS, "ColourGains", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<int32_t> ColourTemperature(COLOUR_TEMPERATURE, "ColourTemperature", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const Control<float> Saturation(SATURATION, "Saturation", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const int32_t, 4>> SensorBlackLevels(SENSOR_BLACK_LEVELS, "SensorBlackLevels", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const Control<float> Sharpness(SHARPNESS, "Sharpness", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<int32_t> FocusFoM(FOCUS_FO_M, "FocusFoM", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const float, 9>> ColourCorrectionMatrix(COLOUR_CORRECTION_MATRIX, "ColourCorrectionMatrix", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<Rectangle> ScalerCrop(SCALER_CROP, "ScalerCrop", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<float> DigitalGain(DIGITAL_GAIN, "DigitalGain", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<int64_t> FrameDuration(FRAME_DURATION, "FrameDuration", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const int64_t, 2>> FrameDurationLimits(FRAME_DURATION_LIMITS, "FrameDurationLimits", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<float> SensorTemperature(SENSOR_TEMPERATURE, "SensorTemperature", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const Control<int64_t> SensorTimestamp(SENSOR_TIMESTAMP, "SensorTimestamp", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 3> AfModeValues = {
|
|
static_cast<int32_t>(AfModeManual),
|
|
static_cast<int32_t>(AfModeAuto),
|
|
static_cast<int32_t>(AfModeContinuous),
|
|
};
|
|
extern const std::map<std::string, int32_t> AfModeNameValueMap = {
|
|
{ "AfModeManual", AfModeManual },
|
|
{ "AfModeAuto", AfModeAuto },
|
|
{ "AfModeContinuous", AfModeContinuous },
|
|
};
|
|
extern const Control<int32_t> AfMode(AF_MODE, "AfMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AfModeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 3> AfRangeValues = {
|
|
static_cast<int32_t>(AfRangeNormal),
|
|
static_cast<int32_t>(AfRangeMacro),
|
|
static_cast<int32_t>(AfRangeFull),
|
|
};
|
|
extern const std::map<std::string, int32_t> AfRangeNameValueMap = {
|
|
{ "AfRangeNormal", AfRangeNormal },
|
|
{ "AfRangeMacro", AfRangeMacro },
|
|
{ "AfRangeFull", AfRangeFull },
|
|
};
|
|
extern const Control<int32_t> AfRange(AF_RANGE, "AfRange", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AfRangeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 2> AfSpeedValues = {
|
|
static_cast<int32_t>(AfSpeedNormal),
|
|
static_cast<int32_t>(AfSpeedFast),
|
|
};
|
|
extern const std::map<std::string, int32_t> AfSpeedNameValueMap = {
|
|
{ "AfSpeedNormal", AfSpeedNormal },
|
|
{ "AfSpeedFast", AfSpeedFast },
|
|
};
|
|
extern const Control<int32_t> AfSpeed(AF_SPEED, "AfSpeed", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AfSpeedNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 2> AfMeteringValues = {
|
|
static_cast<int32_t>(AfMeteringAuto),
|
|
static_cast<int32_t>(AfMeteringWindows),
|
|
};
|
|
extern const std::map<std::string, int32_t> AfMeteringNameValueMap = {
|
|
{ "AfMeteringAuto", AfMeteringAuto },
|
|
{ "AfMeteringWindows", AfMeteringWindows },
|
|
};
|
|
extern const Control<int32_t> AfMetering(AF_METERING, "AfMetering", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, AfMeteringNameValueMap);
|
|
|
|
extern const Control<Span<const Rectangle>> AfWindows(AF_WINDOWS, "AfWindows", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 2> AfTriggerValues = {
|
|
static_cast<int32_t>(AfTriggerStart),
|
|
static_cast<int32_t>(AfTriggerCancel),
|
|
};
|
|
extern const std::map<std::string, int32_t> AfTriggerNameValueMap = {
|
|
{ "AfTriggerStart", AfTriggerStart },
|
|
{ "AfTriggerCancel", AfTriggerCancel },
|
|
};
|
|
extern const Control<int32_t> AfTrigger(AF_TRIGGER, "AfTrigger", "libcamera", ControlId::Direction::In, AfTriggerNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 3> AfPauseValues = {
|
|
static_cast<int32_t>(AfPauseImmediate),
|
|
static_cast<int32_t>(AfPauseDeferred),
|
|
static_cast<int32_t>(AfPauseResume),
|
|
};
|
|
extern const std::map<std::string, int32_t> AfPauseNameValueMap = {
|
|
{ "AfPauseImmediate", AfPauseImmediate },
|
|
{ "AfPauseDeferred", AfPauseDeferred },
|
|
{ "AfPauseResume", AfPauseResume },
|
|
};
|
|
extern const Control<int32_t> AfPause(AF_PAUSE, "AfPause", "libcamera", ControlId::Direction::In, AfPauseNameValueMap);
|
|
|
|
extern const Control<float> LensPosition(LENS_POSITION, "LensPosition", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 4> AfStateValues = {
|
|
static_cast<int32_t>(AfStateIdle),
|
|
static_cast<int32_t>(AfStateScanning),
|
|
static_cast<int32_t>(AfStateFocused),
|
|
static_cast<int32_t>(AfStateFailed),
|
|
};
|
|
extern const std::map<std::string, int32_t> AfStateNameValueMap = {
|
|
{ "AfStateIdle", AfStateIdle },
|
|
{ "AfStateScanning", AfStateScanning },
|
|
{ "AfStateFocused", AfStateFocused },
|
|
{ "AfStateFailed", AfStateFailed },
|
|
};
|
|
extern const Control<int32_t> AfState(AF_STATE, "AfState", "libcamera", ControlId::Direction::Out, AfStateNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 3> AfPauseStateValues = {
|
|
static_cast<int32_t>(AfPauseStateRunning),
|
|
static_cast<int32_t>(AfPauseStatePausing),
|
|
static_cast<int32_t>(AfPauseStatePaused),
|
|
};
|
|
extern const std::map<std::string, int32_t> AfPauseStateNameValueMap = {
|
|
{ "AfPauseStateRunning", AfPauseStateRunning },
|
|
{ "AfPauseStatePausing", AfPauseStatePausing },
|
|
{ "AfPauseStatePaused", AfPauseStatePaused },
|
|
};
|
|
extern const Control<int32_t> AfPauseState(AF_PAUSE_STATE, "AfPauseState", "libcamera", ControlId::Direction::Out, AfPauseStateNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 5> HdrModeValues = {
|
|
static_cast<int32_t>(HdrModeOff),
|
|
static_cast<int32_t>(HdrModeMultiExposureUnmerged),
|
|
static_cast<int32_t>(HdrModeMultiExposure),
|
|
static_cast<int32_t>(HdrModeSingleExposure),
|
|
static_cast<int32_t>(HdrModeNight),
|
|
};
|
|
extern const std::map<std::string, int32_t> HdrModeNameValueMap = {
|
|
{ "HdrModeOff", HdrModeOff },
|
|
{ "HdrModeMultiExposureUnmerged", HdrModeMultiExposureUnmerged },
|
|
{ "HdrModeMultiExposure", HdrModeMultiExposure },
|
|
{ "HdrModeSingleExposure", HdrModeSingleExposure },
|
|
{ "HdrModeNight", HdrModeNight },
|
|
};
|
|
extern const Control<int32_t> HdrMode(HDR_MODE, "HdrMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, HdrModeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 4> HdrChannelValues = {
|
|
static_cast<int32_t>(HdrChannelNone),
|
|
static_cast<int32_t>(HdrChannelShort),
|
|
static_cast<int32_t>(HdrChannelMedium),
|
|
static_cast<int32_t>(HdrChannelLong),
|
|
};
|
|
extern const std::map<std::string, int32_t> HdrChannelNameValueMap = {
|
|
{ "HdrChannelNone", HdrChannelNone },
|
|
{ "HdrChannelShort", HdrChannelShort },
|
|
{ "HdrChannelMedium", HdrChannelMedium },
|
|
{ "HdrChannelLong", HdrChannelLong },
|
|
};
|
|
extern const Control<int32_t> HdrChannel(HDR_CHANNEL, "HdrChannel", "libcamera", ControlId::Direction::Out, HdrChannelNameValueMap);
|
|
|
|
extern const Control<float> Gamma(GAMMA, "Gamma", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<bool> DebugMetadataEnable(DEBUG_METADATA_ENABLE, "DebugMetadataEnable", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<int64_t> FrameWallClock(FRAME_WALL_CLOCK, "FrameWallClock", "libcamera", ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 5> WdrModeValues = {
|
|
static_cast<int32_t>(WdrOff),
|
|
static_cast<int32_t>(WdrLinear),
|
|
static_cast<int32_t>(WdrPower),
|
|
static_cast<int32_t>(WdrExponential),
|
|
static_cast<int32_t>(WdrHistogramEqualization),
|
|
};
|
|
extern const std::map<std::string, int32_t> WdrModeNameValueMap = {
|
|
{ "WdrOff", WdrOff },
|
|
{ "WdrLinear", WdrLinear },
|
|
{ "WdrPower", WdrPower },
|
|
{ "WdrExponential", WdrExponential },
|
|
{ "WdrHistogramEqualization", WdrHistogramEqualization },
|
|
};
|
|
extern const Control<int32_t> WdrMode(WDR_MODE, "WdrMode", "libcamera", ControlId::Direction::In | ControlId::Direction::Out, WdrModeNameValueMap);
|
|
|
|
extern const Control<float> WdrStrength(WDR_STRENGTH, "WdrStrength", "libcamera", ControlId::Direction::In);
|
|
|
|
extern const Control<float> WdrMaxBrightPixels(WDR_MAX_BRIGHT_PIXELS, "WdrMaxBrightPixels", "libcamera", ControlId::Direction::In);
|
|
|
|
extern const Control<bool> LensDewarpEnable(LENS_DEWARP_ENABLE, "LensDewarpEnable", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<bool> LensShadingCorrectionEnable(LENS_SHADING_CORRECTION_ENABLE, "LensShadingCorrectionEnable", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<float> Hue(HUE, "Hue", "libcamera", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
|
|
|
|
namespace draft {
|
|
|
|
extern const std::array<const ControlValue, 3> AePrecaptureTriggerValues = {
|
|
static_cast<int32_t>(AePrecaptureTriggerIdle),
|
|
static_cast<int32_t>(AePrecaptureTriggerStart),
|
|
static_cast<int32_t>(AePrecaptureTriggerCancel),
|
|
};
|
|
extern const std::map<std::string, int32_t> AePrecaptureTriggerNameValueMap = {
|
|
{ "AePrecaptureTriggerIdle", AePrecaptureTriggerIdle },
|
|
{ "AePrecaptureTriggerStart", AePrecaptureTriggerStart },
|
|
{ "AePrecaptureTriggerCancel", AePrecaptureTriggerCancel },
|
|
};
|
|
extern const Control<int32_t> AePrecaptureTrigger(AE_PRECAPTURE_TRIGGER, "AePrecaptureTrigger", "draft", ControlId::Direction::In | ControlId::Direction::Out, AePrecaptureTriggerNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 5> NoiseReductionModeValues = {
|
|
static_cast<int32_t>(NoiseReductionModeOff),
|
|
static_cast<int32_t>(NoiseReductionModeFast),
|
|
static_cast<int32_t>(NoiseReductionModeHighQuality),
|
|
static_cast<int32_t>(NoiseReductionModeMinimal),
|
|
static_cast<int32_t>(NoiseReductionModeZSL),
|
|
};
|
|
extern const std::map<std::string, int32_t> NoiseReductionModeNameValueMap = {
|
|
{ "NoiseReductionModeOff", NoiseReductionModeOff },
|
|
{ "NoiseReductionModeFast", NoiseReductionModeFast },
|
|
{ "NoiseReductionModeHighQuality", NoiseReductionModeHighQuality },
|
|
{ "NoiseReductionModeMinimal", NoiseReductionModeMinimal },
|
|
{ "NoiseReductionModeZSL", NoiseReductionModeZSL },
|
|
};
|
|
extern const Control<int32_t> NoiseReductionMode(NOISE_REDUCTION_MODE, "NoiseReductionMode", "draft", ControlId::Direction::In | ControlId::Direction::Out, NoiseReductionModeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 3> ColorCorrectionAberrationModeValues = {
|
|
static_cast<int32_t>(ColorCorrectionAberrationOff),
|
|
static_cast<int32_t>(ColorCorrectionAberrationFast),
|
|
static_cast<int32_t>(ColorCorrectionAberrationHighQuality),
|
|
};
|
|
extern const std::map<std::string, int32_t> ColorCorrectionAberrationModeNameValueMap = {
|
|
{ "ColorCorrectionAberrationOff", ColorCorrectionAberrationOff },
|
|
{ "ColorCorrectionAberrationFast", ColorCorrectionAberrationFast },
|
|
{ "ColorCorrectionAberrationHighQuality", ColorCorrectionAberrationHighQuality },
|
|
};
|
|
extern const Control<int32_t> ColorCorrectionAberrationMode(COLOR_CORRECTION_ABERRATION_MODE, "ColorCorrectionAberrationMode", "draft", ControlId::Direction::In | ControlId::Direction::Out, ColorCorrectionAberrationModeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 4> AwbStateValues = {
|
|
static_cast<int32_t>(AwbStateInactive),
|
|
static_cast<int32_t>(AwbStateSearching),
|
|
static_cast<int32_t>(AwbConverged),
|
|
static_cast<int32_t>(AwbLocked),
|
|
};
|
|
extern const std::map<std::string, int32_t> AwbStateNameValueMap = {
|
|
{ "AwbStateInactive", AwbStateInactive },
|
|
{ "AwbStateSearching", AwbStateSearching },
|
|
{ "AwbConverged", AwbConverged },
|
|
{ "AwbLocked", AwbLocked },
|
|
};
|
|
extern const Control<int32_t> AwbState(AWB_STATE, "AwbState", "draft", ControlId::Direction::Out, AwbStateNameValueMap);
|
|
|
|
extern const Control<int64_t> SensorRollingShutterSkew(SENSOR_ROLLING_SHUTTER_SKEW, "SensorRollingShutterSkew", "draft", ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 2> LensShadingMapModeValues = {
|
|
static_cast<int32_t>(LensShadingMapModeOff),
|
|
static_cast<int32_t>(LensShadingMapModeOn),
|
|
};
|
|
extern const std::map<std::string, int32_t> LensShadingMapModeNameValueMap = {
|
|
{ "LensShadingMapModeOff", LensShadingMapModeOff },
|
|
{ "LensShadingMapModeOn", LensShadingMapModeOn },
|
|
};
|
|
extern const Control<int32_t> LensShadingMapMode(LENS_SHADING_MAP_MODE, "LensShadingMapMode", "draft", ControlId::Direction::In | ControlId::Direction::Out, LensShadingMapModeNameValueMap);
|
|
|
|
extern const Control<int32_t> PipelineDepth(PIPELINE_DEPTH, "PipelineDepth", "draft", ControlId::Direction::Out);
|
|
|
|
extern const Control<int32_t> MaxLatency(MAX_LATENCY, "MaxLatency", "draft", ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 6> TestPatternModeValues = {
|
|
static_cast<int32_t>(TestPatternModeOff),
|
|
static_cast<int32_t>(TestPatternModeSolidColor),
|
|
static_cast<int32_t>(TestPatternModeColorBars),
|
|
static_cast<int32_t>(TestPatternModeColorBarsFadeToGray),
|
|
static_cast<int32_t>(TestPatternModePn9),
|
|
static_cast<int32_t>(TestPatternModeCustom1),
|
|
};
|
|
extern const std::map<std::string, int32_t> TestPatternModeNameValueMap = {
|
|
{ "TestPatternModeOff", TestPatternModeOff },
|
|
{ "TestPatternModeSolidColor", TestPatternModeSolidColor },
|
|
{ "TestPatternModeColorBars", TestPatternModeColorBars },
|
|
{ "TestPatternModeColorBarsFadeToGray", TestPatternModeColorBarsFadeToGray },
|
|
{ "TestPatternModePn9", TestPatternModePn9 },
|
|
{ "TestPatternModeCustom1", TestPatternModeCustom1 },
|
|
};
|
|
extern const Control<int32_t> TestPatternMode(TEST_PATTERN_MODE, "TestPatternMode", "draft", ControlId::Direction::In | ControlId::Direction::Out, TestPatternModeNameValueMap);
|
|
|
|
extern const std::array<const ControlValue, 3> FaceDetectModeValues = {
|
|
static_cast<int32_t>(FaceDetectModeOff),
|
|
static_cast<int32_t>(FaceDetectModeSimple),
|
|
static_cast<int32_t>(FaceDetectModeFull),
|
|
};
|
|
extern const std::map<std::string, int32_t> FaceDetectModeNameValueMap = {
|
|
{ "FaceDetectModeOff", FaceDetectModeOff },
|
|
{ "FaceDetectModeSimple", FaceDetectModeSimple },
|
|
{ "FaceDetectModeFull", FaceDetectModeFull },
|
|
};
|
|
extern const Control<int32_t> FaceDetectMode(FACE_DETECT_MODE, "FaceDetectMode", "draft", ControlId::Direction::In | ControlId::Direction::Out, FaceDetectModeNameValueMap);
|
|
|
|
extern const Control<Span<const Rectangle>> FaceDetectFaceRectangles(FACE_DETECT_FACE_RECTANGLES, "FaceDetectFaceRectangles", "draft", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const uint8_t>> FaceDetectFaceScores(FACE_DETECT_FACE_SCORES, "FaceDetectFaceScores", "draft", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const Point>> FaceDetectFaceLandmarks(FACE_DETECT_FACE_LANDMARKS, "FaceDetectFaceLandmarks", "draft", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const int32_t>> FaceDetectFaceIds(FACE_DETECT_FACE_IDS, "FaceDetectFaceIds", "draft", ControlId::Direction::Out);
|
|
|
|
|
|
|
|
} /* namespace draft */
|
|
|
|
namespace rpi {
|
|
|
|
extern const Control<bool> StatsOutputEnable(STATS_OUTPUT_ENABLE, "StatsOutputEnable", "rpi", ControlId::Direction::In | ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const uint8_t>> Bcm2835StatsOutput(BCM2835_STATS_OUTPUT, "Bcm2835StatsOutput", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const Rectangle>> ScalerCrops(SCALER_CROPS, "ScalerCrops", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const uint8_t>> PispStatsOutput(PISP_STATS_OUTPUT, "PispStatsOutput", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const std::array<const ControlValue, 3> SyncModeValues = {
|
|
static_cast<int32_t>(SyncModeOff),
|
|
static_cast<int32_t>(SyncModeServer),
|
|
static_cast<int32_t>(SyncModeClient),
|
|
};
|
|
extern const std::map<std::string, int32_t> SyncModeNameValueMap = {
|
|
{ "SyncModeOff", SyncModeOff },
|
|
{ "SyncModeServer", SyncModeServer },
|
|
{ "SyncModeClient", SyncModeClient },
|
|
};
|
|
extern const Control<int32_t> SyncMode(SYNC_MODE, "SyncMode", "rpi", ControlId::Direction::In, SyncModeNameValueMap);
|
|
|
|
extern const Control<bool> SyncReady(SYNC_READY, "SyncReady", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const Control<int64_t> SyncTimer(SYNC_TIMER, "SyncTimer", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const Control<int32_t> SyncFrames(SYNC_FRAMES, "SyncFrames", "rpi", ControlId::Direction::In);
|
|
|
|
extern const Control<Span<const float>> CnnOutputTensor(CNN_OUTPUT_TENSOR, "CnnOutputTensor", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const uint8_t>> CnnOutputTensorInfo(CNN_OUTPUT_TENSOR_INFO, "CnnOutputTensorInfo", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const Control<bool> CnnEnableInputTensor(CNN_ENABLE_INPUT_TENSOR, "CnnEnableInputTensor", "rpi", ControlId::Direction::In);
|
|
|
|
extern const Control<Span<const uint8_t>> CnnInputTensor(CNN_INPUT_TENSOR, "CnnInputTensor", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const uint8_t>> CnnInputTensorInfo(CNN_INPUT_TENSOR_INFO, "CnnInputTensorInfo", "rpi", ControlId::Direction::Out);
|
|
|
|
extern const Control<Span<const int32_t, 2>> CnnKpiInfo(CNN_KPI_INFO, "CnnKpiInfo", "rpi", ControlId::Direction::Out);
|
|
|
|
|
|
|
|
} /* namespace rpi */
|
|
|
|
namespace debug {
|
|
|
|
|
|
|
|
} /* namespace debug */
|
|
|
|
#endif /* __DOXYGEN__ */
|
|
|
|
/**
|
|
* \brief List of all supported libcamera controls
|
|
*
|
|
* Unless otherwise stated, all controls are bi-directional, i.e. they can be
|
|
* set through Request::controls() and returned out through Request::metadata().
|
|
*/
|
|
extern const ControlIdMap controls {
|
|
{ AE_ENABLE, &AeEnable },
|
|
{ AE_STATE, &AeState },
|
|
{ AE_METERING_MODE, &AeMeteringMode },
|
|
{ AE_CONSTRAINT_MODE, &AeConstraintMode },
|
|
{ AE_EXPOSURE_MODE, &AeExposureMode },
|
|
{ EXPOSURE_VALUE, &ExposureValue },
|
|
{ EXPOSURE_TIME, &ExposureTime },
|
|
{ EXPOSURE_TIME_MODE, &ExposureTimeMode },
|
|
{ ANALOGUE_GAIN, &AnalogueGain },
|
|
{ ANALOGUE_GAIN_MODE, &AnalogueGainMode },
|
|
{ AE_FLICKER_MODE, &AeFlickerMode },
|
|
{ AE_FLICKER_PERIOD, &AeFlickerPeriod },
|
|
{ AE_FLICKER_DETECTED, &AeFlickerDetected },
|
|
{ BRIGHTNESS, &Brightness },
|
|
{ CONTRAST, &Contrast },
|
|
{ LUX, &Lux },
|
|
{ AWB_ENABLE, &AwbEnable },
|
|
{ AWB_MODE, &AwbMode },
|
|
{ AWB_LOCKED, &AwbLocked },
|
|
{ COLOUR_GAINS, &ColourGains },
|
|
{ COLOUR_TEMPERATURE, &ColourTemperature },
|
|
{ SATURATION, &Saturation },
|
|
{ SENSOR_BLACK_LEVELS, &SensorBlackLevels },
|
|
{ SHARPNESS, &Sharpness },
|
|
{ FOCUS_FO_M, &FocusFoM },
|
|
{ COLOUR_CORRECTION_MATRIX, &ColourCorrectionMatrix },
|
|
{ SCALER_CROP, &ScalerCrop },
|
|
{ DIGITAL_GAIN, &DigitalGain },
|
|
{ FRAME_DURATION, &FrameDuration },
|
|
{ FRAME_DURATION_LIMITS, &FrameDurationLimits },
|
|
{ SENSOR_TEMPERATURE, &SensorTemperature },
|
|
{ SENSOR_TIMESTAMP, &SensorTimestamp },
|
|
{ AF_MODE, &AfMode },
|
|
{ AF_RANGE, &AfRange },
|
|
{ AF_SPEED, &AfSpeed },
|
|
{ AF_METERING, &AfMetering },
|
|
{ AF_WINDOWS, &AfWindows },
|
|
{ AF_TRIGGER, &AfTrigger },
|
|
{ AF_PAUSE, &AfPause },
|
|
{ LENS_POSITION, &LensPosition },
|
|
{ AF_STATE, &AfState },
|
|
{ AF_PAUSE_STATE, &AfPauseState },
|
|
{ HDR_MODE, &HdrMode },
|
|
{ HDR_CHANNEL, &HdrChannel },
|
|
{ GAMMA, &Gamma },
|
|
{ DEBUG_METADATA_ENABLE, &DebugMetadataEnable },
|
|
{ FRAME_WALL_CLOCK, &FrameWallClock },
|
|
{ WDR_MODE, &WdrMode },
|
|
{ WDR_STRENGTH, &WdrStrength },
|
|
{ WDR_MAX_BRIGHT_PIXELS, &WdrMaxBrightPixels },
|
|
{ LENS_DEWARP_ENABLE, &LensDewarpEnable },
|
|
{ LENS_SHADING_CORRECTION_ENABLE, &LensShadingCorrectionEnable },
|
|
{ HUE, &Hue },
|
|
{ draft::AE_PRECAPTURE_TRIGGER, &draft::AePrecaptureTrigger },
|
|
{ draft::NOISE_REDUCTION_MODE, &draft::NoiseReductionMode },
|
|
{ draft::COLOR_CORRECTION_ABERRATION_MODE, &draft::ColorCorrectionAberrationMode },
|
|
{ draft::AWB_STATE, &draft::AwbState },
|
|
{ draft::SENSOR_ROLLING_SHUTTER_SKEW, &draft::SensorRollingShutterSkew },
|
|
{ draft::LENS_SHADING_MAP_MODE, &draft::LensShadingMapMode },
|
|
{ draft::PIPELINE_DEPTH, &draft::PipelineDepth },
|
|
{ draft::MAX_LATENCY, &draft::MaxLatency },
|
|
{ draft::TEST_PATTERN_MODE, &draft::TestPatternMode },
|
|
{ draft::FACE_DETECT_MODE, &draft::FaceDetectMode },
|
|
{ draft::FACE_DETECT_FACE_RECTANGLES, &draft::FaceDetectFaceRectangles },
|
|
{ draft::FACE_DETECT_FACE_SCORES, &draft::FaceDetectFaceScores },
|
|
{ draft::FACE_DETECT_FACE_LANDMARKS, &draft::FaceDetectFaceLandmarks },
|
|
{ draft::FACE_DETECT_FACE_IDS, &draft::FaceDetectFaceIds },
|
|
{ rpi::STATS_OUTPUT_ENABLE, &rpi::StatsOutputEnable },
|
|
{ rpi::BCM2835_STATS_OUTPUT, &rpi::Bcm2835StatsOutput },
|
|
{ rpi::SCALER_CROPS, &rpi::ScalerCrops },
|
|
{ rpi::PISP_STATS_OUTPUT, &rpi::PispStatsOutput },
|
|
{ rpi::SYNC_MODE, &rpi::SyncMode },
|
|
{ rpi::SYNC_READY, &rpi::SyncReady },
|
|
{ rpi::SYNC_TIMER, &rpi::SyncTimer },
|
|
{ rpi::SYNC_FRAMES, &rpi::SyncFrames },
|
|
{ rpi::CNN_OUTPUT_TENSOR, &rpi::CnnOutputTensor },
|
|
{ rpi::CNN_OUTPUT_TENSOR_INFO, &rpi::CnnOutputTensorInfo },
|
|
{ rpi::CNN_ENABLE_INPUT_TENSOR, &rpi::CnnEnableInputTensor },
|
|
{ rpi::CNN_INPUT_TENSOR, &rpi::CnnInputTensor },
|
|
{ rpi::CNN_INPUT_TENSOR_INFO, &rpi::CnnInputTensorInfo },
|
|
{ rpi::CNN_KPI_INFO, &rpi::CnnKpiInfo },
|
|
};
|
|
|
|
} /* namespace controls */
|
|
|
|
} /* namespace libcamera */ |