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 PEAK_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
 
#if !defined(PEAK_NO_WARN_DEPRECATED)
#    if defined(__cplusplus) && __cplusplus >= 201402L || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
#        define PEAK_DEPRECATED_ATTR [[ deprecated ]]
#        define PEAK_DEPRECATED_ATTR_MSG(X) [[ deprecated(X) ]]
#        define PEAK_DEPRECATED(X) X PEAK_DEPRECATED_ATTR
#        define PEAK_DEPRECATED_MSG(X, Y) X [[ deprecated(Y) ]]
#    elif defined(__GNUC__)
#        define PEAK_DEPRECATED_ATTR __attribute__(( deprecated ))
#        define PEAK_DEPRECATED_ATTR_MSG(X) __attribute__(( deprecated(X) ))
#        define PEAK_DEPRECATED(X) X PEAK_DEPRECATED_ATTR
#        define PEAK_DEPRECATED_MSG(X, Y) X __attribute__(( deprecated(Y) ))
#    else
#        define PEAK_DEPRECATED_ATTR
#        define PEAK_DEPRECATED_ATTR_MSG(X)
#        define PEAK_DEPRECATED(X) X
#        define PEAK_DEPRECATED_MSG(X, Y) X
#    endif
#    if defined(__cplusplus) && __cplusplus >= 201703L || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) \
        || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
#        define PEAK_DEPRECATED_ENUM_ATTR [[deprecated]]
#        define PEAK_DEPRECATED_ENUM_MSG(X, Y) X [[ deprecated(Y) ]]
#    elif defined(__GNUC__)
#        define PEAK_DEPRECATED_ENUM_ATTR __attribute__((deprecated))
#        define PEAK_DEPRECATED_ENUM_MSG(X, Y) X __attribute__(( deprecated(Y) ))
#    else
#        define PEAK_DEPRECATED_ENUM_ATTR
#        define PEAK_DEPRECATED_ENUM_MSG(X, Y) X
#    endif
#else
#    define PEAK_DEPRECATED_ATTR
#    define PEAK_DEPRECATED_ENUM_ATTR
#    define PEAK_DEPRECATED_ENUM_MSG(X, Y) X
#    define PEAK_DEPRECATED_ATTR_MSG(X)
#    define PEAK_DEPRECATED(X) X
#    define PEAK_DEPRECATED_MSG(X, Y) X
#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;
struct peak_imagewriter;
struct peak_histogram;
 
#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_STATUS_DEPRECATED(X) PEAK_EXPORT PEAK_DEPRECATED_ATTR_MSG(X) 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_NOT_SUPPORTED              = 0x8012
 
} 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 = 0x0,

    PEAK_INTERFACE_TECHNOLOGY_GEV = 0x1,

    PEAK_INTERFACE_TECHNOLOGY_U3V = 0x2,

    PEAK_INTERFACE_TECHNOLOGY_UEYE = 0x3,
 
    PEAK_DEPRECATED_ENUM_MSG(peak_interface_technology_INVALID, "Use PEAK_INTERFACE_TECHNOLOGY_INVALID instead") = 0x0,
    PEAK_DEPRECATED_ENUM_MSG(peak_interface_technology_GEV, "Use PEAK_INTERFACE_TECHNOLOGY_GEV instead") = 0x1,
    PEAK_DEPRECATED_ENUM_MSG(peak_interface_technology_U3V, "Use PEAK_INTERFACE_TECHNOLOGY_U3V instead") = 0x2,
    PEAK_DEPRECATED_ENUM_MSG(peak_interface_technology_UEYE, "Use PEAK_INTERFACE_TECHNOLOGY_UEYE instead") = 0x3,
} 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* patchVersion,
    uint32_t* legacyVersion);

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_BUFFER_HANDLING_MODE_INVALID,

    PEAK_BUFFER_HANDLING_MODE_OLDEST_FIRST,

    PEAK_BUFFER_HANDLING_MODE_NEWEST_ONLY,

    PEAK_BUFFER_HANDLING_MODE_OLDEST_FIRST_SINGLE_BUFFER,

    PEAK_BUFFER_HANDLING_MODE_OLDEST_FIRST_DEPEND_ON_CAMERA_FIFO,
}peak_buffer_handling_mode;

PEAK_API_ACCESS_STATUS peak_Acquisition_BufferHandling_Mode_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Acquisition_BufferHandling_Mode_GetList(peak_camera_handle hCam, peak_buffer_handling_mode* bufferHandlingModeList, size_t* bufferHandlingModesCount);

PEAK_API_STATUS peak_Acquisition_BufferHandling_Mode_Set(peak_camera_handle hCam, peak_buffer_handling_mode mode);

PEAK_API_STATUS peak_Acquisition_BufferHandling_Mode_Get(peak_camera_handle hCam, peak_buffer_handling_mode* mode);

typedef enum 
{
    PEAK_LOSS_HANDLING_MODE_INVALID,

    PEAK_LOSS_HANDLING_MODE_OFF,

    PEAK_LOSS_HANDLING_MODE_LIMITED,

    PEAK_LOSS_HANDLING_MODE_UNLIMITED,
 
}peak_loss_handling_mode;

PEAK_API_ACCESS_STATUS peak_Acquisition_LossHandling_Mode_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Acquisition_LossHandling_Mode_GetList(peak_camera_handle hCam, peak_loss_handling_mode* lossHandlingModeList, size_t* lossHandlingModesCount);

