ids_peak_comfort_c.h

Go to the documentation of this file.

#ifndef PEAK_COMFORT_C_H
#define PEAK_COMFORT_C_H

/* Function declaration modifiers */
#if defined(_WIN32)
#    ifndef PEAK_NO_DECLSPEC_STATEMENTS
#        ifdef paiconstant_EXPORTING
#            define PEAK_EXPORT __declspec(dllexport)
#        else
#            define PEAK_EXPORT __declspec(dllimport)
#        endif
#    else
#        define PEAK_EXPORT
#    endif
#    if defined(_M_IX86) || defined(__i386__)
#        define PEAK_CALLCONV __cdecl
#    else
#        define PEAK_CALLCONV
#    endif
#elif defined(__linux__)
#    define PEAK_EXPORT
#    if defined(__i386__)
#        define PEAK_CALLCONV __attribute__((cdecl))
#    else
#        define PEAK_CALLCONV
#    endif
#else
#    error Platform is not supported yet!
#endif

#ifdef __cplusplus
#    include <cstddef>
#    include <cstdint>

extern "C" {
#else
#    include <stddef.h>
#    include <stdint.h>
#endif

/* helper entities */
struct peak_camera;
struct peak_frame;
struct peak_video;
struct peak_inference;
struct peak_inference_result;
struct peak_message_queue;
struct peak_message;
struct peak_i2c;

#define PEAK_VERSION_CODE(major,minor,subminor,patch) (((major) << 24) + ((minor) << 16) + ((subminor) << 8) + (patch))
#define PEAK_API_STATUS PEAK_EXPORT peak_status PEAK_CALLCONV
#define PEAK_API_ACCESS_STATUS PEAK_EXPORT peak_access_status PEAK_CALLCONV
#define PEAK_API_BOOL PEAK_EXPORT peak_bool PEAK_CALLCONV
#define PEAK_API_CAMERA_ID PEAK_EXPORT peak_camera_id PEAK_CALLCONV

#define PEAK_INVALID_HANDLE NULL

#define PEAK_INFINITE 0xffffffff

typedef uint8_t peak_bool;

#define PEAK_TRUE 1

#define PEAK_FALSE 0

#pragma pack(push, 1)

typedef struct
{
    uint8_t* memoryAddress;

    size_t memorySize;

    void* userContext;

} peak_buffer;
#pragma pack(pop)

#pragma pack(push, 1)

typedef struct
{
    uint32_t width;

    uint32_t height;

} peak_size;
#pragma pack(pop)

#pragma pack(push, 1)

typedef struct
{
    uint32_t x;

    uint32_t y;

} peak_position;
#pragma pack(pop)

#pragma pack(push, 1)

typedef struct
{
    peak_position offset;

    peak_size size;

} peak_roi;
#pragma pack(pop)

#pragma pack(push, 1)

typedef union
{
    struct
    {
        double element_00;

        double element_01;

        double element_02;

        double element_10;

        double element_11;

        double element_12;

        double element_20;

        double element_21;

        double element_22;

    } elements;

    double elementArray[3][3];

} peak_matrix;
#pragma pack(pop)

#define PEAK_IDENTITY_MATRIX    { 1.0, 0.0, 0.0, \
                                  0.0, 1.0, 0.0, \
                                  0.0, 0.0, 1.0 }

typedef enum
{
    PEAK_STATUS_SUCCESS                     = 0,

    PEAK_STATUS_WARNING                     = 0x4000,

    PEAK_STATUS_VALUE_ADJUSTED              = 0x4001,

    PEAK_STATUS_WARNING_OVERFLOW            = 0x4002,

    PEAK_STATUS_WARNING_OPERATION           = 0x4003,

    PEAK_STATUS_ERROR                       = 0x8000,

    PEAK_STATUS_NOT_INITIALIZED             = 0x8001,

    PEAK_STATUS_NOT_IMPLEMENTED             = 0x8002,

    PEAK_STATUS_ACCESS_DENIED               = 0x8003,

    PEAK_STATUS_CAMERA_NOT_FOUND            = 0x8004,

    PEAK_STATUS_CAMERA_NOT_AVAILABLE        = 0x8005,

    PEAK_STATUS_INVALID_HANDLE              = 0x8006,

    PEAK_STATUS_INVALID_PARAMETER           = 0x8007,

    PEAK_STATUS_OUT_OF_RANGE                = 0x8008,

    PEAK_STATUS_BUFFER_TOO_SMALL            = 0x8009,

    PEAK_STATUS_INVALID_CONFIGURATION       = 0x800A,

    PEAK_STATUS_TIMEOUT                     = 0x800B,

    PEAK_STATUS_ABORTED                     = 0x800C,

    PEAK_STATUS_NO_DATA                     = 0x800D,

    PEAK_STATUS_INVALID_PEAK_INSTALLATION   = 0x800E,

    PEAK_STATUS_BUSY                       = 0x800F,

    PEAK_STATUS_OUT_OF_MEMORY              = 0x8010,

    PEAK_STATUS_IO                         = 0x8011,
} peak_status;

#define PEAK_SUCCESS(status) ((((status) & 0xf000) == 0x0000) ? PEAK_TRUE : PEAK_FALSE)

#define PEAK_WARNING(status) ((((status) & 0xf000) == 0x4000) ? PEAK_TRUE : PEAK_FALSE)

#define PEAK_ERROR(status) ((((status) & 0xf000) == 0x8000) ? PEAK_TRUE : PEAK_FALSE)

typedef enum
{
    PEAK_ACCESS_INVALID         = 0,

    PEAK_ACCESS_NOT_SUPPORTED   = 0x0001,

    PEAK_ACCESS_NONE            = 0x0101,

    PEAK_ACCESS_GFA_LOCK        = 0x0201,

    PEAK_ACCESS_READONLY        = 0x1101,

    PEAK_ACCESS_WRITEONLY       = 0x2101,

    PEAK_ACCESS_READWRITE       = 0x3101

} peak_access_status;

#define PEAK_IS_WRITEABLE(accessStatus) ((((accessStatus) & 0x2000) == 0x2000) ? PEAK_TRUE : PEAK_FALSE)

#define PEAK_IS_READABLE(accessStatus) ((((accessStatus) & 0x1000) == 0x1000) ? PEAK_TRUE : PEAK_FALSE)

#define PEAK_IS_SUPPORTED(accessStatus) (((accessStatus) != PEAK_ACCESS_NOT_SUPPORTED) ? PEAK_TRUE : PEAK_FALSE)

typedef enum
{
    peak_interface_technology_INVALID = 0,
    peak_interface_technology_GEV,
    peak_interface_technology_U3V,
    peak_interface_technology_UEYE
} peak_interface_technology;


PEAK_API_STATUS peak_Library_Init();

PEAK_API_STATUS peak_Library_Exit();

PEAK_API_STATUS peak_Library_GetVersion(uint32_t* majorVersion, uint32_t* minorVersion, uint32_t* subminorVersion,
    uint32_t* patchVersion);

PEAK_API_STATUS peak_Library_GetLastError(peak_status* lastErrorCode, char* lastErrorMessage,
    size_t* lastErrorMessageSize);

PEAK_API_BOOL peak_Library_InterfaceTechnology_IsSupported(peak_interface_technology interfaceTech);

typedef enum
{
    PEAK_CAMERA_TYPE_INVALID        = 0,

    PEAK_CAMERA_TYPE_UEYE_USB       = 0x1101,

    PEAK_CAMERA_TYPE_UEYE_ETH       = 0x1202,

    PEAK_CAMERA_TYPE_UEYE_PLUS_U3V  = 0x2101,

    PEAK_CAMERA_TYPE_UEYE_PLUS_GEV  = 0x2202

} peak_camera_type;

typedef struct peak_camera* peak_camera_handle;

typedef uint64_t peak_camera_id;

#define PEAK_INVALID_CAMERA_ID UINT64_C(0)

#pragma pack(push, 1)

typedef struct
{
    peak_camera_id cameraID;

    peak_camera_type cameraType;

    char modelName[64];

    char serialNumber[64];

    char userDefinedName[64];

    peak_interface_technology interfaceTechnology;

    uint8_t reserved[444];

} peak_camera_descriptor;
 
#pragma pack(pop)

typedef struct
{
    peak_bool isReconnectSuccessful;

    peak_bool isAcquisitionRunning;

    peak_bool isConfigurationRestored;

    uint8_t reserved[64];

} peak_reconnect_information;

PEAK_API_STATUS peak_Reconnect_Enable(peak_interface_technology interfaceTech, peak_bool enabled);

PEAK_API_BOOL peak_Reconnect_IsEnabled(peak_interface_technology interfaceTech);

PEAK_API_ACCESS_STATUS peak_Reconnect_GetAccessStatus(peak_interface_technology interfaceTech);

PEAK_API_STATUS peak_CameraList_Update(size_t* cameraCount);

PEAK_API_STATUS peak_CameraList_Get(peak_camera_descriptor* cameraList, size_t* cameraCount);

PEAK_API_CAMERA_ID peak_Camera_ID_FromHandle(peak_camera_handle hCam);

PEAK_API_CAMERA_ID peak_Camera_ID_FromSerialNumber(const char* serialNumber);

PEAK_API_CAMERA_ID peak_Camera_ID_FromUserDefinedName(const char* userDefinedName);

#pragma pack(push, 1)

typedef union
{
    uint8_t octets[6];

    struct
    {
        uint16_t high_part;

        uint32_t low_part;

    } parts;

} peak_mac_address;
#pragma pack(pop)

PEAK_API_CAMERA_ID peak_Camera_ID_FromMAC(peak_mac_address macAddress);

PEAK_API_ACCESS_STATUS peak_Camera_GetAccessStatus(peak_camera_id cameraID);

PEAK_API_STATUS peak_Camera_GetDescriptor(peak_camera_id cameraID, peak_camera_descriptor* cameraDescriptor);

PEAK_API_STATUS peak_Camera_Open(peak_camera_id cameraID, peak_camera_handle* hCam);

PEAK_API_STATUS peak_Camera_OpenFirstAvailable(peak_camera_handle* hCam);

PEAK_API_STATUS peak_Camera_Close(peak_camera_handle hCam);

PEAK_API_STATUS peak_Camera_ResetToDefaultSettings(peak_camera_handle hCam);

PEAK_API_STATUS peak_Camera_UserDefinedName_Set(peak_camera_handle hCam, const char* userDefinedName);

PEAK_API_STATUS peak_Camera_UserDefinedName_Get(peak_camera_handle hCam, char* userDefinedName,
    size_t* userDefinedNameSize);

PEAK_API_BOOL peak_Camera_IsConnected(peak_camera_handle hCam);

PEAK_API_STATUS peak_Camera_Reboot(peak_camera_handle hCam);

#pragma pack(push, 1)

typedef union
{
    uint32_t addr;

    uint8_t parts[4];

} peak_ip_address;
#pragma pack (pop)

#pragma pack (push, 1)

typedef struct
{
    peak_ip_address address;

    peak_ip_address subnetMask;

    uint8_t reserved[4];

} peak_ip_config;
#pragma pack (pop)

typedef enum
{
    PEAK_ETHERNET_STATUS_INVALID            = 0,

    PEAK_ETHERNET_STATUS_OK                 = 0x0001,

    PEAK_ETHERNET_STATUS_NOK                = 0x8001,

    PEAK_ETHERNET_STATUS_SUBNET_MISMATCH    = 0x8002,

    PEAK_ETHERNET_STATUS_INAPPLICABLE_IP    = 0x8003

} peak_ethernet_status;

#pragma pack (push, 1)

