File SpinnakerC.h

File List > include > spinc > SpinnakerC.h

Go to the documentation of this file

//=============================================================================
// Copyright (c) 2026 FLIR Integrated Imaging Solutions, Inc. All Rights Reserved.
//
// This software is the confidential and proprietary information of FLIR
// Integrated Imaging Solutions, Inc. ("Confidential Information"). You
// shall not disclose such Confidential Information and shall use it only in
// accordance with the terms of the license agreement you entered into
// with FLIR Integrated Imaging Solutions, Inc. (FLIR).
//
// FLIR MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
// SOFTWARE, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE, OR NON-INFRINGEMENT. FLIR SHALL NOT BE LIABLE FOR ANY DAMAGES
// SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
// THIS SOFTWARE OR ITS DERIVATIVES.
//=============================================================================

#ifndef FLIR_SPINNAKER_C_H
#define FLIR_SPINNAKER_C_H

#include "SpinnakerPlatformC.h"

#include "SpinnakerDefsC.h"
#include "CameraDefsC.h"
#include "ChunkDataDefC.h"

#include "SpinnakerGenApiDefsC.h"
#include "SpinnakerGenApiC.h"

#include "QuickSpinC.h"

#ifdef __cplusplus
extern "C"
{
#endif
    SPINNAKERC_API spinErrorGetLast(spinError* pError);

    SPINNAKERC_API spinErrorGetLastMessage(char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinErrorGetLastBuildDate(char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinErrorGetLastBuildTime(char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinErrorGetLastFileName(char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinErrorGetLastFullMessage(char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinErrorGetLastFunctionName(char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinErrorGetLastLineNumber(int64_t* pLineNum);
    SPINNAKERC_API spinSystemGetInstance(spinSystem* phSystem);

    SPINNAKERC_API spinSystemReleaseInstance(spinSystem hSystem);

    SPINNAKERC_API spinSystemGetInterfaces(spinSystem hSystem, spinInterfaceList hInterfaceList);

    SPINNAKERC_API spinSystemGetCameras(spinSystem hSystem, spinCameraList hCameraList);

    SPINNAKERC_API spinSystemGetCamerasEx(
        spinSystem hSystem,
        bool8_t bUpdateInterfaces,
        bool8_t bUpdateCameras,
        spinCameraList hCameraList);

    SPINNAKERC_API spinSystemSetLoggingLevel(spinSystem hSystem, spinnakerLogLevel logLevel);

    SPINNAKERC_API spinSystemGetLoggingLevel(spinSystem hSystem, spinnakerLogLevel* pLogLevel);

    SPINNAKERC_API spinSystemRegisterLogEventHandler(spinSystem hSystem, spinLogEventHandler hLogEventHandler);

    SPINNAKERC_API spinSystemUnregisterLogEventHandler(spinSystem hSystem, spinLogEventHandler hLogEventHandler);

    SPINNAKERC_API spinSystemUnregisterAllLogEventHandlers(spinSystem hSystem);

    SPINNAKERC_API spinSystemIsInUse(spinSystem hSystem, bool8_t* pbIsInUse);

    SPINNAKERC_API spinSystemRegisterDeviceArrivalEventHandler(
        spinSystem hSystem,
        spinDeviceArrivalEventHandler hDeviceArrivalEventHandler);

    SPINNAKERC_API spinSystemRegisterDeviceRemovalEventHandler(
        spinSystem hSystem,
        spinDeviceRemovalEventHandler hDeviceRemovalEventHandler);

    SPINNAKERC_API spinSystemUnregisterDeviceArrivalEventHandler(
        spinSystem hSystem,
        spinDeviceArrivalEventHandler hDeviceArrivalEventHandler);

    SPINNAKERC_API spinSystemUnregisterDeviceRemovalEventHandler(
        spinSystem hSystem,
        spinDeviceRemovalEventHandler hDeviceRemovalEventHandler);

    SPINNAKERC_API spinSystemRegisterInterfaceEventHandler(
        spinSystem hSystem,
        spinInterfaceEventHandler hInterfaceEventHandler);

    SPINNAKERC_API spinSystemUnregisterInterfaceEventHandler(
        spinSystem hSystem,
        spinInterfaceEventHandler hInterfaceEventHandler);

    SPINNAKERC_API spinSystemUpdateCameras(spinSystem hSystem, bool8_t* pbChanged);

    SPINNAKERC_API spinSystemUpdateCamerasEx(spinSystem hSystem, bool8_t bUpdateInterfaces, bool8_t* pbChanged);

    SPINNAKERC_API spinSystemSendActionCommand(
        spinSystem hSystem,
        size_t iDeviceKey,
        size_t iGroupKey,
        size_t iGroupMask,
        size_t iActionTime,
        bool8_t requestAck,
        size_t* piResultSize,
        actionCommandResult results[]);

    SPINNAKERC_API spinSystemGetLibraryVersion(spinSystem hSystem, spinLibraryVersion* hLibraryVersion);

    SPINNAKERC_API spinSystemGetTLNodeMap(spinSystem hSystem, spinNodeMapHandle* phNodeMap);
    SPINNAKERC_API spinInterfaceListCreateEmpty(spinInterfaceList* phInterfaceList);

    SPINNAKERC_API spinInterfaceListDestroy(spinInterfaceList hInterfaceList);

    SPINNAKERC_API spinInterfaceListGetSize(spinInterfaceList hInterfaceList, size_t* pSize);

    SPINNAKERC_API spinInterfaceListGet(spinInterfaceList hInterfaceList, size_t index, spinInterface* phInterface);

    SPINNAKERC_API spinInterfaceListClear(spinInterfaceList hInterfaceList);
    SPINNAKERC_API spinCameraListCreateEmpty(spinCameraList* phCameraList);

    SPINNAKERC_API spinCameraListDestroy(spinCameraList hCameraList);

    SPINNAKERC_API spinCameraListGetSize(spinCameraList hCameraList, size_t* pSize);

    SPINNAKERC_API spinCameraListGet(spinCameraList hCameraList, size_t index, spinCamera* phCamera);

    SPINNAKERC_API spinCameraListClear(spinCameraList hCameraList);

    SPINNAKERC_API spinCameraListRemove(spinCameraList hCameraList, size_t index);

    SPINNAKERC_API spinCameraListAppend(spinCameraList hCameraListBase, spinCameraList hCameraListToAppend);

    SPINNAKERC_API spinCameraListGetBySerial(spinCameraList hCameraList, const char* pSerial, spinCamera* phCamera);

    SPINNAKERC_API spinCameraListRemoveBySerial(spinCameraList hCameraList, const char* pSerial);
    SPINNAKERC_API spinImageListCreateEmpty(spinImageList* phImageList);

    SPINNAKERC_API spinImageListDestroy(spinImageList hImageList);

    SPINNAKERC_API spinImageListGetSize(spinImageList hImageList, size_t* pSize);

    SPINNAKERC_API spinImageListGet(spinImageList hImageList, size_t index, spinImage* phImage);

    SPINNAKERC_API spinImageListClear(spinImageList hImageList);

    SPINNAKERC_API spinImageListRemove(spinImageList hImageList, size_t index);

    SPINNAKERC_API spinImageListAppend(spinImageList hImageListBase, spinImageList hImageListToAppend);

    SPINNAKERC_API spinImageListGetImagesByPixelFormat(
        spinImageList hImageList,
        spinPixelFormatEnums pixelFormat,
        spinImageList* hImageListReturn);

    SPINNAKERC_API spinImageListGetByPixelFormat(
        spinImageList hImageList,
        spinPixelFormatEnums pixelFormat,
        spinImage* phImage);

    SPINNAKERC_API spinImageListGetByStreamIndex(spinImageList hImageList, uint64_t streamIndex, spinImage* phImage);

    SPINNAKERC_API spinImageListRemoveByPixelFormat(spinImageList hImageList, spinPixelFormatEnums pixelFormat);

    SPINNAKERC_API spinImageListRemoveByStreamIndex(spinImageList hImageList, uint64_t streamIndex);

    /*
     * Releases all the images that were acquired calling spinCameraGetNextImageSync().
     * @see spinCameraInit()
     * @see spinCameraGetNextImageSync(grabTimeout)
     * @see spinImageRelease(spinImage hImage)
     * @see spinError
     *
     * @param hImageList The image list of the image to remove
     *
     * @return spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
     */
    SPINNAKERC_API spinImageListRelease(spinImageList hImageList);

    SPINNAKERC_API spinImageListSave(spinImageList hImageList, const char* fileName);

    SPINNAKERC_API spinImageListLoad(spinImageList* phImageList, const char* fileName);

    SPINNAKERC_API spinInterfaceUpdateCameras(spinInterface hInterface, bool8_t* pbChanged);

    SPINNAKERC_API spinInterfaceGetCameras(spinInterface hInterface, spinCameraList hCameraList);

    SPINNAKERC_API spinInterfaceGetCamerasEx(
        spinInterface hInterface,
        bool8_t bUpdateCameras,
        spinCameraList hCameraList);

    SPINNAKERC_API spinInterfaceGetTLNodeMap(spinInterface hInterface, spinNodeMapHandle* phNodeMap);

    SPINNAKERC_API spinInterfaceRegisterDeviceArrivalEventHandler(
        spinInterface hInterface,
        spinDeviceArrivalEventHandler hDeviceArrivalEventHandler);

    SPINNAKERC_API spinInterfaceRegisterDeviceRemovalEventHandler(
        spinInterface hInterface,
        spinDeviceRemovalEventHandler hDeviceRemovalEventHandler);

    SPINNAKERC_API spinInterfaceUnregisterDeviceArrivalEventHandler(
        spinInterface hInterface,
        spinDeviceArrivalEventHandler hDeviceArrivalEventHandler);

    SPINNAKERC_API spinInterfaceUnregisterDeviceRemovalEventHandler(
        spinInterface hInterface,
        spinDeviceRemovalEventHandler hDeviceRemovalEventHandler);

    SPINNAKERC_API spinInterfaceRegisterInterfaceEventHandler(
        spinInterface hInterface,
        spinInterfaceEventHandler hInterfaceEventHandler);

    SPINNAKERC_API spinInterfaceUnregisterInterfaceEventHandler(
        spinInterface hInterface,
        spinInterfaceEventHandler hInterfaceEventHandler);

    SPINNAKERC_API spinInterfaceRelease(spinInterface hInterface);

    SPINNAKERC_API spinInterfaceIsInUse(spinInterface hInterface, bool8_t* pbIsInUse);

    SPINNAKERC_API spinInterfaceSendActionCommand(
        spinInterface hInterface,
        size_t iDeviceKey,
        size_t iGroupKey,
        size_t iGroupMask,
        size_t iActionTime,
        bool8_t requestAck,
        size_t* piResultSize,
        actionCommandResult results[]);
    SPINNAKERC_API spinCameraInit(spinCamera hCamera);

    SPINNAKERC_API spinCameraDeInit(spinCamera hCamera);

    SPINNAKERC_API spinCameraGetNodeMap(spinCamera hCamera, spinNodeMapHandle* phNodeMap);

    SPINNAKERC_API spinCameraGetTLDeviceNodeMap(spinCamera hCamera, spinNodeMapHandle* phNodeMap);

    SPINNAKERC_API spinCameraGetTLStreamNodeMap(spinCamera hCamera, spinNodeMapHandle* phNodeMap);

    SPINNAKERC_API spinCameraGetAccessMode(spinCamera hCamera, spinAccessMode* pAccessMode);

    /*
     * Reads a remote port on a physical Camera. This function can be used to read
     * registers on Cameras.
     *
     * Caution: Only perform direct read/write to a register if the register isn't
     *          supported in the device nodemap. Otherwise the camera and nodemap
     *          may be left in an undefined state after the register read/write.
     *
     * @see WritePort()
     *
     * @param iAddress A 64 bit address to a register on the camera
     * @param pBuffer A pointer to a data buffer that will store result
     * @param iSize Number of bytes to read
     *
     * @return spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
     */
    SPINNAKERC_API spinCameraReadPort(spinCamera hCamera, uint64_t iAddress, void* pBuffer, size_t iSize);

    /*
     * Writes a remote port on a physical Camera. This function can be used to write
     * registers on Cameras.
     *
     * Caution: Only perform direct read/write to a register if the register isn't
     *          supported in the device nodemap. Otherwise the camera and nodemap
     *          may be left in an undefined state after the register read/write.
     *
     * @see ReadPort()
     *
     * @param iAddress A 64 bit address to a register on the camera
     * @param pBuffer A pointer to a data buffer that will be written
     * @param iSize Number of bytes to write
     *
     * @return spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
     */
    SPINNAKERC_API spinCameraWritePort(spinCamera hCamera, uint64_t iAddress, void* pBuffer, size_t iSize);

    SPINNAKERC_API spinCameraBeginAcquisition(spinCamera hCamera);

    SPINNAKERC_API spinCameraEndAcquisition(spinCamera hCamera);

    SPINNAKERC_API spinCameraGetNextImage(spinCamera hCamera, spinImage* phImage);

    SPINNAKERC_API spinCameraGetNextImageEx(spinCamera hCamera, uint64_t grabTimeout, spinImage* phImage);

    SPINNAKERC_API spinCameraGetNextImageSync(spinCamera hCamera, uint64_t grabTimeout, spinImageList* phImageList);

    SPINNAKERC_API spinCameraGetDeviceID(spinCamera hCamera, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinCameraGetDeviceSerialNumber(spinCamera hCamera, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API_DEPRECATED("Use spinCameraGetDeviceID() instead.",
                              spinCameraGetUniqueID(spinCamera hCamera, char* pBuf, size_t* pBufLen);)

    SPINNAKERC_API spinCameraIsStreaming(spinCamera hCamera, bool8_t* pbIsStreaming);

    SPINNAKERC_API spinCameraGetGuiXml(spinCamera hCamera, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API_DEPRECATED(
        "Use spinNodeRegisterCallback() and spinNodeDeregisterCallback() for handling device node callbacks instead.",
        spinCameraRegisterDeviceEventHandler(spinCamera hCamera, spinDeviceEventHandler hDeviceEventHandler));

    SPINNAKERC_API_DEPRECATED(
        "Use spinNodeRegisterCallback() and spinNodeDeregisterCallback() for handling device node callbacks instead.",
        spinCameraRegisterDeviceEventHandlerEx(
            spinCamera hCamera,
            spinDeviceEventHandler hDeviceEventHandler,
            const char* pName));

    SPINNAKERC_API_DEPRECATED(
        "Use spinNodeRegisterCallback() and spinNodeDeregisterCallback() for handling device node callbacks instead.",
        spinCameraUnregisterDeviceEventHandler(spinCamera hCamera, spinDeviceEventHandler hDeviceEventHandler));

    SPINNAKERC_API spinCameraRegisterImageEventHandler(spinCamera hCamera, spinImageEventHandler hImageEventHandler);

    SPINNAKERC_API spinCameraRegisterImageEventHandlerEx(
        spinCamera hCamera,
        spinImageEventHandler hImageEventHandler,
        uint64_t streamIndex);

    SPINNAKERC_API spinCameraUnregisterImageEventHandler(spinCamera hCamera, spinImageEventHandler hImageEventHandler);

    SPINNAKERC_API spinCameraRegisterImageListEventHandler(
        spinCamera hCamera,
        spinImageListEventHandler hImageListEventHandler);

    SPINNAKERC_API spinCameraUnregisterImageListEventHandler(
        spinCamera hCamera,
        spinImageListEventHandler hImageListEventHandler);

    SPINNAKERC_API spinCameraRelease(spinCamera hCamera);

    SPINNAKERC_API spinCameraIsValid(spinCamera hCamera, bool8_t* pbValid);

    SPINNAKERC_API spinCameraIsInitialized(spinCamera hCamera, bool8_t* pbInit);

    SPINNAKERC_API spinCameraDiscoverMaxPacketSize(spinCamera hCamera, unsigned int* pMaxPacketSize);

    SPINNAKERC_API spinCameraForceIP();
    SPINNAKERC_API spinImageCreateEmpty(spinImage* phImage);

    SPINNAKERC_API spinImageCreate(spinImage hSrcImage, spinImage* phDestImage);

    SPINNAKERC_API spinImageCreateEx(
        spinImage* phImage,
        size_t width,
        size_t height,
        size_t offsetX,
        size_t offsetY,
        spinPixelFormatEnums pixelFormat,
        void* pData);

    SPINNAKERC_API spinImageCreateEx2(
        spinImage* phImage,
        size_t width,
        size_t height,
        size_t offsetX,
        size_t offsetY,
        spinPixelFormatEnums pixelFormat,
        void* pData,
        spinTLPayloadType dataPayloadType,
        size_t dataSize);

    SPINNAKERC_API spinImageDestroy(spinImage hImage);

    SPINNAKERC_API spinImageGetColorProcessing(spinImage hImage, spinColorProcessingAlgorithm* pAlgorithm);

    SPINNAKERC_API spinImageLoad(spinImage* phImage, const char* fileName);

    SPINNAKERC_API spinImageReset(
        spinImage hImage,
        size_t width,
        size_t height,
        size_t offsetX,
        size_t offsetY,
        spinPixelFormatEnums pixelFormat);

    SPINNAKERC_API spinImageResetEx(
        spinImage hImage,
        size_t width,
        size_t height,
        size_t offsetX,
        size_t offsetY,
        spinPixelFormatEnums pixelFormat,
        void* pData);

    SPINNAKERC_API spinImageGetID(spinImage hImage, uint64_t* pId);

    SPINNAKERC_API spinImageGetData(spinImage hImage, void** ppData);

    SPINNAKERC_API spinImageGetPrivateData(spinImage hImage, void** ppData);

    SPINNAKERC_API spinImageGetBufferSize(spinImage hImage, size_t* pSize);

    SPINNAKERC_API spinImageDeepCopy(spinImage hSrcImage, spinImage hDestImage);

    SPINNAKERC_API spinImageGetWidth(spinImage hImage, size_t* pWidth);

    SPINNAKERC_API spinImageGetHeight(spinImage hImage, size_t* pHeight);

    SPINNAKERC_API spinImageGetOffsetX(spinImage hImage, size_t* pOffsetX);

    SPINNAKERC_API spinImageGetOffsetY(spinImage hImage, size_t* pOffsetY);

    SPINNAKERC_API spinImageGetPaddingX(spinImage hImage, size_t* pPaddingX);

    SPINNAKERC_API spinImageGetPaddingY(spinImage hImage, size_t* pPaddingY);

    SPINNAKERC_API spinImageGetFrameID(spinImage hImage, uint64_t* pFrameID);

    SPINNAKERC_API spinImageGetTimeStamp(spinImage hImage, uint64_t* pTimeStamp);

    SPINNAKERC_API spinImageGetPayloadType(spinImage hImage, size_t* pPayloadType);

    SPINNAKERC_API spinImageGetTLPayloadType(spinImage hImage, spinTLPayloadType* pPayloadType);

    SPINNAKERC_API spinImageGetPixelFormat(spinImage hImage, spinPixelFormatEnums* pPixelFormat);

    SPINNAKERC_API spinImageGetTLPixelFormat(spinImage hImage, uint64_t* pPixelFormat);

    SPINNAKERC_API spinImageGetTLPixelFormatNamespace(
        spinImage hImage,
        spinTLPixelFormatNamespace* pPixelFormatNamespace);

    SPINNAKERC_API spinImageGetPixelFormatName(spinImage hImage, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinImageIsIncomplete(spinImage hImage, bool8_t* pbIsIncomplete);

    SPINNAKERC_API spinImageGetValidPayloadSize(spinImage hImage, size_t* pSize);

    SPINNAKERC_API spinImageSave(spinImage hImage, const char* pFilename, spinImageFileFormat format);

    SPINNAKERC_API spinImageSaveFromExt(spinImage hImage, const char* pFilename);

    SPINNAKERC_API spinImageSavePng(spinImage hImage, const char* pFilename, const spinPNGOption* pOption);

    SPINNAKERC_API spinImageSavePpm(spinImage hImage, const char* pFilename, const spinPPMOption* pOption);

    SPINNAKERC_API spinImageSavePgm(spinImage hImage, const char* pFilename, const spinPGMOption* pOption);

    SPINNAKERC_API spinImageSaveTiff(spinImage hImage, const char* pFilename, const spinTIFFOption* pOption);

    SPINNAKERC_API spinImageSaveJpeg(spinImage hImage, const char* pFilename, const spinJPEGOption* pOption);

    SPINNAKERC_API spinImageSaveJpg2(spinImage hImage, const char* pFilename, const spinJPG2Option* pOption);

    SPINNAKERC_API spinImageSaveBmp(spinImage hImage, const char* pFilename, const spinBMPOption* pOption);

    SPINNAKERC_API spinImageGetChunkLayoutID(spinImage hImage, uint64_t* pId);

    SPINNAKERC_API spinImageCalculateStatistics(spinImage hImage, const spinImageStatistics hStatistics);

    SPINNAKERC_API spinImageGetStatus(spinImage hImage, spinImageStatus* pStatus);

    SPINNAKERC_API spinImageGetStatusDescription(spinImageStatus status, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinImageRelease(spinImage hImage);

    SPINNAKERC_API spinImageHasCRC(spinImage hImage, bool8_t* pbHasCRC);

    SPINNAKERC_API spinImageCheckCRC(spinImage hImage, bool8_t* pbCheckCRC);

    SPINNAKERC_API spinImageGetBitsPerPixel(spinImage hImage, size_t* pBitsPerPixel);

    SPINNAKERC_API spinImageGetSize(spinImage hImage, size_t* pImageSize);

    SPINNAKERC_API spinImageGetStride(spinImage hImage, size_t* pStride);
    SPINNAKERC_API spinImageProcessorCreate(spinImageProcessor* phImageProcessor);

    SPINNAKERC_API spinImageProcessorDestroy(spinImageProcessor hImageProcessor);

    SPINNAKERC_API spinImageProcessorSetColorProcessing(
        spinImageProcessor hImageProcessor,
        spinColorProcessingAlgorithm colorAlgorithm);

    SPINNAKERC_API spinImageProcessorGetColorProcessing(
        spinImageProcessor hImageProcessor,
        spinColorProcessingAlgorithm* pColorAlgorithm);

    SPINNAKERC_API spinImageProcessorSetNumDecompressionThreads(
        spinImageProcessor hImageProcessor,
        unsigned int numThreads);

    SPINNAKERC_API spinImageProcessorGetNumDecompressionThreads(
        spinImageProcessor hImageProcessor,
        unsigned int* pNumThreads);

    SPINNAKERC_API spinImageProcessorConvert(
        spinImageProcessor hImageProcessor,
        spinImage hSrcImage,
        spinImage hDestImage,
        spinPixelFormatEnums destFormat);

    SPINNAKERC_API spinImageProcessorConvertImageList(
        spinImageProcessor hImageProcessor,
        spinImageList hSrcImageList,
        spinImage hDestImage,
        spinPixelFormatEnums destFormat);

    SPINNAKERC_API spinImageProcessorApplyGamma(
        spinImageProcessor hImageProcessor,
        spinImage hSrcImage,
        spinImage hDestImage,
        float gamma,
        bool8_t applyGammaInverse);

    SPINNAKERC_API spinDeviceEventHandlerCreate(
        spinDeviceEventHandler* phDeviceEventHandler,
        spinDeviceEventFunction pFunction,
        void* pUserData);

    SPINNAKERC_API spinDeviceEventHandlerDestroy(spinDeviceEventHandler hDeviceEventHandler);

    SPINNAKERC_API spinImageEventHandlerCreate(
        spinImageEventHandler* phImageEventHandler,
        spinImageEventFunction pFunction,
        void* pUserData);

    SPINNAKERC_API spinImageEventHandlerDestroy(spinImageEventHandler hImageEventHandler);

    SPINNAKERC_API spinImageListEventHandlerCreate(
        spinImageListEventHandler* phImageEventHandler,
        spinImageListEventFunction pFunction,
        void* pUserData);

    SPINNAKERC_API spinImageListEventHandlerDestroy(spinImageListEventHandler hImageListEventHandler);

    SPINNAKERC_API spinDeviceArrivalEventHandlerCreate(
        spinDeviceArrivalEventHandler* phDeviceArrivalEventHandler,
        spinArrivalEventFunction pFunction,
        void* pUserData);

    SPINNAKERC_API spinDeviceArrivalEventHandlerDestroy(spinDeviceArrivalEventHandler hDeviceArrivalEventHandler);

    SPINNAKERC_API spinDeviceRemovalEventHandlerCreate(
        spinDeviceRemovalEventHandler* phDeviceRemovalEventHandler,
        spinRemovalEventFunction pFunction,
        void* pUserData);

    SPINNAKERC_API spinDeviceRemovalEventHandlerDestroy(spinDeviceRemovalEventHandler hDeviceRemovalEventHandler);

    SPINNAKERC_API spinInterfaceEventHandlerCreate(
        spinInterfaceEventHandler* phInterfaceEventHandler,
        spinArrivalEventFunction pArrivalFunction,
        spinRemovalEventFunction pRemovalFunction,
        void* pUserData);

    SPINNAKERC_API spinInterfaceEventHandlerDestroy(spinInterfaceEventHandler hInterfaceEventHandler);

    SPINNAKERC_API spinLogEventHandlerCreate(
        spinLogEventHandler* phLogEventHandler,
        spinLogEventFunction pFunction,
        void* pUserData);

    SPINNAKERC_API spinLogEventHandlerDestroy(spinLogEventHandler hLogEventHandler);
    SPINNAKERC_API spinImageStatisticsCreate(spinImageStatistics* phStatistics);

    SPINNAKERC_API spinImageStatisticsDestroy(spinImageStatistics hStatistics);

    SPINNAKERC_API spinImageStatisticsEnableAll(spinImageStatistics hStatistics);

    SPINNAKERC_API spinImageStatisticsDisableAll(spinImageStatistics hStatistics);

    SPINNAKERC_API spinImageStatisticsEnableGreyOnly(spinImageStatistics hStatistics);

    SPINNAKERC_API spinImageStatisticsEnableRgbOnly(spinImageStatistics hStatistics);

    SPINNAKERC_API spinImageStatisticsEnableHslOnly(spinImageStatistics hStatistics);

    SPINNAKERC_API spinImageStatisticsGetChannelStatus(
        spinImageStatistics hStatistics,
        spinStatisticsChannel channel,
        bool8_t* pbEnabled);

    SPINNAKERC_API spinImageStatisticsSetChannelStatus(
        spinImageStatistics hStatistics,
        spinStatisticsChannel channel,
        bool8_t bEnable);

    SPINNAKERC_API spinImageStatisticsGetRange(
        spinImageStatistics hStatistics,
        spinStatisticsChannel channel,
        unsigned int* pMin,
        unsigned int* pMax);

    SPINNAKERC_API spinImageStatisticsGetPixelValueRange(
        spinImageStatistics hStatistics,
        spinStatisticsChannel channel,
        unsigned int* pMin,
        unsigned int* pMax);

    SPINNAKERC_API spinImageStatisticsGetNumPixelValues(
        spinImageStatistics hStatistics,
        spinStatisticsChannel channel,
        unsigned int* pNumValues);

    SPINNAKERC_API spinImageStatisticsGetMean(
        spinImageStatistics hStatistics,
        spinStatisticsChannel channel,
        float* pMean);

    SPINNAKERC_API spinImageStatisticsGetHistogram(
        spinImageStatistics hStatistics,
        spinStatisticsChannel channel,
        int** ppHistogram);

    SPINNAKERC_API spinImageStatisticsGetAll(
        spinImageStatistics hStatistics,
        spinStatisticsChannel channel,
        unsigned int* pRangeMin,
        unsigned int* pRangeMax,
        unsigned int* pPixelValueMin,
        unsigned int* pPixelValueMax,
        unsigned int* pNumPixelValues,
        float* pPixelValueMean,
        int** ppHistogram);
    SPINNAKERC_API spinLogDataGetCategoryName(spinLogEventData hLogEventData, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinLogDataGetPriority(spinLogEventData hLogEventData, int64_t* pValue);

    SPINNAKERC_API spinLogDataGetPriorityName(spinLogEventData hLogEventData, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinLogDataGetTimestamp(spinLogEventData hLogEventData, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinLogDataGetNDC(spinLogEventData hLogEventData, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinLogDataGetThreadName(spinLogEventData hLogEventData, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinLogDataGetLogMessage(spinLogEventData hLogEventData, char* pBuf, size_t* pBufLen);

    SPINNAKERC_API spinDeviceEventGetId(spinDeviceEventData hDeviceEventData, uint64_t* pEventId);

    SPINNAKERC_API spinDeviceEventGetPayloadData(
        spinDeviceEventData hDeviceEventData,
        const uint8_t* pBuf,
        size_t* pBufSize);

    SPINNAKERC_API spinDeviceEventGetPayloadDataSize(spinDeviceEventData hDeviceEventData, size_t* pBufSize);

    SPINNAKERC_API spinDeviceEventGetName(spinDeviceEventData hDeviceEventData, char* pBuf, size_t* pBufLen);

    // Chunk data from Image
    /*
     * Retrieves an integer value of a piece of chunk data
     * @see spinError
     *
     * @param hImage The image of the chunk data to retrieve
     * @param pName The name of the piece of chunk data to retrieve
     * @param pValue The integer pointer in which the piece of chunk data is returned
     *
     * @return spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
     */
    SPINNAKERC_API spinImageChunkDataGetIntValue(spinImage hImage, const char* pName, int64_t* pValue);

    /*
     * Retrieves a float value of a piece of chunk data
     * @see spinError
     *
     * @param hImage The image of the chunk data to retrieve
     * @param pName The name of the piece of chunk data to retrieve
     * @param pValue The float pointer in which the piece of chunk data is returned
     *
     * @return spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
     */
    SPINNAKERC_API spinImageChunkDataGetFloatValue(spinImage hImage, const char* pName, double* pValue);

    /*
     * Retrieves a pointer to memory of a piece of chunk data
     * @see spinError
     *
     * @param hImage The image of the chunk data to retrieve
     * @param pName The name of the piece of chunk data to retrieve
     * @param pData The uint8_t pointer in which the piece of chunk data is returned
     *
     * @return spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
     */
    SPINNAKERC_API spinImageChunkDataGetRawData(spinImage hImage, const char* pName, uint8_t** pData);

    /*
     * Retrieves a boolean value of a piece of chunk data
     * @see spinError
     *
     * @param hImage The image of the chunk data to retrieve
     * @param pName The name of the piece of chunk data to retrieve
     * @param pValue The boolean pointer in which the piece of chunk data is returned
     *
     * @return spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
     */
    SPINNAKERC_API spinImageChunkDataGetBoolValue(spinImage hImage, const char* pName, bool8_t* pValue);

#ifdef __cplusplus
}
#endif

#endif /* FLIR_SPINNAKER_C_H */