PEAK_API_STATUS peak_Acquisition_LossHandling_Mode_Set(peak_camera_handle hCam, peak_loss_handling_mode mode);

PEAK_API_STATUS peak_Acquisition_LossHandling_Mode_Get(peak_camera_handle hCam, peak_loss_handling_mode* mode);

PEAK_API_ACCESS_STATUS peak_Acquisition_LossHandling_Extent_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Acquisition_LossHandling_Extent_GetRange(peak_camera_handle hCam, int64_t* minExtent, int64_t* maxExtent, int64_t* incExtent);

PEAK_API_STATUS peak_Acquisition_LossHandling_Extent_Set(peak_camera_handle hCam, int64_t extent);

PEAK_API_STATUS peak_Acquisition_LossHandling_Extent_Get(peak_camera_handle hCam, int64_t* extent);

PEAK_API_ACCESS_STATUS peak_Acquisition_LossHandling_FrameAbortTimeout_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Acquisition_LossHandling_FrameAbortTimeout_GetRange(peak_camera_handle hCam, int64_t* minTimeout, int64_t* maxTimeout, int64_t* incTimeout);

PEAK_API_STATUS peak_Acquisition_LossHandling_FrameAbortTimeout_Set(peak_camera_handle hCam, int64_t timeout);

PEAK_API_STATUS peak_Acquisition_LossHandling_FrameAbortTimeout_Get(peak_camera_handle hCam, int64_t* timeout);

PEAK_API_ACCESS_STATUS peak_Acquisition_LossHandling_ResendRequestTimeout_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Acquisition_LossHandling_ResendRequestTimeout_GetRange(peak_camera_handle hCam, int64_t* minTimeout,
     int64_t* maxTimeout, int64_t* incTimeout);

PEAK_API_STATUS peak_Acquisition_LossHandling_ResendRequestTimeout_Set(peak_camera_handle hCam, int64_t timeout);

PEAK_API_STATUS peak_Acquisition_LossHandling_ResendRequestTimeout_Get(peak_camera_handle hCam, int64_t* timeout);

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_YUV422_8_UYVY     = 0x0210001F,

    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);

PEAK_API_STATUS peak_Frame_Save(peak_frame_handle hFrame, const char* fileName);

PEAK_API_BOOL peak_Frame_HasChunks(peak_frame_handle hFrame);

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_ShutterMode_GetAccessStatus(peak_camera_handle hCam);

typedef enum
{
    PEAK_SHUTTER_MODE_UNKNOWN        = 0,

    PEAK_SHUTTER_MODE_ROLLING        = 0x1,

    PEAK_SHUTTER_MODE_GLOBAL         = 0x2,

    PEAK_SHUTTER_MODE_GLOBAL_RESET   = 0x3,
 
} peak_shutter_mode;

PEAK_API_STATUS peak_ShutterMode_GetList(peak_camera_handle hCam, peak_shutter_mode* shutterModeList, size_t* shutterModeCount);

PEAK_API_STATUS peak_ShutterMode_Set(peak_camera_handle hCam, peak_shutter_mode shutterMode);

PEAK_API_STATUS peak_ShutterMode_Get(peak_camera_handle hCam, peak_shutter_mode* shutterMode);

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_DEPRECATED_ENUM_MSG(PEAK_IO_CHANNEL_TRIGGER_INPUT, "Use PEAK_IO_CHANNEL_LINE_0 instead") = 0x2101,

    PEAK_DEPRECATED_ENUM_MSG(PEAK_IO_CHANNEL_FLASH_OUTPUT, "Use PEAK_IO_CHANNEL_LINE_1 instead") = 0x2201,

    PEAK_DEPRECATED_ENUM_MSG(PEAK_IO_CHANNEL_GPIO_1, "Use PEAK_IO_CHANNEL_LINE_2 instead") = 0x6301,

    PEAK_DEPRECATED_ENUM_MSG(PEAK_IO_CHANNEL_GPIO_2, "Use PEAK_IO_CHANNEL_LINE_3 instead") = 0x6302,

    PEAK_IO_CHANNEL_LINE_0          = 0x8000,

    PEAK_IO_CHANNEL_LINE_1          = 0x8001,

    PEAK_IO_CHANNEL_LINE_2          = 0x8002,

    PEAK_IO_CHANNEL_LINE_3          = 0x8003,

    PEAK_IO_CHANNEL_LINE_4          = 0x8004,

    PEAK_IO_CHANNEL_LINE_5          = 0x8005,

    PEAK_IO_CHANNEL_LINE_6          = 0x8006,

    PEAK_IO_CHANNEL_LINE_7          = 0x8007,
 
} peak_io_channel;

PEAK_API_ACCESS_STATUS peak_IOChannel_GetAccessStatus(peak_camera_handle hCam, peak_io_channel ioChannel);

typedef enum
{
    PEAK_IO_DIRECTION_UNKNOWN        = 0,

    PEAK_IO_DIRECTION_INPUT          = 0x1,

    PEAK_IO_DIRECTION_OUTPUT         = 0x2,

    PEAK_IO_DIRECTION_ANY            = 0x10
 
} peak_io_direction;