typedef struct
{
    peak_mac_address cameraMAC;

    peak_ip_config cameraIP;

    peak_bool cameraDHCPEnabled;

    peak_ip_config cameraPersistentIP;

    peak_ethernet_status cameraEthernetStatus;

    uint8_t reservedCamera[64];

    peak_ip_config hostIP;

    peak_mac_address hostMAC;

    uint8_t reserved[64];

} peak_ethernet_info;
#pragma pack (pop)

PEAK_API_ACCESS_STATUS peak_EthernetConfig_GetAccessStatus(peak_camera_id cameraID);

PEAK_API_STATUS peak_EthernetConfig_GetInfo(peak_camera_id cameraID, peak_ethernet_info* ethernetInfo);

PEAK_API_ACCESS_STATUS peak_EthernetConfig_DHCP_GetAccessStatus(peak_camera_id cameraID);

PEAK_API_STATUS peak_EthernetConfig_DHCP_Enable(peak_camera_id cameraID, peak_bool enabled);

PEAK_API_BOOL peak_EthernetConfig_DHCP_IsEnabled(peak_camera_id cameraID);

PEAK_API_ACCESS_STATUS peak_EthernetConfig_PersistentIP_GetAccessStatus(peak_camera_id cameraID);

PEAK_API_STATUS peak_EthernetConfig_PersistentIP_Set(peak_camera_id cameraID, peak_ip_config persistentIP);

PEAK_API_STATUS peak_EthernetConfig_PersistentIP_Get(peak_camera_id cameraID, peak_ip_config* persistentIP);

typedef struct peak_frame* peak_frame_handle;

#pragma pack(push, 1)
typedef struct
{
    uint32_t numUnderrun;

    uint32_t numDropped;

    uint32_t numIncomplete;

    double fps;

    uint8_t reserved[256];

} peak_acquisition_info;
#pragma pack(pop)

PEAK_API_STATUS peak_Acquisition_Start(peak_camera_handle hCam, uint32_t numberOfFrames);

PEAK_API_STATUS peak_Acquisition_Stop(peak_camera_handle hCam);

PEAK_API_BOOL peak_Acquisition_IsStarted(peak_camera_handle hCam);

PEAK_API_STATUS peak_Acquisition_WaitForFrame(peak_camera_handle hCam, uint32_t timeout_ms, peak_frame_handle* hFrame);

PEAK_API_STATUS peak_Acquisition_GetInfo(peak_camera_handle hCam, peak_acquisition_info* acquisitionInfo);

PEAK_API_STATUS peak_Acquisition_Buffer_GetRequiredSize(peak_camera_handle hCam, size_t* requiredBufferSize);

PEAK_API_STATUS peak_Acquisition_Buffer_GetRequiredCount(peak_camera_handle hCam, size_t* requiredBufferCount);

PEAK_API_STATUS peak_Acquisition_Buffer_Announce(peak_camera_handle hCam, uint8_t* memoryAddress, size_t memorySize,
    void* userContext);

PEAK_API_STATUS peak_Acquisition_Buffer_Revoke(peak_camera_handle hCam, uint8_t* memoryAddress);

PEAK_API_STATUS peak_Acquisition_Buffer_RevokeAll(peak_camera_handle hCam);

typedef enum
{
    PEAK_PIXEL_FORMAT_INVALID           = 0,

    PEAK_PIXEL_FORMAT_BAYER_GR8         = 0x01080008,

    PEAK_PIXEL_FORMAT_BAYER_GR10        = 0x0110000C,

    PEAK_PIXEL_FORMAT_BAYER_GR12        = 0x01100010,

    PEAK_PIXEL_FORMAT_BAYER_RG8         = 0x01080009,

    PEAK_PIXEL_FORMAT_BAYER_RG10        = 0x0110000D,

    PEAK_PIXEL_FORMAT_BAYER_RG12        = 0x01100011,

    PEAK_PIXEL_FORMAT_BAYER_GB8         = 0x0108000A,

    PEAK_PIXEL_FORMAT_BAYER_GB10        = 0x0110000E,

    PEAK_PIXEL_FORMAT_BAYER_GB12        = 0x01100012,

    PEAK_PIXEL_FORMAT_BAYER_BG8         = 0x0108000B,

    PEAK_PIXEL_FORMAT_BAYER_BG10        = 0x0110000F,

    PEAK_PIXEL_FORMAT_BAYER_BG12        = 0x01100013,

    PEAK_PIXEL_FORMAT_MONO8             = 0x01080001,

    PEAK_PIXEL_FORMAT_MONO10            = 0x01100003,

    PEAK_PIXEL_FORMAT_MONO12            = 0x01100005,

    PEAK_PIXEL_FORMAT_RGB8              = 0x02180014,

    PEAK_PIXEL_FORMAT_RGB10             = 0x02300018,

    PEAK_PIXEL_FORMAT_RGB12             = 0x0230001A,

    PEAK_PIXEL_FORMAT_BGR8              = 0x02180015,

    PEAK_PIXEL_FORMAT_BGR10             = 0x02300019,

    PEAK_PIXEL_FORMAT_BGR12             = 0x0230001B,

    PEAK_PIXEL_FORMAT_RGBA8             = 0x02200016,

    PEAK_PIXEL_FORMAT_RGBA10            = 0x0240005F,

    PEAK_PIXEL_FORMAT_RGBA12            = 0x02400061,

    PEAK_PIXEL_FORMAT_BGRA8             = 0x02200017,

    PEAK_PIXEL_FORMAT_BGRA10            = 0x0240004C,

    PEAK_PIXEL_FORMAT_BGRA12            = 0x0240004E,

    PEAK_PIXEL_FORMAT_BAYER_GR10P       = 0x010A0056,

    PEAK_PIXEL_FORMAT_BAYER_GR12P       = 0x010C0057,

    PEAK_PIXEL_FORMAT_BAYER_RG10P       = 0x010A0058,

    PEAK_PIXEL_FORMAT_BAYER_RG12P       = 0x010C0059,

    PEAK_PIXEL_FORMAT_BAYER_GB10P       = 0x010A0054,

    PEAK_PIXEL_FORMAT_BAYER_GB12P       = 0x010C0055,

    PEAK_PIXEL_FORMAT_BAYER_BG10P       = 0x010A0052,

    PEAK_PIXEL_FORMAT_BAYER_BG12P       = 0x010C0053,

    PEAK_PIXEL_FORMAT_MONO10P           = 0x010A0046,

    PEAK_PIXEL_FORMAT_MONO12P           = 0x010C0047,

    PEAK_PIXEL_FORMAT_RGB10P32          = 0x0220001D,

    PEAK_PIXEL_FORMAT_BGR10P32          = 0x0220001E,

    PEAK_PIXEL_FORMAT_BAYER_GR10G40_IDS = 0x40000003,

    PEAK_PIXEL_FORMAT_BAYER_RG10G40_IDS = 0x40000001,

    PEAK_PIXEL_FORMAT_BAYER_GB10G40_IDS = 0x40000002,

    PEAK_PIXEL_FORMAT_BAYER_BG10G40_IDS = 0x40000004,

    PEAK_PIXEL_FORMAT_BAYER_GR12G24_IDS = 0x40000013,

    PEAK_PIXEL_FORMAT_BAYER_RG12G24_IDS = 0x40000011,

    PEAK_PIXEL_FORMAT_BAYER_GB12G24_IDS = 0x40000012,

    PEAK_PIXEL_FORMAT_BAYER_BG12G24_IDS = 0x40000014,

    PEAK_PIXEL_FORMAT_MONO10G40_IDS     = 0x4000000f,

    PEAK_PIXEL_FORMAT_MONO12G24_IDS     = 0x4000001f

} peak_pixel_format;

#pragma pack(push, 1)

typedef struct
{
    uint32_t numBitsPerPixel;

    uint32_t numSignificantBitsPerPixel;

    uint32_t numChannels;

    uint32_t numBitsPerChannel;

    uint32_t numSignificantBitsPerChannel;

    uint32_t maxValuePerChannel;

    uint8_t reserved[64];

} peak_pixel_format_info;
#pragma pack(pop)

PEAK_API_STATUS peak_PixelFormat_GetInfo(peak_pixel_format pixelFormat, peak_pixel_format_info* pixelFormatInfo);

PEAK_API_STATUS peak_Frame_Release(peak_camera_handle hCam, peak_frame_handle hFrame);

typedef enum
{
    PEAK_FRAME_TYPE_INVALID = 0,

    PEAK_FRAME_TYPE_IMAGE   = 0x1001

} peak_frame_type;

#pragma pack(push, 1)
typedef struct
{
    peak_frame_type type;

    peak_buffer buffer;

    uint64_t frameID;

    uint64_t timestamp_ns;

    peak_roi roi;

    peak_pixel_format pixelFormat;

    peak_bool isComplete;

    size_t bytesExpected;

    size_t bytesWritten;

    uint32_t processingTime_ms;

    uint8_t reserved[256];

} peak_frame_info;
#pragma pack(pop)

PEAK_API_STATUS peak_Frame_GetInfo(peak_frame_handle hFrame, peak_frame_info* frameInfo);

PEAK_API_STATUS peak_Frame_Type_Get(peak_frame_handle hFrame, peak_frame_type* frameType);

PEAK_API_STATUS peak_Frame_Buffer_Get(peak_frame_handle hFrame, peak_buffer* buffer);

PEAK_API_STATUS peak_Frame_ID_Get(peak_frame_handle hFrame, uint64_t* frameID);

PEAK_API_STATUS peak_Frame_Timestamp_Get(peak_frame_handle hFrame, uint64_t* timestamp_ns);

PEAK_API_STATUS peak_Frame_ROI_Get(peak_frame_handle hFrame, peak_roi* roi);

PEAK_API_STATUS peak_Frame_PixelFormat_Get(peak_frame_handle hFrame, peak_pixel_format* pixelFormat);

PEAK_API_BOOL peak_Frame_IsComplete(peak_frame_handle hFrame);

PEAK_API_STATUS peak_Frame_BytesExpected_Get(peak_frame_handle hFrame, size_t* bytesExpected);

PEAK_API_STATUS peak_Frame_BytesWritten_Get(peak_frame_handle hFrame, size_t* bytesWritten);

PEAK_API_STATUS peak_Frame_ProcessingTime_Get(peak_frame_handle hFrame, uint32_t* processingTime_ms);

typedef enum
{
    PEAK_PARAMETER_SET_INVALID          = 0,

    PEAK_PARAMETER_SET_DEFAULT          = 0x1001,

    PEAK_PARAMETER_SET_LINESCAN         = 0x1002,

    PEAK_PARAMETER_SET_LONG_EXPOSURE    = 0x1003,

    PEAK_PARAMETER_SET_USER_1           = 0x2001,

    PEAK_PARAMETER_SET_USER_2           = 0x2002

} peak_parameter_set;

PEAK_API_ACCESS_STATUS peak_CameraSettings_ParameterSet_GetAccessStatus(peak_camera_handle hCam,
    peak_parameter_set parameterSet);

PEAK_API_STATUS peak_CameraSettings_ParameterSet_GetList(peak_camera_handle hCam, peak_parameter_set* parameterSetList,
    size_t* parameterSetCount);

PEAK_API_STATUS peak_CameraSettings_ParameterSet_Store(peak_camera_handle hCam, peak_parameter_set parameterSet);

PEAK_API_STATUS peak_CameraSettings_ParameterSet_Apply(peak_camera_handle hCam, peak_parameter_set parameterSet);

PEAK_API_ACCESS_STATUS peak_CameraSettings_ParameterSet_Startup_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_CameraSettings_ParameterSet_Startup_Set(peak_camera_handle hCam, peak_parameter_set parameterSet);

