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);
 
typedef struct
{
    double min;
    double max;
}
peak_double_limit;
 
PEAK_API_STATUS peak_IPL_AutoBrightness_ExposureLimit_Get(peak_camera_handle hCam, peak_double_limit* exposureLimit);
 
PEAK_API_STATUS peak_IPL_AutoBrightness_ExposureLimit_Set(peak_camera_handle hCam, peak_double_limit exposureLimit);
 
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);
 
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_AutoBrightness_SkipFrames_Set(peak_camera_handle hCam, uint32_t skipFrames);
 
PEAK_API_STATUS peak_IPL_AutoBrightness_SkipFrames_Get(peak_camera_handle hCam, uint32_t* skipFrames);
 
PEAK_API_STATUS peak_IPL_AutoBrightness_SkipFrames_GetRange(peak_camera_handle hCam,
    uint32_t* skipFramesMin, uint32_t* skipFramesMax, uint32_t* skipFramesInc);
 
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);
 
 
PEAK_API_STATUS peak_IPL_AutoWhiteBalance_SkipFrames_Set(peak_camera_handle hCam, uint32_t skipFrames);
 
PEAK_API_STATUS peak_IPL_AutoWhiteBalance_SkipFrames_Get(peak_camera_handle hCam, uint32_t* skipFrames);
 
PEAK_API_STATUS peak_IPL_AutoWhiteBalance_SkipFrames_GetRange(peak_camera_handle hCam,
    uint32_t* skipFramesMin, uint32_t* skipFramesMax, uint32_t* skipFramesInc);
 
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