basler_fg.h

Go to the documentation of this file.

 
#ifndef __BASLER_FG_H
#define __BASLER_FG_H
 
#pragma warning(push)
#pragma warning(disable: 4005)
#if defined(_MSC_VER) && (_MSC_VER < 1600)
#include <msinttypes/stdint.h>
#else
#include <stdint.h>
#endif
#pragma warning(pop)
 
#include <sys/types.h>
 
#include "fg_struct.h"
#include "fg_define.h"
#include "fg_error_codes.h"
#include "os_type.h"
#include "os_funcs.h"
 
#include "SisoDisplay.h"
 
// For GCC, we control visibility of symbols via attributes
// For MSVC this is done via a .def file.
// TODO: Move this to a common place for all libraries?
#if defined(__GNUC__) && (__GNUC__ >= 4)
    #define PUBLIC_API __attribute__ ((visibility ("default")))
#else
    #define PUBLIC_API
#endif
 
#ifdef __cplusplus
#include <string>
#include <sstream>
#include <new>
#include <cstring>
 
#if defined(__GNUC__) || defined(_MSC_VER) || defined(__clang__)
#define INLINE inline
#else /* __GNUC__ || _MSC_VER || __clang__ */
#define INLINE
#endif /* __GNUC__ || _MSC_VER || __clang__ */
 
extern "C"
{
class dma_mem;
class ShadingMaster;
#else
struct dma_mem_s;
typedef struct dma_mem_s dma_mem;
struct ShadingMaster_s;
typedef struct ShadingMaster_s ShadingMaster;
#endif
 
struct fg_event_info;
 
 
PUBLIC_API int Fg_InitLibraries(const char * sisoDir);
 
PUBLIC_API int Fg_InitLibrariesEx(const char * sisoDir, unsigned int flags, const char * id, unsigned int timeout);
 
PUBLIC_API void Fg_AbortInitLibraries();
 
PUBLIC_API void Fg_InitLibrariesStartNextSlave();
 
PUBLIC_API void Fg_FreeLibraries();
 
PUBLIC_API int Fg_findApplet(const unsigned int BoardIndex, char * Path, size_t Size);
 
PUBLIC_API Fg_Struct * Fg_Init(const char *FileName, unsigned int BoardIndex);
 
PUBLIC_API Fg_Struct * Fg_InitConfig(const char *Config_Name, unsigned int BoardIndex);
 
 
PUBLIC_API Fg_Struct * Fg_InitEx(const char *FileName, unsigned int BoardIndex, int flags);
 
PUBLIC_API Fg_Struct * Fg_InitConfigEx(const char *Config_Name, unsigned int BoardIndex, int flags);
 
PUBLIC_API int Fg_FreeGrabber(Fg_Struct *Fg);
PUBLIC_API void * Fg_AllocMem(Fg_Struct *Fg, const size_t Size, const frameindex_t BufCnt, const unsigned int DmaIndex);
 
PUBLIC_API dma_mem * Fg_AllocMemEx(Fg_Struct *Fg, const size_t Size, const frameindex_t BufCnt);
 
PUBLIC_API int Fg_FreeMem(Fg_Struct *Fg, const unsigned int DmaIndex);
 
PUBLIC_API int Fg_FreeMemEx(Fg_Struct *Fg, dma_mem *mem);
 
PUBLIC_API dma_mem * Fg_AllocMemHead(Fg_Struct *Fg, const size_t Size, const frameindex_t BufCnt);
 
PUBLIC_API int Fg_FreeMemHead(Fg_Struct *Fg, dma_mem *memHandle);
 
PUBLIC_API int Fg_AddMem(Fg_Struct *Fg, void *pBuffer, const size_t Size, const frameindex_t bufferIndex, dma_mem *memHandle);
 
PUBLIC_API int Fg_DelMem(Fg_Struct *Fg, dma_mem *memHandle, const frameindex_t bufferIndex);
 
PUBLIC_API void * Fg_NumaAllocDmaBuffer(Fg_Struct * Fg, size_t Size);
 
PUBLIC_API int Fg_NumaFreeDmaBuffer(Fg_Struct * Fg, void * Buffer);
 
PUBLIC_API int Fg_NumaPinThread(Fg_Struct * Fg);
 
PUBLIC_API int Fg_getNrOfParameter(Fg_Struct *Fg);
 
PUBLIC_API int Fg_getParameterId(Fg_Struct *fg, int index);
 
PUBLIC_API const char * Fg_getParameterName(Fg_Struct *fg, int index);
 
PUBLIC_API int Fg_getParameterIdByName(Fg_Struct *fg, const char *name);
 
PUBLIC_API const char * Fg_getParameterNameById(Fg_Struct *fg, const unsigned int id, const unsigned int dma);
 
PUBLIC_API enum FgParamTypes Fg_getParameterType(Fg_Struct *fg, int index);
 
PUBLIC_API enum FgParamTypes Fg_getParameterTypeById(Fg_Struct *fg, const unsigned int id, const unsigned int dma);
 
PUBLIC_API int Fg_setParameter(Fg_Struct *Fg, const int Parameter, const void *Value, const unsigned int DmaIndex);
 
PUBLIC_API int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const void *Value, const unsigned int DmaIndex, const enum FgParamTypes type);
 
