irs.h

Go to the documentation of this file.

/**
 * @file irs.h
 * @brief HID IR sensor (irs) service IPC wrapper.
 * @author yellows8
 * @copyright libnx Authors
 */
#pragma once
 
#include "../types.h"
#include "../sf/service.h"
#include "../services/hid.h"
 
#define IRS_MAX_CAMERAS 0x9
 
/// IrCameraStatus
typedef enum {
    IrsIrCameraStatus_Available   = 0,    ///< Available
    IrsIrCameraStatus_Unsupported = 1,    ///< Unsupported
    IrsIrCameraStatus_Unconnected = 2,    ///< Unconnected
} IrsIrCameraStatus;
 
/// IrCameraInternalStatus
typedef enum {
    IrsIrCameraInternalStatus_Stopped                  = 0,        ///< Stopped
    IrsIrCameraInternalStatus_FirmwareUpdateNeeded     = 1,        ///< FirmwareUpdateNeeded
    IrsIrCameraInternalStatus_Unknown2                 = 2,        ///< Unknown
    IrsIrCameraInternalStatus_Unknown3                 = 3,        ///< Unknown
    IrsIrCameraInternalStatus_Unknown4                 = 4,        ///< Unknown
    IrsIrCameraInternalStatus_FirmwareVersionRequested = 5,        ///< FirmwareVersionRequested
    IrsIrCameraInternalStatus_FirmwareVersionIsInvalid = 6,        ///< FirmwareVersionIsInvalid
    IrsIrCameraInternalStatus_Ready                    = 7,        ///< [4.0.0+] Ready
    IrsIrCameraInternalStatus_Setting                  = 8,        ///< [4.0.0+] Setting
} IrsIrCameraInternalStatus;
 
/// IrSensorMode
typedef enum {
    IrsIrSensorMode_None                   = 0,    ///< None
    IrsIrSensorMode_MomentProcessor        = 1,    ///< MomentProcessor
    IrsIrSensorMode_ClusteringProcessor    = 2,    ///< ClusteringProcessor
    IrsIrSensorMode_ImageTransferProcessor = 3,    ///< ImageTransferProcessor
    IrsIrSensorMode_PointingProcessor      = 4,    ///< PointingProcessor
    IrsIrSensorMode_TeraPluginProcessor    = 5,    ///< TeraPluginProcessor
    IrsIrSensorMode_IrLedProcessor         = 6,    ///< IrLedProcessor (doesn't apply to IrsDeviceFormat::ir_sensor_mode)
} IrsIrSensorMode;
 
/// ImageProcessorStatus
typedef enum {
    IrsImageProcessorStatus_Stopped = 0,           ///< Stopped
    IrsImageProcessorStatus_Running = 1,           ///< Running
} IrsImageProcessorStatus;
 
/// ImageTransferProcessorFormat. IR Sensor image resolution.
typedef enum {
    IrsImageTransferProcessorFormat_320x240  = 0,  ///< 320x240
    IrsImageTransferProcessorFormat_160x120  = 1,  ///< 160x120
    IrsImageTransferProcessorFormat_80x60    = 2,  ///< 80x60
    IrsImageTransferProcessorFormat_40x30    = 3,  ///< [4.0.0+] 40x30
    IrsImageTransferProcessorFormat_20x15    = 4,  ///< [4.0.0+] 20x15
} IrsImageTransferProcessorFormat;
 
/// AdaptiveClusteringMode
typedef enum {
    IrsAdaptiveClusteringMode_StaticFov    = 0,  ///< StaticFov
    IrsAdaptiveClusteringMode_DynamicFov   = 1,  ///< DynamicFov
} IrsAdaptiveClusteringMode;
 
/// AdaptiveClusteringTargetDistance
typedef enum {
    IrsAdaptiveClusteringTargetDistance_Near   = 0,   ///< Near
    IrsAdaptiveClusteringTargetDistance_Middle = 1,   ///< Middle
    IrsAdaptiveClusteringTargetDistance_Far    = 2,   ///< Far
} IrsAdaptiveClusteringTargetDistance;
 