PEAK_API_STATUS peak_CameraSettings_ParameterSet_Startup_Get(peak_camera_handle hCam, peak_parameter_set* parameterSet);

PEAK_API_ACCESS_STATUS peak_CameraSettings_DiskFile_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_CameraSettings_DiskFile_Store(peak_camera_handle hCam, const char* file);

PEAK_API_STATUS peak_CameraSettings_DiskFile_Apply(peak_camera_handle hCam, const char* file);

PEAK_API_ACCESS_STATUS peak_FrameRate_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_FrameRate_GetRange(peak_camera_handle hCam, double* minFrameRate_fps, double* maxFrameRate_fps,
    double* incFrameRate_fps);

PEAK_API_STATUS peak_FrameRate_Set(peak_camera_handle hCam, double frameRate_fps);

PEAK_API_STATUS peak_FrameRate_Get(peak_camera_handle hCam, double* frameRate_fps);

PEAK_API_ACCESS_STATUS peak_ExposureTime_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_ExposureTime_GetRange(peak_camera_handle hCam, double* minExposureTime_us,
    double* maxExposureTime_us, double* incExposureTime_us);

PEAK_API_STATUS peak_ExposureTime_Set(peak_camera_handle hCam, double exposureTime_us);

PEAK_API_STATUS peak_ExposureTime_Get(peak_camera_handle hCam, double* exposureTime_us);

PEAK_API_ACCESS_STATUS peak_PixelClock_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_BOOL peak_PixelClock_HasRange(peak_camera_handle hCam);

PEAK_API_STATUS peak_PixelClock_GetRange(peak_camera_handle hCam, double* minPixelClock_MHz, double* maxPixelClock_MHz,
    double* incPixelClock_MHz);

PEAK_API_STATUS peak_PixelClock_GetList(peak_camera_handle hCam, double* pixelClockList, size_t* pixelClockCount);

PEAK_API_STATUS peak_PixelClock_Set(peak_camera_handle hCam, double pixelClock_MHz);

PEAK_API_STATUS peak_PixelClock_Get(peak_camera_handle hCam, double* pixelClock_MHz);

typedef enum
{
    PEAK_IO_CHANNEL_INVALID         = 0,

    PEAK_IO_CHANNEL_NONE            = 0x0001,

    PEAK_IO_CHANNEL_SOFTWARE        = 0x1101,

    PEAK_IO_CHANNEL_TRIGGER_INPUT   = 0x2101,

    PEAK_IO_CHANNEL_FLASH_OUTPUT    = 0x2201,

    PEAK_IO_CHANNEL_GPIO_1          = 0x6301,

    PEAK_IO_CHANNEL_GPIO_2          = 0x6302

} peak_io_channel;