PEAK_API_STATUS_DEPRECATED("Use peak_IOChannel_GetListForDirection instead")
    peak_IOChannel_GetList(peak_camera_handle hCam, peak_io_channel* ioChannelList, size_t* ioChannelCount);

PEAK_API_STATUS peak_IOChannel_GetListForDirection(peak_camera_handle hCam,
    peak_io_direction direction, peak_io_channel* ioChannelList, size_t* ioChannelCount);

PEAK_API_ACCESS_STATUS peak_IOChannel_Direction_GetAccessStatus(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_STATUS peak_IOChannel_Direction_Get(peak_camera_handle hCam, peak_io_channel ioChannel, peak_io_direction* direction );

typedef enum
{
 PEAK_IO_TYPE_INVALID = 0,

 PEAK_IO_TYPE_UNKNOWN = 1,

 PEAK_IO_TYPE_TRI_STATE = 2,

 PEAK_IO_TYPE_OPTO_COUPLED = 3,

 PEAK_IO_TYPE_LVTTL = 4
 
} peak_io_type;

PEAK_API_ACCESS_STATUS peak_IOChannel_Type_GetAccessStatus(peak_camera_handle hCam, peak_io_channel ioChannel);

PEAK_API_STATUS peak_IOChannel_Type_Get(peak_camera_handle hCam, peak_io_channel ioChannel, peak_io_type* type);

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_STATUS peak_IOChannel_Level_SetHigh(peak_camera_handle hCam, peak_io_channel ioChannel, peak_bool high);

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_DEPRECATED("Use peak_Trigger_Mode_Config_Get instead")
peak_Trigger_Mode_Get(peak_camera_handle hCam, peak_trigger_mode* triggerMode);

PEAK_API_STATUS peak_Trigger_Mode_Config_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_LINE_1_SIGNAL          = 0x0001,

    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_DEPRECATED("Use peak_Flash_Mode_Config_Get instead")
    peak_Flash_Mode_Get(peak_camera_handle hCam, peak_flash_mode* flashMode);

PEAK_API_STATUS peak_Flash_Mode_Config_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_BRIGHTNESS_ALGORITHM_INVALID     = 0,

    PEAK_AUTO_FEATURE_BRIGHTNESS_ALGORITHM_MEDIAN      = 0x0001,

    PEAK_AUTO_FEATURE_BRIGHTNESS_ALGORITHM_MEAN        = 0x0002
 
} peak_auto_feature_brightness_algorithm;

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_ACCESS_STATUS peak_AutoBrightness_Target_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_ACCESS_STATUS peak_AutoBrightness_TargetTolerance_GetAccessStatus(peak_camera_handle hCam);

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_ACCESS_STATUS peak_AutoBrightness_TargetPercentile_GetAccessStatus(peak_camera_handle hCam);

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_ACCESS_STATUS peak_AutoBrightness_ROI_GetAccessStatus(peak_camera_handle hCam);

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_GetList(peak_camera_handle hCam,
    peak_auto_feature_mode* modeList, size_t* modeListSize);

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_GetList(peak_camera_handle hCam,
    peak_auto_feature_mode* modeList, size_t* modeListSize);

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_ACCESS_STATUS peak_AutoWhiteBalance_ROI_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_STATUS peak_AutoWhiteBalance_Mode_GetList(peak_camera_handle hCam,
    peak_auto_feature_mode* modeList, size_t* modeListSize);

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_ACCESS_STATUS peak_ROI_Offset_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_ROI_Offset_Set(peak_camera_handle hCam, peak_position position);

PEAK_API_STATUS peak_ROI_Offset_Get(peak_camera_handle hCam, peak_position* position);

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

PEAK_API_ACCESS_STATUS peak_ROI_Size_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_ROI_Size_Set(peak_camera_handle hCam, peak_size size);

PEAK_API_STATUS peak_ROI_Size_Get(peak_camera_handle hCam, peak_size* size);

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);

typedef enum {
    PEAK_SUBSAMPLING_ENGINE_INVALID,
    PEAK_SUBSAMPLING_ENGINE_FPGA,
    PEAK_SUBSAMPLING_ENGINE_SENSOR,
    PEAK_SUBSAMPLING_ENGINE_UEYE,
} peak_subsampling_engine;

PEAK_API_ACCESS_STATUS peak_BinningManual_GetAccessStatus(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine);

PEAK_API_STATUS peak_BinningManual_FactorX_GetList(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine, uint32_t* binningFactorXList, size_t* binningFactorXCount);

PEAK_API_STATUS peak_BinningManual_FactorY_GetList(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine, uint32_t* binningFactorYList, size_t* binningFactorYCount);

PEAK_API_STATUS peak_BinningManual_Set(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine, uint32_t binningFactorX, uint32_t binningFactorY);

