Revision control
++ /*
++ * This copyright notice applies to this header file only:
++ *
++ * Copyright (c) 2016
++ *
++ * Permission is hereby granted, free of charge, to any person
++ * obtaining a copy of this software and associated documentation
++ * files (the "Software"), to deal in the Software without
++ * restriction, including without limitation the rights to use,
++ * copy, modify, merge, publish, distribute, sublicense, and/or sell
++ * copies of the software, and to permit persons to whom the
++ * software is furnished to do so, subject to the following
++ * conditions:
++ *
++ * The above copyright notice and this permission notice shall be
++ * included in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
++ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
++ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
++ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
++ * OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++ #if !defined(FFNV_DYNLINK_CUDA_H) && !defined(CUDA_VERSION)
++ #define FFNV_DYNLINK_CUDA_H
++
++ #include <stddef.h>
++ #include <stdint.h>
++
++ #define CUDA_VERSION 7050
++
++ #if defined(_WIN32) || defined(__CYGWIN__)
++ #define CUDAAPI __stdcall
++ #else
++ #define CUDAAPI
++ #endif
++
++ #define CU_CTX_SCHED_BLOCKING_SYNC 4
++
++ typedef int CUdevice;
++ #if defined(__x86_64) || defined(AMD64) || defined(_M_AMD64) || defined(__LP64__) || defined(__aarch64__)
++ typedef unsigned long long CUdeviceptr;
++ #else
++ typedef unsigned int CUdeviceptr;
++ #endif
++ typedef unsigned long long CUtexObject;
++
++ typedef struct CUarray_st *CUarray;
++ typedef struct CUctx_st *CUcontext;
++ typedef struct CUstream_st *CUstream;
++ typedef struct CUevent_st *CUevent;
++ typedef struct CUfunc_st *CUfunction;
++ typedef struct CUmod_st *CUmodule;
++ typedef struct CUmipmappedArray_st *CUmipmappedArray;
++ typedef struct CUgraphicsResource_st *CUgraphicsResource;
++ typedef struct CUextMemory_st *CUexternalMemory;
++ typedef struct CUextSemaphore_st *CUexternalSemaphore;
++ typedef struct CUeglStreamConnection_st *CUeglStreamConnection;
++
++ typedef struct CUlinkState_st *CUlinkState;
++
++ typedef enum cudaError_enum {
++ CUDA_SUCCESS = 0,
++ CUDA_ERROR_INVALID_VALUE = 1,
++ CUDA_ERROR_NOT_READY = 600,
++ CUDA_ERROR_LAUNCH_TIMEOUT = 702,
++ CUDA_ERROR_UNKNOWN = 999
++ } CUresult;
++
++ /**
++ * Device properties (subset)
++ */
++ typedef enum CUdevice_attribute_enum {
++ CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13,
++ CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14,
++ CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16,
++ CU_DEVICE_ATTRIBUTE_INTEGRATED = 18,
++ CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19,
++ CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20,
++ CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31,
++ CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33,
++ CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34,
++ CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35,
++ CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = 36,
++ CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = 37,
++ CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40,
++ CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = 41,
++ CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50,
++ CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = 51,
++ CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75,
++ CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76,
++ CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = 83,
++ CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = 84,
++ CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = 85,
++ } CUdevice_attribute;
++
++ typedef enum CUarray_format_enum {
++ CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
++ CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
++ CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
++ CU_AD_FORMAT_SIGNED_INT8 = 0x08,
++ CU_AD_FORMAT_SIGNED_INT16 = 0x09,
++ CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
++ CU_AD_FORMAT_HALF = 0x10,
++ CU_AD_FORMAT_FLOAT = 0x20,
++ CU_AD_FORMAT_NV12 = 0xb0,
++ CU_AD_FORMAT_P016 = 0xa1,
++ CU_AD_FORMAT_NV16 = 0xa2,
++ CU_AD_FORMAT_P216 = 0xa4,
++ CU_AD_FORMAT_YUV444_8BIT_SEMIPLANAR = 0xb4,
++ CU_AD_FORMAT_YUV444_16BIT_SEMIPLANAR = 0xb5,
++ CU_AD_FORMAT_UINT8_PLANAR_420 = 0x59,
++ CU_AD_FORMAT_UINT16_PLANAR_420 = 0x5a,
++ CU_AD_FORMAT_UINT8_PLANAR_422 = 0x5b,
++ CU_AD_FORMAT_UINT16_PLANAR_422 = 0x5c,
++ CU_AD_FORMAT_UINT8_PLANAR_444 = 0x5d,
++ CU_AD_FORMAT_UINT16_PLANAR_444 = 0x5e,
++ } CUarray_format;
++
++ typedef enum CUmemorytype_enum {
++ CU_MEMORYTYPE_HOST = 1,
++ CU_MEMORYTYPE_DEVICE = 2,
++ CU_MEMORYTYPE_ARRAY = 3
++ } CUmemorytype;
++
++ typedef enum CUlimit_enum {
++ CU_LIMIT_STACK_SIZE = 0,
++ CU_LIMIT_PRINTF_FIFO_SIZE = 1,
++ CU_LIMIT_MALLOC_HEAP_SIZE = 2,
++ CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = 3,
++ CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = 4
++ } CUlimit;
++
++ typedef enum CUresourcetype_enum {
++ CU_RESOURCE_TYPE_ARRAY = 0x00,
++ CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 0x01,
++ CU_RESOURCE_TYPE_LINEAR = 0x02,
++ CU_RESOURCE_TYPE_PITCH2D = 0x03
++ } CUresourcetype;
++
++ typedef enum CUaddress_mode_enum {
++ CU_TR_ADDRESS_MODE_WRAP = 0,
++ CU_TR_ADDRESS_MODE_CLAMP = 1,
++ CU_TR_ADDRESS_MODE_MIRROR = 2,
++ CU_TR_ADDRESS_MODE_BORDER = 3
++ } CUaddress_mode;
++
++ typedef enum CUfilter_mode_enum {
++ CU_TR_FILTER_MODE_POINT = 0,
++ CU_TR_FILTER_MODE_LINEAR = 1
++ } CUfilter_mode;
++
++ typedef enum CUgraphicsRegisterFlags_enum {
++ CU_GRAPHICS_REGISTER_FLAGS_NONE = 0,
++ CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY = 1,
++ CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = 2,
++ CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = 4,
++ CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = 8
++ } CUgraphicsRegisterFlags;
++
++ typedef enum CUexternalMemoryHandleType_enum {
++ CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = 1,
++ CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 = 2,
++ CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3,
++ CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP = 4,
++ CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE = 5,
++ } CUexternalMemoryHandleType;
++
++ typedef enum CUexternalSemaphoreHandleType_enum {
++ CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = 1,
++ CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 = 2,
++ CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3,
++ CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE = 4,
++ CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD = 9,
++ CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32 = 10,
++ } CUexternalSemaphoreHandleType;
++
++ typedef enum CUjit_option_enum
++ {
++ CU_JIT_MAX_REGISTERS = 0,
++ CU_JIT_THREADS_PER_BLOCK = 1,
++ CU_JIT_WALL_TIME = 2,
++ CU_JIT_INFO_LOG_BUFFER = 3,
++ CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4,
++ CU_JIT_ERROR_LOG_BUFFER = 5,
++ CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6,
++ CU_JIT_OPTIMIZATION_LEVEL = 7,
++ CU_JIT_TARGET_FROM_CUCONTEXT = 8,
++ CU_JIT_TARGET = 9,
++ CU_JIT_FALLBACK_STRATEGY = 10,
++ CU_JIT_GENERATE_DEBUG_INFO = 11,
++ CU_JIT_LOG_VERBOSE = 12,
++ CU_JIT_GENERATE_LINE_INFO = 13,
++ CU_JIT_CACHE_MODE = 14,
++ CU_JIT_NEW_SM3X_OPT = 15,
++ CU_JIT_FAST_COMPILE = 16,
++ CU_JIT_GLOBAL_SYMBOL_NAMES = 17,
++ CU_JIT_GLOBAL_SYMBOL_ADDRESSES = 18,
++ CU_JIT_GLOBAL_SYMBOL_COUNT = 19,
++ CU_JIT_NUM_OPTIONS
++ } CUjit_option;
++
++ typedef enum CUjitInputType_enum
++ {
++ CU_JIT_INPUT_CUBIN = 0,
++ CU_JIT_INPUT_PTX = 1,
++ CU_JIT_INPUT_FATBINARY = 2,
++ CU_JIT_INPUT_OBJECT = 3,
++ CU_JIT_INPUT_LIBRARY = 4,
++ CU_JIT_NUM_INPUT_TYPES
++ } CUjitInputType;
++
++ typedef enum CUeglFrameType
++ {
++ CU_EGL_FRAME_TYPE_ARRAY = 0,
++ CU_EGL_FRAME_TYPE_PITCH = 1,
++ } CUeglFrameType;
++
++ typedef enum CUeglColorFormat
++ {
++ CU_EGL_COLOR_FORMAT_YUV420_PLANAR = 0x00,
++ CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR = 0x01,
++ CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR = 0x15,
++ CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR = 0x17,
++ CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR = 0x19,
++ } CUeglColorFormat;
++
++ typedef enum CUd3d11DeviceList_enum
++ {
++ CU_D3D11_DEVICE_LIST_ALL = 1,
++ CU_D3D11_DEVICE_LIST_CURRENT_FRAME = 2,
++ CU_D3D11_DEVICE_LIST_NEXT_FRAME = 3,
++ } CUd3d11DeviceList;
++
++ #ifndef CU_UUID_HAS_BEEN_DEFINED
++ #define CU_UUID_HAS_BEEN_DEFINED
++ typedef struct CUuuid_st {
++ char bytes[16];
++ } CUuuid;
++ #endif
++
++ typedef struct CUDA_MEMCPY2D_st {
++ size_t srcXInBytes;
++ size_t srcY;
++ CUmemorytype srcMemoryType;
++ const void *srcHost;
++ CUdeviceptr srcDevice;
++ CUarray srcArray;
++ size_t srcPitch;
++
++ size_t dstXInBytes;
++ size_t dstY;
++ CUmemorytype dstMemoryType;
++ void *dstHost;
++ CUdeviceptr dstDevice;
++ CUarray dstArray;
++ size_t dstPitch;
++
++ size_t WidthInBytes;
++ size_t Height;
++ } CUDA_MEMCPY2D;
++
++ typedef struct CUDA_RESOURCE_DESC_st {
++ CUresourcetype resType;
++ union {
++ struct {
++ CUarray hArray;
++ } array;
++ struct {
++ CUmipmappedArray hMipmappedArray;
++ } mipmap;
++ struct {
++ CUdeviceptr devPtr;
++ CUarray_format format;
++ unsigned int numChannels;
++ size_t sizeInBytes;
++ } linear;
++ struct {
++ CUdeviceptr devPtr;
++ CUarray_format format;
++ unsigned int numChannels;
++ size_t width;
++ size_t height;
++ size_t pitchInBytes;
++ } pitch2D;
++ struct {
++ int reserved[32];
++ } reserved;
++ } res;
++ unsigned int flags;
++ } CUDA_RESOURCE_DESC;
++
++ typedef struct CUDA_TEXTURE_DESC_st {
++ CUaddress_mode addressMode[3];
++ CUfilter_mode filterMode;
++ unsigned int flags;
++ unsigned int maxAnisotropy;
++ CUfilter_mode mipmapFilterMode;
++ float mipmapLevelBias;
++ float minMipmapLevelClamp;
++ float maxMipmapLevelClamp;
++ float borderColor[4];
++ int reserved[12];
++ } CUDA_TEXTURE_DESC;
++
++ /* Unused type */
++ typedef struct CUDA_RESOURCE_VIEW_DESC_st CUDA_RESOURCE_VIEW_DESC;
++
++ typedef unsigned int GLenum;
++ typedef unsigned int GLuint;
++ /*
++ * Prefix type name to avoid collisions. Clients using these types
++ * will include the real headers with real definitions.
++ */
++ typedef int32_t ffnv_EGLint;
++ typedef void *ffnv_EGLStreamKHR;
++
++ typedef enum CUGLDeviceList_enum {
++ CU_GL_DEVICE_LIST_ALL = 1,
++ CU_GL_DEVICE_LIST_CURRENT_FRAME = 2,
++ CU_GL_DEVICE_LIST_NEXT_FRAME = 3,
++ } CUGLDeviceList;
++
++ typedef struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
++ CUexternalMemoryHandleType type;
++ union {
++ int fd;
++ struct {
++ void *handle;
++ const void *name;
++ } win32;
++ } handle;
++ unsigned long long size;
++ unsigned int flags;
++ unsigned int reserved[16];
++ } CUDA_EXTERNAL_MEMORY_HANDLE_DESC;
++
++ typedef struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st {
++ unsigned long long offset;
++ unsigned long long size;
++ unsigned int flags;
++ unsigned int reserved[16];
++ } CUDA_EXTERNAL_MEMORY_BUFFER_DESC;
++
++ typedef struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
++ CUexternalSemaphoreHandleType type;
++ union {
++ int fd;
++ struct {
++ void *handle;
++ const void *name;
++ } win32;
++ } handle;
++ unsigned int flags;
++ unsigned int reserved[16];
++ } CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC;
++
++ typedef struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st {
++ struct {
++ struct {
++ unsigned long long value;
++ } fence;
++ unsigned int reserved[16];
++ } params;
++ unsigned int flags;
++ unsigned int reserved[16];
++ } CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS;
++
++ typedef CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS;
++
++ typedef struct CUDA_ARRAY_DESCRIPTOR_st {
++ size_t Width;
++ size_t Height;
++
++ CUarray_format Format;
++ unsigned int NumChannels;
++ } CUDA_ARRAY_DESCRIPTOR;
++
++ #define CUDA_ARRAY3D_SURFACE_LDST 0x02
++ #define CUDA_ARRAY3D_VIDEO_ENCODE_DECODE 0x100
++
++ typedef struct CUDA_ARRAY3D_DESCRIPTOR_st {
++ size_t Width;
++ size_t Height;
++ size_t Depth;
++
++ CUarray_format Format;
++ unsigned int NumChannels;
++ unsigned int Flags;
++ } CUDA_ARRAY3D_DESCRIPTOR;
++
++ typedef struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st {
++ unsigned long long offset;
++ CUDA_ARRAY3D_DESCRIPTOR arrayDesc;
++ unsigned int numLevels;
++ unsigned int reserved[16];
++ } CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC;
++
++ #define CU_EGL_FRAME_MAX_PLANES 3
++ typedef struct CUeglFrame_st {
++ union {
++ CUarray pArray[CU_EGL_FRAME_MAX_PLANES];
++ void* pPitch[CU_EGL_FRAME_MAX_PLANES];
++ } frame;
++ unsigned int width;
++ unsigned int height;
++ unsigned int depth;
++ unsigned int pitch;
++ unsigned int planeCount;
++ unsigned int numChannels;
++ CUeglFrameType frameType;
++ CUeglColorFormat eglColorFormat;
++ CUarray_format cuFormat;
++ } CUeglFrame;
++
++ #define CU_STREAM_DEFAULT 0
++ #define CU_STREAM_NON_BLOCKING 1
++
++ #define CU_EVENT_DEFAULT 0
++ #define CU_EVENT_BLOCKING_SYNC 1
++ #define CU_EVENT_DISABLE_TIMING 2
++
++ #define CU_EVENT_WAIT_DEFAULT 0
++ #define CU_EVENT_WAIT_EXTERNAL 1
++
++ #define CU_TRSF_READ_AS_INTEGER 1
++
++ typedef void CUDAAPI CUstreamCallback(CUstream hStream, CUresult status, void *userdata);
++ typedef void CUDAAPI CUhostFn(void *userData);
++
++ typedef CUresult CUDAAPI tcuInit(unsigned int Flags);
++ typedef CUresult CUDAAPI tcuDriverGetVersion(int *driverVersion);
++ typedef CUresult CUDAAPI tcuDeviceGetCount(int *count);
++ typedef CUresult CUDAAPI tcuDeviceGet(CUdevice *device, int ordinal);
++ typedef CUresult CUDAAPI tcuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, CUdevice dev);
++ typedef CUresult CUDAAPI tcuDeviceGetName(char *name, int len, CUdevice dev);
++ typedef CUresult CUDAAPI tcuDeviceGetUuid(CUuuid *uuid, CUdevice dev);
++ typedef CUresult CUDAAPI tcuDeviceGetUuid_v2(CUuuid *uuid, CUdevice dev);
++ typedef CUresult CUDAAPI tcuDeviceGetLuid(char* luid, unsigned int* deviceNodeMask, CUdevice dev);
++ typedef CUresult CUDAAPI tcuDeviceGetByPCIBusId(CUdevice* dev, const char* pciBusId);
++ typedef CUresult CUDAAPI tcuDeviceGetPCIBusId(char* pciBusId, int len, CUdevice dev);
++ typedef CUresult CUDAAPI tcuDeviceComputeCapability(int *major, int *minor, CUdevice dev);
++ typedef CUresult CUDAAPI tcuCtxCreate_v2(CUcontext *pctx, unsigned int flags, CUdevice dev);
++ typedef CUresult CUDAAPI tcuCtxSynchronize(void);
++ typedef CUresult CUDAAPI tcuCtxGetStreamPriorityRange(int *leastPriority, int *greatestPriority);
++ typedef CUresult CUDAAPI tcuCtxGetCurrent(CUcontext *pctx);
++ typedef CUresult CUDAAPI tcuCtxSetLimit(CUlimit limit, size_t value);
++ typedef CUresult CUDAAPI tcuCtxPushCurrent_v2(CUcontext pctx);
++ typedef CUresult CUDAAPI tcuCtxPopCurrent_v2(CUcontext *pctx);
++ typedef CUresult CUDAAPI tcuCtxDestroy_v2(CUcontext ctx);
++ typedef CUresult CUDAAPI tcuMemAlloc_v2(CUdeviceptr *dptr, size_t bytesize);
++ typedef CUresult CUDAAPI tcuMemAllocPitch_v2(CUdeviceptr *dptr, size_t *pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes);
++ typedef CUresult CUDAAPI tcuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize, unsigned int flags);
++ typedef CUresult CUDAAPI tcuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemFree_v2(CUdeviceptr dptr);
++ typedef CUresult CUDAAPI tcuMemHostAlloc(void **pp, size_t bytesize, unsigned int flags);
++ typedef CUresult CUDAAPI tcuMemFreeHost(void *p);
++ typedef CUresult CUDAAPI tcuMemAllocAsync(CUdeviceptr *dptr, size_t bytesize, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemFreeAsync(CUdeviceptr dptr, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t bytesize);
++ typedef CUresult CUDAAPI tcuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t bytesize, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemcpy2D_v2(const CUDA_MEMCPY2D *pcopy);
++ typedef CUresult CUDAAPI tcuMemcpy2DAsync_v2(const CUDA_MEMCPY2D *pcopy, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemcpyHtoD_v2(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount);
++ typedef CUresult CUDAAPI tcuMemcpyHtoDAsync_v2(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemcpyDtoH_v2(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount);
++ typedef CUresult CUDAAPI tcuMemcpyDtoHAsync_v2(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream);
++ typedef CUresult CUDAAPI tcuMemcpyDtoD_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount);
++ typedef CUresult CUDAAPI tcuMemcpyDtoDAsync_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream);
++ typedef CUresult CUDAAPI tcuGetErrorName(CUresult error, const char** pstr);
++ typedef CUresult CUDAAPI tcuGetErrorString(CUresult error, const char** pstr);
++ typedef CUresult CUDAAPI tcuCtxGetDevice(CUdevice *device);
++
++ typedef CUresult CUDAAPI tcuDevicePrimaryCtxRetain(CUcontext *pctx, CUdevice dev);
++ typedef CUresult CUDAAPI tcuDevicePrimaryCtxRelease(CUdevice dev);
++ typedef CUresult CUDAAPI tcuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags);
++ typedef CUresult CUDAAPI tcuDevicePrimaryCtxGetState(CUdevice dev, unsigned int *flags, int *active);
++ typedef CUresult CUDAAPI tcuDevicePrimaryCtxReset(CUdevice dev);
++
++ typedef CUresult CUDAAPI tcuStreamCreate(CUstream *phStream, unsigned int flags);
++ typedef CUresult CUDAAPI tcuStreamCreateWithPriority(CUstream *phStream, unsigned int flags, int priority);
++ typedef CUresult CUDAAPI tcuStreamQuery(CUstream hStream);
++ typedef CUresult CUDAAPI tcuStreamSynchronize(CUstream hStream);
++ typedef CUresult CUDAAPI tcuStreamDestroy_v2(CUstream hStream);
++ typedef CUresult CUDAAPI tcuStreamAddCallback(CUstream hStream, CUstreamCallback *callback, void *userdata, unsigned int flags);
++ typedef CUresult CUDAAPI tcuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int flags);
++ typedef CUresult CUDAAPI tcuEventCreate(CUevent *phEvent, unsigned int flags);
++ typedef CUresult CUDAAPI tcuEventDestroy_v2(CUevent hEvent);
++ typedef CUresult CUDAAPI tcuEventSynchronize(CUevent hEvent);
++ typedef CUresult CUDAAPI tcuEventQuery(CUevent hEvent);
++ typedef CUresult CUDAAPI tcuEventRecord(CUevent hEvent, CUstream hStream);
++
++ typedef CUresult CUDAAPI tcuLaunchKernel(CUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream, void** kernelParams, void** extra);
++ typedef CUresult CUDAAPI tcuLaunchHostFunc(CUstream hStream, CUhostFn *fn, void *userData);
++
++ typedef CUresult CUDAAPI tcuLinkCreate(unsigned int numOptions, CUjit_option* options, void** optionValues, CUlinkState* stateOut);
++ typedef CUresult CUDAAPI tcuLinkAddData(CUlinkState state, CUjitInputType type, void* data, size_t size, const char* name, unsigned int numOptions, CUjit_option* options, void** optionValues);
++ typedef CUresult CUDAAPI tcuLinkComplete(CUlinkState state, void** cubinOut, size_t* sizeOut);
++ typedef CUresult CUDAAPI tcuLinkDestroy(CUlinkState state);
++ typedef CUresult CUDAAPI tcuModuleLoadData(CUmodule* module, const void* image);
++ typedef CUresult CUDAAPI tcuModuleUnload(CUmodule hmod);
++ typedef CUresult CUDAAPI tcuModuleGetFunction(CUfunction* hfunc, CUmodule hmod, const char* name);
++ typedef CUresult CUDAAPI tcuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes, CUmodule hmod, const char* name);
++ typedef CUresult CUDAAPI tcuTexObjectCreate(CUtexObject* pTexObject, const CUDA_RESOURCE_DESC* pResDesc, const CUDA_TEXTURE_DESC* pTexDesc, const CUDA_RESOURCE_VIEW_DESC* pResViewDesc);
++ typedef CUresult CUDAAPI tcuTexObjectDestroy(CUtexObject texObject);
++
++ typedef CUresult CUDAAPI tcuGLGetDevices_v2(unsigned int* pCudaDeviceCount, CUdevice* pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList);
++ typedef CUresult CUDAAPI tcuGraphicsGLRegisterImage(CUgraphicsResource* pCudaResource, GLuint image, GLenum target, unsigned int Flags);
++ typedef CUresult CUDAAPI tcuGraphicsUnregisterResource(CUgraphicsResource resource);
++ typedef CUresult CUDAAPI tcuGraphicsMapResources(unsigned int count, CUgraphicsResource* resources, CUstream hStream);
++ typedef CUresult CUDAAPI tcuGraphicsUnmapResources(unsigned int count, CUgraphicsResource* resources, CUstream hStream);
++ typedef CUresult CUDAAPI tcuGraphicsSubResourceGetMappedArray(CUarray* pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel);
++ typedef CUresult CUDAAPI tcuGraphicsResourceGetMappedPointer(CUdeviceptr *devPtrOut, size_t *sizeOut, CUgraphicsResource resource);
++
++ typedef CUresult CUDAAPI tcuImportExternalMemory(CUexternalMemory* extMem_out, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC* memHandleDesc);
++ typedef CUresult CUDAAPI tcuDestroyExternalMemory(CUexternalMemory extMem);
++ typedef CUresult CUDAAPI tcuExternalMemoryGetMappedBuffer(CUdeviceptr* devPtr, CUexternalMemory extMem, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC* bufferDesc);
++ typedef CUresult CUDAAPI tcuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray* mipmap, CUexternalMemory extMem, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC* mipmapDesc);
++ typedef CUresult CUDAAPI tcuMipmappedArrayGetLevel(CUarray* pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level);
++ typedef CUresult CUDAAPI tcuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray);
++
++ typedef CUresult CUDAAPI tcuImportExternalSemaphore(CUexternalSemaphore* extSem_out, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC* semHandleDesc);
++ typedef CUresult CUDAAPI tcuDestroyExternalSemaphore(CUexternalSemaphore extSem);
++ typedef CUresult CUDAAPI tcuSignalExternalSemaphoresAsync(const CUexternalSemaphore* extSemArray, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* paramsArray, unsigned int numExtSems, CUstream stream);
++ typedef CUresult CUDAAPI tcuWaitExternalSemaphoresAsync(const CUexternalSemaphore* extSemArray, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* paramsArray, unsigned int numExtSems, CUstream stream);
++
++ typedef CUresult CUDAAPI tcuArrayCreate(CUarray *pHandle, const CUDA_ARRAY_DESCRIPTOR* pAllocateArray);
++ typedef CUresult CUDAAPI tcuArray3DCreate(CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray);
++ typedef CUresult CUDAAPI tcuArrayDestroy(CUarray hArray);
++ typedef CUresult CUDAAPI tcuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray);
++ typedef CUresult CUDAAPI tcuArrayGetPlane(CUarray *pPlaneArray, CUarray hArray, unsigned int planeIdx);
++
++ typedef CUresult CUDAAPI tcuEGLStreamProducerConnect(CUeglStreamConnection* conn, ffnv_EGLStreamKHR stream, ffnv_EGLint width, ffnv_EGLint height);
++ typedef CUresult CUDAAPI tcuEGLStreamProducerDisconnect(CUeglStreamConnection* conn);
++ typedef CUresult CUDAAPI tcuEGLStreamConsumerDisconnect(CUeglStreamConnection* conn);
++ typedef CUresult CUDAAPI tcuEGLStreamProducerPresentFrame(CUeglStreamConnection* conn, CUeglFrame eglframe, CUstream* pStream);
++ typedef CUresult CUDAAPI tcuEGLStreamProducerReturnFrame(CUeglStreamConnection* conn, CUeglFrame* eglframe, CUstream* pStream);
++
++ typedef CUresult CUDAAPI tcuD3D11GetDevice(CUdevice *device, void *dxgiAdapter);
++ typedef CUresult CUDAAPI tcuD3D11GetDevices(unsigned int *deviceCountOut, CUdevice *devices, unsigned int deviceCount, void *d3d11device, CUd3d11DeviceList listType);
++ typedef CUresult CUDAAPI tcuGraphicsD3D11RegisterResource(CUgraphicsResource *cudaResourceOut, void *d3d11Resource, unsigned int flags);
++ #endif