/// HandAnalysisMode
typedef enum {
    IrsHandAnalysisMode_Silhouette         = 1,   ///< Silhouette
    IrsHandAnalysisMode_Image              = 2,   ///< Image
    IrsHandAnalysisMode_SilhouetteAndImage = 3,   ///< SilhouetteAndImage
    IrsHandAnalysisMode_SilhouetteOnly     = 4,   ///< [4.0.0+] SilhouetteOnly
} IrsHandAnalysisMode;
 
/// Internal validation callblack.
typedef bool (*IrsValidationCb)(void* userdata, void* arg);
 
/// IrCameraHandle
typedef struct {
    u8 player_number;       ///< PlayerNumber
    u8 device_type;         ///< DeviceType
    u8 reserved[0x2];       ///< Reserved
} IrsIrCameraHandle;
 
/// PackedMcuVersion
typedef struct {
    u16 major_version;      ///< MajorVersion
    u16 minor_version;      ///< MinorVersion
} IrsPackedMcuVersion;
 
/// PackedFunctionLevel
typedef struct {
    u8 ir_sensor_function_level;  ///< IrSensorFunctionLevel
    u8 reserved[0x3];             ///< Reserved
} IrsPackedFunctionLevel;
 
/// Rect
typedef struct {
    s16 x;                                      ///< X
    s16 y;                                      ///< Y
    s16 width;                                  ///< Width
    s16 height;                                 ///< Height
} IrsRect;
 
/// IrsMomentProcessorConfig
typedef struct {
    u64 exposure_time;                          ///< IR Sensor exposure time in nanoseconds.
    u32 light_target;                           ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u32 gain;                                   ///< IR sensor signal's digital gain.
    u8 is_negative_image_used;                  ///< Inverts the colors of the captured image. 0: Normal image, 1: Negative image.
    u8 reserved[0x7];                           ///< Reserved.
    IrsRect window_of_interest;                 ///< WindowOfInterest
    u32 preprocess;                             ///< Preprocess
    u32 preprocess_intensity_threshold;         ///< PreprocessIntensityThreshold
} IrsMomentProcessorConfig;
 
/// PackedMomentProcessorConfig
typedef struct {
    u64 exposure_time;                          ///< IR Sensor exposure time in nanoseconds.
    u8 light_target;                            ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u8 gain;                                    ///< IR sensor signal's digital gain.
    u8 is_negative_image_used;                  ///< Inverts the colors of the captured image. 0: Normal image, 1: Negative image.
    u8 reserved[0x5];                           ///< Reserved.
    IrsRect window_of_interest;                 ///< WindowOfInterest
    IrsPackedMcuVersion required_mcu_version;   ///< RequiredMcuVersion
    u8 preprocess;                              ///< Preprocess
    u8 preprocess_intensity_threshold;          ///< PreprocessIntensityThreshold
    u8 reserved2[0x2];                          ///< Reserved.
} IrsPackedMomentProcessorConfig;
 
/// ClusteringProcessorConfig
typedef struct {
    u64 exposure_time;                          ///< IR Sensor exposure time in nanoseconds.
    u32 light_target;                           ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u32 gain;                                   ///< IR sensor signal's digital gain.
    u8 is_negative_image_used;                  ///< Inverts the colors of the captured image. 0: Normal image, 1: Negative image.
    u8 reserved[0x7];                           ///< Reserved.
    IrsRect window_of_interest;                 ///< WindowOfInterest
    u32 object_pixel_count_min;                 ///< ObjectPixelCountMin
    u32 object_pixel_count_max;                 ///< ObjectPixelCountMax
    u32 object_intensity_min;                   ///< ObjectIntensityMin
    u8 is_external_light_filter_enabled;        ///< IsExternalLightFilterEnabled
} IrsClusteringProcessorConfig;
 