#ifdef __cplusplus
}
 
static INLINE int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const uint64_t Value, const unsigned int DmaIndex)
{
        return Fg_setParameterWithType(Fg, Parameter, &Value, DmaIndex, FG_PARAM_TYPE_UINT64_T);
}
 
static INLINE int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const int64_t Value, const unsigned int DmaIndex)
{
        return Fg_setParameterWithType(Fg, Parameter, &Value, DmaIndex, FG_PARAM_TYPE_INT64_T);
}
 
static INLINE int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const uint32_t Value, const unsigned int DmaIndex)
{
        return Fg_setParameterWithType(Fg, Parameter, &Value, DmaIndex, FG_PARAM_TYPE_UINT32_T);
}
 
static INLINE int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const int32_t Value, const unsigned int DmaIndex)
{
        return Fg_setParameterWithType(Fg, Parameter, &Value, DmaIndex, FG_PARAM_TYPE_INT32_T);
}
 
static INLINE int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const float Value, const unsigned int DmaIndex)
{
        double val = Value;
        return Fg_setParameterWithType(Fg, Parameter, &val, DmaIndex, FG_PARAM_TYPE_DOUBLE);
}
 
static INLINE int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const double Value, const unsigned int DmaIndex)
{
        return Fg_setParameterWithType(Fg, Parameter, &Value, DmaIndex, FG_PARAM_TYPE_DOUBLE);
}
 
 
static INLINE int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const char *Value, const unsigned int DmaIndex)
{
        return Fg_setParameterWithType(Fg, Parameter, Value, DmaIndex, FG_PARAM_TYPE_CHAR_PTR);
}
 
static INLINE int Fg_setParameterWithType(Fg_Struct *Fg, const int Parameter, const std::string & Value, const unsigned int DmaIndex)
{
        return Fg_setParameterWithType(Fg, Parameter, Value.c_str(), DmaIndex, FG_PARAM_TYPE_CHAR_PTR);
}
 
extern "C" {
#endif /* __cplusplus */
 
PUBLIC_API int Fg_getParameter(Fg_Struct *Fg, int Parameter, void *Value, const unsigned int DmaIndex);
 
PUBLIC_API int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, void *Value, const unsigned int DmaIndex, const enum FgParamTypes type);
 
PUBLIC_API int Fg_freeParameterStringWithType(Fg_Struct *Fg, const int Parameter, void *Value, const unsigned int DmaIndex, const enum FgParamTypes type);
 
#ifdef __cplusplus
}
 
static INLINE int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, uint64_t *Value, const unsigned int DmaIndex)
{
        return Fg_getParameterWithType(Fg, Parameter, Value, DmaIndex, FG_PARAM_TYPE_UINT64_T);
}
 
static INLINE int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, int64_t *Value, const unsigned int DmaIndex)
{
        return Fg_getParameterWithType(Fg, Parameter, Value, DmaIndex, FG_PARAM_TYPE_INT64_T);
}
 
static INLINE int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, uint32_t *Value, const unsigned int DmaIndex)
{
        return Fg_getParameterWithType(Fg, Parameter, Value, DmaIndex, FG_PARAM_TYPE_UINT32_T);
}
 
static INLINE int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, int32_t *Value, const unsigned int DmaIndex)
{
        return Fg_getParameterWithType(Fg, Parameter, Value, DmaIndex, FG_PARAM_TYPE_INT32_T);
}
 
static INLINE int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, float *Value, const unsigned int DmaIndex)
{
        double val = 0;
        int result = Fg_getParameterWithType(Fg, Parameter, &val, DmaIndex, FG_PARAM_TYPE_DOUBLE);
        if (result == FG_OK)
                *Value = static_cast<float>(val);
        return result;
}
 
static INLINE int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, double *Value, const unsigned int DmaIndex)
{
        return Fg_getParameterWithType(Fg, Parameter, Value, DmaIndex, FG_PARAM_TYPE_DOUBLE);
}
 
static INLINE int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, std::string & Value, const unsigned int DmaIndex)
{
        char * cstr = NULL;
        int result = Fg_getParameterWithType(Fg, Parameter, &cstr, DmaIndex, FG_PARAM_TYPE_CHAR_PTR_PTR);
        if (result != 0) {
                return result;
        }
 
        Value = cstr;
        Fg_freeParameterStringWithType(Fg, Parameter, cstr, DmaIndex, FG_PARAM_TYPE_CHAR_PTR_PTR);
        return 0;
}
 