PEAK_API_ACCESS_STATUS peak_IOChannel_GetAccessStatus(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_STATUS peak_IOChannel_GetList(peak_camera_handle hCam, peak_io_channel* ioChannelList, size_t* ioChannelCount);

PEAK_API_ACCESS_STATUS peak_IOChannel_Level_GetAccessStatus(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_BOOL peak_IOChannel_Level_IsHigh(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_ACCESS_STATUS peak_IOChannel_Inverter_GetAccessStatus(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_STATUS peak_IOChannel_Inverter_Enable(peak_camera_handle hCam, peak_io_channel ioChannel, peak_bool enabled);

PEAK_API_BOOL peak_IOChannel_Inverter_IsEnabled(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_ACCESS_STATUS peak_IOChannel_NoiseFilter_GetAccessStatus(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_STATUS peak_IOChannel_NoiseFilter_Enable(peak_camera_handle hCam, peak_io_channel ioChannel,
    peak_bool enabled);

PEAK_API_BOOL peak_IOChannel_NoiseFilter_IsEnabled(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_STATUS peak_IOChannel_NoiseFilter_Duration_GetRange(peak_camera_handle hCam, peak_io_channel ioChannel,
    double* minNoiseFilterDuration_us, double* maxNoiseFilterDuration_us, double* incNoiseFilterDuration_us);

PEAK_API_STATUS peak_IOChannel_NoiseFilter_Duration_Set(peak_camera_handle hCam, peak_io_channel ioChannel,
    double noiseFilterDuration_us);

PEAK_API_STATUS peak_IOChannel_NoiseFilter_Duration_Get(peak_camera_handle hCam, peak_io_channel ioChannel,
    double* noiseFilterDuration_us);

typedef enum
{
    PEAK_TRIGGER_TARGET_INVALID                     = 0,

    PEAK_TRIGGER_TARGET_FRAME_START                 = 0x1001,

    PEAK_TRIGGER_TARGET_LEVEL_CONTROLLED_EXPOSURE   = 0x2001

} peak_trigger_target;

typedef struct
{
    peak_trigger_target triggerTarget;

    peak_io_channel ioChannel;

} peak_trigger_mode;

#define PEAK_TRIGGER_MODE_HARDWARE_TRIGGER { PEAK_TRIGGER_TARGET_FRAME_START, PEAK_IO_CHANNEL_TRIGGER_INPUT }

#define PEAK_TRIGGER_MODE_SOFTWARE_TRIGGER { PEAK_TRIGGER_TARGET_FRAME_START, PEAK_IO_CHANNEL_SOFTWARE }

PEAK_API_ACCESS_STATUS peak_Trigger_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Trigger_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_Trigger_IsEnabled(peak_camera_handle hCam);

PEAK_API_BOOL peak_Trigger_IsExecutable(peak_camera_handle hCam);

PEAK_API_STATUS peak_Trigger_Execute(peak_camera_handle hCam);

PEAK_API_ACCESS_STATUS peak_Trigger_Mode_GetAccessStatus(peak_camera_handle hCam, peak_trigger_mode triggerMode);

PEAK_API_STATUS peak_Trigger_Mode_Set(peak_camera_handle hCam, peak_trigger_mode triggerMode);

PEAK_API_STATUS peak_Trigger_Mode_Get(peak_camera_handle hCam, peak_trigger_mode* triggerMode);

typedef enum
{
    PEAK_TRIGGER_EDGE_INVALID   = 0,

    PEAK_TRIGGER_EDGE_RISING    = 0x0001,

    PEAK_TRIGGER_EDGE_FALLING   = 0x0002,

    PEAK_TRIGGER_EDGE_ANY       = 0x0003

} peak_trigger_edge;

PEAK_API_ACCESS_STATUS peak_Trigger_Edge_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Trigger_Edge_GetList(peak_camera_handle hCam, peak_trigger_edge* triggerEdgeList,
    size_t* triggerEdgeCount);

PEAK_API_STATUS peak_Trigger_Edge_Set(peak_camera_handle hCam, peak_trigger_edge triggerEdge);

PEAK_API_STATUS peak_Trigger_Edge_Get(peak_camera_handle hCam, peak_trigger_edge* triggerEdge);

PEAK_API_ACCESS_STATUS peak_Trigger_Delay_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Trigger_Delay_GetRange(peak_camera_handle hCam, double* minTriggerDelay_us,
    double* maxTriggerDelay_us, double* incTriggerDelay_us);

PEAK_API_STATUS peak_Trigger_Delay_Set(peak_camera_handle hCam, double triggerDelay_us);

PEAK_API_STATUS peak_Trigger_Delay_Get(peak_camera_handle hCam, double* triggerDelay_us);

PEAK_API_ACCESS_STATUS peak_Trigger_Divider_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Trigger_Divider_GetRange(peak_camera_handle hCam, uint32_t* minTriggerDivider,
    uint32_t* maxTriggerDivider, uint32_t* incTriggerDivider);

PEAK_API_STATUS peak_Trigger_Divider_Set(peak_camera_handle hCam, uint32_t triggerDivider);

PEAK_API_STATUS peak_Trigger_Divider_Get(peak_camera_handle hCam, uint32_t* triggerDivider);

PEAK_API_ACCESS_STATUS peak_Trigger_Burst_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Trigger_Burst_GetRange(peak_camera_handle hCam, uint32_t* minTriggerBurst,
    uint32_t* maxTriggerBurst, uint32_t* incTriggerBurst);

PEAK_API_STATUS peak_Trigger_Burst_Set(peak_camera_handle hCam, uint32_t triggerBurst);

PEAK_API_STATUS peak_Trigger_Burst_Get(peak_camera_handle hCam, uint32_t* triggerBurst);

typedef enum
{
    PEAK_FLASH_REFERENCE_INVALID                = 0,

    PEAK_FLASH_REFERENCE_EXPOSURE_ACTIVE        = 0x1001,

    PEAK_FLASH_REFERENCE_GLOBAL_START_WINDOW    = 0x1002,

    PEAK_FLASH_REFERENCE_ACQUISITION_ACTIVE     = 0x2001

} peak_flash_reference;

typedef struct
{
    peak_flash_reference flashReference;

    peak_io_channel ioChannel;

} peak_flash_mode;

#define PEAK_FLASH_MODE_EXPOSURE_ACTIVE { PEAK_FLASH_REFERENCE_EXPOSURE_ACTIVE, PEAK_IO_CHANNEL_FLASH_OUTPUT }

#define PEAK_FLASH_MODE_ACQUISITION_ACTIVE { PEAK_FLASH_REFERENCE_ACQUISITION_ACTIVE, PEAK_IO_CHANNEL_FLASH_OUTPUT }

#define PEAK_FLASH_MODE_GLOBAL_START_WINDOW { PEAK_FLASH_REFERENCE_GLOBAL_START_WINDOW, PEAK_IO_CHANNEL_FLASH_OUTPUT }

PEAK_API_ACCESS_STATUS peak_Flash_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Flash_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_Flash_IsEnabled(peak_camera_handle hCam);

PEAK_API_ACCESS_STATUS peak_Flash_Mode_GetAccessStatus(peak_camera_handle hCam, peak_flash_mode flashMode);

PEAK_API_STATUS peak_Flash_Mode_Set(peak_camera_handle hCam, peak_flash_mode flashMode);

PEAK_API_STATUS peak_Flash_Mode_Get(peak_camera_handle hCam, peak_flash_mode* flashMode);

PEAK_API_ACCESS_STATUS peak_Flash_StartDelay_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Flash_StartDelay_GetRange(peak_camera_handle hCam, double* minFlashStartDelay_us,
    double* maxFlashStartDelay_us, double* incFlashStartDelay_us);

PEAK_API_STATUS peak_Flash_StartDelay_Set(peak_camera_handle hCam, double flashStartDelay_us);

PEAK_API_STATUS peak_Flash_StartDelay_Get(peak_camera_handle hCam, double* flashStartDelay_us);

PEAK_API_ACCESS_STATUS peak_Flash_EndDelay_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Flash_EndDelay_GetRange(peak_camera_handle hCam, double* minFlashEndDelay_us,
    double* maxFlashEndDelay_us, double* incFlashEndDelay_us);

PEAK_API_STATUS peak_Flash_EndDelay_Set(peak_camera_handle hCam, double flashEndDelay_us);

PEAK_API_STATUS peak_Flash_EndDelay_Get(peak_camera_handle hCam, double* flashEndDelay_us);

PEAK_API_ACCESS_STATUS peak_Flash_Duration_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Flash_Duration_GetRange(peak_camera_handle hCam, double* minFlashDuration_us,
    double* maxFlashDuration_us, double* incFlashDuration_us);

PEAK_API_STATUS peak_Flash_Duration_Set(peak_camera_handle hCam, double flashDuration_us);

PEAK_API_STATUS peak_Flash_Duration_Get(peak_camera_handle hCam, double* flashDuration_us);

PEAK_API_ACCESS_STATUS peak_Focus_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Focus_GetRange(peak_camera_handle hCam, uint32_t* minFocus, uint32_t* maxFocus,
    uint32_t* incFocus);

PEAK_API_STATUS peak_Focus_Set(peak_camera_handle hCam, uint32_t focus);

PEAK_API_STATUS peak_Focus_Get(peak_camera_handle hCam, uint32_t* focus);

PEAK_API_ACCESS_STATUS peak_PixelFormat_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_PixelFormat_GetList(peak_camera_handle hCam, peak_pixel_format* pixelFormatList,
    size_t* pixelFormatCount);

PEAK_API_STATUS peak_PixelFormat_Set(peak_camera_handle hCam, peak_pixel_format pixelFormat);

PEAK_API_STATUS peak_PixelFormat_Get(peak_camera_handle hCam, peak_pixel_format* pixelFormat);

typedef enum
{
    PEAK_GAIN_TYPE_INVALID  = 0,

    PEAK_GAIN_TYPE_ANALOG   = 0x1001,

    PEAK_GAIN_TYPE_DIGITAL  = 0x2001,

    PEAK_GAIN_TYPE_COMBINED = 0x3001

} peak_gain_type;

typedef enum
{
    PEAK_GAIN_CHANNEL_INVALID   = 0,

    PEAK_GAIN_CHANNEL_RED       = 0x0001,

    PEAK_GAIN_CHANNEL_GREEN     = 0x0002,

    PEAK_GAIN_CHANNEL_BLUE      = 0x0004,

    PEAK_GAIN_CHANNEL_MASTER    = 0x0007

} peak_gain_channel;

PEAK_API_ACCESS_STATUS peak_Gain_GetAccessStatus(peak_camera_handle hCam, peak_gain_type gainType,
    peak_gain_channel gainChannel);

PEAK_API_STATUS peak_Gain_GetChannelList(peak_camera_handle hCam, peak_gain_type gainType,
    peak_gain_channel* gainChannelList, size_t* gainChannelCount);

PEAK_API_STATUS peak_Gain_GetRange(peak_camera_handle hCam, peak_gain_type gainType, peak_gain_channel gainChannel,
    double* minGain, double* maxGain, double* incGain);

PEAK_API_STATUS peak_Gain_Set(peak_camera_handle hCam, peak_gain_type gainType, peak_gain_channel gainChannel,
    double gain);

PEAK_API_STATUS peak_Gain_Get(peak_camera_handle hCam, peak_gain_type gainType, peak_gain_channel gainChannel,
    double* gain);

PEAK_API_ACCESS_STATUS peak_Gamma_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Gamma_GetRange(peak_camera_handle hCam, double* minGamma, double* maxGamma, double* incGamma);

PEAK_API_STATUS peak_Gamma_Set(peak_camera_handle hCam, double gamma);

PEAK_API_STATUS peak_Gamma_Get(peak_camera_handle hCam, double* gamma);

typedef enum
{
    PEAK_COLOR_CORRECTION_MODE_INVALID  = 0,

    PEAK_COLOR_CORRECTION_MODE_HQ       = 0x1001,

    PEAK_COLOR_CORRECTION_MODE_USER_1   = 0x2001,

} peak_color_correction_mode;

PEAK_API_ACCESS_STATUS peak_ColorCorrection_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_ColorCorrection_Mode_GetList(peak_camera_handle hCam,
    peak_color_correction_mode* colorCorrectionModeList, size_t* colorCorrectionModeCount);

PEAK_API_STATUS peak_ColorCorrection_Mode_Set(peak_camera_handle hCam, peak_color_correction_mode colorCorrectionMode);

PEAK_API_STATUS peak_ColorCorrection_Mode_Get(peak_camera_handle hCam, peak_color_correction_mode* colorCorrectionMode);

PEAK_API_ACCESS_STATUS peak_ColorCorrection_Matrix_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_ColorCorrection_Matrix_GetRange(peak_camera_handle hCam, double* minMatrixElementValue,
    double* maxMatrixElementValue, double* incMatrixElementValue);

PEAK_API_STATUS peak_ColorCorrection_Matrix_Set(peak_camera_handle hCam, peak_matrix colorCorrectionMatrix);

PEAK_API_STATUS peak_ColorCorrection_Matrix_Get(peak_camera_handle hCam, peak_matrix* colorCorrectionMatrix);

PEAK_API_STATUS peak_ColorCorrection_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_ColorCorrection_IsEnabled(peak_camera_handle hCam);

typedef enum
{
    PEAK_AUTO_FEATURE_MODE_INVALID      = 0,

    PEAK_AUTO_FEATURE_MODE_OFF          = 0x0001,

    PEAK_AUTO_FEATURE_MODE_ONCE         = 0x1001,

    PEAK_AUTO_FEATURE_MODE_CONTINUOUS   = 0x1002

} peak_auto_feature_mode;

typedef enum
{
    PEAK_AUTO_FEATURE_ROI_MODE_INVALID      = 0,

    PEAK_AUTO_FEATURE_ROI_MODE_FULL_IMAGE   = 0x1001,

    PEAK_AUTO_FEATURE_ROI_MODE_MANUAL       = 0x2001

} peak_auto_feature_roi_mode;

PEAK_API_ACCESS_STATUS peak_AutoBrightness_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_AutoBrightness_Target_GetRange(peak_camera_handle hCam, uint32_t* minAutoBrightnessTarget,
    uint32_t* maxAutoBrightnessTarget, uint32_t* incAutoBrightnessTarget);

PEAK_API_STATUS peak_AutoBrightness_Target_Set(peak_camera_handle hCam, uint32_t autoBrightnessTarget);

PEAK_API_STATUS peak_AutoBrightness_Target_Get(peak_camera_handle hCam, uint32_t* autoBrightnessTarget);

PEAK_API_STATUS peak_AutoBrightness_TargetTolerance_GetRange(peak_camera_handle hCam,
    uint32_t* minAutoBrightnessTargetTolerance, uint32_t* maxAutoBrightnessTargetTolerance,
    uint32_t* incAutoBrightnessTargetTolerance);

PEAK_API_STATUS peak_AutoBrightness_TargetTolerance_Set(peak_camera_handle hCam,
    uint32_t autoBrightnessTargetTolerance);

PEAK_API_STATUS peak_AutoBrightness_TargetTolerance_Get(peak_camera_handle hCam,
    uint32_t* autoBrightnessTargetTolerance);

PEAK_API_STATUS peak_AutoBrightness_TargetPercentile_GetRange(peak_camera_handle hCam,
    double* minAutoBrightnessTargetPercentile, double* maxAutoBrightnessTargetPercentile,
    double* incAutoBrightnessTargetPercentile);

PEAK_API_STATUS peak_AutoBrightness_TargetPercentile_Set(peak_camera_handle hCam,
    double autoBrightnessTargetPercentile);

PEAK_API_STATUS peak_AutoBrightness_TargetPercentile_Get(peak_camera_handle hCam,
    double* autoBrightnessTargetPercentile);

PEAK_API_STATUS peak_AutoBrightness_ROI_Mode_Set(peak_camera_handle hCam,
    peak_auto_feature_roi_mode autoBrightnessROIMode);

PEAK_API_STATUS peak_AutoBrightness_ROI_Mode_Get(peak_camera_handle hCam,
    peak_auto_feature_roi_mode* autoBrightnessROIMode);

PEAK_API_STATUS peak_AutoBrightness_ROI_Offset_GetRange(peak_camera_handle hCam,
    peak_position* minAutoBrightnessROIOffset, peak_position* maxAutoBrightnessROIOffset,
    peak_position* incAutoBrightnessROIOffset);

PEAK_API_STATUS peak_AutoBrightness_ROI_Size_GetRange(peak_camera_handle hCam, peak_size* minAutoBrightnessROISize,
    peak_size* maxAutoBrightnessROISize, peak_size* incAutoBrightnessROISize);

PEAK_API_STATUS peak_AutoBrightness_ROI_Set(peak_camera_handle hCam, peak_roi autoBrightnessROI);

PEAK_API_STATUS peak_AutoBrightness_ROI_Get(peak_camera_handle hCam, peak_roi* autoBrightnessROI);

PEAK_API_ACCESS_STATUS peak_AutoBrightness_Exposure_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_AutoBrightness_Exposure_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoExposureMode);

PEAK_API_STATUS peak_AutoBrightness_Exposure_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoExposureMode);

PEAK_API_ACCESS_STATUS peak_AutoBrightness_Gain_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_AutoBrightness_Gain_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoGainMode);

PEAK_API_STATUS peak_AutoBrightness_Gain_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoGainMode);

PEAK_API_ACCESS_STATUS peak_AutoWhiteBalance_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_AutoWhiteBalance_ROI_Mode_Set(peak_camera_handle hCam,
    peak_auto_feature_roi_mode autoWhiteBalanceROIMode);

PEAK_API_STATUS peak_AutoWhiteBalance_ROI_Mode_Get(peak_camera_handle hCam,
    peak_auto_feature_roi_mode* autoWhiteBalanceROIMode);

PEAK_API_STATUS peak_AutoWhiteBalance_ROI_Offset_GetRange(peak_camera_handle hCam,
    peak_position* minAutoWhiteBalanceROIOffset, peak_position* maxAutoWhiteBalanceROIOffset,
    peak_position* incAutoWhiteBalanceROIOffset);

PEAK_API_STATUS peak_AutoWhiteBalance_ROI_Size_GetRange(peak_camera_handle hCam, peak_size* minAutoWhiteBalanceROISize,
    peak_size* maxAutoWhiteBalanceROISize, peak_size* incAutoWhiteBalanceROISize);

PEAK_API_STATUS peak_AutoWhiteBalance_ROI_Set(peak_camera_handle hCam, peak_roi autoWhiteBalanceROI);

PEAK_API_STATUS peak_AutoWhiteBalance_ROI_Get(peak_camera_handle hCam, peak_roi* autoWhiteBalanceROI);

PEAK_API_STATUS peak_AutoWhiteBalance_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoWhiteBalanceMode);

PEAK_API_STATUS peak_AutoWhiteBalance_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoWhiteBalanceMode);

PEAK_API_ACCESS_STATUS peak_ROI_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_ROI_Offset_GetRange(peak_camera_handle hCam, peak_position* minROIOffset,
    peak_position* maxROIOffset, peak_position* incROIOffset);

PEAK_API_STATUS peak_ROI_Size_GetRange(peak_camera_handle hCam, peak_size* minROISize, peak_size* maxROISize,
    peak_size* incROISize);

PEAK_API_STATUS peak_ROI_Set(peak_camera_handle hCam, peak_roi roi);

PEAK_API_STATUS peak_ROI_Get(peak_camera_handle hCam, peak_roi* roi);

PEAK_API_ACCESS_STATUS peak_Binning_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Binning_FactorX_GetList(peak_camera_handle hCam, uint32_t* binningFactorXList,
    size_t* binningFactorXCount);

PEAK_API_STATUS peak_Binning_FactorY_GetList(peak_camera_handle hCam, uint32_t* binningFactorYList,
    size_t* binningFactorYCount);

PEAK_API_STATUS peak_Binning_Set(peak_camera_handle hCam, uint32_t binningFactorX, uint32_t binningFactorY);

PEAK_API_STATUS peak_Binning_Get(peak_camera_handle hCam, uint32_t* binningFactorX, uint32_t* binningFactorY);

PEAK_API_ACCESS_STATUS peak_Decimation_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Decimation_FactorX_GetList(peak_camera_handle hCam, uint32_t* decimationFactorXList,
    size_t* decimationFactorXCount);

PEAK_API_STATUS peak_Decimation_FactorY_GetList(peak_camera_handle hCam, uint32_t* decimationFactorYList,
    size_t* decimationFactorYCount);

PEAK_API_STATUS peak_Decimation_Set(peak_camera_handle hCam, uint32_t decimationFactorX, uint32_t decimationFactorY);

PEAK_API_STATUS peak_Decimation_Get(peak_camera_handle hCam, uint32_t* decimationFactorX, uint32_t* decimationFactorY);

PEAK_API_ACCESS_STATUS peak_Mirror_LeftRight_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Mirror_LeftRight_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_Mirror_LeftRight_IsEnabled(peak_camera_handle hCam);

PEAK_API_ACCESS_STATUS peak_Mirror_UpDown_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Mirror_UpDown_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_Mirror_UpDown_IsEnabled(peak_camera_handle hCam);

typedef enum
{
    PEAK_CAMERA_MEMORY_AREA_INVALID     = 0,

    PEAK_CAMERA_MEMORY_AREA_USER_DATA_1 = 0x01,

    PEAK_CAMERA_MEMORY_AREA_USER_DATA_2 = 0x02

} peak_camera_memory_area;

PEAK_API_ACCESS_STATUS peak_CameraMemory_Area_GetAccessStatus(peak_camera_handle hCam,
    peak_camera_memory_area cameraMemoryArea);

PEAK_API_STATUS peak_CameraMemory_Area_GetList(peak_camera_handle hCam,
    peak_camera_memory_area* cameraMemoryAreaList, size_t* cameraMemoryAreaCount);

PEAK_API_STATUS peak_CameraMemory_Area_Size_Get(peak_camera_handle hCam,
    peak_camera_memory_area cameraMemoryArea, size_t* cameraMemoryAreaSize);

PEAK_API_STATUS peak_CameraMemory_Area_Data_Clear(peak_camera_handle hCam,
    peak_camera_memory_area cameraMemoryArea);

PEAK_API_STATUS peak_CameraMemory_Area_Data_Write(peak_camera_handle hCam,
    peak_camera_memory_area cameraMemoryArea, const uint8_t* data, size_t dataSize);

PEAK_API_STATUS peak_CameraMemory_Area_Data_Read(peak_camera_handle hCam,
    peak_camera_memory_area cameraMemoryArea, uint8_t* data, size_t dataSize);

PEAK_API_STATUS peak_GFA_EnableWriteAccess(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_GFA_IsWriteAccessEnabled(peak_camera_handle hCam);

typedef enum
{
    PEAK_GFA_MODULE_INVALID         = 0,

    PEAK_GFA_MODULE_SYSTEM          = 0x0001,

    PEAK_GFA_MODULE_INTERFACE       = 0x0002,

    PEAK_GFA_MODULE_LOCAL_DEVICE    = 0x0003,

    PEAK_GFA_MODULE_REMOTE_DEVICE   = 0x1003,

    PEAK_GFA_MODULE_DATA_STREAM     = 0x0004

} peak_gfa_module;

PEAK_API_ACCESS_STATUS peak_GFA_Feature_GetAccessStatus(peak_camera_handle hCam, peak_gfa_module module,
    const char* featureName);

PEAK_API_BOOL peak_GFA_Float_HasRange(peak_camera_handle hCam, peak_gfa_module module, const char* floatFeatureName);

PEAK_API_STATUS peak_GFA_Float_GetRange(peak_camera_handle hCam, peak_gfa_module module, const char* floatFeatureName,
    double* minFloatValue, double* maxFloatValue, double* incFloatValue);

PEAK_API_STATUS peak_GFA_Float_GetList(peak_camera_handle hCam, peak_gfa_module module, const char* floatFeatureName,
    double* floatList, size_t* floatCount);

PEAK_API_STATUS peak_GFA_Float_Set(peak_camera_handle hCam, peak_gfa_module module, const char* floatFeatureName,
    double floatValue);

PEAK_API_STATUS peak_GFA_Float_Get(peak_camera_handle hCam, peak_gfa_module module, const char* floatFeatureName,
    double* floatValue);

PEAK_API_BOOL peak_GFA_Integer_HasRange(peak_camera_handle hCam, peak_gfa_module module,
    const char* integerFeatureName);

PEAK_API_STATUS peak_GFA_Integer_GetRange(peak_camera_handle hCam, peak_gfa_module module,
    const char* integerFeatureName, int64_t* minIntegerValue, int64_t* maxIntegerValue, int64_t* incIntegerValue);

PEAK_API_STATUS peak_GFA_Integer_GetList(peak_camera_handle hCam, peak_gfa_module module,
    const char* integerFeatureName, int64_t* integerList, size_t* integerCount);

PEAK_API_STATUS peak_GFA_Integer_Set(peak_camera_handle hCam, peak_gfa_module module, const char* integerFeatureName,
    int64_t integerValue);

PEAK_API_STATUS peak_GFA_Integer_Get(peak_camera_handle hCam, peak_gfa_module module, const char* integerFeatureName,
    int64_t* integerValue);

PEAK_API_STATUS peak_GFA_Boolean_Set(peak_camera_handle hCam, peak_gfa_module module, const char* booleanFeatureName,
    peak_bool booleanValue);

PEAK_API_STATUS peak_GFA_Boolean_Get(peak_camera_handle hCam, peak_gfa_module module, const char* booleanFeatureName,
    peak_bool* booleanValue);

PEAK_API_STATUS peak_GFA_String_Set(peak_camera_handle hCam, peak_gfa_module module, const char* stringFeatureName,
    const char* stringValue);

PEAK_API_STATUS peak_GFA_String_Get(peak_camera_handle hCam, peak_gfa_module module, const char* stringFeatureName,
    char* stringValue, size_t* stringValueSize);

PEAK_API_STATUS peak_GFA_Command_Execute(peak_camera_handle hCam, peak_gfa_module module,
    const char* commandFeatureName);

PEAK_API_STATUS peak_GFA_Command_WaitForDone(peak_camera_handle hCam, peak_gfa_module module,
    const char* commandFeatureName, uint32_t timeout_ms);

 typedef struct
{
     char symbolicValue[64];

     int64_t integerValue;

} peak_gfa_enumeration_entry;

PEAK_API_STATUS peak_GFA_Enumeration_GetList(peak_camera_handle hCam, peak_gfa_module module,
    const char* enumerationFeatureName, peak_gfa_enumeration_entry* enumerationEntryList,
    size_t* enumerationEntryCount);

PEAK_API_ACCESS_STATUS peak_GFA_EnumerationEntry_GetAccessStatus(peak_camera_handle hCam, peak_gfa_module module,
    const char* enumerationFeatureName, const peak_gfa_enumeration_entry* enumerationEntry);

PEAK_API_ACCESS_STATUS peak_GFA_EnumerationEntry_GetAccessStatusBySymbolicValue(peak_camera_handle hCam,
    peak_gfa_module module, const char* enumerationFeatureName, const char* enumerationEntrySymbolicValue);

PEAK_API_ACCESS_STATUS peak_GFA_EnumerationEntry_GetAccessStatusByIntegerValue(peak_camera_handle hCam,
    peak_gfa_module module, const char* enumerationFeatureName, int64_t enumerationEntryIntegerValue);

PEAK_API_STATUS peak_GFA_Enumeration_Set(peak_camera_handle hCam, peak_gfa_module module,
    const char* enumerationFeatureName, const peak_gfa_enumeration_entry* enumerationEntry);

PEAK_API_STATUS peak_GFA_Enumeration_SetBySymbolicValue(peak_camera_handle hCam, peak_gfa_module module,
    const char* enumerationFeatureName, const char* enumerationEntrySymbolicValue);

PEAK_API_STATUS peak_GFA_Enumeration_SetByIntegerValue(peak_camera_handle hCam, peak_gfa_module module,
    const char* enumerationFeatureName, int64_t enumerationEntryIntegerValue);

PEAK_API_STATUS peak_GFA_Enumeration_Get(peak_camera_handle hCam, peak_gfa_module module,
    const char* enumerationFeatureName, peak_gfa_enumeration_entry* enumerationEntry);

PEAK_API_STATUS peak_GFA_Register_Set(peak_camera_handle hCam, peak_gfa_module module, const char* registerFeatureName,
    const uint8_t* registerValue, size_t registerValueSize);

PEAK_API_STATUS peak_GFA_Register_Get(peak_camera_handle hCam, peak_gfa_module module, const char* registerFeatureName,
    uint8_t* registerValue, size_t* registerValueSize);

PEAK_API_STATUS peak_GFA_Data_Write(peak_camera_handle hCam, peak_gfa_module module, uint64_t address,
    const uint8_t* data, size_t dataSize);

PEAK_API_STATUS peak_GFA_Data_Read(peak_camera_handle hCam, peak_gfa_module module, uint64_t address, uint8_t* data,
    size_t dataSize);

PEAK_API_STATUS peak_IPL_PixelFormat_GetList(peak_camera_handle hCam, peak_pixel_format inputPixelFormat,
    peak_pixel_format* outputPixelFormatList, size_t* outputPixelFormatCount);

PEAK_API_STATUS peak_IPL_PixelFormat_Set(peak_camera_handle hCam, peak_pixel_format pixelFormat);

PEAK_API_STATUS peak_IPL_PixelFormat_Get(peak_camera_handle hCam, peak_pixel_format* pixelFormat);

PEAK_API_STATUS peak_IPL_Gain_GetRange(peak_camera_handle hCam, peak_gain_channel gainChannel, double* minGain,
    double* maxGain, double* incGain);

PEAK_API_STATUS peak_IPL_Gain_Set(peak_camera_handle hCam, peak_gain_channel gainChannel, double gain);

PEAK_API_STATUS peak_IPL_Gain_Get(peak_camera_handle hCam, peak_gain_channel gainChannel, double* gain);

PEAK_API_STATUS peak_IPL_Gamma_GetRange(peak_camera_handle hCam, double* minGamma, double* maxGamma, double* incGamma);

PEAK_API_STATUS peak_IPL_Gamma_Set(peak_camera_handle hCam, double gamma);

PEAK_API_STATUS peak_IPL_Gamma_Get(peak_camera_handle hCam, double* gamma);

PEAK_API_STATUS peak_IPL_ColorCorrection_Matrix_Set(peak_camera_handle hCam, peak_matrix colorCorrectionMatrix);

PEAK_API_STATUS peak_IPL_ColorCorrection_Matrix_Get(peak_camera_handle hCam, peak_matrix* colorCorrectionMatrix);

PEAK_API_STATUS peak_IPL_ColorCorrection_Saturation_Get(peak_camera_handle hCam, double* saturation);

PEAK_API_STATUS peak_IPL_ColorCorrection_Saturation_Set(peak_camera_handle hCam, double saturation);

PEAK_API_STATUS peak_IPL_ColorCorrection_Saturation_GetRange(peak_camera_handle hCam, double* minSaturation, double* maxSaturation, double* incSaturation);

PEAK_API_STATUS peak_IPL_ColorCorrection_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_IPL_ColorCorrection_IsEnabled(peak_camera_handle hCam);

PEAK_API_STATUS peak_IPL_AutoBrightness_Target_GetRange(peak_camera_handle hCam, uint32_t* minAutoBrightnessTarget,
    uint32_t* maxAutoBrightnessTarget, uint32_t* incAutoBrightnessTarget);

PEAK_API_STATUS peak_IPL_AutoBrightness_Target_Set(peak_camera_handle hCam, uint32_t autoBrightnessTarget);

PEAK_API_STATUS peak_IPL_AutoBrightness_Target_Get(peak_camera_handle hCam, uint32_t* autoBrightnessTarget);

PEAK_API_STATUS peak_IPL_AutoBrightness_TargetTolerance_GetRange(peak_camera_handle hCam,
    uint32_t* minAutoBrightnessTargetTolerance, uint32_t* maxAutoBrightnessTargetTolerance,
    uint32_t* incAutoBrightnessTargetTolerance);

PEAK_API_STATUS peak_IPL_AutoBrightness_TargetTolerance_Set(peak_camera_handle hCam,
    uint32_t autoBrightnessTargetTolerance);

PEAK_API_STATUS peak_IPL_AutoBrightness_TargetTolerance_Get(peak_camera_handle hCam,
    uint32_t* autoBrightnessTargetTolerance);

PEAK_API_STATUS peak_IPL_AutoBrightness_TargetPercentile_GetRange(peak_camera_handle hCam,
    double* minAutoBrightnessTargetPercentile, double* maxAutoBrightnessTargetPercentile,
    double* incAutoBrightnessTargetPercentile);

PEAK_API_STATUS peak_IPL_AutoBrightness_TargetPercentile_Set(peak_camera_handle hCam,
    double autoBrightnessTargetPercentile);

PEAK_API_STATUS peak_IPL_AutoBrightness_TargetPercentile_Get(peak_camera_handle hCam,
    double* autoBrightnessTargetPercentile);

PEAK_API_STATUS peak_IPL_AutoBrightness_ROI_Mode_Set(peak_camera_handle hCam,
    peak_auto_feature_roi_mode autoBrightnessROIMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_ROI_Mode_Get(peak_camera_handle hCam,
    peak_auto_feature_roi_mode* autoBrightnessROIMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_ROI_Offset_GetRange(peak_camera_handle hCam,
    peak_position* minAutoBrightnessROIOffset, peak_position* maxAutoBrightnessROIOffset,
    peak_position* incAutoBrightnessROIOffset);

PEAK_API_STATUS peak_IPL_AutoBrightness_ROI_Size_GetRange(peak_camera_handle hCam,
    peak_size* minAutoBrightnessROISize, peak_size* maxAutoBrightnessROISize, peak_size* incAutoBrightnessROISize);

PEAK_API_STATUS peak_IPL_AutoBrightness_ROI_Set(peak_camera_handle hCam, peak_roi autoBrightnessROI);

PEAK_API_STATUS peak_IPL_AutoBrightness_ROI_Get(peak_camera_handle hCam, peak_roi* autoBrightnessROI);

PEAK_API_STATUS peak_IPL_AutoBrightness_Exposure_Mode_Set(peak_camera_handle hCam,
    peak_auto_feature_mode autoExposureMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_Exposure_Mode_Get(peak_camera_handle hCam,
    peak_auto_feature_mode* autoExposureMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_Gain_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_Gain_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoGainMode);

typedef struct
{
    double min;
    double max;
}
peak_double_limit;

PEAK_API_STATUS peak_IPL_AutoBrightness_GainLimit_Get(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainLimit_Set(peak_camera_handle hCam, peak_double_limit gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainLimit_GetRange(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoWhiteBalance_ROI_Mode_Set(peak_camera_handle hCam,
    peak_auto_feature_roi_mode autoWhiteBalanceROIMode);

PEAK_API_STATUS peak_IPL_AutoWhiteBalance_ROI_Mode_Get(peak_camera_handle hCam,
    peak_auto_feature_roi_mode* autoWhiteBalanceROIMode);

PEAK_API_STATUS peak_IPL_AutoWhiteBalance_ROI_Offset_GetRange(peak_camera_handle hCam,
    peak_position* minAutoWhiteBalanceROIOffset, peak_position* maxAutoWhiteBalanceROIOffset,
    peak_position* incAutoWhiteBalanceROIOffset);

PEAK_API_STATUS peak_IPL_AutoWhiteBalance_ROI_Size_GetRange(peak_camera_handle hCam,
    peak_size* minAutoWhiteBalanceROISize, peak_size* maxAutoWhiteBalanceROISize,
    peak_size* incAutoWhiteBalanceROISize);

PEAK_API_STATUS peak_IPL_AutoWhiteBalance_ROI_Set(peak_camera_handle hCam, peak_roi autoWhiteBalanceROI);

PEAK_API_STATUS peak_IPL_AutoWhiteBalance_ROI_Get(peak_camera_handle hCam, peak_roi* autoWhiteBalanceROI);

PEAK_API_STATUS peak_IPL_AutoWhiteBalance_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoWhiteBalanceMode);

PEAK_API_STATUS peak_IPL_AutoWhiteBalance_Mode_Get(peak_camera_handle hCam,
    peak_auto_feature_mode* autoWhiteBalanceMode);

typedef enum
{
    PEAK_FOCUS_ROI_WEIGHT_INVALID   = 0x00,

    PEAK_FOCUS_ROI_WEIGHT_WEAK      = 0x01,

    PEAK_FOCUS_ROI_WEIGHT_MEDIUM    = 0x02,

    PEAK_FOCUS_ROI_WEIGHT_STRONG    = 0x03

} peak_focus_roi_weight;

#pragma pack(push, 1)

typedef struct
{
    peak_roi roi;

    peak_focus_roi_weight  weight;

} peak_focus_roi;
#pragma pack(pop)

PEAK_API_ACCESS_STATUS peak_IPL_AutoFocus_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_IPL_AutoFocus_ROI_Set(peak_camera_handle hCam, const peak_focus_roi* autoFocusROIList,
    size_t autoFocusROICount);

PEAK_API_STATUS peak_IPL_AutoFocus_ROI_Get(peak_camera_handle hCam, peak_focus_roi* autoFocusROIList,
    size_t* autoFocusROICount);

PEAK_API_STATUS peak_IPL_AutoFocus_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoFocusMode);

PEAK_API_STATUS peak_IPL_AutoFocus_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoFocusMode);

typedef enum
{
    PEAK_AUTO_FOCUS_SEARCH_ALGORITHM_INVALID        = 0x0,

    PEAK_AUTO_FOCUS_SEARCH_ALGORITHM_GOLDEN_RATIO   = 0x1,

    PEAK_AUTO_FOCUS_SEARCH_ALGORITHM_HILL_CLIMBING  = 0x2,

    PEAK_AUTO_FOCUS_SEARCH_ALGORITHM_FULL_SCAN      = 0x3,

     PEAK_AUTO_FOCUS_SEARCH_ALGORITHM_GLOBAL_SEARCH = 0x4

} peak_auto_focus_search_algorithm;

PEAK_API_STATUS peak_IPL_AutoFocus_SearchAlgorithm_Set(peak_camera_handle hCam,
    peak_auto_focus_search_algorithm searchAlgorithm);

PEAK_API_STATUS peak_IPL_AutoFocus_SearchAlgorithm_Get(peak_camera_handle hCam,
    peak_auto_focus_search_algorithm* searchAlgorithm);

typedef enum
{
    PEAK_SHARPNESS_ALGORITHM_INVALID            = 0x0,

    PEAK_SHARPNESS_ALGORITHM_TENENGRAD          = 0x1,

    PEAK_SHARPNESS_ALGORITHM_SOBEL              = 0x2,

    PEAK_SHARPNESS_ALGORITHM_MEAN_SCORE         = 0x3,

    PEAK_SHARPNESS_ALGORITHM_HISTOGRAM_VARIANCE = 0x4,

} peak_sharpness_algorithm;

PEAK_API_STATUS peak_IPL_AutoFocus_SharpnessAlgorithm_Set(peak_camera_handle hCam,
    peak_sharpness_algorithm sharpnessAlgorithm);

PEAK_API_STATUS peak_IPL_AutoFocus_SharpnessAlgorithm_Get(peak_camera_handle hCam,
    peak_sharpness_algorithm* sharpnessAlgorithm);

PEAK_API_STATUS peak_IPL_AutoFocus_Range_Set(peak_camera_handle hCam, uint32_t rangeBegin, uint32_t rangeEnd);

PEAK_API_STATUS peak_IPL_AutoFocus_Range_Get(peak_camera_handle hCam, uint32_t* rangeBegin, uint32_t* rangeEnd);

PEAK_API_STATUS peak_IPL_AutoFocus_Hysteresis_Set(peak_camera_handle hCam, uint8_t hysteresis);

PEAK_API_STATUS peak_IPL_AutoFocus_Hysteresis_Get(peak_camera_handle hCam, uint8_t* hysteresis);

PEAK_API_STATUS peak_IPL_AutoFocus_Hysteresis_GetRange(peak_camera_handle hCam, uint8_t* minHysteresis,
    uint8_t* maxHysteresis, uint8_t* incHysteresis);

typedef enum
{
    PEAK_HOTPIXEL_CORRECTION_SENSITIVITY_INVALID    = 0,

    PEAK_HOTPIXEL_CORRECTION_SENSITIVITY_LEVEL_1    = 0x0001,

    PEAK_HOTPIXEL_CORRECTION_SENSITIVITY_LEVEL_2    = 0x0002,

    PEAK_HOTPIXEL_CORRECTION_SENSITIVITY_LEVEL_3    = 0x0003,

    PEAK_HOTPIXEL_CORRECTION_SENSITIVITY_LEVEL_4    = 0x0004,

    PEAK_HOTPIXEL_CORRECTION_SENSITIVITY_LEVEL_5    = 0x0005

} peak_hotpixel_correction_sensitivity;

PEAK_API_STATUS peak_IPL_HotpixelCorrection_Sensitivity_Set(peak_camera_handle hCam,
    peak_hotpixel_correction_sensitivity hotpixelCorrectionSensitivity);

PEAK_API_STATUS peak_IPL_HotpixelCorrection_Sensitivity_Get(peak_camera_handle hCam,
    peak_hotpixel_correction_sensitivity* hotpixelCorrectionSensitivity);

PEAK_API_STATUS peak_IPL_HotpixelCorrection_GetList(peak_camera_handle hCam, peak_position* hotpixelList,
    size_t* hotpixelCount);

PEAK_API_STATUS peak_IPL_HotpixelCorrection_SetList(peak_camera_handle hCam, const peak_position* hotpixelList,
    size_t hotpixelCount);

PEAK_API_STATUS peak_IPL_HotpixelCorrection_ResetList(peak_camera_handle hCam);

PEAK_API_STATUS peak_IPL_HotpixelCorrection_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_IPL_HotpixelCorrection_IsEnabled(peak_camera_handle hCam);

PEAK_API_STATUS peak_IPL_Mirror_UpDown_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_IPL_Mirror_UpDown_IsEnabled(peak_camera_handle hCam);

PEAK_API_STATUS peak_IPL_Mirror_LeftRight_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_IPL_Mirror_LeftRight_IsEnabled(peak_camera_handle hCam);

PEAK_API_STATUS peak_IPL_ProcessFrame(peak_camera_handle hCam, peak_frame_handle hFrame,
    peak_frame_handle* hResultFrame);

PEAK_API_STATUS peak_IPL_ProcessFrameInplace(peak_camera_handle hCam, peak_frame_handle hFrame);

PEAK_API_STATUS peak_IPL_EdgeEnhancement_Enable(peak_camera_handle hCam, peak_bool enable);

PEAK_API_BOOL peak_IPL_EdgeEnhancement_IsEnabled(peak_camera_handle hCam);


PEAK_API_STATUS peak_IPL_EdgeEnhancement_Factor_Set(peak_camera_handle hCam, uint32_t factor);

PEAK_API_STATUS peak_IPL_EdgeEnhancement_Factor_Get(peak_camera_handle hCam, uint32_t* factor);

PEAK_API_STATUS peak_IPL_EdgeEnhancement_Factor_GetDefault(peak_camera_handle hCam, uint32_t* defaultFactor);

PEAK_API_STATUS peak_IPL_EdgeEnhancement_Factor_GetRange(peak_camera_handle hCam,
  uint32_t* minFactor, uint32_t* maxFactor, uint32_t* incFactor);

PEAK_API_STATUS peak_IPL_Sharpness_Measure(peak_frame_handle hFrame, peak_roi roi,
    peak_sharpness_algorithm sharpnessAlgorithm, double* calculatedValue);

typedef struct peak_video* peak_video_handle;

typedef enum
{
    PEAK_VIDEO_ENCODER_INVALID = 0x0,

    PEAK_VIDEO_ENCODER_MJPEG   = 0x1

} peak_video_encoder;

typedef enum
{
    PEAK_VIDEO_CONTAINER_INVALID = 0x0,

    PEAK_VIDEO_CONTAINER_AVI     = 0x1

} peak_video_container;

PEAK_API_STATUS peak_VideoWriter_Open(peak_video_handle* hVideo, const char* fileName,
    peak_video_container container, peak_video_encoder encoder);

PEAK_API_STATUS peak_VideoWriter_Close(peak_video_handle hVideo);

PEAK_API_STATUS peak_VideoWriter_AddFrame(peak_video_handle hVideo, peak_frame_handle hFrame);

PEAK_API_STATUS peak_VideoWriter_Container_GetEncoderList(peak_video_container container,
    peak_video_encoder* encoderList, size_t* encoderCount);

PEAK_API_STATUS peak_VideoWriter_Encoder_GetPixelFormatList(peak_video_encoder encoder,
    peak_pixel_format* pixelFormatList, size_t* pixelFormatCount);

PEAK_API_STATUS peak_VideoWriter_Encoder_GetContainerList(peak_video_encoder encoder,
    peak_video_container* containerList, size_t* containerCount);

typedef struct
{
    /* \brief Overall encoded frames */
    uint64_t encodedFrames;

    /* \brief Overall dropped frames */
    uint64_t droppedFrames;

    /* \brief Current file size in bytes */
    uint64_t fileSize;

    uint8_t reserved[256];
} peak_video_info;

PEAK_API_STATUS peak_VideoWriter_GetInfo(peak_video_handle hVideo, peak_video_info* videoInfo);

typedef enum
{
    PEAK_VIDEO_CONTAINER_OPTION_INVALID = 0x0,

    PEAK_VIDEO_CONTAINER_OPTION_FRAMERATE = 0x1

} peak_video_container_option;

typedef enum
{
    PEAK_VIDEO_ENCODER_OPTION_INVALID = 0x0,

    PEAK_VIDEO_ENCODER_OPTION_QUALITY = 0x1

} peak_video_encoder_option;

PEAK_API_STATUS peak_VideoWriter_Container_Option_Set(peak_video_handle hVideo,
    peak_video_container_option containerOption, const void* value, size_t count);

PEAK_API_STATUS peak_VideoWriter_Container_Option_Get(peak_video_handle hVideo,
    peak_video_container_option containerOption, void* value, size_t count, size_t* outCount);

PEAK_API_STATUS peak_VideoWriter_Encoder_Option_Set(peak_video_handle hVideo,
    peak_video_encoder_option encoderOption, const void* value, size_t count);

PEAK_API_STATUS peak_VideoWriter_Encoder_Option_Get(peak_video_handle hVideo,
    peak_video_encoder_option encoderOption, void* value, size_t count, size_t* outCount);

PEAK_API_STATUS peak_VideoWriter_WaitUntilQueueEmpty(peak_video_handle hVideo, int32_t timeout_ms);

typedef struct peak_inference* peak_inference_handle;

typedef struct peak_inference_result* peak_inference_result_handle;

typedef enum
{
    PEAK_INFERENCE_TYPE_INVALID        = 0x0,

    PEAK_INFERENCE_TYPE_DETECTION      = 0x1,

    PEAK_INFERENCE_TYPE_CLASSIFICATION = 0x2,
} peak_inference_type;

typedef enum
{
    PEAK_INFERENCE_PREPROCESSING_MODE_INVALID = 0x0,

    PEAK_INFERENCE_PREPROCESSING_MODE_CAFFE = 0x1,

    PEAK_INFERENCE_PREPROCESSING_MODE_TENSORFLOW = 0x2,
} peak_inference_preprocessing_mode;

typedef struct
{
    peak_inference_type type;

    float score;

    char label[256];

    peak_roi rect;

} peak_inference_result_detection;

typedef struct
{
    peak_inference_type type;

    float score;

    char label[256];

} peak_inference_result_classification;

typedef struct
{
    peak_inference_type type;

    peak_frame_handle frameHandle;

    uint32_t preprocessing_time_us;

    uint32_t inference_time_us;

    char reserved[256];

} peak_inference_result_data;

typedef struct
{
    uint32_t major;

    uint32_t minor;

    uint32_t subMinor;

    uint32_t patch;
} peak_version;


typedef struct
{
    peak_version fileVersion;

    char lighthouseID[256];

    uint64_t creationTime_s;

    char projectName[256];

    char networkName[256];

    peak_inference_type inferenceType;

    size_t inputWidth;

    size_t inputHeight;

    peak_pixel_format inputPixelFormat;

    peak_inference_preprocessing_mode preprocessingMode;

    size_t numberOfClasses;

    uint8_t reserved[256];
} peak_inference_info;

PEAK_API_STATUS peak_Inference_CNN_Open(const char* path, peak_inference_handle* hInference);

PEAK_API_STATUS peak_Inference_CNN_Close(peak_inference_handle hInference);

PEAK_API_STATUS peak_Inference_CNN_ProcessFrame(peak_inference_handle hInference, peak_frame_handle hFrame,
    peak_inference_result_handle* hInferenceHandle);

PEAK_API_STATUS peak_Inference_CNN_Info_Get(peak_inference_handle hInference, peak_inference_info* info);

PEAK_API_STATUS peak_Inference_Result_Get(peak_inference_result_handle hInferenceHandle,
    peak_inference_result_data* result);

PEAK_API_STATUS peak_Inference_Result_Release(peak_inference_result_handle hInferenceHandle);

PEAK_API_STATUS peak_Inference_Result_Classification_GetList(peak_inference_result_handle hInferenceHandle,
    peak_inference_result_classification* resultList, size_t* resultCount);

PEAK_API_STATUS peak_Inference_Result_Detection_GetList(peak_inference_result_handle hInferenceHandle,
    peak_inference_result_detection* resultList, size_t* resultCount);

typedef struct
{
    uint32_t numInferencesSuccessful;

    uint32_t numInferencesFailed;

    char reserved[256];
} peak_inference_statistics;

PEAK_API_STATUS peak_Inference_Statistics_Get(peak_inference_handle hInference, peak_inference_statistics* statistics);

PEAK_API_STATUS peak_Inference_Statistics_Reset(peak_inference_handle hInference);

PEAK_API_STATUS peak_Inference_ConfidenceThreshold_Get(peak_inference_handle hInference, uint32_t* threshold);

PEAK_API_STATUS peak_Inference_ConfidenceThreshold_GetRange(peak_inference_handle hInference, uint32_t* minThreshold,
    uint32_t* maxThreshold, uint32_t* incThreshold);

PEAK_API_STATUS peak_Inference_ConfidenceThreshold_Set(peak_inference_handle hInference, uint32_t threshold);

typedef enum
{
    PEAK_QUEUE_MODE_INVALID = 0,

    PEAK_QUEUE_MODE_OLDEST_FIRST,

    PEAK_QUEUE_MODE_NEWEST_ONLY

} peak_message_queue_mode;

typedef enum
{
    PEAK_MESSAGE_TYPE_INVALID = 0,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_CRITICAL_ERROR = 0x9011,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_ERROR = 0x9010,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_EVENT_DROPPED = 0x9012,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_EXPOSURE_START = 0x9000,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_EXPOSURE_END = 0x9001,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_FRAME_START = 0x9002,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_FRAME_DROPPED = 0x900B,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_MISSED_TRIGGER_EXPOSURE = 0x900C,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_MISSED_TRIGGER_LINE = 0x900D,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_PTP_MASTER_SYNC_LOST = 0x9013,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_TEMPERATURE = 0x900E,

    PEAK_MESSAGE_TYPE_REMOTE_DEVICE_TEST = 0x4FFF,

    PEAK_MESSAGE_TYPE_DEVICE_FOUND = 0x10001,

    PEAK_MESSAGE_TYPE_DEVICE_LOST = 0x10002,

    PEAK_MESSAGE_TYPE_DEVICE_RECONNECTED = 0x10003,

    PEAK_MESSAGE_TYPE_DEVICE_DISCONNECTED = 0x10004,

    PEAK_MESSAGE_TYPE_AUTO_FOCUS_ONCE_FINISHED = 0x20000,

    PEAK_MESSAGE_TYPE_AUTO_FOCUS_NEW_DATA = 0x20001,

    PEAK_MESSAGE_TYPE_AUTO_WHITEBALANCE_ONCE_FINISHED = 0x20002,

    PEAK_MESSAGE_TYPE_AUTO_BRIGHTNESS_GAIN_ONCE_FINISHED = 0x20003,

    PEAK_MESSAGE_TYPE_AUTO_BRIGHTNESS_EXPOSURE_ONCE_FINISHED = 0x20004,

    PEAK_MESSAGE_TYPE_AUTO_BRIGHTNESS_ONCE_FINISHED = 0x20005,
} peak_message_type;

typedef enum
{
    PEAK_MESSAGE_DATA_TYPE_INVALID = 0,

    PEAK_MESSAGE_DATA_TYPE_NO_DATA,

    PEAK_MESSAGE_DATA_TYPE_REMOTE_DEVICE,

    PEAK_MESSAGE_DATA_TYPE_REMOTE_DEVICE_ERROR,

    PEAK_MESSAGE_DATA_TYPE_REMOTE_DEVICE_DROPPED,

    PEAK_MESSAGE_DATA_TYPE_REMOTE_DEVICE_FRAME,

    PEAK_MESSAGE_DATA_TYPE_REMOTE_DEVICE_TEMPERATURE,

    PEAK_MESSAGE_DATA_TYPE_AUTOFOCUS_DATA,

    PEAK_MESSAGE_DATA_TYPE_DEVICE_FOUND,

    PEAK_MESSAGE_DATA_TYPE_DEVICE_LOST,

    PEAK_MESSAGE_DATA_TYPE_DEVICE_RECONNECTED,

    PEAK_MESSAGE_DATA_TYPE_DEVICE_DISCONNECTED,
} peak_message_data_type;

typedef struct
{
    int64_t timestamp_ns;

    uint8_t reserved[32];
} peak_message_data_remote_device;

typedef struct
{
    int64_t timestamp_ns;

    int64_t error_type;

    uint8_t reserved[32];
} peak_message_data_remote_device_error;

typedef struct
{
    int64_t timestamp_ns;

    int64_t count;

    uint8_t reserved[32];
} peak_message_data_remote_device_dropped;

typedef struct
{
    int64_t timestamp_ns;

    int64_t frameId;

    uint8_t reserved[32];
} peak_message_data_remote_device_frame;

typedef struct
{
    int64_t timestamp_ns;

    double temperature;

    uint8_t reserved[32];
} peak_message_data_remote_device_temperature;

typedef struct
{
    int32_t focusValue;

    int32_t sharpnessValue;

    uint8_t reserved[32];
} peak_message_data_autofocus;

typedef struct {
    peak_camera_descriptor cameraDescriptor;

    uint8_t reserved[32];
} peak_message_data_device_found;

typedef struct
{
    peak_camera_descriptor cameraDescriptor;

    uint8_t reserved[32];
} peak_message_data_device_lost;

typedef struct
{
    peak_camera_descriptor cameraDescriptor;

    peak_reconnect_information reconnectInformation;

    uint8_t reserved[32];
} peak_message_data_device_reconnected;

typedef struct
{
    peak_camera_descriptor cameraDescriptor;

    uint8_t reserved[32];
} peak_message_data_device_disconnected;

typedef struct
{
    uint64_t numQueued;

    uint64_t numDelivered;

    uint64_t numDropped;

    uint64_t numInQueue;

    uint64_t numMaxQueueSize;

    uint8_t reserved[32];
} peak_message_queue_statistics_info;

typedef struct
{
    peak_message_type type;

    peak_camera_handle hCam;

    uint64_t messageID;

    uint64_t hostMessageTimestamp_ns;

    peak_message_data_type dataType;

    uint8_t reserved[256];
} peak_message_info;

typedef struct peak_message_queue* peak_message_queue_handle;

typedef struct peak_message* peak_message_handle;

PEAK_API_STATUS peak_MessageQueue_Create(peak_message_queue_handle* hMessageQueue);

PEAK_API_STATUS peak_MessageQueue_Destroy(peak_message_queue_handle hMessageQueue);

PEAK_API_STATUS peak_MessageQueue_EnableMessage(peak_message_queue_handle hMessageQueue,
    peak_camera_handle hCam, peak_message_type messageType);
PEAK_API_STATUS peak_MessageQueue_DisableMessage(peak_message_queue_handle hMessageQueue,
    peak_camera_handle hCam, peak_message_type messageType);

PEAK_API_STATUS peak_MessageQueue_EnableMessageList(peak_message_queue_handle hMessageQueue,
    peak_camera_handle hCam, const peak_message_type* messageTypesArray, size_t messageTypesArraySize);

PEAK_API_STATUS peak_MessageQueue_DisableMessageList(peak_message_queue_handle hMessageQueue,
    peak_camera_handle hCam, const peak_message_type* messageTypesArray, size_t messageTypesArraySize);

PEAK_API_STATUS peak_MessageQueue_EnabledMessages_GetList(peak_message_queue_handle hMessageQueue,
    peak_message_type* messageTypesArray, size_t* messageTypesArraySize);

PEAK_API_STATUS peak_MessageQueue_SetMode(peak_message_queue_handle hMessageQueue,
    peak_message_queue_mode queueMode);

PEAK_API_STATUS peak_MessageQueue_GetMode(peak_message_queue_handle hMessageQueue,
    peak_message_queue_mode* queueMode);

PEAK_API_STATUS peak_MessageQueue_Start(peak_message_queue_handle hMessageQueue);

PEAK_API_STATUS peak_MessageQueue_Stop(peak_message_queue_handle hMessageQueue);

PEAK_API_BOOL peak_MessageQueue_IsStarted(peak_message_queue_handle hMessageQueue);

PEAK_API_STATUS peak_MessageQueue_WaitForMessage(peak_message_queue_handle hMessageQueue,
    uint32_t timeout_ms, peak_message_handle* hMessage);

PEAK_API_STATUS peak_MessageQueue_Flush(peak_message_queue_handle hMessageQueue);

PEAK_API_BOOL peak_MessageQueue_IsMessageSupported(peak_message_queue_handle hMessageQueue,
  peak_camera_handle hCam, peak_message_type messageType);

PEAK_API_STATUS peak_MessageQueue_Statistics_Get(peak_message_queue_handle hMessageQueue,
    peak_message_queue_statistics_info* messageQueueInfo);

PEAK_API_STATUS peak_MessageQueue_Statistics_Reset(peak_message_queue_handle hMessageQueue);

PEAK_API_STATUS peak_MessageQueue_MaxQueueSize_Set(peak_message_queue_handle hMessageQueue,
    size_t messageQueueMaxSize);

PEAK_API_STATUS peak_MessageQueue_MaxQueueSize_Get(peak_message_queue_handle hMessageQueue,
    size_t* messageQueueMaxSize);

PEAK_API_STATUS peak_Message_Release(peak_message_handle hMessage);

PEAK_API_STATUS peak_Message_GetInfo(peak_message_handle hMessage,
    peak_message_info* messageInfo);

PEAK_API_STATUS peak_Message_Type_Get(peak_message_handle hMessage,
    peak_message_type* messageType);

PEAK_API_STATUS peak_Message_CameraHandle_Get(peak_message_handle hMessage,
    peak_camera_handle* hCam);

PEAK_API_STATUS peak_Message_ID_Get(peak_message_handle hMessage, uint64_t* messageID);

PEAK_API_STATUS peak_Message_HostTimestamp_Get(peak_message_handle hMessage,
    uint64_t* hostTimestamp_ns);

PEAK_API_STATUS peak_Message_Data_Type_Get(peak_message_handle hMessage,
    peak_message_data_type* messageType);

PEAK_API_STATUS peak_Message_Data_RemoteDevice_Get(peak_message_handle hMessage,
    peak_message_data_remote_device* message);

PEAK_API_STATUS peak_Message_Data_RemoteDeviceError_Get(peak_message_handle hMessage,
    peak_message_data_remote_device_error* message);

PEAK_API_STATUS peak_Message_Data_RemoteDeviceDropped_Get(peak_message_handle hMessage,
    peak_message_data_remote_device_dropped* message);

PEAK_API_STATUS peak_Message_Data_RemoteDeviceFrame_Get(peak_message_handle hMessage,
    peak_message_data_remote_device_frame* message);

PEAK_API_STATUS peak_Message_Data_RemoteDeviceTemperature_Get(peak_message_handle hMessage,
    peak_message_data_remote_device_temperature* message);

PEAK_API_STATUS peak_Message_Data_AutoFocusData_Get(peak_message_handle hMessage,
    peak_message_data_autofocus* message);

PEAK_API_STATUS peak_Message_Data_DeviceFound_Get(peak_message_handle hMessage,
    peak_message_data_device_found* message);

PEAK_API_STATUS peak_Message_Data_DeviceLost_Get(peak_message_handle hMessage,
    peak_message_data_device_lost* message);

PEAK_API_STATUS peak_Message_Data_DeviceReconnected_Get(peak_message_handle hMessage,
    peak_message_data_device_reconnected* message);

PEAK_API_STATUS peak_Message_Data_DeviceDisconnected_Get(peak_message_handle hMessage,
    peak_message_data_device_disconnected* message);

typedef struct peak_i2c* peak_i2c_handle;

PEAK_API_STATUS peak_I2C_Create(peak_camera_handle hCam, peak_i2c_handle* hI2C);

PEAK_API_STATUS peak_I2C_Destroy(peak_i2c_handle hI2C);

PEAK_API_ACCESS_STATUS peak_I2C_GetAccessStatus(peak_i2c_handle hI2C);

typedef enum
{
    PEAK_I2C_MODE_INVALID = 0,
    PEAK_I2C_MODE_STANDARD = 100,
    PEAK_I2C_MODE_FAST = 400, 
    PEAK_I2C_MODE_FAST_PLUS = 1000
} peak_i2c_mode;

PEAK_API_STATUS peak_I2C_Mode_GetList(peak_i2c_handle hI2C, peak_i2c_mode* modeList, size_t* modeListSize);

PEAK_API_STATUS peak_I2C_Mode_Set(peak_i2c_handle hI2C, peak_i2c_mode mode);

PEAK_API_STATUS peak_I2C_Mode_Get(peak_i2c_handle hI2C, peak_i2c_mode* mode);

PEAK_API_STATUS peak_I2C_DeviceAddress_GetRange(peak_i2c_handle hI2C, uint32_t* minAddress, uint32_t* maxAddress);

PEAK_API_STATUS peak_I2C_DeviceAddress_Set(peak_i2c_handle hI2C, uint32_t address);

PEAK_API_STATUS peak_I2C_DeviceAddress_Get(peak_i2c_handle hI2C, uint32_t* address);

typedef enum
{
    PEAK_I2C_REGISTER_ADDRESS_LENGTH_INVALID = 0,
    PEAK_I2C_REGISTER_ADDRESS_LENGTH_0BIT = 1,
    PEAK_I2C_REGISTER_ADDRESS_LENGTH_8BIT = 2,
    PEAK_I2C_REGISTER_ADDRESS_LENGTH_16BIT = 3, 
    PEAK_I2C_REGISTER_ADDRESS_LENGTH_24BIT = 4
} peak_i2c_register_address_length;

PEAK_API_STATUS peak_I2C_RegisterAddress_Length_GetList(peak_i2c_handle hI2C,
    peak_i2c_register_address_length* i2cLengthList, size_t* i2cLengthCount);

PEAK_API_STATUS peak_I2C_RegisterAddress_Length_Set(peak_i2c_handle hI2C, peak_i2c_register_address_length length);

PEAK_API_STATUS peak_I2C_RegisterAddress_Length_Get(peak_i2c_handle hI2C, peak_i2c_register_address_length* length);

typedef enum
{
    PEAK_ENDIANNESS_INVALID = 0,

    PEAK_ENDIANNESS_BIG_ENDIAN = 1,

    PEAK_ENDIANNESS_LITTLE_ENDIAN = 2,
} peak_endianness;

PEAK_API_STATUS peak_I2C_RegisterAddress_Endianness_Set(peak_i2c_handle hI2C, peak_endianness endianness);

PEAK_API_STATUS peak_I2C_RegisterAddress_Endianness_Get(peak_i2c_handle hI2C, peak_endianness* endianness);

PEAK_API_STATUS peak_I2C_RegisterAddress_Set(peak_i2c_handle hI2C, uint32_t address);

PEAK_API_STATUS peak_I2C_RegisterAddress_Get(peak_i2c_handle hI2C, uint32_t* address);

PEAK_API_STATUS peak_I2C_AckPolling_Enable(peak_i2c_handle hI2C, peak_bool enabled);

PEAK_API_BOOL peak_I2C_AckPolling_IsEnabled(peak_i2c_handle hI2C);

PEAK_API_ACCESS_STATUS peak_I2C_AckPolling_Timeout_GetAccessStatus(peak_i2c_handle hI2C);

PEAK_API_STATUS peak_I2C_AckPolling_Timeout_GetRange(peak_i2c_handle hI2C, uint32_t* minTimeout_ms, uint32_t* maxTimeout_ms, uint32_t* incTimeout_ms);

PEAK_API_STATUS peak_I2C_AckPolling_Timeout_Set(peak_i2c_handle hI2C, uint32_t timeout_ms);

PEAK_API_STATUS peak_I2C_AckPolling_Timeout_Get(peak_i2c_handle hI2C, uint32_t* timeout_ms);

PEAK_API_STATUS peak_I2C_Data_Write(peak_i2c_handle hI2C, const uint8_t* data, size_t dataSize);

PEAK_API_STATUS peak_I2C_Data_Read(peak_i2c_handle hI2C, size_t maxDataSize, uint8_t* data, size_t* dataSize);

PEAK_API_STATUS peak_I2C_Data_MaxSize_Get(peak_i2c_handle hI2C, size_t* maxDataSize);

typedef enum
{
    PEAK_I2C_OPERATION_STATUS_INVALID = 0,

    PEAK_I2C_OPERATION_STATUS_READY = 1,

    PEAK_I2C_OPERATION_STATUS_ERROR = 2,

    PEAK_I2C_OPERATION_STATUS_TIMEOUT_ERROR = 3,

    PEAK_I2C_OPERATION_STATUS_INVALID_DEVICE_ADDRESS = 4
} peak_i2c_operation_status;

PEAK_API_STATUS peak_I2C_OperationStatus_Get(peak_i2c_handle hI2C, peak_i2c_operation_status* operationStatus);

#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus

#endif // PEAK_COMFORT_C_H