c_driver.h

#pragma once
 
#if defined __GNUC__ && !defined CVB_SHOW_WARNINGS 
# pragma GCC system_header
#endif // __GNUC__
 
#include "../namespace.hpp"
 
#include "c_core.h"
#include "c_img.h"
 
 
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace CExports
{
 
CVB_DEF_CAPI_X(cvbbool_t, CanGrabber, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanBoardSelect, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanBoardSelect2, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanCameraSelect, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanCameraSelect2, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanDeviceControl, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanImageRect, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanBasicDIO, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanRingBuffer, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanNodeMapHandle, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanNodeMapHandle2, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanNotify, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanSoftwareTrigger, (IMG Image))
CVB_DEF_CAPI_X(cvbbool_t, CanGrab2, (IMG Image))
 
 
CVB_DEF_CAPI_X(cvbres_t, GetDriverID, (IMG Image, cvbguid_t & guid))
 
 
 
 
 
CVB_DEF_CAPI_X(cvbres_t, SetBoard, (IMG Image, cvbval_t nBoard))
CVB_DEF_CAPI_X(cvbres_t, GetBoard, (IMG Image, cvbval_t * nBoard))
 
 
CVB_DEF_CAPI_X(cvbres_t, BS2GetNumBoards, (IMG Image, cvbval_t & NumBoards))
CVB_DEF_CAPI_X(cvbres_t, BS2GetBoard, (IMG Image, cvbval_t & ActBoard))
CVB_DEF_CAPI_X(cvbres_t, BS2SetBoard, (IMG Image, cvbval_t  NewBoard, IMG & imgNew))
 
 
 
CVB_DEF_CAPI_X(cvbres_t, SetCamPort, (IMG Image, cvbval_t Port, cvbval_t ImagesToWait))
CVB_DEF_CAPI_X(cvbres_t, GetNumPorts, (IMG Image, cvbval_t & NumPorts))
CVB_DEF_CAPI_X(cvbres_t, GetCamPort, (IMG Image, cvbval_t & Port))
 
 
CVB_DEF_CAPI_X(cvbres_t, CS2GetNumPorts, (IMG Image, cvbval_t & NumPorts))
CVB_DEF_CAPI_X(cvbres_t, CS2GetCamPort, (IMG Image, cvbval_t & Port))
CVB_DEF_CAPI_X(cvbres_t, CS2SetCamPort, (IMG Image, cvbval_t  Port, cvbval_t ImgToWait, IMG & imgNew))
 
 
#ifdef _WIN32
typedef long DEVICECTRL_CMD;
#elif defined __linux__
typedef uint32_t DEVICECTRL_CMD;
#else
#error CVB: Unsupported platform and/or compiler!
#endif
 
enum DC_OPERATION
{
  DC_GET = 0x00000000,
  // gets the current setting of the parameter
  DC_SET = 0x10000000,
  // sets the given parameter
  DC_GETMIN = 0x20000000,
  // gets the min valid value for a parameter (if possible)
  DC_GETMAX = 0x30000000,
  // gets the max valid value for a parameter (if possible)
  DC_VERIFY = 0x40000000,
  // verifies the validity of a parameter settings without actually setting it (if possible)
  DC_OPERATION_MASK = 0xF0000000,
  DC_PARAM_MASK = 0x0FFFFFFF
};
 
 
 
 
 
CVB_DEF_CAPI_X(cvbres_t, DCBinaryCommand , (IMG Image, DEVICECTRL_CMD iCmd, const void * pInBuf, size_t iInBufSize, void * pOutBuf, size_t & iOutBufSize))
CVB_DEF_CAPI_X(cvbres_t, DCStrCommand, (IMG Image, DEVICECTRL_CMD iCmd, const char * pInStr, size_t iInStrSize, char * pOutStr, size_t & iOutStrSize))
 
 
 
CVB_DEF_CAPI_X(cvbres_t, STTrigger, (IMG Image, cvbval_t iSWTrgID))
 
 
 
enum IMAGERECT_CMD
{
 
  IMAGERECT_CMD_GET = 0,
  IMAGERECT_CMD_SET_AUTODELETE = 1,
  IMAGERECT_CMD_VALIDATE = 2,
  IMAGERECT_CMD_SET = 3,
  IMAGERECT_CMD_RESET = 4,
  IMAGERECT_CMD_CHECK = 5
};
 
 
CVB_DEF_CAPI_X(cvbres_t, IRImageSize, (IMG Image, IMAGERECT_CMD lAction, cvbdim_t & Dx, cvbdim_t & Dy, IMG & imgNew))
CVB_DEF_CAPI_X(cvbres_t, IRImageOffset, (IMG Image, IMAGERECT_CMD lAction, cvbdim_t & XOffset, cvbdim_t & YOffset))
 
 
 
CVB_DEF_CAPI_X(cvbres_t, BDIOGetNumInputs, (IMG Image, cvbval_t & Num))
CVB_DEF_CAPI_X(cvbres_t, BDIOGetNumOutputs, (IMG Image, cvbval_t & Num))
CVB_DEF_CAPI_X(cvbres_t, BDIOGetInBit, (IMG Image, cvbval_t  Num, cvbval_t &    Bit))
CVB_DEF_CAPI_X(cvbres_t, BDIOGetInDword, (IMG Image, cvbval_t  Num, cvbuint32_t & Value))
CVB_DEF_CAPI_X(cvbres_t, BDIOGetOutBit, (IMG Image, cvbval_t  Num, cvbval_t &    Bit))
CVB_DEF_CAPI_X(cvbres_t, BDIOGetOutDword, (IMG Image, cvbval_t  Num, cvbuint32_t & Value))
CVB_DEF_CAPI_X(cvbres_t, BDIOSetOutBit, (IMG Image, cvbval_t  Num, cvbval_t     Value))
CVB_DEF_CAPI_X(cvbres_t, BDIOSetOutDword, (IMG Image, cvbval_t  Num, cvbuint32_t  Value, cvbuint32_t Mask))
 
 
 
enum GRAB_INFO_CMD
{
 
  GRAB_INFO_NUMBER_IMAGES_AQCUIRED = 0,
  GRAB_INFO_NUMBER_IMAGES_LOST = 1,
  GRAB_INFO_NUMBER_IMAGES_LOST_LOCKED = 2,
  GRAB_INFO_NUMBER_IMAGES_LOCKED = 3,
  GRAB_INFO_NUMBER_IMAGES_PENDIG = 4,
  GRAB_INFO_GRAB_ACTIVE = 5,
  GRAB_INFO_TIMESTAMP = 6,
  GRAB_INFO_NUMBER_TRIGGERS_LOST = 7,
  GRAB_INFO_CAMERA_DETECTED = 8,
  G2INFO_NumBuffersPending = 10,
  G2INFO_NumBuffersDelivered = 11,
  G2INFO_NumBuffersCorrupt = 12,
  G2INFO_NumBuffersCorruptOnDelivery = 13,
  G2INFO_NumBuffersLost = 14,
  G2INFO_NumBuffersLostLocked = 15,
  G2INFO_NumBuffersAcquired = 16,
  G2INFO_NumBuffersQueued = 17,
  G2INFO_NumBuffersAnnounced = 18,
  G2INFO_NumBuffersInIncompleteList = 19,
  G2INFO_NumPacketsReceived = 20,
  G2INFO_NumResends = 21,
  G2INFO_NumBuffersLocked = 22
 
};
 
 
CVB_DEF_CAPI_X(cvbres_t, G2Grab, (IMG Image))
CVB_DEF_CAPI_X(cvbres_t, G2Wait, (IMG Image))
CVB_DEF_CAPI_X(cvbres_t, G2Freeze, (IMG Image, cvbbool_t bKill))
CVB_DEF_CAPI_X(cvbres_t, G2GetGrabStatus, (IMG Image, GRAB_INFO_CMD RequestType, double & RequestAnswer))
 
 
enum RINGBUFFER_INFO_CMD
{
  RINGBUFFER_INFO_TIMESTAMP = 0,
  RINGBUFFER_INFO_TAG = 1,
  RINGBUFFER_INFO_LOCKED = 2
};
 
enum RINGBUFFER_NUMBUFFER_CMD
{
  RINGBUFFER_NUMBUFFER_CMD_GET = 0,
  RINGBUFFER_NUMBUFFER_CMD_SET = 1,
  RINGBUFFER_NUMBUFFER_CMD_VALIDATE = 2
};
 
enum RINGBUFFER_LOCKMODE_CMD
{
  RINGBUFFER_LOCKMODE_CMD_GET = 0,
  RINGBUFFER_LOCKMODE_CMD_SET = 1,
  RINGBUFFER_LOCKMODE_CMD_VALIDATE = 2
};
 
enum RINGBUFFER_LOCKMODE
{
  RINGBUFFER_LOCKMODE_AUTO = 0,
  // lockmode off was 1 (removed)
  RINGBUFFER_LOCKMODE_ON = 2,
  RINGBUFFER_LOCKMODE_INVALID = 3
};
 
CVB_DEF_CAPI_X(cvbres_t, Snap, (IMG Image))
CVB_DEF_CAPI_X(cvbres_t, SetTimeout, (IMG Image, cvbuint32_t dwTimeout))
 
 
CVB_DEF_CAPI_X(cvbres_t, RBNumBuffer, (IMG Image, RINGBUFFER_NUMBUFFER_CMD Action, cvbval_t & Num, IMG & imgNew))
CVB_DEF_CAPI_X(cvbres_t, RBUnlock, (IMG Image, cvbval_t BufferIndex))
CVB_DEF_CAPI_X(cvbres_t, RBLockMode, (IMG Image, RINGBUFFER_LOCKMODE_CMD LockModeCmd, RINGBUFFER_LOCKMODE & Mode))
CVB_DEF_CAPI_X(cvbres_t, RBIsLocked, (IMG Image, cvbval_t lBufferIndex, cvbbool_t & bIsLocked))
CVB_DEF_CAPI_X(cvbres_t, RBGetBufferImage, (IMG Image, cvbval_t lBufferIndex, IMG & I))
CVB_DEF_CAPI_X(cvbres_t, RBBufferSeq, (IMG Image, cvbval_t lSequenceIndex, cvbval_t & lBufferIndex))
CVB_DEF_CAPI_X(cvbres_t, RBGetRingBufferInfo, (IMG Image, cvbval_t lBufferIndex, RINGBUFFER_INFO_CMD lRequestedInformation, double & dInfo))
 
 
typedef void * NODEMAP;
 
CVB_DEF_CAPI_X(cvbres_t, NMHGetNodeMap, (IMG Image, NODEMAP & NodeMap))
 
static const char  NMH2_ID_DEVICE[] = "Device"; // NOLINT(cppcoreguidelines-avoid-c-arrays)
static const char  NMH2_ID_FACTORY[] = "TLFactory"; // NOLINT(cppcoreguidelines-avoid-c-arrays)
static const char  NMH2_ID_SYSTEM[] = "TLSystem"; // NOLINT(cppcoreguidelines-avoid-c-arrays)
static const char  NMH2_ID_INTERFACE[] = "TLInterface"; // NOLINT(cppcoreguidelines-avoid-c-arrays)
static const char  NMH2_ID_TLDEVICE[] = "TLDevice"; // NOLINT(cppcoreguidelines-avoid-c-arrays)
static const char  NMH2_ID_DATASTREAM[] = "TLDatastream"; // NOLINT(cppcoreguidelines-avoid-c-arrays)
 
 
CVB_DEF_CAPI_X(cvbres_t,  NMH2GetNum, (IMG Image, size_t & NumNodeMaps))
CVB_DEF_CAPI_X(cvbres_t,  NMH2GetID, (IMG Image, size_t IDIndex, char * IDBuffer, size_t & IDBufferSize))
CVB_DEF_CAPI_X(cvbres_t,  NMH2GetNodeMap, (IMG Image, const char * ID, NODEMAP & NodeMap))
CVB_DEF_CAPI_X(cvbres_t,  NMH2GetDescription, (IMG Image, const char * ID, char * DescBuffer, size_t & DescBufferSize))
 
 
enum DODiscoverLevel
{
  DO_AT_LEVEL_UNKNOWN = 0,
  DO_AT_LEVEL_SYSTEM = 1,
  DO_AT_LEVEL_VIN = 2,
  DO_AT_LEVEL_TLSYSTEM = 3,
  DO_AT_LEVEL_TLIFACE = 4,
  DO_AT_LEVEL_TLDEVICE = 5,
  DO_AT_LEVEL_TLSTREAM = 6
};
 
 
enum DODiscoverInfoCommands
{
  DO_DISCOVER_INFO_ACCESS_TOKEN = 1000,
  DO_DISCOVER_INFO_LEVEL,
  DO_DISCOVER_INFO_INTERFACE_NET_LIST = 2000,
  DO_DISCOVER_INFO_INTERFACE_NET_MAC,
  DO_DISCOVER_INFO_INTERFACE_TLTYPE,
  DO_DISCOVER_INFO_INTERFACE_DISPLAYNAME,
  DO_DISCOVER_INFO_INTERFACE_DRIVERTYPE,
  DO_DISCOVER_INFO_INTERFACE_ID,
  DO_DISCOVER_INFO_DEVICE_TLTYPE = 3000,
  DO_DISCOVER_INFO_DEVICE_USERNAME,
  DO_DISCOVER_INFO_DEVICE_SERIALNUMBER,
  DO_DISCOVER_INFO_DEVICE_NET_MAC,
  DO_DISCOVER_INFO_DEVICE_NET_IP,
  DO_DISCOVER_INFO_DEVICE_NET_SUBNETMASK,
  DO_DISCOVER_INFO_DEVICE_USB_VID,
  DO_DISCOVER_INFO_DEVICE_USB_PID,
  DO_DISCOVER_INFO_DEVICE_VENDOR,
  DO_DISCOVER_INFO_DEVICE_MODEL,
  DO_DISCOVER_INFO_DEVICE_ID,
  DO_DISCOVER_INFO_DEVICE_ACCESS_STATUS,
  DO_DISCOVER_INFO_TRANSPORTLAYER_ID = 4000,
  DO_DISCOVER_INFO_TRANSPORTLAYER_PATH,
  DO_DISCOVER_INFO_TRANSPORTLAYER_VENDOR,
  DO_DISCOVER_INFO_DEVICE_USB_PORT_PATH,
  DO_DISCOVER_INFO_CUSTOM
};
 
 
union DODiscoverFlags
{
 
  cvbuint64_t AsUINT;
  struct Flags
  {
 
    cvbuint64_t Partial : 1;
    cvbuint64_t Depth : 4;
    cvbuint64_t Reserved : 3;
    cvbuint64_t IgnoreVINs : 1;
    cvbuint64_t IgnoreTLs : 1;
    cvbuint64_t IgnoreSD : 1;
    cvbuint64_t IgnoreFD : 1;
    cvbuint64_t IgnoreAccessStatus : 1;
    cvbuint64_t IncludeMockTL : 1;
  }
  AsFlags;
};
 
 
enum
{
  DO_DISCOVER_FLAG_PARTIAL = 0x1,
 
  DO_DISCOVER_FLAG_LEVEL_SYSTEM = DO_AT_LEVEL_SYSTEM << 1,
  DO_DISCOVER_FLAG_LEVEL_VIN = DO_AT_LEVEL_VIN << 1,
  DO_DISCOVER_FLAG_LEVEL_TL = DO_AT_LEVEL_TLSYSTEM << 1,
  DO_DISCOVER_FLAG_LEVEL_INTERFACE = DO_AT_LEVEL_TLIFACE << 1,
  DO_DISCOVER_FLAG_LEVEL_DEVICE = DO_AT_LEVEL_TLDEVICE << 1,
  DO_DISCOVER_FLAG_LEVEL_STREAM = DO_AT_LEVEL_TLSTREAM << 1,
 
  DO_DISCOVER_FLAG_IGNORE_VINS = 0x1 << 8,
  DO_DISCOVER_FLAG_IGNORE_TLS = 0x1 << 9,
  DO_DISCOVER_FLAG_IGNORE_SD = 0x1 << 10,
  DO_DISCOVER_FLAG_IGNORE_FD = 0x1 << 11,
  DO_DISCOVER_FLAG_IGNORE_ACCESS_STATUS = 0x1 << 12,
  DO_DISCOVER_FLAG_INCLUDE_MOCKTL = 0x1 << 13
};
 
typedef void * ATLIST;
typedef void * DEVOBJ;
 
CVB_DEF_CAPI_X(cvbres_t, DODiscover, (const char * Seed, cvbuint64_t Flags, cvbuint64_t Reserved, ATLIST & List, size_t DiscoverTimeout))
CVB_DEF_CAPI_X(cvbres_t, DODiscoverW, (const wchar_t * Seed, cvbuint64_t Flags, cvbuint64_t Reserved, ATLIST & List, size_t DiscoverTimeout))
CVB_DEF_CAPI_X(cvbres_t, DOEntryGetInfo, (ATLIST List, size_t Index, DODiscoverInfoCommands InfoCommand, char * InfoUtf8, size_t & InfoSize))
CVB_DEF_CAPI_X(cvbres_t, DOEntryGetInfoW, (ATLIST List, size_t Index, DODiscoverInfoCommands InfoCommand, wchar_t * Info, size_t & InfoSize))
CVB_DEF_CAPI_X(cvbres_t, DOGetNumEntries, (ATLIST List, size_t & NumEntries))
CVB_DEF_CAPI_X(cvbres_t, DOSetParameter, (ATLIST List, size_t Index, const char * Name, const char * Value))
CVB_DEF_CAPI_X(cvbres_t, DOSetParameterW, (ATLIST List, size_t Index, const wchar_t * Name, const wchar_t * Value))
CVB_DEF_CAPI_X(cvbres_t, DOSetFeature, (ATLIST List, size_t Index, const char * NodeMapID, const char * Name, const char * Value))
CVB_DEF_CAPI_X(cvbres_t, DOSetFeatureW, (ATLIST List, size_t Index, const wchar_t * NodeMapID, const wchar_t * Name, const wchar_t * Value))
 
CVB_DEF_CAPI_X(cvbres_t, LoadDeviceObject, (const char * AccessToken, DEVOBJ & DeviceObject))
CVB_DEF_CAPI_X(cvbres_t, LoadDeviceObjectW, (const wchar_t * AccessToken, DEVOBJ & DeviceObject))
 
 
inline cvbres_t DODiscoverTyped(const char * Seed, cvbuint64_t Flags, cvbuint64_t Reserved, ATLIST & List, size_t DiscoverTimeout)
{
  return DODiscover(Seed, Flags, Reserved, List, DiscoverTimeout);
}
 
inline cvbres_t DODiscoverTyped(const wchar_t * Seed, cvbuint64_t Flags, cvbuint64_t Reserved, ATLIST & List, size_t DiscoverTimeout)
{
  return DODiscoverW(Seed, Flags, Reserved, List, DiscoverTimeout);
}
 
inline cvbres_t  DOEntryGetInfoTyped(ATLIST List, size_t Index, DODiscoverInfoCommands InfoCommand, wchar_t * InfoUtf8, size_t & InfoSize)
{
  return DOEntryGetInfoW(List, Index, InfoCommand, InfoUtf8, InfoSize);
}
 
 
inline cvbres_t  DOEntryGetInfoTyped(ATLIST List, size_t Index, DODiscoverInfoCommands InfoCommand, char * InfoUtf8, size_t & InfoSize)
{
  return DOEntryGetInfo(List, Index, InfoCommand, InfoUtf8, InfoSize);
}
 
 
 
inline cvbres_t  DOSetParameterTyped(ATLIST List, size_t Index, const char * Name, const char * Value)
{
  return DOSetParameter(List, Index, Name, Value);
}
 
inline cvbres_t  DOSetParameterTyped(ATLIST List, size_t Index, const wchar_t * Name, const wchar_t * Value)
{
  return DOSetParameterW(List, Index, Name, Value);
}
 
inline cvbres_t  DOSetFeatureTyped(ATLIST List, size_t Index, const char * NodeMapID, const char * Name, const char * Value)
{
  return DOSetFeature(List, Index, NodeMapID, Name, Value);
}
 
inline cvbres_t  DOSetFeatureTyped(ATLIST List, size_t Index, const wchar_t * NodeMapID, const wchar_t * Name, const wchar_t * Value)
{
  return DOSetFeatureW(List, Index, NodeMapID, Name, Value);
}
 
inline cvbres_t  _ppLoadDeviceObjectTyped(const char * AccessToken, DEVOBJ & DeviceObject)
{
  return LoadDeviceObject(AccessToken, DeviceObject);
}
 
inline cvbres_t  _ppLoadDeviceObjectTyped(const wchar_t * AccessToken, DEVOBJ & DeviceObject)
{
  return LoadDeviceObjectW(AccessToken, DeviceObject);
}
 
 
 
enum CVNotifyInfoCmd
{
  CVNO_INFO_COUNT_REGISTERED,
  CVNO_INFO_COUNT_FIRED,
  CVNO_INFO_IS_AVAILABLE,
  NO_INFO_CUSTOM_CMD = 0x10000
};
 
typedef cvbval_t CVNotifyInfo_t;
 
 
enum CVNotifyDatatypes
{
  CVNO_DATA_VOID = -1,
  CVNO_DATA_INTEGER64 = 0,
  CVNO_DATA_FLOAT64,
  CVNO_DATA_STRING,
  CVNO_DATA_BINARY,
  CVNO_DATA_BOOL8,
  CVNO_DATA_CUSTOM = 0x10000
};
 
 
typedef cvbval_t CVNotifyDatatype_t;
 
 
enum CVNotifyEventIDs
{
  CVNO_REGISTRATION_INVALID = 0,
  CVNO_EID_ERROR = 1,
  CVNO_EID_DEVICE_DISCONNECTED = 2,
  CVNO_EID_DEVICE_RECONNECT = 3,
  CVNO_EID_GEOMETRY_CHANGE = 4,
  CVNO_EID_METADATA_CHANGE = 5,
  CVNO_EID_CUSTOM = 0x10000
};
 
typedef cvbval_t CVNotifyEvent_t;
typedef void(__stdcall *CVBDRIVER_NOTIFY_CB) (CVNotifyEvent_t EventID, void *Buf, size_t Size, CVNotifyDatatype_t DataType, void *UserData);
 
 
CVB_DEF_CAPI_X(cvbres_t, NORegister, (IMG Image, CVNotifyEvent_t EventID, CVBDRIVER_NOTIFY_CB pCB, void *UserData, intptr_t &Cookie))
CVB_DEF_CAPI_X(cvbres_t, NOUnregister, (IMG Image, intptr_t Cookie))
CVB_DEF_CAPI_X(cvbres_t, NOGetNumSupported, (IMG Image, size_t &NumEvents))
CVB_DEF_CAPI_X(cvbres_t, NOGetDescription, (IMG Image, size_t Index, char *DescriptiveName, size_t &Size, CVNotifyEvent_t &EventID))
CVB_DEF_CAPI_X(cvbres_t, NOGetStatus, (IMG Image, CVNotifyEvent_t eventID, CVNotifyInfo_t StatusCmd, cvbint64_t &Info))
CVB_DEF_CAPI_X(cvbres_t, NOIsCookieValid, (IMG Image, intptr_t Cookie, cvbbool_t &IsValid))
 
 
CVB_DEF_CAPI(cvbres_t, CVDCreateOrGetDeviceObject, (const char* AccessToken, DEVOBJ& DeviceObject))
CVB_DEF_CAPI(cvbres_t, CVDCreateOrGetDeviceObjectW, (const wchar_t* AccessToken, DEVOBJ& DeviceObject))
 
inline cvbres_t  _ppCVDCreateOrGetDeviceObjectTyped(const char* AccessToken, DEVOBJ& DeviceObject)
{
  return _ppCVDCreateOrGetDeviceObject(AccessToken, DeviceObject);
}
 
inline cvbres_t  _ppCVDCreateOrGetDeviceObjectTyped(const wchar_t* AccessToken, DEVOBJ& DeviceObject)
{
  return _ppCVDCreateOrGetDeviceObjectW(AccessToken, DeviceObject);
}
 
 
typedef void* CVDSTREAM;
 
 
CVB_DEF_CAPI(cvbres_t, CVDDeviceGetStreamCount, (DEVOBJ DeviceObject, size_t& Count))
CVB_DEF_CAPI(cvbres_t, CVDDeviceGetStreamAt, (DEVOBJ DeviceObject, size_t Index, CVDSTREAM& Stream))
 
 
typedef cvbres_t(__stdcall* CVDReleaseFlowSetPool) (void* Context);
 
 
struct CVDFlow
{
  size_t Size;
  void* Buffer;
};
 
 
struct CVDFlowSet
{
  cvbuint32_t Version;
  size_t NumEntries;
  CVDFlow* Flows;
};
 
 
CVB_DEF_CAPI(cvbres_t,  CVDStreamRegisterManagedFlowSetPool, (CVDSTREAM Stream, size_t Count))
CVB_DEF_CAPI(cvbres_t,  CVDStreamRegisterExternalFlowSetPool, (CVDSTREAM Stream, const CVDFlowSet Pool[], size_t PoolSize, CVDReleaseFlowSetPool OnRelease, void* pPrivate))
CVB_DEF_CAPI(cvbres_t,  CVDStreamUnregisterFlowSetPool, (CVDSTREAM Stream))
CVB_DEF_CAPI(cvbres_t,  CVDStreamGetFlowSetCount, (CVDSTREAM Stream, size_t& Count))
 
 
CVB_DEF_CAPI(cvbres_t,  CVDStreamFlowSetInfoGetFlowSetMinCount, (CVDSTREAM Stream, size_t& Count))
CVB_DEF_CAPI(cvbres_t,  CVDStreamFlowSetInfoGetFlowCount, (CVDSTREAM Stream, size_t& Count))
CVB_DEF_CAPI(cvbres_t,  CVDStreamFlowSetInfoGetFlowSize, (CVDSTREAM Stream, size_t FlowIndex, size_t& SizeInBytes))
CVB_DEF_CAPI(cvbres_t,  CVDStreamFlowSetInfoGetFlowAlignment, (CVDSTREAM Stream, size_t FlowIndex, size_t& AlignmentInBytes))
CVB_DEF_CAPI(cvbbool_t, CVDCanFlowSetInfo, (CVDSTREAM Stream))
 
 
enum CVDWaitStatus
{
  CVDWS_Ok,
  CVDWS_Canceled,
  CVDWS_Timeout
};
 
 
typedef void* CVCANCELLATIONTOKEN;
 
 
CVB_DEF_CAPI(cvbres_t, CVDStreamAcquisitionEngineStart, (CVDSTREAM Stream, cvbint64_t BufferCountToAcquire))
CVB_DEF_CAPI(cvbres_t, CVDStreamAcquisitionEngineStop, (CVDSTREAM Stream, cvbint64_t Timeout))
CVB_DEF_CAPI(cvbres_t, CVDStreamAcquisitionEngineAbort, (CVDSTREAM Stream))
CVB_DEF_CAPI(cvbres_t, CVDStreamAcquisitionEngineWaitForNextComposite, (CVDSTREAM Stream, cvbint64_t Timeout, CVCANCELLATIONTOKEN Token, CVDWaitStatus& WaitStatus, CVCOMPOSITE& Composite))
 
 
CVB_DEF_CAPI(cvbres_t, CVDStreamControlStart, (CVDSTREAM Stream, cvbint64_t FrameCountToAcquire))
CVB_DEF_CAPI(cvbres_t, CVDStreamControlStop, (CVDSTREAM Stream))
CVB_DEF_CAPI(cvbres_t, CVDStreamControlAbort, (CVDSTREAM Stream))
 
 
enum CVDGNDCHeaderInfoCmd
{
  CVDGNDCCNTI_VersionMajor = 0,
  CVDGNDCCNTI_VersionMinor = 1,
  CVDGNDCCNTI_VersionSubMinor = 2,
  CVDGNDCCNTI_HeaderType = 6,
  CVDGNDCCNTI_FlagsValue = 7,
  CVDGNDCCNTI_HeaderSize = 8,
  CVDGNDCCNTI_ContainerId = 9,
  CVDGNDCCNTI_VariableFields = 10,
  CVDGNDCCNTI_DataSize = 16,
  CVDGNDCCNTI_DataOffset = 17,
  CVDGNDCCNTI_DescriptorSize = 18,
  CVDGNDCCNTI_ComponentCount = 19
};
 
enum CVDGNDCComponentInfoCmd
{
  CVDGNDCCMPI_ComponentOffset = 0,
  CVDGNDCCMPI_HeaderType = 1,
  CVDGNDCCMPI_FlagsValue = 2,
  CVDGNDCCMPI_HeaderSize = 3,
  // Reserved values 4-9
  CVDGNDCCMPI_GroupId = 10,
  CVDGNDCCMPI_SourceId = 11,
  CVDGNDCCMPI_RegionId = 12,
  CVDGNDCCMPI_RegionOffsetX = 13,
  CVDGNDCCMPI_RegionOffsetY = 14,
  CVDGNDCCMPI_Timestamp = 15,
  CVDGNDCCMPI_TypeId = 16,
  CVDGNDCCMPI_Format = 17,
  // Reserved values 18-20
  CVDGNDCCMPI_PartCount = 21,
};
 
 
enum CVDGNDCPartInfoCmd
{
  CVDGNDCPI_PartOffset = 0,
  CVDGNDCPI_HeaderType = 1,
  CVDGNDCPI_FlagsValue = 2,
  CVDGNDCPI_HeaderSize = 3,
  CVDGNDCPI_Format = 4,
  // Reserved values 5-6
  CVDGNDCPI_FlowId = 7,
  CVDGNDCPI_FlowOffset = 8,
  CVDGNDCPI_DataSize = 9,
  CVDGNDCPI_DataOffset = 10,
 
  CVDGNDC1DPI_Size = 1000,
  CVDGNDC1DPI_Padding = 1001,
  // 1002-1003 reserved
  CVDGNCDC1DPI_InfoTypeSpecific = 1004,
 
  CVDGNDC2DPI_SizeX = 2000,
  CVDGNDC2DPI_SizeY = 2001,
  CVDGNDC2DPI_PaddingX = 2002,
  CVDGNDC2DPI_PaddingY = 2003,
 
  CVDGNDCH264PI_SizeX = 3000,
  CVDGNDCH264PI_SizeY = 3001,
  CVDGNDCH264PI_PaddingX = 3002,
  CVDGNDCH264PI_PaddingY = 3003,
  // 3004-3005 Reserved
  CVDGNDCH264PI_ProfileIDC = 3006,
  CVDGNDCH264PI_H264Flags = 3007,
  CVDGNDCH264PI_LevelIDC = 3008,
  CVDGNDCH264PI_SpropInterleavingDepth = 3009,
  CVDGNDCH264PI_SpropMaxDonDiff = 3010,
  CVDGNDCH264PI_SpropDeintBufReq = 3011,
  CVDGNDCH264PI_SpropInitBufTime = 3012
};
 
 
struct CVDGenDCPartConfig
{
  cvbuint16_t PartType;
  cvbuint32_t PfncFormat;
  cvbuint16_t FlowId;
  cvbuint64_t FlowOffset;
  cvbuint64_t DataSize;
};
 
 
struct CVDGenDCComponentConfig
{
  cvbuint32_t TypeId;
  cvbuint32_t PfncFormat;
  cvbuint16_t PartCount;
  CVDGenDCPartConfig* Parts;
};
 
 
struct CVDGenDCDescriptorConfig
{
  cvbuint32_t ComponentCount;
  CVDGenDCComponentConfig* Components;
};
 
 
typedef void* CVDGNDCDESCRIPTORDATA;
 
 
CVB_DEF_CAPI(cvbres_t, CVDGNDCCreateDescriptor, (const CVDGenDCDescriptorConfig &Config, CVDGNDCDESCRIPTORDATA &Descriptor))
CVB_DEF_CAPI(cvbres_t, CVDGNDCSetHeaderInfo, (CVDGNDCDESCRIPTORDATA Descriptor, CVDGNDCHeaderInfoCmd Cmd, size_t InfoSize, const void* Info))
CVB_DEF_CAPI(cvbres_t, CVDGNDCSetComponentInfo, (CVDGNDCDESCRIPTORDATA Descriptor, CVDGNDCComponentInfoCmd Cmd, size_t InfoSize, const void *Info, size_t ComponentIndex))
CVB_DEF_CAPI(cvbres_t, CVDGNDCSetPartInfo, (CVDGNDCDESCRIPTORDATA Descriptor, CVDGNDCPartInfoCmd Cmd, size_t InfoSize, const void *Info, size_t ComponentIndex, size_t PartIndex))
 
 
typedef void* CVDGNDCDESCRIPTOR;
 
 
CVB_DEF_CAPI(cvbres_t, CVDGNDCGetHeaderInfo, (CVDGNDCDESCRIPTOR Descriptor, CVDGNDCHeaderInfoCmd InfoCmd, size_t& InfoSize, void* Info))
CVB_DEF_CAPI(cvbres_t, CVDGNDCGetComponentInfo, (CVDGNDCDESCRIPTOR Descriptor, CVDGNDCComponentInfoCmd InfoCmd, size_t& InfoSize, void *Info, size_t ComponentIndex))
CVB_DEF_CAPI(cvbres_t, CVDGNDCGetPartInfo, (CVDGNDCDESCRIPTOR Descriptor, CVDGNDCPartInfoCmd InfoCmd, size_t& InfoSize, void *Info, size_t ComponentIndex, size_t PartIndex))
CVB_DEF_CAPI(cvbres_t, CVDGNDCSerialize, (CVDGNDCDESCRIPTOR Descriptor, size_t& BufferSize, void* Buffer))
 
typedef void *CVDGNDCDESCRIPTORPROVIDER;
 
CVB_DEF_CAPI(cvbres_t, CVDGNDCPGetDescriptor, (CVDGNDCDESCRIPTORPROVIDER Provider, CVDGNDCDESCRIPTOR &Descriptor))
CVB_DEF_CAPI(cvbbool_t, CVDCanGenDCDescriptorProvider, (CVDGNDCDESCRIPTORPROVIDER Provider))
 
}
 
 
CVB_END_INLINE_NS
 
 
}