extern "C" {
#endif /* __cplusplus */
 
PUBLIC_API int Fg_getParameterEx(Fg_Struct *Fg, const int Parameter, void *Value, const unsigned int DmaIndex, dma_mem *pMem, const frameindex_t ImgNr);
 
PUBLIC_API int Fg_getParameterInfoXML(Fg_Struct *Fg, int port, char * infoBuffer, size_t *infoBufferSize);
 
PUBLIC_API int Fg_getBitsPerPixel(int format);
 
PUBLIC_API int Fg_saveConfig(Fg_Struct *Fg, const char *Filename);
 
PUBLIC_API int Fg_saveFieldParameterToFile(Fg_Struct * Fg, const int Parameter, const unsigned int DmaIndex, const char * FileName);
 
PUBLIC_API int Fg_loadConfig(Fg_Struct *Fg, const char *Filename);
 
PUBLIC_API int Fg_loadFieldParameterFromFile(Fg_Struct * Fg, const int Parameter, const unsigned int DmaIndex, const char * FileName);
 
PUBLIC_API int Fg_Acquire(Fg_Struct *Fg, const unsigned int DmaIndex, const frameindex_t PicCount);
 
PUBLIC_API int Fg_stopAcquire(Fg_Struct *Fg, const unsigned int DmaIndex);
 
PUBLIC_API frameindex_t Fg_getLastPicNumberBlocking(Fg_Struct *Fg, const frameindex_t PicNr, const unsigned int DmaIndex, const int Timeout);
 
PUBLIC_API frameindex_t Fg_getLastPicNumber(Fg_Struct *Fg, const unsigned int DmaIndex);
 
PUBLIC_API frameindex_t Fg_getLastPicNumberBlockingEx(Fg_Struct *Fg, const frameindex_t PicNr, const unsigned int DmaIndex, const int Timeout, dma_mem *pMem);
 
PUBLIC_API frameindex_t Fg_getLastPicNumberEx(Fg_Struct *Fg, const unsigned int DmaIndex, dma_mem *pMem);
 
PUBLIC_API void * Fg_getImagePtr(Fg_Struct *Fg, const frameindex_t PicNr, const unsigned int DmaIndex);
 
PUBLIC_API void * Fg_getImagePtrEx(Fg_Struct *Fg, const frameindex_t PicNr, const unsigned int DmaIndex, dma_mem *pMem);
 
PUBLIC_API int Fg_AcquireEx(Fg_Struct *Fg, const unsigned int DmaIndex, const frameindex_t PicCount, const int nFlag, dma_mem *memHandle);
 
PUBLIC_API int Fg_sendImage(Fg_Struct *Fg, const frameindex_t startImage, const frameindex_t PicCount, const int nFlag, const unsigned int DmaIndex);
PUBLIC_API int Fg_sendImageEx(Fg_Struct *Fg, const frameindex_t startImage, const frameindex_t PicCount, const int nFlag, const unsigned int DmaIndex, dma_mem *memHandle);
 
PUBLIC_API int Fg_stopAcquireEx(Fg_Struct *Fg, const unsigned int DmaIndex, dma_mem *memHandle, int nFlag);
 
PUBLIC_API frameindex_t Fg_getImage(Fg_Struct *Fg, const int Param, const frameindex_t PicNr, const unsigned int DmaIndex, const unsigned int Timeout);
 
PUBLIC_API frameindex_t Fg_getImageEx(Fg_Struct *Fg, const int Param, const frameindex_t PicNr, const unsigned int DmaIndex, const unsigned int Timeout, dma_mem *pMem);
 
PUBLIC_API int Fg_queueBuffer(Fg_Struct *fg, frameindex_t bufferIndex, uint64_t transferLength, uint32_t dmaIndex, dma_mem *memoryHandle);
 
#ifdef __cplusplus
 
extern "C++" {
    
    inline int Fg_queueBuffer(Fg_Struct *fg, frameindex_t bufferIndex, uint64_t transferLength, uint32_t dmaIndex) {
        return Fg_queueBuffer(fg, bufferIndex, transferLength, dmaIndex, nullptr);
    }
 
    inline int Fg_queueBuffer(Fg_Struct *fg, frameindex_t bufferIndex, uint64_t transferLength, dma_mem *memoryHandle)
    {
            return Fg_queueBuffer(fg, bufferIndex, transferLength, UINT32_MAX, memoryHandle);
    }
 
}
#endif // __cplusplus
 
 
PUBLIC_API int Fg_waitForBuffers(Fg_Struct *fg, uint32_t dmaIndex, uint64_t timeoutSeconds, void *reserved1, size_t reserved2);
 
#ifdef __cplusplus
 
extern "C++" inline int Fg_waitForBuffers(Fg_Struct *fg, const uint32_t dmaIndex, const uint64_t timeoutSeconds)
{
        return Fg_waitForBuffers(fg, dmaIndex, timeoutSeconds, nullptr, 0);
}
 
#endif // __cplusplus
 
PUBLIC_API int Fg_startBufferQueue(Fg_Struct *fg, uint32_t dmaIndex, dma_mem *memoryHandle);
 
PUBLIC_API int Fg_stopBufferQueue(Fg_Struct *fg, uint32_t dmaIndex, int32_t flags);
 
PUBLIC_API int Fg_registerApcHandler(Fg_Struct *Fg, const unsigned int DmaIndex, const struct FgApcControl *control, enum FgApcControlFlags flags);
 
#ifdef __cplusplus
}
 
