EGrabberTypes.h

Go to the documentation of this file.

/* Copyright Euresys 2015 */
 
#ifndef EGRABBER_TYPES_HEADER_FILE
#define EGRABBER_TYPES_HEADER_FILE
 
namespace EURESYS_NAMESPACE {
 
// --------------------------------------------------------------------------
// EGrabberDiscovery structures
// --------------------------------------------------------------------------
 
struct EGrabberInfo
{
    int interfaceIndex;
    int deviceIndex;
    int streamIndex;
 
    std::string interfaceID;
    std::string deviceID;
    std::string streamID;
 
    std::string deviceVendorName;
    std::string deviceModelName;
    std::string deviceDescription;
    std::string streamDescription;
    std::string deviceUserID;
    std::string deviceSerialNumber;
    std::string tlType;
    std::string firmwareStatus;
    std::string fanStatus;
    std::string licenseStatus;
 
    bool isRemoteAvailable;
    bool isDeviceReadOnly;
 
    EGenTL *gentl;
};
 
struct EGrabberCameraInfo
{
    std::vector<EGrabberInfo> grabbers;
};
 
// --------------------------------------------------------------------------
// Available Memory types to announce GenTL buffers
// --------------------------------------------------------------------------
 
struct GenTLMemory;
struct UserMemory;
struct BusMemory;
struct NvidiaRdmaMemory;
struct UserMemoryArray;
 
struct GenTLMemory {
    GenTLMemory(size_t bufferSize = 0, void *userPointer = 0)
    : bufferSize(bufferSize)
    , userPointer(userPointer)
    {}
    size_t bufferSize;
    void *userPointer;
};
 
struct UserMemory {
    UserMemory(void *base, size_t size, void *userPointer = 0)
    : base(base)
    , size(size)
    , userPointer(userPointer)
    {}
    void *base;
    size_t size;
    void *userPointer;
};
 
struct BusMemory {
    BusMemory(uint64_t busAddress, size_t size, void *userPointer = 0)
    : busAddress(busAddress)
    , size(size)
    , userPointer(userPointer)
    {}
    uint64_t busAddress;
    size_t size;
    void *userPointer;
};
 
struct NvidiaRdmaMemory {
    NvidiaRdmaMemory(void *deviceAddress, size_t size, void *userPointer = 0)
    : deviceAddress(deviceAddress)
    , size(size)
    , userPointer(userPointer)
    {}
    void *deviceAddress;
    size_t size;
    void *userPointer;
};
 
struct UserMemoryArray {
    UserMemoryArray(const UserMemory &memory, size_t bufferSize)
    : memory(memory)
    , bufferSize(bufferSize)
    {}
    UserMemory memory;
    size_t bufferSize;
};
 
// --------------------------------------------------------------------------
// Buffer Index Range returned by announce
// --------------------------------------------------------------------------
 
struct BufferIndexRange {
    BufferIndexRange(size_t begin = 0, size_t end = 0, bool reverse = false)
    : begin(begin)
    , end(end)
    , reverse(reverse)
    {}
    BufferIndexRange(const BufferIndexRange &range)
    : begin(range.begin)
    , end(range.end)
    , reverse(range.reverse)
    {}
    BufferIndexRange& operator=(BufferIndexRange range) {
        begin = range.begin;
        end = range.end;
        reverse = range.reverse;
        return *this;
    }
    size_t indexAt(size_t offset) const {
        size_t ix = begin;
        ix += (reverse) ? size() - 1 - offset : offset;
        if (begin <= ix && ix < end) { return ix; }
        throw client_error("out of range");
    }
    size_t size() const {
        return (begin < end) ? end - begin : 0;
    }
    size_t begin;
    size_t end;
    bool reverse;
};
 
// --------------------------------------------------------------------------
// Available (Port) Modules (see getInfo<M, T>, GenApi methods <P>)
// --------------------------------------------------------------------------
 
struct SystemModule {
};
 
struct InterfaceModule {
};
 
struct DeviceModule {
};
 
struct StreamModule {
};
 
struct RemoteModule {
};
 
// --------------------------------------------------------------------------
// Available Event DATA types (see enableEvent<DATA>)
// --------------------------------------------------------------------------
 
struct NewBufferData {
    gc::DS_HANDLE dsh;      
    gc::BUFFER_HANDLE bh;   
    void *userPointer;      
    uint64_t timestamp;     
    void *owner;            
    size_t ownerType;       
    size_t bufferId;        
};
 
struct IoToolboxData {
    uint64_t timestamp;                 
    uint32_t numid;                     
    uint32_t context1;                  
    uint32_t context2;                  
    uint32_t context3;                  
};
 
struct CicData {
    uint64_t timestamp;                 
    uint32_t numid;                     
    uint32_t context1;                  
    uint32_t context2;                  
    uint32_t context3;                  
};
 
struct DataStreamData {
    uint64_t timestamp;                 
    uint32_t numid;                     
    uint32_t context1;                  
    uint32_t context2;                  
    uint32_t context3;                  
};
 
struct CxpInterfaceData {
    uint64_t timestamp;                 
    uint32_t numid;                     
    uint32_t context1;                  
    uint32_t context2;                  
    uint32_t context3;                  
};
 
struct DeviceErrorData {
    uint64_t timestamp;                 
    uint32_t numid;                     
    uint32_t context1;                  
    uint32_t context2;                  
    uint32_t context3;                  
};
 
struct CxpDeviceData {
    uint64_t timestamp;                 
    uint32_t numid;                     
    uint32_t context1;                  
    uint32_t context2;                  
    uint32_t context3;                  
};
 
struct RemoteDeviceData {
    uint64_t timestamp;                 
    uint32_t eventNs;                   
    uint32_t eventId;                   
    uint32_t size;                      
    unsigned char data[1012];           
};
 
struct All {
};
 
struct Undefined {
    // An undefined event DATA type
    // For implementation purpose only, see OneOf
};
 
template < typename D1
         , typename D2 = Undefined
         , typename D3 = Undefined
         , typename D4 = Undefined
         , typename D5 = Undefined
         , typename D6 = Undefined
         , typename D7 = Undefined
         , typename D8 = Undefined >
union OneOf {
    D1 data1;
    D2 data2;
    D3 data3;
    D4 data4;
    D5 data5;
    D6 data6;
    D7 data7;
    D8 data8;
};
 
typedef OneOf<NewBufferData,
              IoToolboxData,
              CicData,
              DataStreamData,
              CxpInterfaceData,
              DeviceErrorData,
              CxpDeviceData,
              RemoteDeviceData>
        OneOfAll;
 
typedef OneOfAll Any;
 
enum EventType {
    AnyType          = -1,
    NewBufferType    = (1 << 0),
    IoToolboxType    = (1 << 1),
    CicType          = (1 << 2),
    DataStreamType   = (1 << 3),
    CxpInterfaceType = (1 << 4),
    DeviceErrorType  = (1 << 5),
    CxpDeviceType    = (1 << 6),
    RemoteDeviceType = (1 << 7),
};
 
// --------------------------------------------------------------------------
// Available Callback threading models
// --------------------------------------------------------------------------
 
struct CallbackOnDemand {
};
 
struct CallbackSingleThread {
};
 
struct CallbackMultiThread {
};
 
} // EURESYS_NAMESPACE
 
#include "internal/common/EGrabberTypes.h"
 
#endif