/// PackedClusteringProcessorConfig
typedef struct {
    u64 exposure_time;                          ///< IR Sensor exposure time in nanoseconds.
    u8 light_target;                            ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u8 gain;                                    ///< IR sensor signal's digital gain.
    u8 is_negative_image_used;                  ///< Inverts the colors of the captured image. 0: Normal image, 1: Negative image.
    u8 reserved[0x5];                           ///< Reserved.
    IrsRect window_of_interest;                 ///< WindowOfInterest
    IrsPackedMcuVersion required_mcu_version;   ///< RequiredMcuVersion
    u32 object_pixel_count_min;                 ///< ObjectPixelCountMin
    u32 object_pixel_count_max;                 ///< ObjectPixelCountMax
    u8 object_intensity_min;                    ///< ObjectIntensityMin
    u8 is_external_light_filter_enabled;        ///< IsExternalLightFilterEnabled
    u8 reserved2[0x2];                          ///< Reserved.
} IrsPackedClusteringProcessorConfig;
 
/// ImageTransferProcessorConfig
typedef struct {
    u64 exposure_time;          ///< IR Sensor exposure time in nanoseconds.
    u32 light_target;           ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u32 gain;                   ///< IR sensor signal's digital gain.
    u8 is_negative_image_used;  ///< Inverts the colors of the captured image. 0: Normal image, 1: Negative image.
    u8 reserved[0x7];           ///< Reserved.
    u32 format;                 ///< \ref IrsImageTransferProcessorFormat
} IrsImageTransferProcessorConfig;
 
/// ImageTransferProcessorExConfig
typedef struct {
    u64 exposure_time;                          ///< IR Sensor exposure time in nanoseconds.
    u32 light_target;                           ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u32 gain;                                   ///< IR sensor signal's digital gain.
    u8 is_negative_image_used;                  ///< Inverts the colors of the captured image. 0: Normal image, 1: Negative image.
    u8 reserved[0x7];                           ///< Reserved.
    u32 orig_format;                            ///< OrigFormat \ref IrsImageTransferProcessorFormat
    u32 trimming_format;                        ///< TrimmingFormat \ref IrsImageTransferProcessorFormat
    u16 trimming_start_x;                       ///< TrimmingStartX
    u16 trimming_start_y;                       ///< TrimmingStartY
    u8 is_external_light_filter_enabled;        ///< IsExternalLightFilterEnabled
} IrsImageTransferProcessorExConfig;
 
/// PackedImageTransferProcessorConfig
typedef struct {
    u64 exposure_time;                          ///< IR Sensor exposure time in nanoseconds.
    u8 light_target;                            ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u8 gain;                                    ///< IR sensor signal's digital gain.
    u8 is_negative_image_used;                  ///< Inverts the colors of the captured image. 0: Normal image, 1: Negative image.
    u8 reserved[0x5];                           ///< Reserved.
    IrsPackedMcuVersion required_mcu_version;   ///< RequiredMcuVersion
    u8 format;                                  ///< \ref IrsImageTransferProcessorFormat
    u8 reserved2[0x3];                          ///< Reserved.
} IrsPackedImageTransferProcessorConfig;
 
/// PackedImageTransferProcessorExConfig
typedef struct {
    u64 exposure_time;                          ///< IR Sensor exposure time in nanoseconds.
    u8 light_target;                            ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u8 gain;                                    ///< IR sensor signal's digital gain.
    u8 is_negative_image_used;                  ///< Inverts the colors of the captured image. 0: Normal image, 1: Negative image.
    u8 reserved[0x5];                           ///< Reserved.
    IrsPackedMcuVersion required_mcu_version;   ///< RequiredMcuVersion
    u8 orig_format;                             ///< OrigFormat \ref IrsImageTransferProcessorFormat
    u8 trimming_format;                         ///< TrimmingFormat \ref IrsImageTransferProcessorFormat
    u16 trimming_start_x;                       ///< TrimmingStartX
    u16 trimming_start_y;                       ///< TrimmingStartY
    u8 is_external_light_filter_enabled;        ///< IsExternalLightFilterEnabled
    u8 reserved2[0x5];                          ///< Reserved.
} IrsPackedImageTransferProcessorExConfig;
 