static INLINE int Fg_registerApcHandlerEx(Fg_Struct *Fg, const unsigned int DmaIndex, Fg_ApcFunc_t func, void *data, const unsigned int timeout, const unsigned int flags)
{
        FgApcControl control;
        control.version = 0;
        control.func = func;
        control.data = data;
        control.timeout = timeout;
        control.flags = flags;
        return Fg_registerApcHandler(Fg, DmaIndex, &control, FG_APC_CONTROL_BASIC);
}
 
static INLINE int Fg_unregisterApcHandler(Fg_Struct *Fg, const unsigned int DmaIndex)
{
        return Fg_registerApcHandler(Fg, DmaIndex, NULL, FG_APC_CONTROL_BASIC);
}
 
extern "C" {
#endif
PUBLIC_API int Fg_getLastErrorNumber(Fg_Struct *Fg);
 
PUBLIC_API const char * getErrorDescription(int ErrorNumber);
 
PUBLIC_API const char * Fg_getLastErrorDescription(Fg_Struct *Fg);
 
PUBLIC_API const char * Fg_getErrorDescription(Fg_Struct *Fg, int ErrorNumber);
 
PUBLIC_API int Fg_getBoardType(int BoardIndex);
 
PUBLIC_API const char * Fg_getBoardNameByType(const int BoardType, const int UseShortName);
 
PUBLIC_API unsigned int Fg_getSerialNumber(Fg_Struct *Fg);
 
PUBLIC_API const char * Fg_getSWVersion();
 
PUBLIC_API const char * Fg_getAppletVersion(Fg_Struct *Fg, int AppletId);
 
PUBLIC_API int Fg_getAppletId(Fg_Struct *Fg, const char *ignored);
 
 
 
 
PUBLIC_API int Fg_getParameterProperty(Fg_Struct *Fg, 
                                       const int parameterId, 
                                       const enum FgProperty propertyId, 
                                       void* buffer, int* bufLen);
 
#ifdef __cplusplus
}
 
