GenTL.h

Go to the documentation of this file.

/****************************************************************************
(c) 2004-2019 by GenICam GenTL Subcommittee
 
License: This file is published under the license of the EMVA GenICam Standard Group.
A text file describing the legal terms is included in your installation as 'license.txt'.
If for some reason you are missing this file please contact the EMVA or visit the website
(http://www.genicam.org) for a full copy.
 
THIS SOFTWARE IS PROVIDED BY THE EMVA GENICAM STANDARD GROUP "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE EMVA GENICAM STANDARD  GROUP
OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,  SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT  LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,  DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY  THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT  (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
 
******************************************************************************/
 
#ifndef GC_TLI_CLIENT_H_
#define GC_TLI_CLIENT_H_ 1
 
#ifndef GC_USER_DEFINED_TYPES
/* The types should be the same as defined in GCTypes.h from GenApi. But in
 * case you do not have this header the necessary types are defined here. */
#if defined(_WIN32)
#if defined(_MSC_VER) && _MSC_VER >= 1600 /* VS2010 provides stdint.h */
#include <stdint.h>
#elif !defined _STDINT_H && !defined _STDINT
/* stdint.h is usually not available under Windows */
typedef unsigned char uint8_t;
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
#endif
#else
#include <stdint.h>
#endif
 
#ifdef __cplusplus
typedef bool bool8_t;
#else
typedef uint8_t bool8_t;
#endif
#endif /* GC_DEFINE_TYPES */
 
#include <stddef.h>
 
/* Function declaration modifiers */
#if defined(_WIN32)
#define GCTLIDLL
#ifndef GCTLI_NO_DECLSPEC_STATEMENTS
#ifdef GCTLIDLL
#define GC_IMPORT_EXPORT __declspec(dllexport)
#else
#define GC_IMPORT_EXPORT __declspec(dllimport)
#endif
#else
#define GC_IMPORT_EXPORT
#endif /* #  ifndef GCTLI_NO_DECLSPEC_STATEMENTS */
#if defined(_M_IX86) || defined(__i386__)
#define GC_CALLTYPE __stdcall
#else
#define GC_CALLTYPE /* default */
#endif
#ifndef EXTERN_C
#define EXTERN_C extern "C"
#endif
 
#elif defined(__GNUC__) && (__GNUC__ >= 4) && (defined(__linux__) || defined(__APPLE__))
#define GC_IMPORT_EXPORT __attribute__((visibility("default")))
#if defined(__i386__)
#define GC_CALLTYPE __attribute__((stdcall))
#else
#define GC_CALLTYPE /* default */
#endif
#ifndef EXTERN_C
#define EXTERN_C extern "C"
#endif
 
#else
#error Unknown platform, file needs adaption
#endif
 