/// ImageTransferProcessorState
typedef struct {
    u64 sampling_number;        ///< SamplingNumber
    u32 ambient_noise_level;    ///< AmbientNoiseLevel
    u8 reserved[0x4];           ///< Reserved
} IrsImageTransferProcessorState;
 
/// PackedPointingProcessorConfig
typedef struct {
    IrsRect window_of_interest;                ///< WindowOfInterest
    IrsPackedMcuVersion required_mcu_version;  ///< RequiredMcuVersion
} IrsPackedPointingProcessorConfig;
 
/// TeraPluginProcessorConfig
typedef struct {
    u8 mode;                                   ///< Mode
    u8 unk_x1;                                 ///< [6.0.0+] Unknown
    u8 unk_x2;                                 ///< [6.0.0+] Unknown
    u8 unk_x3;                                 ///< [6.0.0+] Unknown
} IrsTeraPluginProcessorConfig;
 
/// PackedTeraPluginProcessorConfig
typedef struct {
    IrsPackedMcuVersion required_mcu_version;  ///< RequiredMcuVersion
    u8 mode;                                   ///< Mode
    u8 unk_x5;                                 ///< [6.0.0+] This is set to 0x2 | (IrsTeraPluginProcessorConfig::unk_x1 << 7).
    u8 unk_x6;                                 ///< [6.0.0+] IrsTeraPluginProcessorConfig::unk_x2
    u8 unk_x7;                                 ///< [6.0.0+] IrsTeraPluginProcessorConfig::unk_x3
} IrsPackedTeraPluginProcessorConfig;
 
/// IrLedProcessorConfig
typedef struct {
    u32 light_target;                          ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
} IrsIrLedProcessorConfig;
 
/// PackedIrLedProcessorConfig
typedef struct {
    IrsPackedMcuVersion required_mcu_version;  ///< RequiredMcuVersion
    u8 light_target;                           ///< Controls the IR leds. 0: All leds, 1: Bright group, 2: Dim group, 3: None.
    u8 pad[0x3];                               ///< Padding
} IrsPackedIrLedProcessorConfig;
 
/// AdaptiveClusteringProcessorConfig
typedef struct {
    u32 mode;                                  ///< \ref IrsAdaptiveClusteringMode
    u32 target_distance;                       ///< [6.0.0+] \ref IrsAdaptiveClusteringTargetDistance
} IrsAdaptiveClusteringProcessorConfig;
 
/// HandAnalysisConfig
typedef struct {
    u32 mode;                                  ///< \ref IrsHandAnalysisMode
} IrsHandAnalysisConfig;
 
/// MomentStatistic
typedef struct {
    float average_intensity;              ///< AverageIntensity
    float centroid_x;                     ///< CentroidX
    float centroid_y;                     ///< CentroidY
} IrsMomentStatistic;
 
/// MomentProcessorState
typedef struct {
    s64 sampling_number;                  ///< SamplingNumber
    u64 timestamp;                        ///< TimeStamp
 
    u32 ambient_noise_level;              ///< AmbientNoiseLevel
    u8 reserved[0x4];                     ///< Reserved
    IrsMomentStatistic statistic[0x30];   ///< \ref IrsMomentStatistic
} IrsMomentProcessorState;
 
/// ClusteringData
typedef struct {
    float average_intensity; ///< AverageIntensity
    float centroid_x;        ///< CentroidX
    float centroid_y;        ///< CentroidY
    u32 pixel_count;         ///< PixelCount
    u16 bound_x;             ///< BoundX
    u16 bound_y;             ///< BoundY
    u16 boundt_width;        ///< BoundtWidth
    u16 bound_height;        ///< BoundHeight
} IrsClusteringData;
 