PEAK_API_STATUS peak_BinningManual_Get(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine, 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_DecimationManual_GetAccessStatus(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine);

PEAK_API_STATUS peak_DecimationManual_FactorX_GetList(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine, uint32_t* decimationFactorXList, size_t* decimationFactorXCount);

PEAK_API_STATUS peak_DecimationManual_FactorY_GetList(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine, uint32_t* decimationFactorYList, size_t* decimationFactorYCount);

PEAK_API_STATUS peak_DecimationManual_Set(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine, uint32_t decimationFactorX, uint32_t decimationFactorY);

PEAK_API_STATUS peak_DecimationManual_Get(peak_camera_handle hCam,
    peak_subsampling_engine subsamplingEngine, uint32_t *decimationFactorX, uint32_t *decimationFactorY);

PEAK_API_ACCESS_STATUS peak_Scaling_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Scaling_FactorX_GetRange(peak_camera_handle hCam, double* minScalingFactorX,
    double* maxScalingFactorX, double* incScalingFactorX);

PEAK_API_STATUS peak_Scaling_FactorY_GetRange(peak_camera_handle hCam, double* minScalingFactorY,
    double* maxScalingFactorY, double* incScalingFactorY);

PEAK_API_STATUS peak_Scaling_Set(peak_camera_handle hCam, double scalingFactorX, double scalingFactorY);

PEAK_API_STATUS peak_Scaling_Get(peak_camera_handle hCam, double* scalingFactorX, double* scalingFactorY);

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);

typedef enum
{
    PEAK_CHROMATIC_ADAPTION_ALGORITHM_INVALID   = 0x00,

    PEAK_CHROMATIC_ADAPTION_ALGORITHM_LEGACY   = 0x01,

    PEAK_CHROMATIC_ADAPTION_ALGORITHM_BRADFORD = 0x02
} peak_chromatic_adaption_algorithm;
 

typedef enum
{
    PEAK_CHROMATIC_ADAPTION_COLOR_SPACE_INVALID       = 0x00,

    PEAK_CHROMATIC_ADAPTION_COLOR_SPACE_SRGB_D50      = 0x01,

    PEAK_CHROMATIC_ADAPTION_COLOR_SPACE_SRGB_D65      = 0x02,

    PEAK_CHROMATIC_ADAPTION_COLOR_SPACE_CIE_RGB_E     = 0x03,

    PEAK_CHROMATIC_ADAPTION_COLOR_SPACE_ECI_RGB_D50   = 0x04,

    PEAK_CHROMATIC_ADAPTION_COLOR_SPACE_ADOBE_RGB_D65 = 0x05
} peak_chromatic_adaption_color_space;

PEAK_API_STATUS peak_IPL_ColorCorrection_ChromaticAdaption_ColorSpace_Get(peak_camera_handle hCam,
    peak_chromatic_adaption_color_space* colorSpace);

PEAK_API_STATUS peak_IPL_ColorCorrection_ChromaticAdaption_ColorSpace_Set(peak_camera_handle hCam,
    peak_chromatic_adaption_color_space colorSpace);

PEAK_API_STATUS peak_IPL_ColorCorrection_ChromaticAdaption_Algorithm_Get(peak_camera_handle hCam,
    peak_chromatic_adaption_algorithm* algorithm);

PEAK_API_STATUS peak_IPL_ColorCorrection_ChromaticAdaption_Algorithm_Set(peak_camera_handle hCam,
    peak_chromatic_adaption_algorithm algorithm);

PEAK_API_STATUS peak_IPL_ColorCorrection_ChromaticAdaption_ColorTemperature_Get(
    peak_camera_handle hCam, uint32_t* colorTemperature);

PEAK_API_STATUS peak_IPL_ColorCorrection_ChromaticAdaption_ColorTemperature_Set(
    peak_camera_handle hCam, uint32_t colorTemperature);

PEAK_API_STATUS peak_IPL_ColorCorrection_ChromaticAdaption_ColorTemperature_GetRange(
    peak_camera_handle hCam, uint32_t* minColorTemperature, uint32_t* maxColorTemperature, uint32_t* incColorTemperature);

PEAK_API_STATUS peak_IPL_ColorCorrection_ChromaticAdaption_Enable(peak_camera_handle hCam,
    peak_bool enable);