#ifdef __cplusplus
extern "C"
{
    namespace GenTL
    {
#endif
 
    enum GC_ERROR_LIST
    {
        GC_ERR_SUCCESS = 0,                                           
        GC_ERR_ERROR = -1001,                                         
        GC_ERR_NOT_INITIALIZED = -1002,                               
        GC_ERR_NOT_IMPLEMENTED = -1003,                               
        GC_ERR_RESOURCE_IN_USE = -1004,                               
        GC_ERR_ACCESS_DENIED = -1005,                                 
        GC_ERR_INVALID_HANDLE = -1006,                                
        GC_ERR_INVALID_ID = -1007,                                    
        GC_ERR_NO_DATA = -1008,                                       
        GC_ERR_INVALID_PARAMETER = -1009,                             
        GC_ERR_IO = -1010,                                            
        GC_ERR_TIMEOUT = -1011,                                       
        GC_ERR_ABORT = -1012,                            /* GenTL v1.1 */
        GC_ERR_INVALID_BUFFER = -1013,          /* GenTL v1.1 */
        GC_ERR_NOT_AVAILABLE = -1014,              /* GenTL v1.2 */
        GC_ERR_INVALID_ADDRESS = -1015,        /* GenTL v1.3 */
        GC_ERR_BUFFER_TOO_SMALL = -1016,   /* GenTL v1.4 */
        GC_ERR_INVALID_INDEX = -1017,            /* GenTL v1.4 */
        GC_ERR_PARSING_CHUNK_DATA = -1018,    /* GenTL v1.4 */
        GC_ERR_INVALID_VALUE = -1019,            /* GenTL v1.4 */
        GC_ERR_RESOURCE_EXHAUSTED = -1020,  /* GenTL v1.4 */
        GC_ERR_OUT_OF_MEMORY = -1021,            /* GenTL v1.4 */
        GC_ERR_BUSY = -1022,                              /* GenTL v1.5 */
        GC_ERR_AMBIGUOUS = -1023,                    /* GenTL v1.6 */
 
        GC_ERR_CUSTOM_ID = -10000
    };
    typedef int32_t GC_ERROR;
 
#ifndef GC_GENTL_HEADER_VERSION
 
#define GenTLMajorVersion                                                                                              \
    1 /* defines the major version of the GenICam GenTL standard version this header is based on */
#define GenTLMinorVersion                                                                                              \
    6 /* defines the minor version of the GenICam GenTL standard version this header is based on */
#define GenTLSubMinorVersion                                                                                           \
    0 /* defines the sub minor version of the GenICam GenTL standard version this header is based on */
 
#define GC_GENTL_HEADER_VERSION_CODE(major, minor, subminor) (((major) << 24) + ((minor) << 16) + (subminor))
#define GC_GENTL_HEADER_VERSION GC_GENTL_HEADER_VERSION_CODE(GenTLMajorVersion, GenTLMinorVersion, GenTLSubMinorVersion)
 
#endif /* GC_GENTL_HEADER_VERSION */
 
#ifndef GC_GENTL_DONT_USE_TYPE_DEFINITIONS
#define TLTypeMixedName "Mixed"       /* Type to use for several supported technologies */
#define TLTypeCustomName "Custom"     /* Type to use for custom technologies */
#define TLTypeGEVName "GEV"           /* Type to use for GigE Vision technology */
#define TLTypeCLName "CL"             /* Type to use for Camera Link technology */
#define TLTypeIIDCName "IIDC"         /* Type to use for IIDC 1394 technology */
#define TLTypeUVCName "UVC"           /* Type to use for USB video class devices */
#define TLTypeCXPName "CXP"           /* Type to use for CoaXPress, V1.3 */
#define TLTypeCLHSName "CLHS"         /* Type to use for Camera Link HS, V1.3 */
#define TLTypeU3VName "U3V"           /* Type to use for USB3 Vision Standard, V1.4 */
#define TLTypeETHERNETName "Ethernet" /* Type to use for Ethernet devices, V1.3 */
#define TLTypePCIName "PCI"           /* Type to use for PCI/PCIe devices, V1.3 */
#endif                                /* GC_GENTL_DONT_USE_TYPE_DEFINITIONS */
 
#ifndef GC_GENTL_DONT_USE_MODULE_NAMES
#define TLSystemModuleName "TLSystem"         /* Name to identify a system module */
#define TLInterfaceModuleName "TLInterface"   /* Name to identify a interface module */
#define TLDeviceModuleName "TLDevice"         /* Name to identify a device module */
#define TLDataStreamModuleName "TLDataStream" /* Name to identify a data stream module */
#define TLBufferModuleName "TLBuffer"         /* Name to identify a buffer module */
#define TLRemoteDeviceModuleName "Device"     /* Name to identify a remote device module */
#endif                                        /* GC_GENTL_DONT_USE_MODULE_NAMES */
 
    /* Handles */
    typedef void *TL_HANDLE;   
    typedef void *IF_HANDLE;   
    typedef void *DEV_HANDLE;  
    typedef void *DS_HANDLE;   
    typedef void *PORT_HANDLE; 
    typedef void *BUFFER_HANDLE; /*>! Buffer handle, obtained through the ::DSAnnounceBuffer or related function */
    typedef void *
        EVENTSRC_HANDLE; /* A Event source handle is used to register a OS Event and to retrieve a GenTL event handle */
                         /* a EVENTSRC_HANDLE can be on of the following TL_HANDLE, */
                         /* IF_HANDLE, DEV_HANDLE, DS_HANDLE, BUFFER_HANDLE */
    typedef void *EVENT_HANDLE; /* Event handle, obtained through the ::GCRegisterEvent */
 
#define GENTL_INVALID_HANDLE NULL            /* Invalid handle value, V1.4 */
#define GENTL_INFINITE 0xFFFFFFFFFFFFFFFFULL /* Infinite value to be used in various function calls, V1.4 */
 
    enum INFO_DATATYPE_LIST
    {
        INFO_DATATYPE_UNKNOWN = 0, 
        INFO_DATATYPE_STRING = 1,  
        INFO_DATATYPE_STRINGLIST =
            2, 
        INFO_DATATYPE_INT16 = 3,   
        INFO_DATATYPE_UINT16 = 4,  
        INFO_DATATYPE_INT32 = 5,   
        INFO_DATATYPE_UINT32 = 6,  
        INFO_DATATYPE_INT64 = 7,   
        INFO_DATATYPE_UINT64 = 8,  
        INFO_DATATYPE_FLOAT64 = 9, 
        INFO_DATATYPE_PTR = 10,   
        INFO_DATATYPE_BOOL8 = 11, 
        INFO_DATATYPE_SIZET = 12, 
        INFO_DATATYPE_BUFFER = 13,  
        INFO_DATATYPE_PTRDIFF = 14, 
        INFO_DATATYPE_CUSTOM_ID = 1000, 
        INFO_DATATYPE_FLOAT32 = 1001,
    };
    typedef int32_t INFO_DATATYPE;
 
    enum TL_CHAR_ENCODING_LIST
    {
        TL_CHAR_ENCODING_ASCII = 0, 
        TL_CHAR_ENCODING_UTF8 = 1   
    };
    typedef int32_t TL_CHAR_ENCODING; /* GenTL v1.4 */
 
    enum TL_INFO_CMD_LIST
    {
        TL_INFO_ID = 0,            
        TL_INFO_VENDOR = 1,        
        TL_INFO_MODEL = 2,         
        TL_INFO_VERSION = 3,       
        TL_INFO_TLTYPE = 4,        
        TL_INFO_NAME = 5,          
        TL_INFO_PATHNAME = 6,      
        TL_INFO_DISPLAYNAME = 7,   
        TL_INFO_CHAR_ENCODING = 8, 
        TL_INFO_GENTL_VER_MAJOR =
            9, 
        TL_INFO_GENTL_VER_MINOR =
            10, 
        TL_INFO_CUSTOM_ID = 1000, 
        TL_INFO_COMMIT_ID = 1001, 
        TL_INFO_COMPILE = 1002,   
    };
    typedef int32_t TL_INFO_CMD;
 
    enum INTERFACE_INFO_CMD_LIST
    {
        INTERFACE_INFO_ID = 0,          
        INTERFACE_INFO_DISPLAYNAME = 1, 
        INTERFACE_INFO_TLTYPE = 2,      
        INTERFACE_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t INTERFACE_INFO_CMD;
 
    enum DEVICE_ACCESS_FLAGS_LIST
    {
        DEVICE_ACCESS_UNKNOWN =
            0, 
        DEVICE_ACCESS_NONE = 1, 
        DEVICE_ACCESS_READONLY = 2, 
        DEVICE_ACCESS_CONTROL = 3, 
        DEVICE_ACCESS_EXCLUSIVE = 4, 
        DEVICE_ACCESS_CUSTOM_ID = 1000 
    };
    typedef int32_t DEVICE_ACCESS_FLAGS;
 
    enum DEVICE_ACCESS_STATUS_LIST
    {
        DEVICE_ACCESS_STATUS_UNKNOWN = 0,   
        DEVICE_ACCESS_STATUS_READWRITE = 1, 
        DEVICE_ACCESS_STATUS_READONLY = 2,  
        DEVICE_ACCESS_STATUS_NOACCESS = 3,  
        DEVICE_ACCESS_STATUS_BUSY = 4, 
        DEVICE_ACCESS_STATUS_OPEN_READWRITE = 5, 
        DEVICE_ACCESS_STATUS_OPEN_READONLY = 6,  
        DEVICE_ACCESS_STATUS_CUSTOM_ID = 1000 
    };
    typedef int32_t DEVICE_ACCESS_STATUS;
 
    enum DEVICE_INFO_CMD_LIST
    {
        DEVICE_INFO_ID = 0,     
        DEVICE_INFO_VENDOR = 1, 
        DEVICE_INFO_MODEL = 2,  
        DEVICE_INFO_TLTYPE = 3, 
        DEVICE_INFO_DISPLAYNAME =
            4, 
        DEVICE_INFO_ACCESS_STATUS = 5, 
        DEVICE_INFO_USER_DEFINED_NAME = 6, 
        DEVICE_INFO_SERIAL_NUMBER = 7,     
        DEVICE_INFO_VERSION = 8,           
        DEVICE_INFO_TIMESTAMP_FREQUENCY = 9, 
        DEVICE_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t DEVICE_INFO_CMD; /* DEVICE_INFO_CMD_LIST */
 
    enum ACQ_STOP_FLAGS_LIST
    {
        ACQ_STOP_FLAGS_DEFAULT = 0, 
        ACQ_STOP_FLAGS_KILL = 1, 
        ACQ_STOP_FLAGS_CUSTOM_ID = 1000 
    };
    typedef int32_t ACQ_STOP_FLAGS;
 
    enum ACQ_START_FLAGS_LIST
    {
        ACQ_START_FLAGS_DEFAULT = 0, 
        ACQ_START_FLAGS_CUSTOM_ID = 1000 
    };
    typedef int32_t ACQ_START_FLAGS;
 
    enum ACQ_QUEUE_TYPE_LIST
    {
        ACQ_QUEUE_INPUT_TO_OUTPUT = 0, 
        ACQ_QUEUE_OUTPUT_DISCARD = 1,  
        ACQ_QUEUE_ALL_TO_INPUT = 2, 
        ACQ_QUEUE_UNQUEUED_TO_INPUT =
            3, 
        ACQ_QUEUE_ALL_DISCARD = 4, 
        ACQ_QUEUE_CUSTOM_ID = 1000 
    };
    typedef int32_t ACQ_QUEUE_TYPE;
 
    enum STREAM_INFO_CMD_LIST
    {
        STREAM_INFO_ID = 0,                 
        STREAM_INFO_NUM_DELIVERED = 1,      
        STREAM_INFO_NUM_UNDERRUN = 2,       
        STREAM_INFO_NUM_ANNOUNCED = 3,      
        STREAM_INFO_NUM_QUEUED = 4,         
        STREAM_INFO_NUM_AWAIT_DELIVERY = 5, 
        STREAM_INFO_NUM_STARTED = 6,        
        STREAM_INFO_PAYLOAD_SIZE = 7,       
        STREAM_INFO_IS_GRABBING =
            8, 
        STREAM_INFO_DEFINES_PAYLOADSIZE = 9, 
        STREAM_INFO_TLTYPE = 10,             
        STREAM_INFO_NUM_CHUNKS_MAX = 11,     
        STREAM_INFO_BUF_ANNOUNCE_MIN =
            12, 
        STREAM_INFO_BUF_ALIGNMENT = 13,             
        STREAM_INFO_FLOW_TABLE = 14,                
        STREAM_INFO_GENDC_PREFETCH_DESCRIPTOR = 15, 
        STREAM_INFO_CUSTOM_ID = 1000, 
        STREAM_CAM_INT_PARA = 1001,   
        STREAM_CAM_EXT_PARA = 1002,   
    };
    typedef int32_t STREAM_INFO_CMD;
 
    enum BUFFER_INFO_CMD_LIST
    {
        BUFFER_INFO_BASE = 0,      
        BUFFER_INFO_SIZE = 1,      
        BUFFER_INFO_USER_PTR = 2,  
        BUFFER_INFO_TIMESTAMP = 3, 
        BUFFER_INFO_NEW_DATA =
            4, 
        BUFFER_INFO_IS_QUEUED =
            5, 
        BUFFER_INFO_IS_ACQUIRING =
            6, 
        BUFFER_INFO_IS_INCOMPLETE =
            7, 
        BUFFER_INFO_TLTYPE = 8,        
        BUFFER_INFO_SIZE_FILLED = 9,   
        BUFFER_INFO_WIDTH = 10,        
        BUFFER_INFO_HEIGHT = 11,       
        BUFFER_INFO_XOFFSET = 12,      
        BUFFER_INFO_YOFFSET = 13,      
        BUFFER_INFO_XPADDING = 14,     
        BUFFER_INFO_YPADDING = 15,     
        BUFFER_INFO_FRAMEID = 16,      
        BUFFER_INFO_IMAGEPRESENT = 17, 
        BUFFER_INFO_IMAGEOFFSET = 18,  
        BUFFER_INFO_PAYLOADTYPE = 19,  
        BUFFER_INFO_PIXELFORMAT = 20,  
        BUFFER_INFO_PIXELFORMAT_NAMESPACE = 21,      
        BUFFER_INFO_DELIVERED_IMAGEHEIGHT = 22,      
        BUFFER_INFO_DELIVERED_CHUNKPAYLOADSIZE = 23, 
        BUFFER_INFO_CHUNKLAYOUTID = 24,              
        BUFFER_INFO_FILENAME = 25,                   
        BUFFER_INFO_PIXEL_ENDIANNESS = 26,           
        BUFFER_INFO_DATA_SIZE = 27,                  
        BUFFER_INFO_TIMESTAMP_NS = 28,               
        BUFFER_INFO_DATA_LARGER_THAN_BUFFER = 29,    
        BUFFER_INFO_CONTAINS_CHUNKDATA = 30,         
        BUFFER_INFO_IS_COMPOSITE = 31,               
        BUFFER_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t BUFFER_INFO_CMD;
 
    enum BUFFER_PART_INFO_CMD_LIST
    {
        BUFFER_PART_INFO_BASE = 0,      
        BUFFER_PART_INFO_DATA_SIZE = 1, 
        BUFFER_PART_INFO_DATA_TYPE =
            2, 
        BUFFER_PART_INFO_DATA_FORMAT =
            3, 
        BUFFER_PART_INFO_DATA_FORMAT_NAMESPACE =
            4,                         
        BUFFER_PART_INFO_WIDTH = 5,    
        BUFFER_PART_INFO_HEIGHT = 6,   
        BUFFER_PART_INFO_XOFFSET = 7,  
        BUFFER_PART_INFO_YOFFSET = 8,  
        BUFFER_PART_INFO_XPADDING = 9, 
        BUFFER_PART_INFO_SOURCE_ID =
            10, 
        BUFFER_PART_INFO_DELIVERED_IMAGEHEIGHT =
            11, 
        BUFFER_PART_INFO_REGION_ID =
            12, 
        BUFFER_PART_INFO_DATA_PURPOSE_ID =
            13, 
        BUFFER_PART_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t BUFFER_PART_INFO_CMD; /* GenTL v1.5 */
 
    enum PAYLOADTYPE_INFO_IDS
    {
        PAYLOAD_TYPE_UNKNOWN = 0,         
        PAYLOAD_TYPE_IMAGE = 1,           
        PAYLOAD_TYPE_RAW_DATA = 2,        
        PAYLOAD_TYPE_FILE = 3,            
        PAYLOAD_TYPE_CHUNK_DATA = 4,      
        PAYLOAD_TYPE_JPEG = 5,            
        PAYLOAD_TYPE_JPEG2000 = 6,        
        PAYLOAD_TYPE_H264 = 7,            
        PAYLOAD_TYPE_CHUNK_ONLY = 8,      
        PAYLOAD_TYPE_DEVICE_SPECIFIC = 9, 
        PAYLOAD_TYPE_MULTI_PART = 10,     
        PAYLOAD_TYPE_GENDC = 11,          
        PAYLOAD_TYPE_CUSTOM_ID = 1000 
    };
    typedef int32_t PAYLOADTYPE_INFO_ID;
 
    enum PIXELFORMAT_NAMESPACE_IDS
    {
        PIXELFORMAT_NAMESPACE_UNKNOWN = 0,    
        PIXELFORMAT_NAMESPACE_GEV = 1,        
        PIXELFORMAT_NAMESPACE_IIDC = 2,       
        PIXELFORMAT_NAMESPACE_PFNC_16BIT = 3, 
        PIXELFORMAT_NAMESPACE_PFNC_32BIT = 4, 
        PIXELFORMAT_NAMESPACE_CUSTOM_ID = 1000 
    };
    typedef int32_t PIXELFORMAT_NAMESPACE_ID; /* GenTL v1.2 */
 
    enum PIXELENDIANNESS_IDS
    {
        PIXELENDIANNESS_UNKNOWN = 0, 
        PIXELENDIANNESS_LITTLE = 1,  
        PIXELENDIANNESS_BIG = 2      
    };
    typedef int32_t PIXELENDIANNESS_ID; /* GenTL v1.4*/
 
    enum PARTDATATYPE_IDS
    {
        PART_DATATYPE_UNKNOWN = 0,             
        PART_DATATYPE_2D_IMAGE = 1,            
        PART_DATATYPE_2D_PLANE_BIPLANAR = 2,   
        PART_DATATYPE_2D_PLANE_TRIPLANAR = 3,  
        PART_DATATYPE_2D_PLANE_QUADPLANAR = 4, 
        PART_DATATYPE_3D_IMAGE = 5,            
        PART_DATATYPE_3D_PLANE_BIPLANAR = 6,   
        PART_DATATYPE_3D_PLANE_TRIPLANAR = 7,  
        PART_DATATYPE_3D_PLANE_QUADPLANAR = 8, 
        PART_DATATYPE_CONFIDENCE_MAP = 9,      
        PART_DATATYPE_JPEG = 10,               
        PART_DATATYPE_JPEG2000 = 11,           
        PART_DATATYPE_CUSTOM_ID = 1000 
    };
    typedef int32_t PARTDATATYPE_ID; /* GenTL v1.5*/
 
    enum PORT_INFO_CMD_LIST
    {
        PORT_INFO_ID = 0,            
        PORT_INFO_VENDOR = 1,        
        PORT_INFO_MODEL = 2,         
        PORT_INFO_TLTYPE = 3,        
        PORT_INFO_MODULE = 4,        
        PORT_INFO_LITTLE_ENDIAN = 5, 
        PORT_INFO_BIG_ENDIAN = 6,    
        PORT_INFO_ACCESS_READ = 7,   
        PORT_INFO_ACCESS_WRITE = 8,  
        PORT_INFO_ACCESS_NA = 9,     
        PORT_INFO_ACCESS_NI = 10,    
        PORT_INFO_VERSION = 11,      
        PORT_INFO_PORTNAME = 12,     
        PORT_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t PORT_INFO_CMD;
 
    enum URL_SCHEME_IDS
    {
        URL_SCHEME_LOCAL = 0, 
        URL_SCHEME_HTTP = 1,  
        URL_SCHEME_FILE = 2,  
        URL_SCHEME_CUSTOM_ID = 1000 
    };
    typedef int32_t URL_SCHEME_ID;
 
    enum URL_INFO_CMD_LIST
    {
        URL_INFO_URL = 0,              
        URL_INFO_SCHEMA_VER_MAJOR = 1, 
        URL_INFO_SCHEMA_VER_MINOR = 2, 
        URL_INFO_FILE_VER_MAJOR = 3,   
        URL_INFO_FILE_VER_MINOR = 4,   
        URL_INFO_FILE_VER_SUBMINOR =
            5,                       
        URL_INFO_FILE_SHA1_HASH = 6, 
        URL_INFO_FILE_REGISTER_ADDRESS = 7, 
        URL_INFO_FILE_SIZE = 8,             
        URL_INFO_SCHEME = 9,    
        URL_INFO_FILENAME = 10, 
        URL_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t URL_INFO_CMD; /* GenTL v1.1 */
 
    enum EVENT_TYPE_LIST
    {
        EVENT_ERROR = 0,              
        EVENT_NEW_BUFFER = 1,         
        EVENT_FEATURE_INVALIDATE = 2, 
        EVENT_FEATURE_CHANGE = 3, 
        EVENT_REMOTE_DEVICE = 4,  
        EVENT_MODULE = 5, 
        EVENT_CUSTOM_ID = 1000 
    };
    typedef int32_t EVENT_TYPE;
 
    enum EVENT_INFO_CMD_LIST
    {
        EVENT_EVENT_TYPE = 0,   
        EVENT_NUM_IN_QUEUE = 1, 
        EVENT_NUM_FIRED = 2,    
        EVENT_SIZE_MAX = 3,     
        EVENT_INFO_DATA_SIZE_MAX =
            4, 
        EVENT_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t EVENT_INFO_CMD;
 
    enum EVENT_DATA_INFO_CMD_LIST
    {
        EVENT_DATA_ID = 0,    
        EVENT_DATA_VALUE = 1, 
        EVENT_DATA_NUMID = 2, 
        EVENT_DATA_CUSTOM_ID = 1000 
    };
    typedef int32_t EVENT_DATA_INFO_CMD;
 
    enum FLOW_INFO_CMD_LIST
    {
        FLOW_INFO_SIZE = 0,        
        FLOW_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t FLOW_INFO_CMD; /* GenTL v1.6 */
 
    enum SEGMENT_INFO_CMD_LIST
    {
        SEGMENT_INFO_BASE = 0, 
        SEGMENT_INFO_SIZE = 1, 
        SEGMENT_INFO_IS_INCOMPLETE =
            2, 
        SEGMENT_INFO_SIZE_FILLED =
            3, 
        SEGMENT_INFO_DATA_SIZE =
            4, 
        SEGMENT_INFO_CUSTOM_ID = 1000 
    };
    typedef int32_t SEGMENT_INFO_CMD; 
#pragma pack(push, 1)
    typedef struct S_EVENT_NEW_BUFFER
    {
        BUFFER_HANDLE BufferHandle; 
        void *pUserPointer;         
    } EVENT_NEW_BUFFER_DATA;
#pragma pack(pop)
 
#pragma pack(push, 1)
    typedef struct S_PORT_REGISTER_STACK_ENTRY
    {
        uint64_t Address; 
        void *pBuffer;    
        size_t Size;      
    } PORT_REGISTER_STACK_ENTRY;
#pragma pack(pop)
 
#pragma pack(push, 1)
    typedef struct S_SINGLE_CHUNK_DATA
    {
        uint64_t ChunkID;      
        ptrdiff_t ChunkOffset; 
        size_t ChunkLength;    
    } SINGLE_CHUNK_DATA;
#pragma pack(pop)
 
#pragma pack(push, 1)
    typedef struct S_DS_BUFFER_INFO_STACKED
    {
        BUFFER_INFO_CMD iInfoCmd; 
        INFO_DATATYPE iType;      
        void *pBuffer;            
        size_t iSize;             
        GC_ERROR iResult;         
    } DS_BUFFER_INFO_STACKED;
#pragma pack(pop)
 
#pragma pack(push, 1)
    typedef struct S_DS_BUFFER_PART_INFO_STACKED
    {
        uint32_t iPartIndex;           
        BUFFER_PART_INFO_CMD iInfoCmd; 
        GC_ERROR iResult;              
        INFO_DATATYPE iType;           
        void *pBuffer;                 
        size_t iSize;                  
    } DS_BUFFER_PART_INFO_STACKED;
#pragma pack(pop)
 
    /* C API Interface Functions */
#define GC_API GC_IMPORT_EXPORT GC_ERROR GC_CALLTYPE
    GC_API GCGetInfo(TL_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
 
    GC_API GCGetLastError(GC_ERROR *piErrorCode, char *sErrText, size_t *piSize);
 
    GC_API GCInitLib(void);
 
    GC_API GCCloseLib(void);
 
    GC_API GCReadPort(PORT_HANDLE hPort, uint64_t iAddress, void *pBuffer, size_t *piSize);
 
    GC_API GCWritePort(PORT_HANDLE hPort, uint64_t iAddress, const void *pBuffer, size_t *piSize);
 
    GC_API GCGetPortURL(PORT_HANDLE hPort, char *sURL, size_t *piSize);
 
    GC_API GCGetPortInfo(PORT_HANDLE hPort, PORT_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
                         size_t *piSize);
 
    GC_API GCRegisterEvent(EVENTSRC_HANDLE hEventSrc, EVENT_TYPE iEventID, EVENT_HANDLE *phEvent);
 
    GC_API GCUnregisterEvent(EVENTSRC_HANDLE hEventSrc, EVENT_TYPE iEventID);
 
    GC_API EventGetData(EVENT_HANDLE hEvent, void *pBuffer, size_t *piSize, uint64_t iTimeout);
 
    GC_API EventGetDataInfo(EVENT_HANDLE hEvent, const void *pInBuffer, size_t iInSize, EVENT_DATA_INFO_CMD iInfoCmd,
                            INFO_DATATYPE *piType, void *pOutBuffer, size_t *piOutSize);
 
    GC_API EventGetInfo(EVENT_HANDLE hEvent, EVENT_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
                        size_t *piSize);
 
    GC_API EventFlush(EVENT_HANDLE hEvent);
 
    GC_API EventKill(EVENT_HANDLE hEvent);
 
    GC_API TLOpen(TL_HANDLE *phTL);
 
    GC_API TLClose(TL_HANDLE hTL);
 
    GC_API TLGetInfo(TL_HANDLE hTL, TL_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
 
    GC_API TLGetNumInterfaces(TL_HANDLE hTL, uint32_t *piNumIfaces);
 
    GC_API TLGetInterfaceID(TL_HANDLE hTL, uint32_t iIndex, char *sID, size_t *piSize);
 
    GC_API TLGetInterfaceInfo(TL_HANDLE hTL, const char *sIfaceID, INTERFACE_INFO_CMD iInfoCmd, INFO_DATATYPE *piType,
                              void *pBuffer, size_t *piSize);
    GC_API TLOpenInterface(TL_HANDLE hTL, const char *sIfaceID, IF_HANDLE *phIface);
    GC_API TLUpdateInterfaceList(TL_HANDLE hTL, bool8_t *pbChanged, uint64_t iTimeout);
 
    GC_API IFClose(IF_HANDLE hIface);
 
    GC_API IFGetInfo(IF_HANDLE hIface, INTERFACE_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
                     size_t *piSize);
 
    GC_API IFGetNumDevices(IF_HANDLE hIface, uint32_t *piNumDevices);
 
    GC_API IFGetDeviceID(IF_HANDLE hIface, uint32_t iIndex, char *sIDeviceID, size_t *piSize);
 
    GC_API IFUpdateDeviceList(IF_HANDLE hIface, bool8_t *pbChanged, uint64_t iTimeout);
 
    GC_API IFGetDeviceInfo(IF_HANDLE hIface, const char *sDeviceID, DEVICE_INFO_CMD iInfoCmd, INFO_DATATYPE *piType,
                           void *pBuffer, size_t *piSize);
    GC_API IFOpenDevice(IF_HANDLE hIface, const char *sDeviceID, DEVICE_ACCESS_FLAGS iOpenFlag, DEV_HANDLE *phDevice);
 
    GC_API DevGetPort(DEV_HANDLE hDevice, PORT_HANDLE *phRemoteDevice);
 
    GC_API DevGetNumDataStreams(DEV_HANDLE hDevice, uint32_t *piNumDataStreams);
 
    GC_API DevGetDataStreamID(DEV_HANDLE hDevice, uint32_t iIndex, char *sDataStreamID, size_t *piSize);
    GC_API DevOpenDataStream(DEV_HANDLE hDevice, const char *sDataStreamID, DS_HANDLE *phDataStream);
 
    GC_API DevGetInfo(DEV_HANDLE hDevice, DEVICE_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
                      size_t *piSize);
    GC_API DevClose(DEV_HANDLE hDevice);
 
    GC_API DSAnnounceBuffer(DS_HANDLE hDataStream, void *pBuffer, size_t iSize, void *pPrivate,
                            BUFFER_HANDLE *phBuffer);
 
    GC_API DSAllocAndAnnounceBuffer(DS_HANDLE hDataStream, size_t iSize, void *pPrivate, BUFFER_HANDLE *phBuffer);
 
    GC_API DSFlushQueue(DS_HANDLE hDataStream, ACQ_QUEUE_TYPE iOperation);
 
    GC_API DSStartAcquisition(DS_HANDLE hDataStream, ACQ_START_FLAGS iStartFlags, uint64_t iNumToAcquire);
 
    GC_API DSStopAcquisition(DS_HANDLE hDataStream, ACQ_STOP_FLAGS iStopFlags);
    GC_API DSGetInfo(DS_HANDLE hDataStream, STREAM_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
                     size_t *piSize);
 
    GC_API DSGetBufferID(DS_HANDLE hDataStream, uint32_t iIndex, BUFFER_HANDLE *phBuffer);
 
    GC_API DSClose(DS_HANDLE hDataStream);
 
    GC_API DSRevokeBuffer(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, void **pBuffer, void **pPrivate);
 
    GC_API DSQueueBuffer(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer);
 
    GC_API DSGetBufferInfo(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, BUFFER_INFO_CMD iInfoCmd,
                           INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
 
    // start customize
    GC_API GCReadPortByName(PORT_HANDLE hPort, const char *varName, INFO_DATATYPE *piType, void *pBuffer,
                            size_t *piSize);
    GC_API GCWritePortByName(PORT_HANDLE hPort, const char *varName, INFO_DATATYPE *piType, const void *pBuffer,
                             size_t *piSize);
 
    GC_API PDBufferGetInfo(BUFFER_HANDLE hBuffer, BUFFER_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
                           size_t *piSize);
    GC_API PDBufferGetMeta(BUFFER_HANDLE hBuffer, uint32_t index, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
 
    GC_API PDBufferGetMetaByName(BUFFER_HANDLE hBuffer, const char *varName, INFO_DATATYPE *piType, void *pBuffer,
                                 size_t *piSize);
 
    GC_API PDBufferGetMetaDesc(BUFFER_HANDLE hBuffer, uint32_t index, const char **ppVarName, const char **ppDescName);
 
    GC_API PDBufferGetMetaNum(BUFFER_HANDLE hBuffer, size_t *pMetaItemNum);
 
    GC_API PDBufferSave(BUFFER_HANDLE hBuffer, const char *filesName, int opt);
    // end customize
 
    /* GenTL v1.1 */
    GC_API GCGetNumPortURLs(PORT_HANDLE hPort, uint32_t *piNumURLs);
 
    GC_API GCGetPortURLInfo(PORT_HANDLE hPort, uint32_t iURLIndex, URL_INFO_CMD iInfoCmd, INFO_DATATYPE *piType,
                            void *pBuffer, size_t *piSize);
 
    GC_API GCReadPortStacked(PORT_HANDLE hPort, PORT_REGISTER_STACK_ENTRY *pEntries, size_t *piNumEntries);
 
    GC_API GCWritePortStacked(PORT_HANDLE hPort, PORT_REGISTER_STACK_ENTRY *pEntries, size_t *piNumEntries);
 
    /* GenTL v1.3 */
    GC_API DSGetBufferChunkData(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, SINGLE_CHUNK_DATA *pChunkData,
                                size_t *piNumChunks);
 
    /* GenTL v1.4 */
    GC_API IFGetParentTL(IF_HANDLE hIface, TL_HANDLE *phSystem);
 
    GC_API DevGetParentIF(DEV_HANDLE hDevice, IF_HANDLE *phIface);
 
    GC_API DSGetParentDev(DS_HANDLE hDataStream, DEV_HANDLE *phDevice);
 
    /* GenTL v1.5 */
    GC_API DSGetNumBufferParts(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, uint32_t *piNumParts);
 
    GC_API DSGetBufferPartInfo(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, uint32_t iPartIndex,
                               BUFFER_PART_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
 
    /* GenTL v1.6 */
    GC_API DSAnnounceCompositeBuffer(DS_HANDLE hDataStream, size_t iNumSegments, void **ppSegments, size_t *piSizes,
                                     void *pPrivate, BUFFER_HANDLE *phBuffer);
    GC_API DSGetBufferInfoStacked(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, DS_BUFFER_INFO_STACKED *pInfoStacked,
                                  size_t iNumInfos);
    GC_API DSGetBufferPartInfoStacked(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer,
                                      DS_BUFFER_PART_INFO_STACKED *pInfoStacked, size_t iNumInfos);
    GC_API DSGetNumFlows(DS_HANDLE hDataStream, uint32_t *piNumFlows);
    GC_API DSGetFlowInfo(DS_HANDLE hDataStream, uint32_t iFlowIndex, FLOW_INFO_CMD iInfoCmd, INFO_DATATYPE *piType,
                         void *pBuffer, size_t *piSize);
    GC_API DSGetNumBufferSegments(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, uint32_t *piNumSegments);
    GC_API DSGetBufferSegmentInfo(DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, uint32_t iSegmentIndex,
                                  SEGMENT_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
 
    /* typedefs for dynamic loading */
#define GC_API_P(function) typedef GC_ERROR(GC_CALLTYPE *function)
    GC_API_P(PGCGetInfo)
    (TL_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
    GC_API_P(PGCGetLastError)
    (GC_ERROR *piErrorCode, char *sErrText, size_t *piSize);
    GC_API_P(PGCInitLib)
    (void);
    GC_API_P(PGCCloseLib)
    (void);
    GC_API_P(PGCReadPort)
    (PORT_HANDLE hPort, uint64_t iAddress, void *pBuffer, size_t *piSize);
    GC_API_P(PGCWritePort)
    (PORT_HANDLE hPort, uint64_t iAddress, const void *pBuffer, size_t *piSize);
    GC_API_P(PGCGetPortURL)
    (PORT_HANDLE hPort, char *sURL, size_t *piSize);
    GC_API_P(PGCGetPortInfo)
    (PORT_HANDLE hPort, PORT_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
 
    GC_API_P(PGCRegisterEvent)
    (EVENTSRC_HANDLE hEventSrc, EVENT_TYPE iEventID, EVENT_HANDLE *phEvent);
    GC_API_P(PGCUnregisterEvent)
    (EVENTSRC_HANDLE hEventSrc, EVENT_TYPE iEventID);
    GC_API_P(PEventGetData)
    (EVENT_HANDLE hEvent, void *pBuffer, size_t *piSize, uint64_t iTimeout);
    GC_API_P(PEventGetDataInfo)
    (EVENT_HANDLE hEvent, const void *pInBuffer, size_t iInSize, EVENT_DATA_INFO_CMD iInfoCmd, INFO_DATATYPE *piType,
     void *pOutBuffer, size_t *piOutSize);
    GC_API_P(PEventGetInfo)
    (EVENT_HANDLE hEvent, EVENT_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
    GC_API_P(PEventFlush)
    (EVENT_HANDLE hEvent);
    GC_API_P(PEventKill)
    (EVENT_HANDLE hEvent);
    GC_API_P(PTLOpen)
    (TL_HANDLE *phTL);
    GC_API_P(PTLClose)
    (TL_HANDLE hTL);
    GC_API_P(PTLGetInfo)
    (TL_HANDLE hTL, TL_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
    GC_API_P(PTLGetNumInterfaces)
    (TL_HANDLE hTL, uint32_t *piNumIfaces);
    GC_API_P(PTLGetInterfaceID)
    (TL_HANDLE hTL, uint32_t iIndex, char *sID, size_t *piSize);
    GC_API_P(PTLGetInterfaceInfo)
    (TL_HANDLE hTL, const char *sIfaceID, INTERFACE_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
     size_t *piSize);
    GC_API_P(PTLOpenInterface)
    (TL_HANDLE hTL, const char *sIfaceID, IF_HANDLE *phIface);
    GC_API_P(PTLUpdateInterfaceList)
    (TL_HANDLE hTL, bool8_t *pbChanged, uint64_t iTimeout);
    GC_API_P(PIFClose)
    (IF_HANDLE hIface);
    GC_API_P(PIFGetInfo)
    (IF_HANDLE hIface, INTERFACE_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
    GC_API_P(PIFGetNumDevices)
    (IF_HANDLE hIface, uint32_t *piNumDevices);
    GC_API_P(PIFGetDeviceID)
    (IF_HANDLE hIface, uint32_t iIndex, char *sIDeviceID, size_t *piSize);
    GC_API_P(PIFUpdateDeviceList)
    (IF_HANDLE hIface, bool8_t *pbChanged, uint64_t iTimeout);
    GC_API_P(PIFGetDeviceInfo)
    (IF_HANDLE hIface, const char *sDeviceID, DEVICE_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
     size_t *piSize);
    GC_API_P(PIFOpenDevice)
    (IF_HANDLE hIface, const char *sDeviceID, DEVICE_ACCESS_FLAGS iOpenFlag, DEV_HANDLE *phDevice);
 
    GC_API_P(PDevGetPort)
    (DEV_HANDLE hDevice, PORT_HANDLE *phRemoteDevice);
    GC_API_P(PDevGetNumDataStreams)
    (DEV_HANDLE hDevice, uint32_t *piNumDataStreams);
    GC_API_P(PDevGetDataStreamID)
    (DEV_HANDLE hDevice, uint32_t iIndex, char *sDataStreamID, size_t *piSize);
    GC_API_P(PDevOpenDataStream)
    (DEV_HANDLE hDevice, const char *sDataStreamID, DS_HANDLE *phDataStream);
    GC_API_P(PDevGetInfo)
    (DEV_HANDLE hDevice, DEVICE_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
    GC_API_P(PDevClose)
    (DEV_HANDLE hDevice);
 
    GC_API_P(PDSAnnounceBuffer)
    (DS_HANDLE hDataStream, void *pBuffer, size_t iSize, void *pPrivate, BUFFER_HANDLE *phBuffer);
    GC_API_P(PDSAllocAndAnnounceBuffer)
    (DS_HANDLE hDataStream, size_t iSize, void *pPrivate, BUFFER_HANDLE *phBuffer);
    GC_API_P(PDSFlushQueue)
    (DS_HANDLE hDataStream, ACQ_QUEUE_TYPE iOperation);
    GC_API_P(PDSStartAcquisition)
    (DS_HANDLE hDataStream, ACQ_START_FLAGS iStartFlags, uint64_t iNumToAcquire);
    GC_API_P(PDSStopAcquisition)
    (DS_HANDLE hDataStream, ACQ_STOP_FLAGS iStopFlags);
    GC_API_P(PDSGetInfo)
    (DS_HANDLE hDataStream, STREAM_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
    GC_API_P(PDSGetBufferID)
    (DS_HANDLE hDataStream, uint32_t iIndex, BUFFER_HANDLE *phBuffer);
    GC_API_P(PDSClose)
    (DS_HANDLE hDataStream);
    GC_API_P(PDSRevokeBuffer)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, void **pBuffer, void **pPrivate);
    GC_API_P(PDSQueueBuffer)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer);
    GC_API_P(PDSGetBufferInfo)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, BUFFER_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
     size_t *piSize);
 
    // start customize
    GC_API_P(PPDBufferGetInfo)
    (BUFFER_HANDLE hBuffer, BUFFER_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
    GC_API_P(PPDBufferGetMeta)
    (BUFFER_HANDLE hBuffer, uint32_t index, INFO_DATATYPE *piType, void *buffer, size_t *piSize);
    GC_API_P(PPDBufferGetMetaByName)
    (BUFFER_HANDLE hBuffer, const char *name, INFO_DATATYPE *piType, void *buffer, size_t *piSize);
    GC_API_P(PPDBufferGetMetaDesc)
    (BUFFER_HANDLE hBuffer, uint32_t index, const char **ppVarName, const char **ppDescName);
    GC_API_P(PPDBufferGetMetaNum)(BUFFER_HANDLE hBuffer, size_t *pMetaItemNum);
    GC_API_P(PPDBufferSave)(BUFFER_HANDLE hBuffer, const char *name, int opt);
    // end customize
 
    /* GenTL v1.1 */
    GC_API_P(PGCGetNumPortURLs)
    (PORT_HANDLE hPort, uint32_t *iNumURLs);
    GC_API_P(PGCGetPortURLInfo)
    (PORT_HANDLE hPort, uint32_t iURLIndex, URL_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
     size_t *piSize);
    GC_API_P(PGCReadPortStacked)
    (PORT_HANDLE hPort, PORT_REGISTER_STACK_ENTRY *pEntries, size_t *piNumEntries);
    GC_API_P(PGCWritePortStacked)
    (PORT_HANDLE hPort, PORT_REGISTER_STACK_ENTRY *pEntries, size_t *piNumEntries);
 
    /* GenTL v1.3 */
    GC_API_P(PDSGetBufferChunkData)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, SINGLE_CHUNK_DATA *pChunkData, size_t *piNumChunks);
 
    /* GenTL v1.4 */
    GC_API_P(PIFGetParentTL)
    (IF_HANDLE hIface, TL_HANDLE *phSystem);
    GC_API_P(PDevGetParentIF)
    (DEV_HANDLE hDevice, IF_HANDLE *phIface);
    GC_API_P(PDSGetParentDev)
    (DS_HANDLE hDataStream, DEV_HANDLE *phDevice);
 
    /* GenTL v1.5 */
    GC_API_P(PDSGetNumBufferParts)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, uint32_t *piNumParts);
    GC_API_P(PDSGetBufferPartInfo)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, uint32_t iPartIndex, BUFFER_PART_INFO_CMD iInfoCmd,
     INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
 
    /* GenTL v1.6 */
    GC_API_P(PDSAnnounceCompositeBuffer)
    (DS_HANDLE hDataStream, size_t iNumSegments, void **ppSegments, size_t *piSizes, void *pPrivate,
     BUFFER_HANDLE *phBuffer);
    GC_API_P(PDSGetBufferInfoStacked)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, DS_BUFFER_INFO_STACKED *pInfoStacked, size_t iNumInfos);
    GC_API_P(PDSGetBufferPartInfoStacked)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, DS_BUFFER_PART_INFO_STACKED *pInfoStacked, size_t iNumInfos);
    GC_API_P(PDSGetNumFlows)
    (DS_HANDLE hDataStream, uint32_t *piNumFlows);
    GC_API_P(PDSGetFlowInfo)
    (DS_HANDLE hDataStream, uint32_t iFlowIndex, FLOW_INFO_CMD iInfoCmd, INFO_DATATYPE *piType, void *pBuffer,
     size_t *piSize);
    GC_API_P(PDSGetNumBufferSegments)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, uint32_t *piNumSegments);
    GC_API_P(PDSGetBufferSegmentInfo)
    (DS_HANDLE hDataStream, BUFFER_HANDLE hBuffer, uint32_t iSegmentIndex, SEGMENT_INFO_CMD iInfoCmd,
     INFO_DATATYPE *piType, void *pBuffer, size_t *piSize);
#ifdef __cplusplus
    } /* end of namespace GenTL */
} /* end of extern "C" */
#endif
#endif /* GC_TLI_CLIENT_H_ */