subprojects/gst-plugins-bad/sys/nvcodec/gstcudaloader.c

   1 /* GStreamer
   2  * Copyright (C) 2019 Seungha Yang <seungha.yang@navercorp.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "gstcudaloader.h"
  25 #include <gmodule.h>
  26
  27 GST_DEBUG_CATEGORY_EXTERN (gst_nvcodec_debug);
  28 #define GST_CAT_DEFAULT gst_nvcodec_debug
  29
  30 #ifndef G_OS_WIN32
  31 #define CUDA_LIBNAME "libcuda.so.1"
  32 #else
  33 #define CUDA_LIBNAME "nvcuda.dll"
  34 #endif
  35
  36 #define LOAD_SYMBOL(name,func) G_STMT_START { \
  37   if (!g_module_symbol (module, G_STRINGIFY (name), (gpointer *) &vtable->func)) { \
  38     GST_ERROR ("Failed to load '%s' from %s, %s", G_STRINGIFY (name), filename, g_module_error()); \
  39     goto error; \
  40   } \
  41 } G_STMT_END;
  42
  43 /* *INDENT-OFF* */
  44 typedef struct _GstNvCodecCudaVTable
  45 {
  46   gboolean loaded;
  47
  48   CUresult (CUDAAPI * CuInit) (unsigned int Flags);
  49   CUresult (CUDAAPI * CuGetErrorName) (CUresult error, const char **pStr);
  50   CUresult (CUDAAPI * CuGetErrorString) (CUresult error, const char **pStr);
  51
  52   CUresult (CUDAAPI * CuCtxCreate) (CUcontext * pctx, unsigned int flags,
  53       CUdevice dev);
  54   CUresult (CUDAAPI * CuCtxDestroy) (CUcontext ctx);
  55   CUresult (CUDAAPI * CuCtxPopCurrent) (CUcontext * pctx);
  56   CUresult (CUDAAPI * CuCtxPushCurrent) (CUcontext ctx);
  57
  58   CUresult (CUDAAPI * CuCtxEnablePeerAccess) (CUcontext peerContext,
  59       unsigned int Flags);
  60   CUresult (CUDAAPI * CuCtxDisablePeerAccess) (CUcontext peerContext);
  61   CUresult (CUDAAPI * CuGraphicsMapResources) (unsigned int count,
  62       CUgraphicsResource * resources, CUstream hStream);
  63   CUresult (CUDAAPI * CuGraphicsUnmapResources) (unsigned int count,
  64       CUgraphicsResource * resources, CUstream hStream);
  65   CUresult (CUDAAPI *
  66       CuGraphicsResourceSetMapFlags) (CUgraphicsResource resource,
  67       unsigned int flags);
  68   CUresult (CUDAAPI * CuGraphicsSubResourceGetMappedArray) (CUarray * pArray,
  69       CUgraphicsResource resource, unsigned int arrayIndex,
  70       unsigned int mipLevel);
  71   CUresult (CUDAAPI * CuGraphicsResourceGetMappedPointer) (CUdeviceptr *
  72       pDevPtr, size_t * pSize, CUgraphicsResource resource);
  73   CUresult (CUDAAPI *
  74       CuGraphicsUnregisterResource) (CUgraphicsResource resource);
  75
  76   CUresult (CUDAAPI * CuMemAlloc) (CUdeviceptr * dptr, unsigned int bytesize);
  77   CUresult (CUDAAPI * CuMemAllocPitch) (CUdeviceptr * dptr, size_t * pPitch,
  78       size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes);
  79   CUresult (CUDAAPI * CuMemAllocHost) (void **pp, unsigned int bytesize);
  80   CUresult (CUDAAPI * CuMemcpy2D) (const CUDA_MEMCPY2D * pCopy);
  81   CUresult (CUDAAPI * CuMemcpy2DAsync) (const CUDA_MEMCPY2D * pCopy,
  82       CUstream hStream);
  83
  84   CUresult (CUDAAPI * CuMemFree) (CUdeviceptr dptr);
  85   CUresult (CUDAAPI * CuMemFreeHost) (void *p);
  86
  87   CUresult (CUDAAPI * CuStreamCreate) (CUstream * phStream,
  88       unsigned int Flags);
  89   CUresult (CUDAAPI * CuStreamDestroy) (CUstream hStream);
  90   CUresult (CUDAAPI * CuStreamSynchronize) (CUstream hStream);
  91
  92   CUresult (CUDAAPI * CuDeviceGet) (CUdevice * device, int ordinal);
  93   CUresult (CUDAAPI * CuDeviceGetCount) (int *count);
  94   CUresult (CUDAAPI * CuDeviceGetName) (char *name, int len, CUdevice dev);
  95   CUresult (CUDAAPI * CuDeviceGetAttribute) (int *pi,
  96       CUdevice_attribute attrib, CUdevice dev);
  97   CUresult (CUDAAPI * CuDeviceCanAccessPeer) (int *canAccessPeer,
  98       CUdevice dev, CUdevice peerDev);
  99   CUresult (CUDAAPI * CuDriverGetVersion) (int *driverVersion);
 100
 101   CUresult (CUDAAPI * CuModuleLoadData) (CUmodule * module,
 102       const void *image);
 103   CUresult (CUDAAPI * CuModuleUnload) (CUmodule module);
 104   CUresult (CUDAAPI * CuModuleGetFunction) (CUfunction * hfunc,
 105       CUmodule hmod, const char *name);
 106   CUresult (CUDAAPI * CuTexObjectCreate) (CUtexObject * pTexObject,
 107       const CUDA_RESOURCE_DESC * pResDesc, const CUDA_TEXTURE_DESC * pTexDesc,
 108       const CUDA_RESOURCE_VIEW_DESC * pResViewDesc);
 109   CUresult (CUDAAPI * CuTexObjectDestroy) (CUtexObject texObject);
 110   CUresult (CUDAAPI * CuLaunchKernel) (CUfunction f, unsigned int gridDimX,
 111       unsigned int gridDimY, unsigned int gridDimZ,
 112       unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ,
 113       unsigned int sharedMemBytes, CUstream hStream, void **kernelParams,
 114       void **extra);
 115
 116   CUresult (CUDAAPI * CuGraphicsGLRegisterImage) (CUgraphicsResource *
 117       pCudaResource, unsigned int image, unsigned int target,
 118       unsigned int Flags);
 119   CUresult (CUDAAPI * CuGraphicsGLRegisterBuffer) (CUgraphicsResource *
 120       pCudaResource, unsigned int buffer, unsigned int Flags);
 121   CUresult (CUDAAPI * CuGLGetDevices) (unsigned int *pCudaDeviceCount,
 122       CUdevice * pCudaDevices, unsigned int cudaDeviceCount,
 123       CUGLDeviceList deviceList);
 124
 125   CUresult (CUDAAPI * CuGraphicsD3D11RegisterResource) (CUgraphicsResource *
 126       pCudaResource, gpointer pD3DResource, unsigned int Flags);
 127   CUresult (CUDAAPI * CuD3D11GetDevice) (CUdevice * device,
 128       gpointer pAdapter);
 129   CUresult (CUDAAPI * CuD3D11GetDevices) (unsigned int *pCudaDeviceCount,
 130       CUdevice * pCudaDevices, unsigned int cudaDeviceCount,
 131       gpointer pD3D11Device, CUD3D11DeviceList deviceList);
 132 } GstNvCodecCudaVTable;
 133 /* *INDENT-ON* */
 134
 135 static GstNvCodecCudaVTable gst_cuda_vtable = { 0, };
 136
 137 gboolean
 138 gst_cuda_load_library (void)
 139 {
 140   GModule *module;
 141   const gchar *filename = CUDA_LIBNAME;
 142   GstNvCodecCudaVTable *vtable;
 143
 144   if (gst_cuda_vtable.loaded)
 145     return TRUE;
 146
 147   module = g_module_open (filename, G_MODULE_BIND_LAZY);
 148   if (module == NULL) {
 149     GST_WARNING ("Could not open library %s, %s", filename, g_module_error ());
 150     return FALSE;
 151   }
 152
 153   vtable = &gst_cuda_vtable;
 154
 155   /* cuda.h */
 156   LOAD_SYMBOL (cuInit, CuInit);
 157   LOAD_SYMBOL (cuGetErrorName, CuGetErrorName);
 158   LOAD_SYMBOL (cuGetErrorString, CuGetErrorString);
 159   LOAD_SYMBOL (cuCtxCreate, CuCtxCreate);
 160   LOAD_SYMBOL (cuCtxDestroy, CuCtxDestroy);
 161   LOAD_SYMBOL (cuCtxPopCurrent, CuCtxPopCurrent);
 162   LOAD_SYMBOL (cuCtxPushCurrent, CuCtxPushCurrent);
 163   LOAD_SYMBOL (cuCtxEnablePeerAccess, CuCtxEnablePeerAccess);
 164   LOAD_SYMBOL (cuCtxDisablePeerAccess, CuCtxDisablePeerAccess);
 165
 166   LOAD_SYMBOL (cuGraphicsMapResources, CuGraphicsMapResources);
 167   LOAD_SYMBOL (cuGraphicsUnmapResources, CuGraphicsUnmapResources);
 168   LOAD_SYMBOL (cuGraphicsResourceSetMapFlags, CuGraphicsResourceSetMapFlags);
 169   LOAD_SYMBOL (cuGraphicsSubResourceGetMappedArray,
 170       CuGraphicsSubResourceGetMappedArray);
 171   LOAD_SYMBOL (cuGraphicsResourceGetMappedPointer,
 172       CuGraphicsResourceGetMappedPointer);
 173   LOAD_SYMBOL (cuGraphicsUnregisterResource, CuGraphicsUnregisterResource);
 174
 175   LOAD_SYMBOL (cuMemAlloc, CuMemAlloc);
 176   LOAD_SYMBOL (cuMemAllocPitch, CuMemAllocPitch);
 177   LOAD_SYMBOL (cuMemAllocHost, CuMemAllocHost);
 178   LOAD_SYMBOL (cuMemcpy2D, CuMemcpy2D);
 179   LOAD_SYMBOL (cuMemcpy2DAsync, CuMemcpy2DAsync);
 180
 181   LOAD_SYMBOL (cuMemFree, CuMemFree);
 182   LOAD_SYMBOL (cuMemFreeHost, CuMemFreeHost);
 183
 184   LOAD_SYMBOL (cuStreamCreate, CuStreamCreate);
 185   LOAD_SYMBOL (cuStreamDestroy, CuStreamDestroy);
 186   LOAD_SYMBOL (cuStreamSynchronize, CuStreamSynchronize);
 187
 188   LOAD_SYMBOL (cuDeviceGet, CuDeviceGet);
 189   LOAD_SYMBOL (cuDeviceGetCount, CuDeviceGetCount);
 190   LOAD_SYMBOL (cuDeviceGetName, CuDeviceGetName);
 191   LOAD_SYMBOL (cuDeviceGetAttribute, CuDeviceGetAttribute);
 192   LOAD_SYMBOL (cuDeviceCanAccessPeer, CuDeviceCanAccessPeer);
 193
 194   LOAD_SYMBOL (cuDriverGetVersion, CuDriverGetVersion);
 195
 196   LOAD_SYMBOL (cuModuleLoadData, CuModuleLoadData);
 197   LOAD_SYMBOL (cuModuleUnload, CuModuleUnload);
 198   LOAD_SYMBOL (cuModuleGetFunction, CuModuleGetFunction);
 199   LOAD_SYMBOL (cuTexObjectCreate, CuTexObjectCreate);
 200   LOAD_SYMBOL (cuTexObjectDestroy, CuTexObjectDestroy);
 201   LOAD_SYMBOL (cuLaunchKernel, CuLaunchKernel);
 202
 203   /* cudaGL.h */
 204   LOAD_SYMBOL (cuGraphicsGLRegisterImage, CuGraphicsGLRegisterImage);
 205   LOAD_SYMBOL (cuGraphicsGLRegisterBuffer, CuGraphicsGLRegisterBuffer);
 206   LOAD_SYMBOL (cuGLGetDevices, CuGLGetDevices);
 207
 208 #ifdef HAVE_NVCODEC_GST_D3D11
 209   /* cudaD3D11.h */
 210   LOAD_SYMBOL (cuGraphicsD3D11RegisterResource,
 211       CuGraphicsD3D11RegisterResource);
 212   LOAD_SYMBOL (cuD3D11GetDevice, CuD3D11GetDevice);
 213   LOAD_SYMBOL (cuD3D11GetDevices, CuD3D11GetDevices);
 214 #endif
 215
 216   vtable->loaded = TRUE;
 217
 218   return TRUE;
 219
 220 error:
 221   g_module_close (module);
 222
 223   return FALSE;
 224 }
 225
 226 CUresult CUDAAPI
 227 CuInit (unsigned int Flags)
 228 {
 229   g_assert (gst_cuda_vtable.CuInit != NULL);
 230
 231   return gst_cuda_vtable.CuInit (Flags);
 232 }
 233
 234 CUresult CUDAAPI
 235 CuGetErrorName (CUresult error, const char **pStr)
 236 {
 237   g_assert (gst_cuda_vtable.CuGetErrorName != NULL);
 238
 239   return gst_cuda_vtable.CuGetErrorName (error, pStr);
 240 }
 241
 242 CUresult CUDAAPI
 243 CuGetErrorString (CUresult error, const char **pStr)
 244 {
 245   g_assert (gst_cuda_vtable.CuGetErrorString != NULL);
 246
 247   return gst_cuda_vtable.CuGetErrorString (error, pStr);
 248 }
 249
 250 CUresult CUDAAPI
 251 CuCtxCreate (CUcontext * pctx, unsigned int flags, CUdevice dev)
 252 {
 253   g_assert (gst_cuda_vtable.CuCtxCreate != NULL);
 254
 255   return gst_cuda_vtable.CuCtxCreate (pctx, flags, dev);
 256 }
 257
 258 CUresult CUDAAPI
 259 CuCtxDestroy (CUcontext ctx)
 260 {
 261   g_assert (gst_cuda_vtable.CuCtxDestroy != NULL);
 262
 263   return gst_cuda_vtable.CuCtxDestroy (ctx);
 264 }
 265
 266 CUresult CUDAAPI
 267 CuCtxPopCurrent (CUcontext * pctx)
 268 {
 269   g_assert (gst_cuda_vtable.CuCtxPopCurrent != NULL);
 270
 271   return gst_cuda_vtable.CuCtxPopCurrent (pctx);
 272 }
 273
 274 CUresult CUDAAPI
 275 CuCtxPushCurrent (CUcontext ctx)
 276 {
 277   g_assert (gst_cuda_vtable.CuCtxPushCurrent != NULL);
 278
 279   return gst_cuda_vtable.CuCtxPushCurrent (ctx);
 280 }
 281
 282 CUresult CUDAAPI
 283 CuCtxEnablePeerAccess (CUcontext peerContext, unsigned int Flags)
 284 {
 285   g_assert (gst_cuda_vtable.CuCtxEnablePeerAccess != NULL);
 286
 287   return gst_cuda_vtable.CuCtxEnablePeerAccess (peerContext, Flags);
 288 }
 289
 290 CUresult CUDAAPI
 291 CuCtxDisablePeerAccess (CUcontext peerContext)
 292 {
 293   g_assert (gst_cuda_vtable.CuCtxDisablePeerAccess != NULL);
 294
 295   return gst_cuda_vtable.CuCtxDisablePeerAccess (peerContext);
 296 }
 297
 298 CUresult CUDAAPI
 299 CuGraphicsMapResources (unsigned int count, CUgraphicsResource * resources,
 300     CUstream hStream)
 301 {
 302   g_assert (gst_cuda_vtable.CuGraphicsMapResources != NULL);
 303
 304   return gst_cuda_vtable.CuGraphicsMapResources (count, resources, hStream);
 305 }
 306
 307 CUresult CUDAAPI
 308 CuGraphicsUnmapResources (unsigned int count, CUgraphicsResource * resources,
 309     CUstream hStream)
 310 {
 311   g_assert (gst_cuda_vtable.CuGraphicsUnmapResources != NULL);
 312
 313   return gst_cuda_vtable.CuGraphicsUnmapResources (count, resources, hStream);
 314 }
 315
 316 CUresult CUDAAPI
 317 CuGraphicsResourceSetMapFlags (CUgraphicsResource resource, unsigned int flags)
 318 {
 319   g_assert (gst_cuda_vtable.CuGraphicsResourceSetMapFlags != NULL);
 320
 321   return gst_cuda_vtable.CuGraphicsResourceSetMapFlags (resource, flags);
 322 }
 323
 324 CUresult CUDAAPI
 325 CuGraphicsSubResourceGetMappedArray (CUarray * pArray,
 326     CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel)
 327 {
 328   g_assert (gst_cuda_vtable.CuGraphicsSubResourceGetMappedArray != NULL);
 329
 330   return gst_cuda_vtable.CuGraphicsSubResourceGetMappedArray (pArray, resource,
 331       arrayIndex, mipLevel);
 332 }
 333
 334 /* *INDENT-OFF* */
 335 CUresult CUDAAPI
 336 CuGraphicsResourceGetMappedPointer (CUdeviceptr * pDevPtr, size_t * pSize,
 337     CUgraphicsResource resource)
 338 {
 339   g_assert (gst_cuda_vtable.CuGraphicsResourceGetMappedPointer != NULL);
 340
 341   return gst_cuda_vtable.CuGraphicsResourceGetMappedPointer (pDevPtr, pSize,
 342       resource);
 343 }
 344 /* *INDENT-ON* */
 345
 346 CUresult CUDAAPI
 347 CuGraphicsUnregisterResource (CUgraphicsResource resource)
 348 {
 349   g_assert (gst_cuda_vtable.CuGraphicsUnregisterResource != NULL);
 350
 351   return gst_cuda_vtable.CuGraphicsUnregisterResource (resource);
 352 }
 353
 354 CUresult CUDAAPI
 355 CuMemAlloc (CUdeviceptr * dptr, unsigned int bytesize)
 356 {
 357   g_assert (gst_cuda_vtable.CuMemAlloc != NULL);
 358
 359   return gst_cuda_vtable.CuMemAlloc (dptr, bytesize);
 360 }
 361
 362 /* *INDENT-OFF* */
 363 CUresult CUDAAPI
 364 CuMemAllocPitch (CUdeviceptr * dptr, size_t * pPitch, size_t WidthInBytes,
 365     size_t Height, unsigned int ElementSizeBytes)
 366 {
 367   g_assert (gst_cuda_vtable.CuMemAllocPitch != NULL);
 368
 369   return gst_cuda_vtable.CuMemAllocPitch (dptr, pPitch, WidthInBytes, Height,
 370       ElementSizeBytes);
 371 }
 372 /* *INDENT-ON* */
 373
 374 CUresult CUDAAPI
 375 CuMemAllocHost (void **pp, unsigned int bytesize)
 376 {
 377   g_assert (gst_cuda_vtable.CuMemAllocHost != NULL);
 378
 379   return gst_cuda_vtable.CuMemAllocHost (pp, bytesize);
 380 }
 381
 382 CUresult CUDAAPI
 383 CuMemcpy2D (const CUDA_MEMCPY2D * pCopy)
 384 {
 385   g_assert (gst_cuda_vtable.CuMemcpy2D != NULL);
 386
 387   return gst_cuda_vtable.CuMemcpy2D (pCopy);
 388 }
 389
 390 CUresult CUDAAPI
 391 CuMemcpy2DAsync (const CUDA_MEMCPY2D * pCopy, CUstream hStream)
 392 {
 393   g_assert (gst_cuda_vtable.CuMemcpy2DAsync != NULL);
 394
 395   return gst_cuda_vtable.CuMemcpy2DAsync (pCopy, hStream);
 396 }
 397
 398 CUresult CUDAAPI
 399 CuMemFree (CUdeviceptr dptr)
 400 {
 401   g_assert (gst_cuda_vtable.CuMemFree != NULL);
 402
 403   return gst_cuda_vtable.CuMemFree (dptr);
 404 }
 405
 406 CUresult CUDAAPI
 407 CuMemFreeHost (void *p)
 408 {
 409   g_assert (gst_cuda_vtable.CuMemFreeHost != NULL);
 410
 411   return gst_cuda_vtable.CuMemFreeHost (p);
 412 }
 413
 414 CUresult CUDAAPI
 415 CuStreamCreate (CUstream * phStream, unsigned int Flags)
 416 {
 417   g_assert (gst_cuda_vtable.CuStreamCreate != NULL);
 418
 419   return gst_cuda_vtable.CuStreamCreate (phStream, Flags);
 420 }
 421
 422 CUresult CUDAAPI
 423 CuStreamDestroy (CUstream hStream)
 424 {
 425   g_assert (gst_cuda_vtable.CuStreamDestroy != NULL);
 426
 427   return gst_cuda_vtable.CuStreamDestroy (hStream);
 428 }
 429
 430 CUresult CUDAAPI
 431 CuStreamSynchronize (CUstream hStream)
 432 {
 433   g_assert (gst_cuda_vtable.CuStreamSynchronize != NULL);
 434
 435   return gst_cuda_vtable.CuStreamSynchronize (hStream);
 436 }
 437
 438 CUresult CUDAAPI
 439 CuDeviceGet (CUdevice * device, int ordinal)
 440 {
 441   g_assert (gst_cuda_vtable.CuDeviceGet != NULL);
 442
 443   return gst_cuda_vtable.CuDeviceGet (device, ordinal);
 444 }
 445
 446 CUresult CUDAAPI
 447 CuDeviceGetCount (int *count)
 448 {
 449   g_assert (gst_cuda_vtable.CuDeviceGetCount != NULL);
 450
 451   return gst_cuda_vtable.CuDeviceGetCount (count);
 452 }
 453
 454 CUresult CUDAAPI
 455 CuDeviceGetName (char *name, int len, CUdevice dev)
 456 {
 457   g_assert (gst_cuda_vtable.CuDeviceGetName != NULL);
 458
 459   return gst_cuda_vtable.CuDeviceGetName (name, len, dev);
 460 }
 461
 462 CUresult CUDAAPI
 463 CuDeviceGetAttribute (int *pi, CUdevice_attribute attrib, CUdevice dev)
 464 {
 465   g_assert (gst_cuda_vtable.CuDeviceGetAttribute != NULL);
 466
 467   return gst_cuda_vtable.CuDeviceGetAttribute (pi, attrib, dev);
 468 }
 469
 470 CUresult CUDAAPI
 471 CuDeviceCanAccessPeer (int *canAccessPeer, CUdevice dev, CUdevice peerDev)
 472 {
 473   g_assert (gst_cuda_vtable.CuDeviceCanAccessPeer != NULL);
 474
 475   return gst_cuda_vtable.CuDeviceCanAccessPeer (canAccessPeer, dev, peerDev);
 476 }
 477
 478 CUresult CUDAAPI
 479 CuDriverGetVersion (int *driverVersion)
 480 {
 481   g_assert (gst_cuda_vtable.CuDriverGetVersion != NULL);
 482
 483   return gst_cuda_vtable.CuDriverGetVersion (driverVersion);
 484 }
 485
 486 CUresult CUDAAPI
 487 CuModuleLoadData (CUmodule * module, const void *image)
 488 {
 489   g_assert (gst_cuda_vtable.CuModuleLoadData != NULL);
 490
 491   return gst_cuda_vtable.CuModuleLoadData (module, image);
 492 }
 493
 494 CUresult CUDAAPI
 495 CuModuleUnload (CUmodule module)
 496 {
 497   g_assert (gst_cuda_vtable.CuModuleUnload != NULL);
 498
 499   return gst_cuda_vtable.CuModuleUnload (module);
 500 }
 501
 502 CUresult CUDAAPI
 503 CuModuleGetFunction (CUfunction * hfunc, CUmodule hmod, const char *name)
 504 {
 505   g_assert (gst_cuda_vtable.CuModuleGetFunction != NULL);
 506
 507   return gst_cuda_vtable.CuModuleGetFunction (hfunc, hmod, name);
 508 }
 509
 510 CUresult CUDAAPI
 511 CuTexObjectCreate (CUtexObject * pTexObject,
 512     const CUDA_RESOURCE_DESC * pResDesc, const CUDA_TEXTURE_DESC * pTexDesc,
 513     const CUDA_RESOURCE_VIEW_DESC * pResViewDesc)
 514 {
 515   g_assert (gst_cuda_vtable.CuTexObjectCreate != NULL);
 516
 517   return gst_cuda_vtable.CuTexObjectCreate (pTexObject, pResDesc, pTexDesc,
 518       pResViewDesc);
 519 }
 520
 521 CUresult CUDAAPI
 522 CuTexObjectDestroy (CUtexObject texObject)
 523 {
 524   g_assert (gst_cuda_vtable.CuTexObjectDestroy != NULL);
 525
 526   return gst_cuda_vtable.CuTexObjectDestroy (texObject);
 527 }
 528
 529 CUresult CUDAAPI
 530 CuLaunchKernel (CUfunction f, unsigned int gridDimX,
 531     unsigned int gridDimY, unsigned int gridDimZ,
 532     unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ,
 533     unsigned int sharedMemBytes, CUstream hStream, void **kernelParams,
 534     void **extra)
 535 {
 536   g_assert (gst_cuda_vtable.CuLaunchKernel != NULL);
 537
 538   return gst_cuda_vtable.CuLaunchKernel (f, gridDimX, gridDimY, gridDimZ,
 539       blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams,
 540       extra);
 541 }
 542
 543 /* cudaGL.h */
 544 CUresult CUDAAPI
 545 CuGraphicsGLRegisterImage (CUgraphicsResource * pCudaResource,
 546     unsigned int image, unsigned int target, unsigned int Flags)
 547 {
 548   g_assert (gst_cuda_vtable.CuGraphicsGLRegisterImage != NULL);
 549
 550   return gst_cuda_vtable.CuGraphicsGLRegisterImage (pCudaResource, image,
 551       target, Flags);
 552 }
 553
 554 CUresult CUDAAPI
 555 CuGraphicsGLRegisterBuffer (CUgraphicsResource * pCudaResource,
 556     unsigned int buffer, unsigned int Flags)
 557 {
 558   g_assert (gst_cuda_vtable.CuGraphicsGLRegisterBuffer != NULL);
 559
 560   return gst_cuda_vtable.CuGraphicsGLRegisterBuffer (pCudaResource, buffer,
 561       Flags);
 562 }
 563
 564 CUresult CUDAAPI
 565 CuGLGetDevices (unsigned int *pCudaDeviceCount, CUdevice * pCudaDevices,
 566     unsigned int cudaDeviceCount, CUGLDeviceList deviceList)
 567 {
 568   g_assert (gst_cuda_vtable.CuGLGetDevices != NULL);
 569
 570   return gst_cuda_vtable.CuGLGetDevices (pCudaDeviceCount, pCudaDevices,
 571       cudaDeviceCount, deviceList);
 572 }
 573
 574 /* cudaD3D11.h */
 575 CUresult CUDAAPI
 576 CuGraphicsD3D11RegisterResource (CUgraphicsResource * pCudaResource,
 577     gpointer pD3DResource, unsigned int Flags)
 578 {
 579   g_assert (gst_cuda_vtable.CuGraphicsD3D11RegisterResource != NULL);
 580
 581   return gst_cuda_vtable.CuGraphicsD3D11RegisterResource (pCudaResource,
 582       pD3DResource, Flags);
 583 }
 584
 585 CUresult CUDAAPI
 586 CuD3D11GetDevice (CUdevice * device, gpointer pAdapter)
 587 {
 588   g_assert (gst_cuda_vtable.CuD3D11GetDevice != NULL);
 589
 590   return gst_cuda_vtable.CuD3D11GetDevice (device, pAdapter);
 591 }
 592
 593 CUresult CUDAAPI
 594 CuD3D11GetDevices (unsigned int *pCudaDeviceCount,
 595     CUdevice * pCudaDevices,
 596     unsigned int cudaDeviceCount,
 597     gpointer pD3D11Device, CUD3D11DeviceList deviceList)
 598 {
 599   g_assert (gst_cuda_vtable.CuD3D11GetDevices != NULL);
 600
 601   return gst_cuda_vtable.CuD3D11GetDevices (pCudaDeviceCount, pCudaDevices,
 602       cudaDeviceCount, pD3D11Device, deviceList);
 603 }