/// ClusteringProcessorState
typedef struct {
    s64 sampling_number;                  ///< SamplingNumber
    u64 timestamp;                        ///< TimeStamp
 
    u8 object_count;                      ///< ObjectCount
    u8 reserved[0x3];                     ///< Reserved
    u32 ambient_noise_level;              ///< AmbientNoiseLevel
    IrsClusteringData data[0x10];         ///< \ref IrsClusteringData
} IrsClusteringProcessorState;
 
/// PointingProcessorMarkerState
typedef struct {
    s64 sampling_number;                  ///< SamplingNumber
    u64 timestamp;                        ///< TimeStamp
 
    struct {
        u8 pointing_status;               ///< PointingStatus
        u8 reserved[0x3];                 ///< Reserved
        u8 unk_x4[0x4];                   ///< Unknown
        float unk_x8;                     ///< Unknown
        float position_x;                 ///< PositionX
        float position_y;                 ///< PositionY
        float unk_x14;                    ///< Unknown
        IrsRect window_of_interest;       ///< WindowOfInterest
    } data[3];
} IrsPointingProcessorMarkerState;
 
/// PointingProcessorState
typedef struct {
    s64 sampling_number;                  ///< SamplingNumber
    u64 timestamp;                        ///< TimeStamp
 
    u32 pointing_status;                  ///< PointingStatus
    float position_x;                     ///< PositionX
    float position_y;                     ///< PositionY
    u8 reserved[0x4];                     ///< Reserved
} IrsPointingProcessorState;
 
/// TeraPluginProcessorState
typedef struct {
    s64 sampling_number;                  ///< SamplingNumber
    u64 timestamp;                        ///< TimeStamp
    u32 ambient_noise_level;              ///< AmbientNoiseLevel
    u8 plugin_data[0x12c];                ///< PluginData
} IrsTeraPluginProcessorState;
 
/// ProcessorState
typedef struct {
    s64 start;                                          ///< Start
    u32 count;                                          ///< Count
    u32 pad;                                            ///< Padding
 
    u8 data[0xe10];                                     ///< Contains an array of *ProcessorState, depending on IrsDeviceFormat::ir_sensor_mode.
} IrsProcessorState;
 
/// DeviceFormat
typedef struct {
    u32 ir_camera_status;                                   ///< \ref IrsIrCameraStatus
    u32 ir_camera_internal_status;                          ///< \ref IrsIrCameraInternalStatus
    u32 ir_sensor_mode;                                     ///< \ref IrsIrSensorMode
    u32 pad;                                                ///< Padding
 
    IrsProcessorState processor_state;                      ///< \ref IrsProcessorState
} IrsDeviceFormat;
 
/// AruidFormat
typedef struct {
    u64 ir_sensor_aruid;        ///< IrSensorAruid
    u32 ir_sensor_aruid_status; ///< IrSensorAruidStatus
    u32 pad;                    ///< Padding
} IrsAruidFormat;
 
/// StatusManager
typedef struct {
    IrsDeviceFormat device_format[IRS_MAX_CAMERAS];
    IrsAruidFormat aruid_format[0x5];
} IrsStatusManager;
 
/// Initialize irs.
Result irsInitialize(void);
 
/// Exit irs.
void irsExit(void);
 
/// Gets the Service object for the actual irs service session.
Service* irsGetServiceSession(void);
 
/// Gets the address of the SharedMemory (\ref IrsStatusManager).
void* irsGetSharedmemAddr(void);
 
/// Gets the \ref IrsIrCameraHandle for the specified controller.
Result irsGetIrCameraHandle(IrsIrCameraHandle *handle, HidNpadIdType id);
 
/// GetIrCameraStatus
Result irsGetIrCameraStatus(IrsIrCameraHandle handle, IrsIrCameraStatus *out);
 
/// CheckFirmwareUpdateNecessity
/// When successful where the output flag is set, the user should use \ref hidLaShowControllerFirmwareUpdate.
/// Only available on [4.0.0+].
Result irsCheckFirmwareUpdateNecessity(IrsIrCameraHandle handle, bool *out);
 