PEAK_API_BOOL peak_IPL_ColorCorrection_ChromaticAdaption_IsEnabled(peak_camera_handle hCam);

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_GetRange(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_GainAnalog_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainAnalog_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainDigital_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainDigital_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainCombined_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainCombined_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainHost_Mode_Set(peak_camera_handle hCam, peak_auto_feature_mode autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainHost_Mode_Get(peak_camera_handle hCam, peak_auto_feature_mode* autoGainMode);

PEAK_API_STATUS peak_IPL_AutoBrightness_Algorithm_Set(peak_camera_handle hCam, peak_auto_feature_brightness_algorithm algorithm);

PEAK_API_STATUS peak_IPL_AutoBrightness_Algorithm_Get(peak_camera_handle hCam, peak_auto_feature_brightness_algorithm* algorithm);

PEAK_API_STATUS peak_IPL_AutoBrightness_AverageLast_Get(peak_camera_handle hCam, uint32_t* lastAverage);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainLimit_Set(peak_camera_handle hCam, peak_double_limit gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainLimit_Get(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_GainAnalogLimit_Set(peak_camera_handle hCam, peak_double_limit gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainAnalogLimit_Get(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainAnalogLimit_GetRange(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainDigitalLimit_Set(peak_camera_handle hCam, peak_double_limit gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainDigitalLimit_Get(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainDigitalLimit_GetRange(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainCombinedLimit_Set(peak_camera_handle hCam, peak_double_limit gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainCombinedLimit_Get(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainCombinedLimit_GetRange(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainHostLimit_Set(peak_camera_handle hCam, peak_double_limit gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainHostLimit_Get(peak_camera_handle hCam, peak_double_limit* gainLimit);

PEAK_API_STATUS peak_IPL_AutoBrightness_GainHostLimit_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_ReadImage(
    peak_camera_handle hCam, const char* path, 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);

PEAK_API_STATUS peak_IPL_Sharpness_GetList(peak_sharpness_algorithm sharpnessAlgorithm, peak_pixel_format* pixelFormatList, size_t* pixelFormatSize);
 

#define PEAK_ROTATION_ANGLE_0 (0)

#define PEAK_ROTATION_ANGLE_180 (180)

#define PEAK_ROTATION_ANGLE_CLOCKWISE_90 (-90)

#define PEAK_ROTATION_ANGLE_CLOCKWISE_270 (-270)

#define PEAK_ROTATION_ANGLE_COUNTERCLOCKWISE_90 (90)

#define PEAK_ROTATION_ANGLE_COUNTERCLOCKWISE_270 (270)

PEAK_API_STATUS peak_IPL_Rotation_Angle_Set(peak_camera_handle hCam, int32_t rotationAngle);

PEAK_API_STATUS peak_IPL_Rotation_Angle_Get(peak_camera_handle hCam, int32_t* rotationAngle);

typedef struct
{
    uint64_t pixelSum;

    uint64_t pixelCount;

    size_t binSize;

    uint8_t reserved[64];
} peak_histogram_channel_info;

typedef struct peak_histogram* peak_histogram_handle;

PEAK_API_STATUS peak_IPL_Histogram_ProcessFrame(peak_frame_handle hFrame,
    peak_histogram_handle* hHistogram);

PEAK_API_STATUS peak_IPL_Histogram_Release(peak_histogram_handle hHistogram);

PEAK_API_STATUS peak_IPL_Histogram_Channel_GetCount(peak_histogram_handle hHistogram, size_t* numChannels);

PEAK_API_STATUS peak_IPL_Histogram_Channel_GetInfo(peak_histogram_handle hHistogram, size_t channel, peak_histogram_channel_info* channelInfo);

PEAK_API_STATUS peak_IPL_Histogram_Channel_GetBinArray(peak_histogram_handle hHistogram, size_t channel, uint64_t* binArray, size_t* binArraySize);

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;

    PEAK_DEPRECATED_MSG(uint32_t subMinor, "Deprecated due to SemVer 2.0 migration.");

    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_FIRMWARE_UPDATE = 0x30000,
} 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_FIRMWARE_UPDATE,
} 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 enum
{
    PEAK_FIRMWARE_UPDATE_STEP_TOTAL = 0x0,
    PEAK_FIRMWARE_UPDATE_STEP_CHECKPRECONDITIONS,
    PEAK_FIRMWARE_UPDATE_STEP_ACQUIREUPDATEDATA,
    PEAK_FIRMWARE_UPDATE_STEP_WRITEFEATURE,
    PEAK_FIRMWARE_UPDATE_STEP_EXECUTEFEATURE,
    PEAK_FIRMWARE_UPDATE_STEP_ASSERTFEATURE,
    PEAK_FIRMWARE_UPDATE_STEP_UPLOADFILE,
    PEAK_FIRMWARE_UPDATE_STEP_RESETDEVICE
} peak_firmware_update_step;

typedef enum
{
    PEAK_FIRMWARE_UPDATE_STATUS_STARTED = 0x0,
    PEAK_FIRMWARE_UPDATE_STATUS_PROGRESS,
    PEAK_FIRMWARE_UPDATE_STATUS_FINSIHED,
    PEAK_FIRMWARE_UPDATE_STATUS_FAILED,
} peak_firmware_update_status;

typedef struct
{
    peak_camera_id cameraId;

    char serialNumber[64];

    peak_firmware_update_step step;

    peak_firmware_update_status stepStatus;

    double stepProgressPercentage;

    char description[256];

    char reserved[32];
} peak_message_data_firmware_update;

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);

PEAK_API_STATUS peak_Message_Data_FirmwareUpdate_Get(peak_message_handle hMessage,
    peak_message_data_firmware_update* 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);
 

typedef struct peak_imagewriter* peak_imagewriter_handle;

PEAK_API_STATUS peak_IPL_ImageWriter_Create(peak_imagewriter_handle* hImageWriter);

PEAK_API_STATUS peak_IPL_ImageWriter_Destroy(peak_imagewriter_handle hImageWriter);

PEAK_API_STATUS peak_IPL_ImageWriter_Save(peak_imagewriter_handle hImageWriter, peak_frame_handle hFrame, const char* fileName);

typedef enum
{
    PEAK_IMAGEFILE_FORMAT_INVALID = 0,

    PEAK_IMAGEFILE_FORMAT_PNG,

    PEAK_IMAGEFILE_FORMAT_JPEG,

    PEAK_IMAGEFILE_FORMAT_TIFF,

    PEAK_IMAGEFILE_FORMAT_BMP,

    PEAK_IMAGEFILE_FORMAT_RAW
 
} peak_imagefile_format, PEAK_DEPRECATED_MSG(papientitiy_imagefile_format, "use peak_imagefile_format");

PEAK_API_STATUS peak_IPL_ImageWriter_Format_Set(peak_imagewriter_handle hImageWriter, peak_imagefile_format imageFormat);

PEAK_API_STATUS peak_IPL_ImageWriter_Format_Get(peak_imagewriter_handle hImageWriter, peak_imagefile_format* imageFormat);

PEAK_API_STATUS peak_IPL_ImageWriter_Compression_Set(peak_imagewriter_handle hImageWriter, uint32_t compression);

PEAK_API_STATUS peak_IPL_ImageWriter_Compression_Get(peak_imagewriter_handle hImageWriter, uint32_t* compression);

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

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

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

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

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

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

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

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

PEAK_API_STATUS peak_FirmwareUpdate_CompatibleCameraList_Get(const char* gufFileName, peak_camera_descriptor* cameraList, size_t* cameraCount);

PEAK_API_STATUS peak_FirmwareUpdate_Execute(peak_camera_id cameraID, const char* gufFileName);

typedef enum {
    PEAK_TEST_PATTERN_INVALID,

    PEAK_TEST_PATTERN_OFF,
    PEAK_TEST_PATTERN_BLACK,
    PEAK_TEST_PATTERN_CHESSPATTERN,
    PEAK_TEST_PATTERN_COLORBAR,
    PEAK_TEST_PATTERN_FPGABLACK,
    PEAK_TEST_PATTERN_FPGACHESSBOARD,
    PEAK_TEST_PATTERN_FPGACOLORSTRIPE,
    PEAK_TEST_PATTERN_FPGAFRAMECOUNT,
    PEAK_TEST_PATTERN_FPGAGRAYSCALE,
    PEAK_TEST_PATTERN_FPGAVERTICALGRAYSCALE,
    PEAK_TEST_PATTERN_FPGAWHITE,
    PEAK_TEST_PATTERN_GREYDIAGONALRAMP,
    PEAK_TEST_PATTERN_GREYDIAGONALRAMPMOVING,
    PEAK_TEST_PATTERN_GREYHORIZONTALRAMP,
    PEAK_TEST_PATTERN_GREYVERTICALRAMP,
    PEAK_TEST_PATTERN_GREYWEDGEMOVINGSENSOR,
    PEAK_TEST_PATTERN_GREYWEDGESENSOR,
    PEAK_TEST_PATTERN_RAMPINGPATTERN,
    PEAK_TEST_PATTERN_SEQUENCEPATTERN1,
    PEAK_TEST_PATTERN_SEQUENCEPATTERN2,
    PEAK_TEST_PATTERN_WHITE,
} peak_test_pattern;

PEAK_API_ACCESS_STATUS peak_TestPattern_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_TestPattern_Set(peak_camera_handle hCam, peak_test_pattern pattern);

PEAK_API_STATUS peak_TestPattern_Get(peak_camera_handle hCam, peak_test_pattern* pattern);

PEAK_API_STATUS peak_TestPattern_GetList(peak_camera_handle hCam, peak_test_pattern* testPatternList,
    size_t* testPatternCount);

typedef enum {

     PEAK_LED_TARGET_INVALID,
     PEAK_LED_TARGET_NETWORK,
     PEAK_LED_TARGET_STATUS
}peak_led_target;

typedef enum {
    PEAK_LED_MODE_INVALID,
    PEAK_LED_MODE_OFF,
    PEAK_LED_MODE_BLINK_SLOW,
    PEAK_LED_MODE_BLINK_FAST,
    PEAK_LED_MODE_CAMERA_STATUS,
    PEAK_LED_MODE_NETWORK_STATUS,
}peak_led_mode;

PEAK_API_ACCESS_STATUS peak_LED_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_LED_Target_GetList(peak_camera_handle hCam, peak_led_target* targetList, size_t* targetCount);

PEAK_API_STATUS peak_LED_Mode_GetList(peak_camera_handle hCam, peak_led_target target, peak_led_mode* modeList, size_t* ledModeCount);

PEAK_API_STATUS peak_LED_Set(peak_camera_handle hCam, peak_led_target target, peak_led_mode mode);

PEAK_API_STATUS peak_LED_Get(peak_camera_handle hCam, peak_led_target target, peak_led_mode* mode);

PEAK_API_ACCESS_STATUS peak_BlackLevel_Auto_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_BlackLevel_Auto_Enable(peak_camera_handle hCam, peak_bool enable);

PEAK_API_BOOL peak_BlackLevel_Auto_IsEnabled(peak_camera_handle hCam);

PEAK_API_ACCESS_STATUS peak_BlackLevel_Offset_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_BlackLevel_Offset_Set(peak_camera_handle hCam, double offset);

PEAK_API_STATUS peak_BlackLevel_Offset_Get(peak_camera_handle hCam, double* offset);

PEAK_API_STATUS peak_BlackLevel_Offset_GetRange(peak_camera_handle hCam, double* min, double* max, double* inc);

PEAK_API_ACCESS_STATUS peak_Bandwidth_LinkSpeed_GetAccessStatus(peak_camera_handle hCam);

#define PEAK_LINKSPEED_ETH_10M             1250000

#define PEAK_LINKSPEED_ETH_100M           12500000

#define PEAK_LINKSPEED_USB2_HIGH_SPEED     60000000

#define PEAK_LINKSPEED_ETH_1G             125000000

#define PEAK_LINKSPEED_ETH_5G            625000000

#define PEAK_LINKSPEED_ETH_10G           1250000000

#define PEAK_LINKSPEED_USB3_SUPER_SPEED   500000000

PEAK_API_STATUS peak_Bandwidth_LinkSpeed_Get(peak_camera_handle hCam, int64_t* linkSpeed_Bps);

PEAK_API_ACCESS_STATUS peak_Bandwidth_ThroughputLimit_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Bandwidth_ThroughputLimit_GetRange(peak_camera_handle hCam, int64_t* minThroughputLimit_Bps,
   int64_t* maxThroughputLimit_Bps, int64_t* incThroughputLimit_Bps);

PEAK_API_STATUS peak_Bandwidth_ThroughputLimit_Set(peak_camera_handle hCam, int64_t throughputLimit_Bps);

PEAK_API_STATUS peak_Bandwidth_ThroughputLimit_Get(peak_camera_handle hCam, int64_t* throughputLimit_Bps);

PEAK_API_ACCESS_STATUS peak_Bandwidth_ThroughputFrameRateLimit_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Bandwidth_ThroughputFrameRateLimit_Get(peak_camera_handle hCam, double* throughputFrameRateLimit_fps);

PEAK_API_ACCESS_STATUS peak_Bandwidth_ThroughputCalculated_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Bandwidth_ThroughputCalculated_Get(peak_camera_handle hCam, int64_t* throughputCalculated_Bps);

PEAK_API_ACCESS_STATUS peak_IPO_GetAccessStatus(peak_interface_technology interfaceTech);

PEAK_API_BOOL peak_IPO_IsEnabled(peak_interface_technology interfaceTech);

PEAK_API_STATUS peak_IPO_Enable(peak_interface_technology interfaceTech, peak_bool enabled);

PEAK_API_STATUS peak_IPL_DigitalBlack_GetRange(peak_camera_handle hCam, double* minDigitalBlack, double* maxDigitalBlack);

PEAK_API_STATUS peak_IPL_DigitalBlack_Set(peak_camera_handle hCam, double digitalBlack);

PEAK_API_STATUS peak_IPL_DigitalBlack_Get(peak_camera_handle hCam, double* digitalBlack);

typedef enum {
    PEAK_LUT_8BIT = 0,

    PEAK_LUT_10BIT = 1,

    PEAK_LUT_12BIT = 2,
}peak_lut_selector;
 

typedef enum {
    PEAK_LUT_CHANNEL_RED = 0,

    PEAK_LUT_CHANNEL_GREEN = 1,

    PEAK_LUT_CHANNEL_BLUE = 2,

    PEAK_LUT_CHANNEL_ALL = 3,
}peak_lut_channel;

typedef enum {
    PEAK_LUT_PRESET_IDENTITY = 0,

    PEAK_LUT_PRESET_INVERSE = 1,

    PEAK_LUT_PRESET_JET = 2,

    PEAK_LUT_PRESET_HOT = 3,

    PEAK_LUT_PRESET_RAINBOW = 4,

    PEAK_LUT_PRESET_ONLY_RED = 5,

    PEAK_LUT_PRESET_ONLY_GREEN = 6,

    PEAK_LUT_PRESET_ONLY_BLUE = 7,

    PEAK_LUT_PRESET_DIGITAL_GAIN2 = 8,

    PEAK_LUT_PRESET_DIGITAL_BLACK_25_PERCENT = 9,

    PEAK_LUT_PRESET_BINARIZE = 10,
}peak_lut_preset;

PEAK_API_STATUS peak_IPL_LUT_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_IPL_LUT_IsEnabled(peak_camera_handle hCam);

PEAK_API_STATUS peak_IPL_LUT_Preset_Set(peak_camera_handle hCam, peak_lut_selector selector, peak_lut_preset preset);

PEAK_API_STATUS peak_IPL_LUT_Value_Set(peak_camera_handle hCam, peak_lut_selector selector, peak_lut_channel channel, uint32_t index, uint32_t value);

PEAK_API_STATUS peak_IPL_LUT_Value_Get(peak_camera_handle hCam, peak_lut_selector selector, peak_lut_channel channel, uint32_t index, uint32_t* value);

PEAK_API_STATUS peak_IPL_LUT_ValueList_Set(peak_camera_handle hCam, peak_lut_selector selector, peak_lut_channel channel, uint32_t* values, size_t size);

PEAK_API_STATUS peak_IPL_LUT_ValueList_Get(peak_camera_handle hCam, peak_lut_selector selector, peak_lut_channel channel, uint32_t* values, size_t* size);

typedef enum
{
    PEAK_CHUNKS_TYPE_INVALID = 0,

    PEAK_CHUNKS_TYPE_FRAME_INFO = 1,

    PEAK_CHUNKS_TYPE_EXPOSURE = 2,

    PEAK_CHUNKS_TYPE_GAIN = 3,

    PEAK_CHUNKS_TYPE_SEQUENCER = 4,

    PEAK_CHUNKS_TYPE_TIMESTAMP = 5,

    PEAK_CHUNKS_TYPE_EXPOSURE_TRIGGER = 6,

    PEAK_CHUNKS_TYPE_USABLE_ROI = 7,

    PEAK_CHUNKS_TYPE_LINE_STATUS = 8,

    PEAK_CHUNKS_TYPE_AUTO_FEATURE_STATUS = 9,

    PEAK_CHUNKS_TYPE_PTP_STATUS = 10
} peak_chunks_type;

PEAK_API_ACCESS_STATUS peak_Chunks_GetAccessStatus(peak_camera_handle hCam);

PEAK_API_STATUS peak_Chunks_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_Chunks_IsEnabled(peak_camera_handle hCam);

PEAK_API_STATUS peak_Chunks_AutoUpdate_Enable(peak_camera_handle hCam, peak_bool enabled);

PEAK_API_BOOL peak_Chunks_AutoUpdate_IsEnabled(peak_camera_handle hCam);

PEAK_API_STATUS peak_Chunks_Update(peak_camera_handle hCam, peak_frame_handle hFrame);

PEAK_API_ACCESS_STATUS peak_Chunks_Type_GetAccessStatus(peak_camera_handle hCam, peak_chunks_type type);

PEAK_API_STATUS peak_Chunks_Type_Enable(peak_camera_handle hCam, peak_chunks_type type, peak_bool enabled);

PEAK_API_BOOL peak_Chunks_Type_IsEnabled(peak_camera_handle hCam, peak_chunks_type type);

PEAK_API_STATUS peak_Chunks_Type_Supported_GetList(peak_camera_handle hCam, peak_chunks_type* chunksTypesSupported, size_t* chunksTypesSize);

typedef struct {
    peak_pixel_format pixelFormat;
    
    peak_roi roi;
    
    uint8_t reserved[64];
} peak_chunks_frame_info;

typedef struct {
    double exposureTime_us;
    
    uint8_t reserved[64];
} peak_chunks_exposure;

typedef struct {
    double analogMasterGain;
    
    double digitalMasterGain;
    
    double digitalRedGain;
    
    double digitalGreenGain;
    
    double digitalBlueGain;
    
    uint8_t reserved[64];
} peak_chunks_gain;

typedef struct {
    int64_t sequencerSetActive;
    
    uint8_t reserved[64];
} peak_chunks_sequencer;

typedef struct {
    int64_t timestamp;
    
    uint8_t reserved[64];
} peak_chunks_timestamp;

typedef struct {
    int64_t timestamp;
    
    uint8_t reserved[64];
} peak_chunks_exposure_trigger;

typedef struct {
    peak_roi roi;
    
    uint8_t reserved[64];
} peak_chunks_usable_roi;

typedef struct {
    uint32_t lineStatusAll;
    
    uint8_t reserved[64];
} peak_chunks_line_status;

typedef enum
{
   PEAK_AUTO_FEATURE_STATUS_INVALID = 0,

   PEAK_AUTO_FEATURE_STATUS_OFF = 1,
 
   PEAK_AUTO_FEATURE_STATUS_DONE = 2,
 
   PEAK_AUTO_FEATURE_STATUS_ACTIVE = 3,

   PEAK_AUTO_FEATURE_STATUS_STUCK = 4   
} peak_auto_feature_status;

typedef struct {
    peak_auto_feature_status status;
    
    uint8_t reserved[64];
} peak_chunks_autofeature_status;

typedef struct {
    peak_chunks_autofeature_status autoBrightnessStatus;
    
    peak_chunks_autofeature_status autoWhiteBalanceStatus;
    
    uint8_t reserved[64];
} peak_chunks_autofeature;

typedef enum
{
   PEAK_PTP_STATUS_INVALID,

   PEAK_PTP_STATUS_INITIALIZING,

   PEAK_PTP_STATUS_FAULTY,

   PEAK_PTP_STATUS_DISABLED,

   PEAK_PTP_STATUS_LISTENING,

   PEAK_PTP_STATUS_PRE_MASTER,

   PEAK_PTP_STATUS_MASTER,

   PEAK_PTP_STATUS_PASSIVE,

   PEAK_PTP_STATUS_UNCALIBRATED,

   PEAK_PTP_STATUS_SLAVE
} peak_ptp_status;

typedef struct {
    peak_ptp_status ptpStatus;
    
    uint8_t reserved[64];
} peak_chunks_ptp_status;

PEAK_API_STATUS peak_Chunks_FrameInfo_Get(peak_camera_handle hCam, peak_chunks_frame_info* data);

PEAK_API_STATUS peak_Chunks_Exposure_Get(peak_camera_handle hCam, peak_chunks_exposure* data);

PEAK_API_STATUS peak_Chunks_Gain_Get(peak_camera_handle hCam, peak_chunks_gain* data);

PEAK_API_STATUS peak_Chunks_Sequencer_Get(peak_camera_handle hCam, peak_chunks_sequencer* data);

PEAK_API_STATUS peak_Chunks_Timestamp_Get(peak_camera_handle hCam, peak_chunks_timestamp* data);

PEAK_API_STATUS peak_Chunks_ExposureTrigger_Get(peak_camera_handle hCam, peak_chunks_exposure_trigger* data);

PEAK_API_STATUS peak_Chunks_UsableROI_Get(peak_camera_handle hCam, peak_chunks_usable_roi* data);

PEAK_API_STATUS peak_Chunks_LineStatus_Get(peak_camera_handle hCam, peak_chunks_line_status* data);

PEAK_API_STATUS peak_Chunks_AutoFeature_Get(peak_camera_handle hCam, peak_chunks_autofeature* data);

PEAK_API_STATUS peak_Chunks_PTPStatus_Get(peak_camera_handle hCam, peak_chunks_ptp_status* data);
 
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
 
#endif // PEAK_COMFORT_C_H