PapaTutuWawa/gpu-screen-recorder
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove dependency on glew and glfw, move external files to external directory

Browse Source
This commit is contained in:
dec05eba
2022-09-28 01:03:06 +02:00
parent 2570d1e86a
commit 1db2282683
13 changed files with 419 additions and 824 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
include/CudaLibrary.hpp
View File

@@ -1,42 +1,29 @@
#pragma once
#include "LibraryLoader.hpp"
#include <cuda.h>
#include <cudaGL.h>
#include <dlfcn.h>
#include <stdio.h>
typedef CUresult CUDAAPI (*CUINIT)(unsigned int Flags);
typedef CUresult CUDAAPI (*CUDEVICEGETCOUNT)(int *count);
typedef CUresult CUDAAPI (*CUDEVICEGET)(CUdevice *device, int ordinal);
typedef CUresult CUDAAPI (*CUCTXCREATE_V2)(CUcontext *pctx, unsigned int flags, CUdevice dev);
typedef CUresult CUDAAPI (*CUCTXPUSHCURRENT_V2)(CUcontext ctx);
typedef CUresult CUDAAPI (*CUCTXPOPCURRENT_V2)(CUcontext *pctx);
typedef CUresult CUDAAPI (*CUGETERRORSTRING)(CUresult error, const char **pStr);
typedef CUresult CUDAAPI (*CUMEMSETD8_V2)(CUdeviceptr dstDevice, unsigned char uc, size_t N);
typedef CUresult CUDAAPI (*CUMEMCPY2D_V2)(const CUDA_MEMCPY2D *pCopy);
typedef CUresult CUDAAPI (*CUGRAPHICSGLREGISTERIMAGE)(CUgraphicsResource *pCudaResource, GLuint image, GLenum target, unsigned int Flags);
typedef CUresult CUDAAPI (*CUGRAPHICSRESOURCESETMAPFLAGS)(CUgraphicsResource resource, unsigned int flags);
typedef CUresult CUDAAPI (*CUGRAPHICSMAPRESOURCES)(unsigned int count, CUgraphicsResource *resources, CUstream hStream);
typedef CUresult CUDAAPI (*CUGRAPHICSUNREGISTERRESOURCE)(CUgraphicsResource resource);
typedef CUresult CUDAAPI (*CUGRAPHICSSUBRESOURCEGETMAPPEDARRAY)(CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel);
typedef struct CUgraphicsResource_st *CUgraphicsResource;
struct Cuda {
CUINIT cuInit;
CUDEVICEGETCOUNT cuDeviceGetCount;
CUDEVICEGET cuDeviceGet;
CUCTXCREATE_V2 cuCtxCreate_v2;
CUCTXPUSHCURRENT_V2 cuCtxPushCurrent_v2;
CUCTXPOPCURRENT_V2 cuCtxPopCurrent_v2;
CUGETERRORSTRING cuGetErrorString;
CUMEMSETD8_V2 cuMemsetD8_v2;
CUMEMCPY2D_V2 cuMemcpy2D_v2;
CUresult CUDAAPI (*cuInit)(unsigned int Flags);
CUresult CUDAAPI (*cuDeviceGetCount)(int *count);
CUresult CUDAAPI (*cuDeviceGet)(CUdevice *device, int ordinal);
CUresult CUDAAPI (*cuCtxCreate_v2)(CUcontext *pctx, unsigned int flags, CUdevice dev);
CUresult CUDAAPI (*cuCtxPushCurrent_v2)(CUcontext ctx);
CUresult CUDAAPI (*cuCtxPopCurrent_v2)(CUcontext *pctx);
CUresult CUDAAPI (*cuGetErrorString)(CUresult error, const char **pStr);
CUresult CUDAAPI (*cuMemsetD8_v2)(CUdeviceptr dstDevice, unsigned char uc, size_t N);
CUresult CUDAAPI (*cuMemcpy2D_v2)(const CUDA_MEMCPY2D *pCopy);
CUGRAPHICSGLREGISTERIMAGE cuGraphicsGLRegisterImage;
CUGRAPHICSRESOURCESETMAPFLAGS cuGraphicsResourceSetMapFlags;
CUGRAPHICSMAPRESOURCES cuGraphicsMapResources;
CUGRAPHICSUNREGISTERRESOURCE cuGraphicsUnregisterResource;
CUGRAPHICSSUBRESOURCEGETMAPPEDARRAY cuGraphicsSubResourceGetMappedArray;
CUresult CUDAAPI (*cuGraphicsGLRegisterImage)(CUgraphicsResource *pCudaResource, unsigned int image, unsigned int target, unsigned int Flags);
CUresult CUDAAPI (*cuGraphicsResourceSetMapFlags)(CUgraphicsResource resource, unsigned int flags);
CUresult CUDAAPI (*cuGraphicsMapResources)(unsigned int count, CUgraphicsResource *resources, CUstream hStream);
CUresult CUDAAPI (*cuGraphicsUnregisterResource)(CUgraphicsResource resource);
CUresult CUDAAPI (*cuGraphicsSubResourceGetMappedArray)(CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel);
~Cuda() {
if(library)
@@ -52,80 +39,39 @@ struct Cuda {
if(!lib) {
lib = dlopen("libcuda.so.1", RTLD_LAZY);
if(!lib) {
fprintf(stderr, "Error: failed to load libcuda.so and libcuda.so.1, error: %s\n", dlerror());
fprintf(stderr, "Error: failed to load libcuda.so/libcuda.so.1, error: %s\n", dlerror());
return false;
}
}
cuInit = (CUINIT)load_symbol(lib, "cuInit");
if(!cuInit)
goto fail;
dlsym_assign required_dlsym[] = {
{ (void**)&cuInit, "cuInit" },
{ (void**)&cuDeviceGetCount, "cuDeviceGetCount" },
{ (void**)&cuDeviceGet, "cuDeviceGet" },
{ (void**)&cuCtxCreate_v2, "cuCtxCreate_v2" },
{ (void**)&cuCtxPushCurrent_v2, "cuCtxPushCurrent_v2" },
{ (void**)&cuCtxPopCurrent_v2, "cuCtxPopCurrent_v2" },
{ (void**)&cuGetErrorString, "cuGetErrorString" },
{ (void**)&cuMemsetD8_v2, "cuMemsetD8_v2" },
{ (void**)&cuMemcpy2D_v2, "cuMemcpy2D_v2" },
cuDeviceGetCount = (CUDEVICEGETCOUNT)load_symbol(lib, "cuDeviceGetCount");
if(!cuDeviceGetCount)
goto fail;
{ (void**)&cuGraphicsGLRegisterImage, "cuGraphicsGLRegisterImage" },
{ (void**)&cuGraphicsResourceSetMapFlags, "cuGraphicsResourceSetMapFlags" },
{ (void**)&cuGraphicsMapResources, "cuGraphicsMapResources" },
{ (void**)&cuGraphicsUnregisterResource, "cuGraphicsUnregisterResource" },
{ (void**)&cuGraphicsSubResourceGetMappedArray, "cuGraphicsSubResourceGetMappedArray" },
cuDeviceGet = (CUDEVICEGET)load_symbol(lib, "cuDeviceGet");
if(!cuDeviceGet)
goto fail;
{ NULL, NULL }
};
cuCtxCreate_v2 = (CUCTXCREATE_V2)load_symbol(lib, "cuCtxCreate_v2");
if(!cuCtxCreate_v2)
goto fail;
cuCtxPushCurrent_v2 = (CUCTXPUSHCURRENT_V2)load_symbol(lib, "cuCtxPushCurrent_v2");
if(!cuCtxPushCurrent_v2)
goto fail;
cuCtxPopCurrent_v2 = (CUCTXPOPCURRENT_V2)load_symbol(lib, "cuCtxPopCurrent_v2");
if(!cuCtxPopCurrent_v2)
goto fail;
cuGetErrorString = (CUGETERRORSTRING)load_symbol(lib, "cuGetErrorString");
if(!cuGetErrorString)
goto fail;
cuMemsetD8_v2 = (CUMEMSETD8_V2)load_symbol(lib, "cuMemsetD8_v2");
if(!cuMemsetD8_v2)
goto fail;
cuMemcpy2D_v2 = (CUMEMCPY2D_V2)load_symbol(lib, "cuMemcpy2D_v2");
if(!cuMemcpy2D_v2)
goto fail;
cuGraphicsGLRegisterImage = (CUGRAPHICSGLREGISTERIMAGE)load_symbol(lib, "cuGraphicsGLRegisterImage");
if(!cuGraphicsGLRegisterImage)
goto fail;
cuGraphicsResourceSetMapFlags = (CUGRAPHICSRESOURCESETMAPFLAGS)load_symbol(lib, "cuGraphicsResourceSetMapFlags");
if(!cuGraphicsResourceSetMapFlags)
goto fail;
cuGraphicsMapResources = (CUGRAPHICSMAPRESOURCES)load_symbol(lib, "cuGraphicsMapResources");
if(!cuGraphicsMapResources)
goto fail;
cuGraphicsUnregisterResource = (CUGRAPHICSUNREGISTERRESOURCE)load_symbol(lib, "cuGraphicsUnregisterResource");
if(!cuGraphicsUnregisterResource)
goto fail;
cuGraphicsSubResourceGetMappedArray = (CUGRAPHICSSUBRESOURCEGETMAPPEDARRAY)load_symbol(lib, "cuGraphicsSubResourceGetMappedArray");
if(!cuGraphicsSubResourceGetMappedArray)
goto fail;
library = lib;
return true;
fail:
dlclose(lib);
return false;
}
private:
void* load_symbol(void *library, const char *symbol) {
void *sym = dlsym(library, symbol);
if(!sym)
fprintf(stderr, "Error: missing required symbol %s from libcuda.so\n", symbol);
return sym;
if(dlsym_load_list(lib, required_dlsym)) {
library = lib;
return true;
} else {
fprintf(stderr, "Error: missing required symbols in libcuda.so\n");
dlclose(lib);
return false;
}
}
private:
void *library = nullptr;

146
include/GlLibrary.hpp Normal file
View File

@@ -0,0 +1,146 @@
#pragma once
#include "LibraryLoader.hpp"
#include <X11/X.h>
#include <X11/Xutil.h>
#include <dlfcn.h>
#include <stdio.h>
typedef XID GLXPixmap;
typedef XID GLXDrawable;
typedef XID GLXWindow;
typedef struct __GLXcontextRec *GLXContext;
typedef struct __GLXFBConfigRec *GLXFBConfig;
#define GL_TEXTURE_2D 0x0DE1
#define GL_RGB 0x1907
#define GL_UNSIGNED_BYTE 0x1401
#define GL_COLOR_BUFFER_BIT 0x00004000
#define GL_TEXTURE_WRAP_S 0x2802
#define GL_TEXTURE_WRAP_T 0x2803
#define GL_TEXTURE_MAG_FILTER 0x2800
#define GL_TEXTURE_MIN_FILTER 0x2801
#define GL_TEXTURE_WIDTH 0x1000
#define GL_TEXTURE_HEIGHT 0x1001
#define GL_NEAREST 0x2600
#define GLX_BUFFER_SIZE 2
#define GLX_DOUBLEBUFFER 5
#define GLX_RED_SIZE 8
#define GLX_GREEN_SIZE 9
#define GLX_BLUE_SIZE 10
#define GLX_ALPHA_SIZE 11
#define GLX_DEPTH_SIZE 12
#define GLX_RGBA_BIT 0x00000001
#define GLX_RENDER_TYPE 0x8011
#define GLX_FRONT_EXT 0x20DE
#define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0
#define GLX_DRAWABLE_TYPE 0x8010
#define GLX_WINDOW_BIT 0x00000001
#define GLX_PIXMAP_BIT 0x00000002
#define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3
#define GLX_TEXTURE_2D_BIT_EXT 0x00000002
#define GLX_TEXTURE_TARGET_EXT 0x20D6
#define GLX_TEXTURE_2D_EXT 0x20DC
#define GLX_TEXTURE_FORMAT_EXT 0x20D5
#define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9
#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
#define GLX_CONTEXT_FLAGS_ARB 0x2094
struct GlLibrary {
GLXPixmap (*glXCreatePixmap)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
void (*glXDestroyPixmap)(Display *dpy, GLXPixmap pixmap);
void (*glXBindTexImageEXT)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
void (*glXReleaseTexImageEXT)(Display *dpy, GLXDrawable drawable, int buffer);
GLXFBConfig* (*glXChooseFBConfig)(Display *dpy, int screen, const int *attribList, int *nitems);
XVisualInfo* (*glXGetVisualFromFBConfig)(Display *dpy, GLXFBConfig config);
GLXContext (*glXCreateContextAttribsARB)(Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
Bool (*glXMakeContextCurrent)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
void (*glXDestroyContext)(Display *dpy, GLXContext ctx);
void (*glXSwapBuffers)(Display *dpy, GLXDrawable drawable);
void (*glXSwapIntervalEXT)(Display *dpy, GLXDrawable drawable, int interval);
int (*glXSwapIntervalMESA)(unsigned int interval);
int (*glXSwapIntervalSGI)(int interval);
void (*glClearTexImage)(unsigned int texture, unsigned int level, unsigned int format, unsigned int type, const void *data);
unsigned int (*glGetError)(void);
void (*glClear)(unsigned int mask);
void (*glGenTextures)(int n, unsigned int *textures);
void (*glDeleteTextures)(int n, const unsigned int *texture);
void (*glBindTexture)(unsigned int target, unsigned int texture);
void (*glTexParameteri)(unsigned int target, unsigned int pname, int param);
void (*glGetTexLevelParameteriv)(unsigned int target, int level, unsigned int pname, int *params);
void (*glTexImage2D)(unsigned int target, int level, int internalFormat, int width, int height, int border, unsigned int format, unsigned int type, const void *pixels);
void (*glCopyImageSubData)(unsigned int srcName, unsigned int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, unsigned int dstName, unsigned int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth);
~GlLibrary() {
if(library)
dlclose(library);
}
bool load() {
if(library)
return true;
dlerror(); // clear
void *lib = dlopen("libGL.so.1", RTLD_LAZY);
if(!lib) {
fprintf(stderr, "Error: failed to load libGL.so.1, error: %s\n", dlerror());
return false;
}
dlsym_assign optional_dlsym[] = {
{ (void**)&glClearTexImage, "glClearTexImage" },
{ (void**)&glXSwapIntervalEXT, "glXSwapIntervalEXT" },
{ (void**)&glXSwapIntervalMESA, "glXSwapIntervalMESA" },
{ (void**)&glXSwapIntervalSGI, "glXSwapIntervalSGI" },
{ NULL, NULL }
};
dlsym_load_list_optional(lib, optional_dlsym);
dlsym_assign required_dlsym[] = {
{ (void**)&glXCreatePixmap, "glXCreatePixmap" },
{ (void**)&glXDestroyPixmap, "glXDestroyPixmap" },
{ (void**)&glXBindTexImageEXT, "glXBindTexImageEXT" },
{ (void**)&glXReleaseTexImageEXT, "glXReleaseTexImageEXT" },
{ (void**)&glXChooseFBConfig, "glXChooseFBConfig" },
{ (void**)&glXGetVisualFromFBConfig, "glXGetVisualFromFBConfig" },
{ (void**)&glXCreateContextAttribsARB, "glXCreateContextAttribsARB" },
{ (void**)&glXMakeContextCurrent, "glXMakeContextCurrent" },
{ (void**)&glXDestroyContext, "glXDestroyContext" },
{ (void**)&glXSwapBuffers, "glXSwapBuffers" },
{ (void**)&glGetError, "glGetError" },
{ (void**)&glClear, "glClear" },
{ (void**)&glGenTextures, "glGenTextures" },
{ (void**)&glDeleteTextures, "glDeleteTextures" },
{ (void**)&glBindTexture, "glBindTexture" },
{ (void**)&glTexParameteri, "glTexParameteri" },
{ (void**)&glGetTexLevelParameteriv, "glGetTexLevelParameteriv" },
{ (void**)&glTexImage2D, "glTexImage2D" },
{ (void**)&glCopyImageSubData, "glCopyImageSubData" },
{ NULL, NULL }
};
if(dlsym_load_list(lib, required_dlsym)) {
library = lib;
return true;
} else {
fprintf(stderr, "Error: missing required symbols in libGL.so.1\n");
dlclose(lib);
return false;
}
}
private:
void *library = nullptr;
};

38
include/LibraryLoader.hpp Normal file
View File

@@ -0,0 +1,38 @@
#pragma once
#include <dlfcn.h>
#include <stdio.h>
typedef struct {
void **func;
const char *name;
} dlsym_assign;
static void* dlsym_print_fail(void *handle, const char *name, bool required) {
dlerror();
void *sym = dlsym(handle, name);
char *err_str = dlerror();
if(!sym)
fprintf(stderr, "%s: dlsym(handle, \"%s\") failed, error: %s\n", required ? "error" : "warning", name, err_str ? err_str : "(null)");
return sym;
}
/* |dlsyms| should be null terminated */
static bool dlsym_load_list(void *handle, const dlsym_assign *dlsyms) {
bool success = true;
for(int i = 0; dlsyms[i].func; ++i) {
*dlsyms[i].func = dlsym_print_fail(handle, dlsyms[i].name, true);
if(!*dlsyms[i].func)
success = false;
}
return success;
}
/* |dlsyms| should be null terminated */
static void dlsym_load_list_optional(void *handle, const dlsym_assign *dlsyms) {
for(int i = 0; dlsyms[i].func; ++i) {
*dlsyms[i].func = dlsym_print_fail(handle, dlsyms[i].name, false);
}
}

2006
include/NvFBC.h
View File

File diff suppressed because it is too large Load Diff

3
include/NvFBCLibrary.hpp
View File

@@ -1,7 +1,6 @@
#pragma once
#include "NvFBC.h"
#include <NvFBC.h>
#include <dlfcn.h>
#include <string.h>
#include <stdio.h>

20692
include/cuda.h
View File

File diff suppressed because it is too large Load Diff

605
include/cudaGL.h
View File

@@ -1,605 +0,0 @@
/*
* Copyright 1993-2014 NVIDIA Corporation. All rights reserved.
*
* NOTICE TO LICENSEE:
*
* This source code and/or documentation ("Licensed Deliverables") are
* subject to NVIDIA intellectual property rights under U.S. and
* international Copyright laws.
*
* These Licensed Deliverables contained herein is PROPRIETARY and
* CONFIDENTIAL to NVIDIA and is being provided under the terms and
* conditions of a form of NVIDIA software license agreement by and
* between NVIDIA and Licensee ("License Agreement") or electronically
* accepted by Licensee. Notwithstanding any terms or conditions to
* the contrary in the License Agreement, reproduction or disclosure
* of the Licensed Deliverables to any third party without the express
* written consent of NVIDIA is prohibited.
*
* NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
* LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
* SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE. IT IS
* PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
* NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
* DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
* NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
* NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
* LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
* SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
* DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THESE LICENSED DELIVERABLES.
*
* U.S. Government End Users. These Licensed Deliverables are a
* "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
* 1995), consisting of "commercial computer software" and "commercial
* computer software documentation" as such terms are used in 48
* C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
* only as a commercial end item. Consistent with 48 C.F.R.12.212 and
* 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
* U.S. Government End Users acquire the Licensed Deliverables with
* only those rights set forth herein.
*
* Any use of the Licensed Deliverables in individual and commercial
* software must include, in the user documentation and internal
* comments to the code, the above Disclaimer and U.S. Government End
* Users Notice.
*/
#ifndef CUDAGL_H
#define CUDAGL_H
#include <cuda.h>
#include <GL/gl.h>
#if defined(__CUDA_API_VERSION_INTERNAL) || defined(__DOXYGEN_ONLY__) || defined(CUDA_ENABLE_DEPRECATED)
#define __CUDA_DEPRECATED
#elif defined(_MSC_VER)
#define __CUDA_DEPRECATED __declspec(deprecated)
#elif defined(__GNUC__)
#define __CUDA_DEPRECATED __attribute__((deprecated))
#else
#define __CUDA_DEPRECATED
#endif
#ifdef CUDA_FORCE_API_VERSION
#error "CUDA_FORCE_API_VERSION is no longer supported."
#endif
#if defined(__CUDA_API_VERSION_INTERNAL) || defined(CUDA_API_PER_THREAD_DEFAULT_STREAM)
#define __CUDA_API_PER_THREAD_DEFAULT_STREAM
#define __CUDA_API_PTDS(api) api ## _ptds
#define __CUDA_API_PTSZ(api) api ## _ptsz
#else
#define __CUDA_API_PTDS(api) api
#define __CUDA_API_PTSZ(api) api
#endif
#define cuGLCtxCreate cuGLCtxCreate_v2
#define cuGLMapBufferObject __CUDA_API_PTDS(cuGLMapBufferObject_v2)
#define cuGLMapBufferObjectAsync __CUDA_API_PTSZ(cuGLMapBufferObjectAsync_v2)
#define cuGLGetDevices cuGLGetDevices_v2
#ifdef __cplusplus
extern "C" {
#endif
/**
* \file cudaGL.h
* \brief Header file for the OpenGL interoperability functions of the
* low-level CUDA driver application programming interface.
*/
/**
* \defgroup CUDA_GL OpenGL Interoperability
* \ingroup CUDA_DRIVER
*
* ___MANBRIEF___ OpenGL interoperability functions of the low-level CUDA
* driver API (___CURRENT_FILE___) ___ENDMANBRIEF___
*
* This section describes the OpenGL interoperability functions of the
* low-level CUDA driver application programming interface. Note that mapping
* of OpenGL resources is performed with the graphics API agnostic, resource
* mapping interface described in \ref CUDA_GRAPHICS "Graphics Interoperability".
*
* @{
*/
#if defined(_WIN32)
#if !defined(WGL_NV_gpu_affinity)
typedef void* HGPUNV;
#endif
#endif /* _WIN32 */
/**
* \brief Registers an OpenGL buffer object
*
* Registers the buffer object specified by \p buffer for access by
* CUDA. A handle to the registered object is returned as \p
* pCudaResource. The register flags \p Flags specify the intended usage,
* as follows:
*
* - ::CU_GRAPHICS_REGISTER_FLAGS_NONE: Specifies no hints about how this
* resource will be used. It is therefore assumed that this resource will be
* read from and written to by CUDA. This is the default value.
* - ::CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY: Specifies that CUDA
* will not write to this resource.
* - ::CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD: Specifies that
* CUDA will not read from this resource and will write over the
* entire contents of the resource, so none of the data previously
* stored in the resource will be preserved.
*
* \param pCudaResource - Pointer to the returned object handle
* \param buffer - name of buffer object to be registered
* \param Flags - Register flags
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_INVALID_HANDLE,
* ::CUDA_ERROR_ALREADY_MAPPED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* \notefnerr
*
* \sa
* ::cuGraphicsUnregisterResource,
* ::cuGraphicsMapResources,
* ::cuGraphicsResourceGetMappedPointer,
* ::cudaGraphicsGLRegisterBuffer
*/
CUresult CUDAAPI cuGraphicsGLRegisterBuffer(CUgraphicsResource *pCudaResource, GLuint buffer, unsigned int Flags);
/**
* \brief Register an OpenGL texture or renderbuffer object
*
* Registers the texture or renderbuffer object specified by \p image for access by CUDA.
* A handle to the registered object is returned as \p pCudaResource.
*
* \p target must match the type of the object, and must be one of ::GL_TEXTURE_2D,
* ::GL_TEXTURE_RECTANGLE, ::GL_TEXTURE_CUBE_MAP, ::GL_TEXTURE_3D, ::GL_TEXTURE_2D_ARRAY,
* or ::GL_RENDERBUFFER.
*
* The register flags \p Flags specify the intended usage, as follows:
*
* - ::CU_GRAPHICS_REGISTER_FLAGS_NONE: Specifies no hints about how this
* resource will be used. It is therefore assumed that this resource will be
* read from and written to by CUDA. This is the default value.
* - ::CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY: Specifies that CUDA
* will not write to this resource.
* - ::CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD: Specifies that
* CUDA will not read from this resource and will write over the
* entire contents of the resource, so none of the data previously
* stored in the resource will be preserved.
* - ::CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST: Specifies that CUDA will
* bind this resource to a surface reference.
* - ::CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER: Specifies that CUDA will perform
* texture gather operations on this resource.
*
* The following image formats are supported. For brevity's sake, the list is abbreviated.
* For ex., {GL_R, GL_RG} X {8, 16} would expand to the following 4 formats
* {GL_R8, GL_R16, GL_RG8, GL_RG16} :
* - GL_RED, GL_RG, GL_RGBA, GL_LUMINANCE, GL_ALPHA, GL_LUMINANCE_ALPHA, GL_INTENSITY
* - {GL_R, GL_RG, GL_RGBA} X {8, 16, 16F, 32F, 8UI, 16UI, 32UI, 8I, 16I, 32I}
* - {GL_LUMINANCE, GL_ALPHA, GL_LUMINANCE_ALPHA, GL_INTENSITY} X
* {8, 16, 16F_ARB, 32F_ARB, 8UI_EXT, 16UI_EXT, 32UI_EXT, 8I_EXT, 16I_EXT, 32I_EXT}
*
* The following image classes are currently disallowed:
* - Textures with borders
* - Multisampled renderbuffers
*
* \param pCudaResource - Pointer to the returned object handle
* \param image - name of texture or renderbuffer object to be registered
* \param target - Identifies the type of object specified by \p image
* \param Flags - Register flags
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_INVALID_HANDLE,
* ::CUDA_ERROR_ALREADY_MAPPED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* \notefnerr
*
* \sa
* ::cuGraphicsUnregisterResource,
* ::cuGraphicsMapResources,
* ::cuGraphicsSubResourceGetMappedArray,
* ::cudaGraphicsGLRegisterImage
*/
CUresult CUDAAPI cuGraphicsGLRegisterImage(CUgraphicsResource *pCudaResource, GLuint image, GLenum target, unsigned int Flags);
#ifdef _WIN32
/**
* \brief Gets the CUDA device associated with hGpu
*
* Returns in \p *pDevice the CUDA device associated with a \p hGpu, if
* applicable.
*
* \param pDevice - Device associated with hGpu
* \param hGpu - Handle to a GPU, as queried via ::WGL_NV_gpu_affinity()
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_INVALID_VALUE
* \notefnerr
*
* \sa ::cuGLMapBufferObject,
* ::cuGLRegisterBufferObject, ::cuGLUnmapBufferObject,
* ::cuGLUnregisterBufferObject, ::cuGLUnmapBufferObjectAsync,
* ::cuGLSetBufferObjectMapFlags,
* ::cudaWGLGetDevice
*/
CUresult CUDAAPI cuWGLGetDevice(CUdevice *pDevice, HGPUNV hGpu);
#endif /* _WIN32 */
/**
* CUDA devices corresponding to an OpenGL device
*/
typedef enum CUGLDeviceList_enum {
CU_GL_DEVICE_LIST_ALL = 0x01, /**< The CUDA devices for all GPUs used by the current OpenGL context */
CU_GL_DEVICE_LIST_CURRENT_FRAME = 0x02, /**< The CUDA devices for the GPUs used by the current OpenGL context in its currently rendering frame */
CU_GL_DEVICE_LIST_NEXT_FRAME = 0x03, /**< The CUDA devices for the GPUs to be used by the current OpenGL context in the next frame */
} CUGLDeviceList;
/**
* \brief Gets the CUDA devices associated with the current OpenGL context
*
* Returns in \p *pCudaDeviceCount the number of CUDA-compatible devices
* corresponding to the current OpenGL context. Also returns in \p *pCudaDevices
* at most cudaDeviceCount of the CUDA-compatible devices corresponding to
* the current OpenGL context. If any of the GPUs being used by the current OpenGL
* context are not CUDA capable then the call will return CUDA_ERROR_NO_DEVICE.
*
* The \p deviceList argument may be any of the following:
* - ::CU_GL_DEVICE_LIST_ALL: Query all devices used by the current OpenGL context.
* - ::CU_GL_DEVICE_LIST_CURRENT_FRAME: Query the devices used by the current OpenGL context to
* render the current frame (in SLI).
* - ::CU_GL_DEVICE_LIST_NEXT_FRAME: Query the devices used by the current OpenGL context to
* render the next frame (in SLI). Note that this is a prediction, it can't be guaranteed that
* this is correct in all cases.
*
* \param pCudaDeviceCount - Returned number of CUDA devices.
* \param pCudaDevices - Returned CUDA devices.
* \param cudaDeviceCount - The size of the output device array pCudaDevices.
* \param deviceList - The set of devices to return.
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_NO_DEVICE,
* ::CUDA_ERROR_INVALID_VALUE,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_INVALID_GRAPHICS_CONTEXT
*
* \notefnerr
*
* \sa
* ::cuWGLGetDevice,
* ::cudaGLGetDevices
*/
CUresult CUDAAPI cuGLGetDevices(unsigned int *pCudaDeviceCount, CUdevice *pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList);
/**
* \defgroup CUDA_GL_DEPRECATED OpenGL Interoperability [DEPRECATED]
*
* ___MANBRIEF___ deprecated OpenGL interoperability functions of the low-level
* CUDA driver API (___CURRENT_FILE___) ___ENDMANBRIEF___
*
* This section describes deprecated OpenGL interoperability functionality.
*
* @{
*/
/** Flags to map or unmap a resource */
typedef enum CUGLmap_flags_enum {
CU_GL_MAP_RESOURCE_FLAGS_NONE = 0x00,
CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY = 0x01,
CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 0x02,
} CUGLmap_flags;
/**
* \brief Create a CUDA context for interoperability with OpenGL
*
* \deprecated This function is deprecated as of Cuda 5.0.
*
* This function is deprecated and should no longer be used. It is
* no longer necessary to associate a CUDA context with an OpenGL
* context in order to achieve maximum interoperability performance.
*
* \param pCtx - Returned CUDA context
* \param Flags - Options for CUDA context creation
* \param device - Device on which to create the context
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_INVALID_VALUE,
* ::CUDA_ERROR_OUT_OF_MEMORY
* \notefnerr
*
* \sa ::cuCtxCreate, ::cuGLInit, ::cuGLMapBufferObject,
* ::cuGLRegisterBufferObject, ::cuGLUnmapBufferObject,
* ::cuGLUnregisterBufferObject, ::cuGLMapBufferObjectAsync,
* ::cuGLUnmapBufferObjectAsync, ::cuGLSetBufferObjectMapFlags,
* ::cuWGLGetDevice
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLCtxCreate(CUcontext *pCtx, unsigned int Flags, CUdevice device );
/**
* \brief Initializes OpenGL interoperability
*
* \deprecated This function is deprecated as of Cuda 3.0.
*
* Initializes OpenGL interoperability. This function is deprecated
* and calling it is no longer required. It may fail if the needed
* OpenGL driver facilities are not available.
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_UNKNOWN
* \notefnerr
*
* \sa ::cuGLMapBufferObject,
* ::cuGLRegisterBufferObject, ::cuGLUnmapBufferObject,
* ::cuGLUnregisterBufferObject, ::cuGLMapBufferObjectAsync,
* ::cuGLUnmapBufferObjectAsync, ::cuGLSetBufferObjectMapFlags,
* ::cuWGLGetDevice
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLInit(void);
/**
* \brief Registers an OpenGL buffer object
*
* \deprecated This function is deprecated as of Cuda 3.0.
*
* Registers the buffer object specified by \p buffer for access by
* CUDA. This function must be called before CUDA can map the buffer
* object. There must be a valid OpenGL context bound to the current
* thread when this function is called, and the buffer name is
* resolved by that context.
*
* \param buffer - The name of the buffer object to register.
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_ALREADY_MAPPED
* \notefnerr
*
* \sa ::cuGraphicsGLRegisterBuffer
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLRegisterBufferObject(GLuint buffer);
/**
* \brief Maps an OpenGL buffer object
*
* \deprecated This function is deprecated as of Cuda 3.0.
*
* Maps the buffer object specified by \p buffer into the address space of the
* current CUDA context and returns in \p *dptr and \p *size the base pointer
* and size of the resulting mapping.
*
* There must be a valid OpenGL context bound to the current thread
* when this function is called. This must be the same context, or a
* member of the same shareGroup, as the context that was bound when
* the buffer was registered.
*
* All streams in the current CUDA context are synchronized with the
* current GL context.
*
* \param dptr - Returned mapped base pointer
* \param size - Returned size of mapping
* \param buffer - The name of the buffer object to map
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_INVALID_VALUE,
* ::CUDA_ERROR_MAP_FAILED
* \notefnerr
*
* \sa ::cuGraphicsMapResources
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLMapBufferObject(CUdeviceptr *dptr, size_t *size, GLuint buffer);
/**
* \brief Unmaps an OpenGL buffer object
*
* \deprecated This function is deprecated as of Cuda 3.0.
*
* Unmaps the buffer object specified by \p buffer for access by CUDA.
*
* There must be a valid OpenGL context bound to the current thread
* when this function is called. This must be the same context, or a
* member of the same shareGroup, as the context that was bound when
* the buffer was registered.
*
* All streams in the current CUDA context are synchronized with the
* current GL context.
*
* \param buffer - Buffer object to unmap
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_INVALID_VALUE
* \notefnerr
*
* \sa ::cuGraphicsUnmapResources
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLUnmapBufferObject(GLuint buffer);
/**
* \brief Unregister an OpenGL buffer object
*
* \deprecated This function is deprecated as of Cuda 3.0.
*
* Unregisters the buffer object specified by \p buffer. This
* releases any resources associated with the registered buffer.
* After this call, the buffer may no longer be mapped for access by
* CUDA.
*
* There must be a valid OpenGL context bound to the current thread
* when this function is called. This must be the same context, or a
* member of the same shareGroup, as the context that was bound when
* the buffer was registered.
*
* \param buffer - Name of the buffer object to unregister
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_INVALID_VALUE
* \notefnerr
*
* \sa ::cuGraphicsUnregisterResource
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLUnregisterBufferObject(GLuint buffer);
/**
* \brief Set the map flags for an OpenGL buffer object
*
* \deprecated This function is deprecated as of Cuda 3.0.
*
* Sets the map flags for the buffer object specified by \p buffer.
*
* Changes to \p Flags will take effect the next time \p buffer is mapped.
* The \p Flags argument may be any of the following:
* - ::CU_GL_MAP_RESOURCE_FLAGS_NONE: Specifies no hints about how this
* resource will be used. It is therefore assumed that this resource will be
* read from and written to by CUDA kernels. This is the default value.
* - ::CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY: Specifies that CUDA kernels which
* access this resource will not write to this resource.
* - ::CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD: Specifies that CUDA kernels
* which access this resource will not read from this resource and will
* write over the entire contents of the resource, so none of the data
* previously stored in the resource will be preserved.
*
* If \p buffer has not been registered for use with CUDA, then
* ::CUDA_ERROR_INVALID_HANDLE is returned. If \p buffer is presently
* mapped for access by CUDA, then ::CUDA_ERROR_ALREADY_MAPPED is returned.
*
* There must be a valid OpenGL context bound to the current thread
* when this function is called. This must be the same context, or a
* member of the same shareGroup, as the context that was bound when
* the buffer was registered.
*
* \param buffer - Buffer object to unmap
* \param Flags - Map flags
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_HANDLE,
* ::CUDA_ERROR_ALREADY_MAPPED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* \notefnerr
*
* \sa ::cuGraphicsResourceSetMapFlags
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLSetBufferObjectMapFlags(GLuint buffer, unsigned int Flags);
/**
* \brief Maps an OpenGL buffer object
*
* \deprecated This function is deprecated as of Cuda 3.0.
*
* Maps the buffer object specified by \p buffer into the address space of the
* current CUDA context and returns in \p *dptr and \p *size the base pointer
* and size of the resulting mapping.
*
* There must be a valid OpenGL context bound to the current thread
* when this function is called. This must be the same context, or a
* member of the same shareGroup, as the context that was bound when
* the buffer was registered.
*
* Stream \p hStream in the current CUDA context is synchronized with
* the current GL context.
*
* \param dptr - Returned mapped base pointer
* \param size - Returned size of mapping
* \param buffer - The name of the buffer object to map
* \param hStream - Stream to synchronize
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_INVALID_VALUE,
* ::CUDA_ERROR_MAP_FAILED
* \notefnerr
*
* \sa ::cuGraphicsMapResources
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLMapBufferObjectAsync(CUdeviceptr *dptr, size_t *size, GLuint buffer, CUstream hStream);
/**
* \brief Unmaps an OpenGL buffer object
*
* \deprecated This function is deprecated as of Cuda 3.0.
*
* Unmaps the buffer object specified by \p buffer for access by CUDA.
*
* There must be a valid OpenGL context bound to the current thread
* when this function is called. This must be the same context, or a
* member of the same shareGroup, as the context that was bound when
* the buffer was registered.
*
* Stream \p hStream in the current CUDA context is synchronized with
* the current GL context.
*
* \param buffer - Name of the buffer object to unmap
* \param hStream - Stream to synchronize
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_DEINITIALIZED,
* ::CUDA_ERROR_NOT_INITIALIZED,
* ::CUDA_ERROR_INVALID_CONTEXT,
* ::CUDA_ERROR_INVALID_VALUE
* \notefnerr
*
* \sa ::cuGraphicsUnmapResources
*/
__CUDA_DEPRECATED CUresult CUDAAPI cuGLUnmapBufferObjectAsync(GLuint buffer, CUstream hStream);
/** @} */ /* END CUDA_GL_DEPRECATED */
/** @} */ /* END CUDA_GL */
#if defined(__CUDA_API_VERSION_INTERNAL)
#undef cuGLCtxCreate
#undef cuGLMapBufferObject
#undef cuGLMapBufferObjectAsync
#undef cuGLGetDevices
CUresult CUDAAPI cuGLGetDevices(unsigned int *pCudaDeviceCount, CUdevice *pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList);
CUresult CUDAAPI cuGLMapBufferObject_v2(CUdeviceptr *dptr, size_t *size, GLuint buffer);
CUresult CUDAAPI cuGLMapBufferObjectAsync_v2(CUdeviceptr *dptr, size_t *size, GLuint buffer, CUstream hStream);
CUresult CUDAAPI cuGLCtxCreate(CUcontext *pCtx, unsigned int Flags, CUdevice device );
CUresult CUDAAPI cuGLMapBufferObject(CUdeviceptr_v1 *dptr, unsigned int *size, GLuint buffer);
CUresult CUDAAPI cuGLMapBufferObjectAsync(CUdeviceptr_v1 *dptr, unsigned int *size, GLuint buffer, CUstream hStream);
#endif /* __CUDA_API_VERSION_INTERNAL */
#ifdef __cplusplus
};
#endif
#undef __CUDA_DEPRECATED
#endif