/// GetImageProcessorStatus
/// Only available on [4.0.0+].
Result irsGetImageProcessorStatus(IrsIrCameraHandle handle, IrsImageProcessorStatus *out);
 
/// Stop the current Processor.
/// \ref irsExit calls this with all IrCameraHandles which were not already used with \ref irsStopImageProcessor.
Result irsStopImageProcessor(IrsIrCameraHandle handle);
 
/// Stop the current Processor, async.
/// Only available on [4.0.0+].
Result irsStopImageProcessorAsync(IrsIrCameraHandle handle);
 
/**
 * @brief Run the MomentProcessor.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[in] config Input config.
 */
Result irsRunMomentProcessor(IrsIrCameraHandle handle, const IrsMomentProcessorConfig *config);
 
/**
 * @brief Gets the states for MomentProcessor or IrLedProcessor.
 * @note The official GetIrLedProcessorState is essentially the same as this, except it uses hard-coded count=1 with output-array on stack, without returning that data. Hence we don't implement a seperate func for that.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[out] states Output array of \ref IrsMomentProcessorState.
 * @param[in] count Size of the states array in entries. Must be 1-5.
 * @param[out] total_out Total output entries.
 */
Result irsGetMomentProcessorStates(IrsIrCameraHandle handle, IrsMomentProcessorState *states, s32 count, s32 *total_out);
 
/**
 * @brief Calculates an \ref IrsMomentStatistic from the specified region in the input \ref IrsMomentProcessorState.
 * @param[in] state \ref IrsMomentProcessorState
 * @param[in] rect \ref IrsRect, containing the image width and height.
 * @param[in] region_x Region x, must be 0-5 (clamped to this range otherwise). region_x = image_x/6.
 * @param[in] region_y Region y, must be 0-7 (clamped to this range otherwise). region_y = image_y/8.
 * @param[in] region_width Region width. region_x+region_width must be <=6 (clamped to this range otherwise).
 * @param[in] region_height Region height.  region_y+region_height must be <=8 (clamped to this range otherwise).
 */
IrsMomentStatistic irsCalculateMomentRegionStatistic(const IrsMomentProcessorState *state, IrsRect rect, s32 region_x, s32 region_y, s32 region_width, s32 region_height);
 
/**
 * @brief Run the ClusteringProcessor.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[in] config Input config.
 */
Result irsRunClusteringProcessor(IrsIrCameraHandle handle, const IrsClusteringProcessorConfig *config);
 
/**
 * @brief Gets the states for ClusteringProcessor.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[out] states Output array of \ref IrsClusteringProcessorState.
 * @param[in] count Size of the states array in entries. Must be 1-5.
 * @param[out] total_out Total output entries.
 */
Result irsGetClusteringProcessorStates(IrsIrCameraHandle handle, IrsClusteringProcessorState *states, s32 count, s32 *total_out);
 
/**
 * @brief Run the ImageTransferProcessor.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[in] config Input config.
 * @param[in] size Work-buffer size, must be 0x1000-byte aligned.
 */
Result irsRunImageTransferProcessor(IrsIrCameraHandle handle, const IrsImageTransferProcessorConfig *config, size_t size);
 
/**
 * @brief Run the ImageTransferExProcessor.
 * @note Only available on [4.0.0+].
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[in] config Input config.
 * @param[in] size Work-buffer size, must be 0x1000-byte aligned.
 */
Result irsRunImageTransferExProcessor(IrsIrCameraHandle handle, const IrsImageTransferProcessorExConfig *config, size_t size);
 
/// GetImageTransferProcessorState
Result irsGetImageTransferProcessorState(IrsIrCameraHandle handle, void* buffer, size_t size, IrsImageTransferProcessorState *state);
 
/**
 * @brief Run the PointingProcessor.
 * @param[in] handle \ref IrsIrCameraHandle
 */
Result irsRunPointingProcessor(IrsIrCameraHandle handle);
 
/**
 * @brief Gets the states for PointingProcessor.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[out] states Output array of \ref IrsPointingProcessorMarkerState.
 * @param[in] count Size of the states array in entries. Must be 1-6.
 * @param[out] total_out Total output entries.
 */