static INLINE int Fg_getParameterPropertyWithType(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, std::string & Value)
{
        char * buffer = 0;
        int len = 0;
 
        int result = Fg_getParameterProperty(Fg, parameterId, propertyId, NULL, &len);
        if (result != FG_OK) return result;
 
        buffer = new(std::nothrow) char[len];
        if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
        result = Fg_getParameterProperty(Fg, parameterId, propertyId, buffer, &len);
        if (result == FG_OK && len > 0) {
                buffer[len - 1] = '\0';
                Value = buffer;
        }
 
        delete[] buffer;
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithType(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, uint64_t *Value)
{
        std::string temp;
        int result = Fg_getParameterPropertyWithType(Fg, parameterId, propertyId, temp);
        if (result == FG_OK) {
                std::istringstream is(temp);
                is >> (*Value);
                if (is.fail()) result = FG_INVALID_TYPE;
        }
 
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithType(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, int64_t *Value)
{
        return Fg_getParameterPropertyWithType(Fg, parameterId, propertyId, reinterpret_cast<uint64_t *>(Value));
}
 
static INLINE int Fg_getParameterPropertyWithType(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, uint32_t *Value)
{
        uint64_t temp = 0;
        int result = Fg_getParameterPropertyWithType(Fg, parameterId, propertyId, &temp);
        if (result == FG_OK) *Value = static_cast<uint32_t>(temp);
 
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithType(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, int32_t *Value)
{
        uint64_t temp = 0;
        int result = Fg_getParameterPropertyWithType(Fg, parameterId, propertyId, &temp);
        if (result == FG_OK) *Value = static_cast<int32_t>(temp);
 
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithType(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, double *Value)
{
        std::string temp;
        int result = Fg_getParameterPropertyWithType(Fg, parameterId, propertyId, temp);
        if (result == FG_OK) {
                std::istringstream is(temp);
                is >> (*Value);
                if (is.fail()) result = FG_INVALID_TYPE;
        }
 
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithType(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, float *Value)
{
        double temp = 0;
        int result = Fg_getParameterPropertyWithType(Fg, parameterId, propertyId, &temp);
        if (result == FG_OK) *Value = static_cast<float>(temp);
 
        return result;
}
 
extern "C" {
#endif /* __cplusplus */
 
PUBLIC_API int Fg_getParameterPropertyEx(Fg_Struct *Fg, 
                                         const int parameterId, 
                                         const enum FgProperty propertyId, 
                                         const int DmaIndex, 
                                         void* buffer, int* bufLen);
 
#ifdef __cplusplus
}
 
static INLINE int Fg_getParameterPropertyWithTypeEx(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, std::string & Value, const unsigned int DmaIndex)
{
        char * buffer = 0;
        int len = 0;
 
        int result = Fg_getParameterPropertyEx(Fg, parameterId, propertyId, static_cast<int>(DmaIndex), NULL, &len);
        if (result != FG_OK) return result;
 
        buffer = new(std::nothrow) char[len];
        if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
        result = Fg_getParameterPropertyEx(Fg, parameterId, propertyId, static_cast<int>(DmaIndex), buffer, &len);
        if (result == FG_OK && len > 0) {
                buffer[len - 1] = '\0';
                Value = buffer;
        }
 
        delete[] buffer;
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithTypeEx(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, uint64_t *Value, const unsigned int DmaIndex)
{
        std::string temp;
        int result = Fg_getParameterPropertyWithTypeEx(Fg, parameterId, propertyId, temp, DmaIndex);
        if (result == FG_OK) {
                std::istringstream is(temp);
                is >> (*Value);
                if (is.fail()) result = FG_INVALID_TYPE;
        }
 
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithTypeEx(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, int64_t *Value, const unsigned int DmaIndex)
{
        return Fg_getParameterPropertyWithTypeEx(Fg, parameterId, propertyId, reinterpret_cast<uint64_t *>(Value), DmaIndex);
}
 
static INLINE int Fg_getParameterPropertyWithTypeEx(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, uint32_t *Value, const unsigned int DmaIndex)
{
        uint64_t temp = 0;
        int result = Fg_getParameterPropertyWithTypeEx(Fg, parameterId, propertyId, &temp, DmaIndex);
        if (result == FG_OK) *Value = static_cast<uint32_t>(temp);
 
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithTypeEx(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, int32_t *Value, const unsigned int DmaIndex)
{
        uint64_t temp = 0;
        int result = Fg_getParameterPropertyWithTypeEx(Fg, parameterId, propertyId, &temp, DmaIndex);
        if (result == FG_OK) *Value = static_cast<int32_t>(temp);
 
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithTypeEx(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, double *Value, const unsigned int DmaIndex)
{
        std::string temp;
        int result = Fg_getParameterPropertyWithTypeEx(Fg, parameterId, propertyId, temp, DmaIndex);
        if (result == FG_OK) {
                std::istringstream is(temp);
                is >> (*Value);
                if (is.fail()) result = FG_INVALID_TYPE;
        }
 
        return result;
}
 
static INLINE int Fg_getParameterPropertyWithTypeEx(Fg_Struct *Fg, const int parameterId, const enum FgProperty propertyId, float *Value, const unsigned int DmaIndex)
{
        double temp = 0;
        int result = Fg_getParameterPropertyWithTypeEx(Fg, parameterId, propertyId, &temp, DmaIndex);
        if (result == FG_OK) *Value = static_cast<float>(temp);
 
        return result;
}
 
extern "C" {
#endif /* __cplusplus */
 
PUBLIC_API int Fg_getSystemInformation(Fg_Struct *Fg, const enum Fg_Info_Selector selector, const enum FgProperty  propertyId, int param1, void* buffer, unsigned int* bufLen);
 
#ifdef __cplusplus
}
 
static INLINE int Fg_getIntSystemInformationForFgHandle(Fg_Struct *Fg, const enum Fg_Info_Selector selector, const enum FgProperty propertyId, int * val)
{
    char * buffer = 0;
    unsigned int len = 0;
 
    int result = Fg_getSystemInformation(Fg, selector, propertyId, -1, NULL, &len);
    if (result != FG_OK) return result;
 
    buffer = new(std::nothrow) char[len];
    if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
    result = Fg_getSystemInformation(Fg, selector, propertyId, -1, buffer, &len);
    if (result == FG_OK) {
        std::istringstream is(buffer);
        is >> (*val);
        if (is.fail()) result = FG_INVALID_TYPE;
    }
 
    delete[] buffer;
    return result;
}
 
static INLINE int Fg_getIntSystemInformationForBoardIndex(unsigned int BoardIndex, const enum Fg_Info_Selector selector, const enum FgProperty propertyId, int * val)
{
    char * buffer = 0;
    unsigned int len = 0;
 
    int result = Fg_getSystemInformation(NULL, selector, propertyId, static_cast<int>(BoardIndex), NULL, &len);
    if (result != FG_OK) return result;
 
    buffer = new(std::nothrow) char[len];
    if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
    result = Fg_getSystemInformation(NULL, selector, propertyId, static_cast<int>(BoardIndex), buffer, &len);
    if (result == FG_OK) {
        std::istringstream is(buffer);
        is >> (*val);
        if (is.fail()) result = FG_INVALID_TYPE;
    }
 
    delete[] buffer;
    return result;
}
 
static INLINE int Fg_getIntSystemInformationGlobal(const enum Fg_Info_Selector selector, const enum FgProperty propertyId, int * val)
{
    return Fg_getIntSystemInformationForBoardIndex(static_cast<unsigned>(-1), selector, propertyId, val);
}
 
static INLINE int Fg_getInt64SystemInformationForFgHandle(Fg_Struct *Fg, const enum Fg_Info_Selector selector, const enum FgProperty propertyId, int64_t * val)
{
    char * buffer = 0;
    unsigned int len = 0;
 
    int result = Fg_getSystemInformation(Fg, selector, propertyId, -1, NULL, &len);
    if (result != FG_OK) return result;
 
    buffer = new(std::nothrow) char[len];
    if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
    result = Fg_getSystemInformation(Fg, selector, propertyId, -1, buffer, &len);
    if (result == FG_OK) {
        std::istringstream is(buffer);
        is >> (*val);
        if (is.fail()) result = FG_INVALID_TYPE;
    }
 
    delete[] buffer;
    return result;
}
 
static INLINE int Fg_getInt64SystemInformationForBoardIndex(unsigned int BoardIndex, const enum Fg_Info_Selector selector, const enum FgProperty propertyId, int64_t * val)
{
    char * buffer = 0;
    unsigned int len = 0;
 
    int result = Fg_getSystemInformation(NULL, selector, propertyId, static_cast<int>(BoardIndex), NULL, &len);
    if (result != FG_OK) return result;
 
    buffer = new(std::nothrow) char[len];
    if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
    result = Fg_getSystemInformation(NULL, selector, propertyId, static_cast<int>(BoardIndex), buffer, &len);
    if (result == FG_OK) {
        std::istringstream is(buffer);
        is >> (*val);
        if (is.fail()) result = FG_INVALID_TYPE;
    }
 
    delete[] buffer;
    return result;
}
 
static INLINE int Fg_getStringSystemInformationForFgHandle(Fg_Struct *Fg, const enum Fg_Info_Selector selector, const enum FgProperty propertyId, std::string & val, const std::string & arg = "")
{
    char * buffer = 0;
    unsigned int len = 0;
 
    if (arg.length()) {
        len = static_cast<unsigned int>(arg.length()) + 1;
        buffer = new(std::nothrow) char[len];
        if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
#ifdef _WIN32
        strncpy_s(buffer, len, arg.c_str(), len - 1);
#else
        strncpy(buffer, arg.c_str(), len - 1);
#endif
    }
 
    int result = Fg_getSystemInformation(Fg, selector, propertyId, -1, buffer, &len);
 
    if (result != FG_OK) {
        delete[] buffer;
        return result;
    }
 
    if (!arg.empty() && len <= static_cast<unsigned int>(arg.length()) + 1) {
        // The buffer size was sufficient and it contains the requested value.
        val = buffer;
        delete[] buffer;
        return FG_OK;
    } else {
        // The buffer was too small. Create a suitable buffer and try again.
        // len has been set the required size.
        delete[] buffer;
        buffer = new(std::nothrow) char[len];
        if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
        if (!arg.empty()) {
#ifdef _WIN32
            strncpy_s(buffer, len, arg.c_str(), arg.length());
#else
            strncpy(buffer, arg.c_str(), arg.length());
#endif
        }
 
        result = Fg_getSystemInformation(Fg, selector, propertyId, -1, buffer, &len);
        if (result == FG_OK) {
            val = buffer;
        }
 
        delete[] buffer;
        return result;
    }
}
 
static INLINE int Fg_getStringSystemInformationForBoardIndex(unsigned int BoardIndex, const enum Fg_Info_Selector selector, const enum FgProperty propertyId, std::string & val, const std::string & arg = "")
{
    char * buffer = 0;
    unsigned int len = 0;
 
    if (!arg.empty()) {
        len = static_cast<unsigned int>(arg.length()) + 1;
        buffer = new(std::nothrow) char[len];
        if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
#ifdef _WIN32
        strncpy_s(buffer, len, arg.c_str(), arg.length());
#else
        strncpy(buffer, arg.c_str(), arg.length());
#endif
    }
 
    int result = Fg_getSystemInformation(NULL, selector, propertyId, static_cast<int>(BoardIndex), buffer, &len);
    if (result != FG_OK) {
        delete[] buffer;
        return result;
    }
 
    if (!arg.empty() && len <= static_cast<unsigned int>(arg.length()) + 1) {
        val = buffer;
        delete[] buffer;
        return FG_OK;
    } else {
        delete[] buffer;
        buffer = new(std::nothrow) char[len];
        if (!buffer) return FG_NOT_ENOUGH_MEMORY;
 
        if (!arg.empty()) {
#ifdef _WIN32
            strncpy_s(buffer, len, arg.c_str(), arg.length());
#else
            strncpy(buffer, arg.c_str(), arg.length());
#endif
        }
 
        result = Fg_getSystemInformation(NULL, selector, propertyId, static_cast<int>(BoardIndex), buffer, &len);
        if (!result) {
            val = buffer;
        }
 
        delete[] buffer;
        return result;
    }
}
 
static INLINE int Fg_getStringSystemInformationGlobal(const enum Fg_Info_Selector selector, const enum FgProperty propertyId, std::string & val, const std::string & arg = "")
{
    return Fg_getStringSystemInformationForBoardIndex(static_cast<unsigned>(-1), selector, propertyId, val, arg);
}
 
extern "C" {
#endif
 
PUBLIC_API int Fg_readUserDataArea(Fg_Struct *Fg, const int boardId, const unsigned int offs, const unsigned int size, void * buffer);
 
PUBLIC_API int Fg_writeUserDataArea(Fg_Struct *Fg, const int boardId, const unsigned int offs, const unsigned int size, const void * buffer);
 
PUBLIC_API frameindex_t Fg_getStatus(Fg_Struct *Fg, const int Param, const frameindex_t Data, const unsigned int DmaIndex);
 
PUBLIC_API frameindex_t Fg_getStatusEx(Fg_Struct *Fg, const int Param, const frameindex_t Data, const unsigned int DmaIndex, dma_mem *pMem);
 
PUBLIC_API int Fg_setStatus(Fg_Struct *Fg, const int Param, const frameindex_t Data, const unsigned int DmaIndex);
 
PUBLIC_API int Fg_setStatusEx(Fg_Struct *Fg, const int Param, const frameindex_t Data, const unsigned int DmaIndex, dma_mem *pMem);
 
PUBLIC_API int Fg_getAppletIterator(int boardIndex, const enum FgAppletIteratorSource src, Fg_AppletIteratorType * iter, int flags);
 
PUBLIC_API int Fg_freeAppletIterator(Fg_AppletIteratorType iter);
 
PUBLIC_API Fg_AppletIteratorItem Fg_getAppletIteratorItem(Fg_AppletIteratorType iter, int index);
 
PUBLIC_API Fg_AppletIteratorItem Fg_findAppletIteratorItem(Fg_AppletIteratorType iter, const char * path);
 
PUBLIC_API Fg_AppletIteratorItem Fg_addAppletIteratorItem(Fg_AppletIteratorType iter, const char * path, int * numItems);
 
PUBLIC_API int64_t Fg_getAppletIntProperty(Fg_AppletIteratorItem item, const enum FgAppletIntProperty property);
 
PUBLIC_API const char * Fg_getAppletStringProperty(Fg_AppletIteratorItem item, const enum FgAppletStringProperty property);
 
#ifdef __cplusplus
} /* extern "C" */
 
static INLINE int Fg_findApplet(const unsigned int BoardIndex, std::string & Path) {
 
        // ensure a defined state of the output argument
        Path.clear();
 
        Fg_AppletIteratorType iter;
        int ret = Fg_getAppletIterator(BoardIndex, FG_AIS_FILESYSTEM, &iter, FG_AF_IS_LOADABLE);
 
        const int numItems = ret;
        ret = FG_FILE_NOT_FOUND;
 
        // Iterate over found applets in case there are more than one.
        for (int i = 0; i < numItems && ret != FG_OK; ++i) {
        const Fg_AppletIteratorItem item = Fg_getAppletIteratorItem(iter, i);
                if (item != nullptr) {
            const int64_t info = Fg_getAppletIntProperty(item, FG_AP_INT_INFO);
                        if (info & FG_AI_IS_VALID) {
                                Path = Fg_getAppletStringProperty(item, FG_AP_STRING_APPLET_PATH);
                                ret = FG_OK;
                        }
                }
        }
    Fg_freeAppletIterator(iter);
        return ret;
}
 
extern "C" {
#endif /* __cplusplus */
 
PUBLIC_API uint64_t Fg_getEventMask(Fg_Struct *Fg, const char *name);
 
PUBLIC_API int Fg_getEventPayload(Fg_Struct *Fg, uint64_t mask);
 
PUBLIC_API const char * Fg_getEventName(Fg_Struct *Fg, uint64_t mask);
 
PUBLIC_API int Fg_getEventCount(Fg_Struct *Fg);
 
PUBLIC_API int Fg_activateEvents(Fg_Struct *Fg, uint64_t mask, int enable);
 
PUBLIC_API int Fg_clearEvents(Fg_Struct *Fg, uint64_t mask);
 
PUBLIC_API uint64_t Fg_eventWait(Fg_Struct *Fg, uint64_t mask, unsigned int timeout, unsigned int flags, struct fg_event_info *info);
 
PUBLIC_API int Fg_registerEventCallback(Fg_Struct *Fg, uint64_t mask, Fg_EventFunc_t handler, void *data, unsigned int flags, struct fg_event_info *info);
 
#ifdef __cplusplus
}
 
static INLINE int Fg_unregisterEventCallback(Fg_Struct *Fg, uint64_t mask)
{
    return Fg_registerEventCallback(Fg, mask, NULL, NULL, FG_EVENT_DEFAULT_FLAGS, NULL);
}
 
extern "C" {
#endif
PUBLIC_API int Fg_registerAsyncNotifyCallback(Fg_Struct *Fg, Fg_AsyncNotifyFunc_t handler, void * context);
 
PUBLIC_API int Fg_unregisterAsyncNotifyCallback(Fg_Struct *Fg, Fg_AsyncNotifyFunc_t handler, void * context);
 
PUBLIC_API int Fg_resetAsyncNotify(Fg_Struct *Fg, unsigned long notification, unsigned long pl, unsigned long ph);
 
PUBLIC_API int Fg_setAsyncNotify(Fg_Struct *Fg, unsigned long notification, unsigned long pl, unsigned long ph);
 
PUBLIC_API int DEPRECATED(Fg_setExsync(Fg_Struct *Fg, int Flag, const unsigned int CamPort));
 
PUBLIC_API int DEPRECATED(Fg_setFlash(Fg_Struct *Fg, int Flag, const unsigned int CamPort));
 
PUBLIC_API int Fg_sendSoftwareTrigger(Fg_Struct *Fg, const unsigned int CamPort);
 
PUBLIC_API int Fg_sendSoftwareTriggerEx(Fg_Struct *Fg, const unsigned int CamPort, const unsigned int Triggers);
 
PUBLIC_API ShadingMaster * Fg_AllocShading(Fg_Struct *Fg, int set, const unsigned int CamPort);
 
PUBLIC_API int Fg_FreeShading(Fg_Struct *Fg, ShadingMaster *sh);
 
PUBLIC_API int Shad_GetAccess(Fg_Struct *Fg, ShadingMaster *sh);
 
PUBLIC_API int Shad_FreeAccess(Fg_Struct *Fg, ShadingMaster *sh);
 
PUBLIC_API int Shad_GetMaxLine(Fg_Struct *Fg, ShadingMaster *sh);
 
PUBLIC_API int Shad_SetSubValueLine(Fg_Struct *Fg, ShadingMaster *sh, int x, int channel, float sub);
 
PUBLIC_API int Shad_SetMultValueLine(Fg_Struct *Fg, ShadingMaster *sh, int x, int channel, float mult);
 
PUBLIC_API int Shad_SetFixedPatternNoiseLine(Fg_Struct *Fg, ShadingMaster *sh, int x, int channel, int on);
 
PUBLIC_API int Shad_WriteActLine(Fg_Struct *Fg, ShadingMaster *sh, int Line);
#ifdef __cplusplus
 
struct VAdevice;
struct RegisterInfo;
class fpga_design;
 
PUBLIC_API Fg_Struct * Fg_InitHandle(const char *appletName, struct VAdevice *hwhandle, fpga_design *deshandle);
 
PUBLIC_API Fg_Struct * Fg_InitHandleSlaveAware(const char *appletName, struct VAdevice *hwhandle, fpga_design *deshandle, int isSlave);
 
PUBLIC_API RegisterInfo * Fg_getParameterInfo(Fg_Struct *Fg, const unsigned int CamPort);
 
#endif /* __cplusplus */
 
/* Deprecated functions, do not use as they will eventually go away */
 
PUBLIC_API int DEPRECATED(getLastErrorNumber());
 
#ifdef __cplusplus
} /* extern "C" */
 
#endif
 
#endif /* __BASLER_FG_H */