Result irsGetPointingProcessorMarkerStates(IrsIrCameraHandle handle, IrsPointingProcessorMarkerState *states, s32 count, s32 *total_out);
 
/**
 * @brief Gets the states for \ref IrsPointingProcessorState.
 * @note This uses \ref irsGetPointingProcessorMarkerStates, then converts the output to \ref IrsPointingProcessorState.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[out] states Output array of \ref IrsPointingProcessorState.
 * @param[in] count Size of the states array in entries. Must be 1-6.
 * @param[out] total_out Total output entries.
 */
Result irsGetPointingProcessorStates(IrsIrCameraHandle handle, IrsPointingProcessorState *states, s32 count, s32 *total_out);
 
/**
 * @brief Run the TeraPluginProcessor.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[in] config Input config.
 */
Result irsRunTeraPluginProcessor(IrsIrCameraHandle handle, const IrsTeraPluginProcessorConfig *config);
 
/**
 * @brief Gets the states for TeraPluginProcessor, filtered using the input params.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[out] states Output array of \ref IrsTeraPluginProcessorState.
 * @param[in] count Size of the states array in entries. Must be 1-5.
 * @param[in] sampling_number Minimum value for IrsTeraPluginProcessorState::sampling_number.
 * @param[in] prefix_data Only used when prefix_bitcount is not 0. The first prefix_bitcount bits from prefix_data must match the first prefix_bitcount bits in IrsTeraPluginProcessorState::plugin_data.
 * @param[in] prefix_bitcount Total bits for prefix_data.
 * @param[out] total_out Total output entries.
 */
Result irsGetTeraPluginProcessorStates(IrsIrCameraHandle handle, IrsTeraPluginProcessorState *states, s32 count, s64 sampling_number, u32 prefix_data, u32 prefix_bitcount, s32 *total_out);
 
/**
 * @brief Run the IrLedProcessor.
 * @note Only available on [4.0.0+].
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[in] config Input config.
 */
Result irsRunIrLedProcessor(IrsIrCameraHandle handle, const IrsIrLedProcessorConfig *config);
 
/**
 * @brief Run the AdaptiveClusteringProcessor.
 * @note Only available on [5.0.0+].
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[in] config Input config.
 */
Result irsRunAdaptiveClusteringProcessor(IrsIrCameraHandle handle, const IrsAdaptiveClusteringProcessorConfig *config);
 
/**
 * @brief Run HandAnalysis.
 * @param[in] handle \ref IrsIrCameraHandle
 * @param[in] config Input config.
 */
Result irsRunHandAnalysis(IrsIrCameraHandle handle, const IrsHandAnalysisConfig *config);
 
/**
 * Gets the default configuration for MomentProcessor.
 */
void irsGetMomentProcessorDefaultConfig(IrsMomentProcessorConfig *config);
 
/**
 * Gets the default configuration for ClusteringProcessor.
 */
void irsGetClusteringProcessorDefaultConfig(IrsClusteringProcessorConfig *config);
 
/**
 * Gets the default configuration for ImageTransferProcessor.
 * Defaults are exposure 300us, 8x digital gain, the rest is all-zero. Format is ::IrsImageTransferProcessorFormat_320x240.
 */
void irsGetDefaultImageTransferProcessorConfig(IrsImageTransferProcessorConfig *config);
 
/**
 * Gets the default configuration for ImageTransferProcessorEx.
 * Defaults are exposure 300us, 8x digital gain, the rest is all-zero. OrigFormat/TrimmingFormat are ::IrsImageTransferProcessorFormat_320x240.
 */
void irsGetDefaultImageTransferProcessorExConfig(IrsImageTransferProcessorExConfig *config);
 
/**
 * Gets the default configuration for IrLedProcessor.
 */
NX_CONSTEXPR void irsGetIrLedProcessorDefaultConfig(IrsIrLedProcessorConfig *config) {
    config->light_target = 0;
}