LCOV - code coverage report
Current view: top level - src/compat/cuda - dynlink_loader.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 51 0.0 %
Date: 2017-07-20 10:18:08 Functions: 0 6 0.0 %

          Line data    Source code
       1             : /*
       2             :  * This copyright notice applies to this header file only:
       3             :  *
       4             :  * Copyright (c) 2016
       5             :  *
       6             :  * Permission is hereby granted, free of charge, to any person
       7             :  * obtaining a copy of this software and associated documentation
       8             :  * files (the "Software"), to deal in the Software without
       9             :  * restriction, including without limitation the rights to use,
      10             :  * copy, modify, merge, publish, distribute, sublicense, and/or sell
      11             :  * copies of the software, and to permit persons to whom the
      12             :  * software is furnished to do so, subject to the following
      13             :  * conditions:
      14             :  *
      15             :  * The above copyright notice and this permission notice shall be
      16             :  * included in all copies or substantial portions of the Software.
      17             :  *
      18             :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      19             :  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      20             :  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      21             :  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      22             :  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      23             :  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      24             :  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      25             :  * OTHER DEALINGS IN THE SOFTWARE.
      26             :  */
      27             : 
      28             : #ifndef AV_COMPAT_CUDA_DYNLINK_LOADER_H
      29             : #define AV_COMPAT_CUDA_DYNLINK_LOADER_H
      30             : 
      31             : #include "compat/cuda/dynlink_cuda.h"
      32             : #include "compat/cuda/dynlink_nvcuvid.h"
      33             : #include "compat/nvenc/nvEncodeAPI.h"
      34             : #include "compat/w32dlfcn.h"
      35             : 
      36             : #include "libavutil/log.h"
      37             : #include "libavutil/error.h"
      38             : 
      39             : #if defined(_WIN32)
      40             : # define LIB_HANDLE HMODULE
      41             : #else
      42             : # define LIB_HANDLE void*
      43             : #endif
      44             : 
      45             : #if defined(_WIN32) || defined(__CYGWIN__)
      46             : # define CUDA_LIBNAME "nvcuda.dll"
      47             : # define NVCUVID_LIBNAME "nvcuvid.dll"
      48             : # if ARCH_X86_64
      49             : #  define NVENC_LIBNAME "nvEncodeAPI64.dll"
      50             : # else
      51             : #  define NVENC_LIBNAME "nvEncodeAPI.dll"
      52             : # endif
      53             : #else
      54             : # define CUDA_LIBNAME "libcuda.so.1"
      55             : # define NVCUVID_LIBNAME "libnvcuvid.so.1"
      56             : # define NVENC_LIBNAME "libnvidia-encode.so.1"
      57             : #endif
      58             : 
      59             : #define LOAD_LIBRARY(l, path)                                     \
      60             :     do {                                                          \
      61             :         if (!((l) = dlopen(path, RTLD_LAZY))) {                   \
      62             :             av_log(NULL, AV_LOG_ERROR, "Cannot load %s\n", path); \
      63             :             ret = AVERROR_UNKNOWN;                                \
      64             :             goto error;                                           \
      65             :         }                                                         \
      66             :         av_log(NULL, AV_LOG_TRACE, "Loaded lib: %s\n", path);     \
      67             :     } while (0)
      68             : 
      69             : #define LOAD_SYMBOL(fun, tp, symbol)                                \
      70             :     do {                                                            \
      71             :         if (!((f->fun) = (tp*)dlsym(f->lib, symbol))) {             \
      72             :             av_log(NULL, AV_LOG_ERROR, "Cannot load %s\n", symbol); \
      73             :             ret = AVERROR_UNKNOWN;                                  \
      74             :             goto error;                                             \
      75             :         }                                                           \
      76             :         av_log(NULL, AV_LOG_TRACE, "Loaded sym: %s\n", symbol);     \
      77             :     } while (0)
      78             : 
      79             : #define LOAD_SYMBOL_OPT(fun, tp, symbol)                                     \
      80             :     do {                                                                     \
      81             :         if (!((f->fun) = (tp*)dlsym(f->lib, symbol))) {                      \
      82             :             av_log(NULL, AV_LOG_DEBUG, "Cannot load optional %s\n", symbol); \
      83             :         } else {                                                             \
      84             :             av_log(NULL, AV_LOG_TRACE, "Loaded sym: %s\n", symbol);          \
      85             :         }                                                                    \
      86             :     } while (0)
      87             : 
      88             : #define GENERIC_LOAD_FUNC_PREAMBLE(T, n, N)  \
      89             :     T *f;                                    \
      90             :     int ret;                                 \
      91             :                                              \
      92             :     n##_free_functions(functions);           \
      93             :                                              \
      94             :     f = *functions = av_mallocz(sizeof(*f)); \
      95             :     if (!f)                                  \
      96             :         return AVERROR(ENOMEM);              \
      97             :                                              \
      98             :     LOAD_LIBRARY(f->lib, N);
      99             : 
     100             : #define GENERIC_LOAD_FUNC_FINALE(n) \
     101             :     return 0;                       \
     102             : error:                              \
     103             :     n##_free_functions(functions);  \
     104             :     return ret;
     105             : 
     106             : #define GENERIC_FREE_FUNC()              \
     107             :     if (!functions)                      \
     108             :         return;                          \
     109             :     if (*functions && (*functions)->lib) \
     110             :         dlclose((*functions)->lib);      \
     111             :     av_freep(functions);
     112             : 
     113             : #ifdef AV_COMPAT_DYNLINK_CUDA_H
     114             : typedef struct CudaFunctions {
     115             :     tcuInit *cuInit;
     116             :     tcuDeviceGetCount *cuDeviceGetCount;
     117             :     tcuDeviceGet *cuDeviceGet;
     118             :     tcuDeviceGetName *cuDeviceGetName;
     119             :     tcuDeviceComputeCapability *cuDeviceComputeCapability;
     120             :     tcuCtxCreate_v2 *cuCtxCreate;
     121             :     tcuCtxPushCurrent_v2 *cuCtxPushCurrent;
     122             :     tcuCtxPopCurrent_v2 *cuCtxPopCurrent;
     123             :     tcuCtxDestroy_v2 *cuCtxDestroy;
     124             :     tcuMemAlloc_v2 *cuMemAlloc;
     125             :     tcuMemFree_v2 *cuMemFree;
     126             :     tcuMemcpy2D_v2 *cuMemcpy2D;
     127             :     tcuGetErrorName *cuGetErrorName;
     128             :     tcuGetErrorString *cuGetErrorString;
     129             : 
     130             :     LIB_HANDLE lib;
     131             : } CudaFunctions;
     132             : #else
     133             : typedef struct CudaFunctions CudaFunctions;
     134             : #endif
     135             : 
     136             : typedef struct CuvidFunctions {
     137             :     tcuvidGetDecoderCaps *cuvidGetDecoderCaps;
     138             :     tcuvidCreateDecoder *cuvidCreateDecoder;
     139             :     tcuvidDestroyDecoder *cuvidDestroyDecoder;
     140             :     tcuvidDecodePicture *cuvidDecodePicture;
     141             :     tcuvidMapVideoFrame *cuvidMapVideoFrame;
     142             :     tcuvidUnmapVideoFrame *cuvidUnmapVideoFrame;
     143             :     tcuvidCtxLockCreate *cuvidCtxLockCreate;
     144             :     tcuvidCtxLockDestroy *cuvidCtxLockDestroy;
     145             :     tcuvidCtxLock *cuvidCtxLock;
     146             :     tcuvidCtxUnlock *cuvidCtxUnlock;
     147             : 
     148             :     tcuvidCreateVideoSource *cuvidCreateVideoSource;
     149             :     tcuvidCreateVideoSourceW *cuvidCreateVideoSourceW;
     150             :     tcuvidDestroyVideoSource *cuvidDestroyVideoSource;
     151             :     tcuvidSetVideoSourceState *cuvidSetVideoSourceState;
     152             :     tcuvidGetVideoSourceState *cuvidGetVideoSourceState;
     153             :     tcuvidGetSourceVideoFormat *cuvidGetSourceVideoFormat;
     154             :     tcuvidGetSourceAudioFormat *cuvidGetSourceAudioFormat;
     155             :     tcuvidCreateVideoParser *cuvidCreateVideoParser;
     156             :     tcuvidParseVideoData *cuvidParseVideoData;
     157             :     tcuvidDestroyVideoParser *cuvidDestroyVideoParser;
     158             : 
     159             :     LIB_HANDLE lib;
     160             : } CuvidFunctions;
     161             : 
     162             : typedef NVENCSTATUS NVENCAPI tNvEncodeAPICreateInstance(NV_ENCODE_API_FUNCTION_LIST *functionList);
     163             : typedef NVENCSTATUS NVENCAPI tNvEncodeAPIGetMaxSupportedVersion(uint32_t* version);
     164             : 
     165             : typedef struct NvencFunctions {
     166             :     tNvEncodeAPICreateInstance *NvEncodeAPICreateInstance;
     167             :     tNvEncodeAPIGetMaxSupportedVersion *NvEncodeAPIGetMaxSupportedVersion;
     168             : 
     169             :     LIB_HANDLE lib;
     170             : } NvencFunctions;
     171             : 
     172             : #ifdef AV_COMPAT_DYNLINK_CUDA_H
     173           0 : static inline void cuda_free_functions(CudaFunctions **functions)
     174             : {
     175           0 :     GENERIC_FREE_FUNC();
     176             : }
     177             : #endif
     178             : 
     179           0 : static inline void cuvid_free_functions(CuvidFunctions **functions)
     180             : {
     181           0 :     GENERIC_FREE_FUNC();
     182             : }
     183             : 
     184           0 : static inline void nvenc_free_functions(NvencFunctions **functions)
     185             : {
     186           0 :     GENERIC_FREE_FUNC();
     187             : }
     188             : 
     189             : #ifdef AV_COMPAT_DYNLINK_CUDA_H
     190           0 : static inline int cuda_load_functions(CudaFunctions **functions)
     191             : {
     192           0 :     GENERIC_LOAD_FUNC_PREAMBLE(CudaFunctions, cuda, CUDA_LIBNAME);
     193             : 
     194           0 :     LOAD_SYMBOL(cuInit, tcuInit, "cuInit");
     195           0 :     LOAD_SYMBOL(cuDeviceGetCount, tcuDeviceGetCount, "cuDeviceGetCount");
     196           0 :     LOAD_SYMBOL(cuDeviceGet, tcuDeviceGet, "cuDeviceGet");
     197           0 :     LOAD_SYMBOL(cuDeviceGetName, tcuDeviceGetName, "cuDeviceGetName");
     198           0 :     LOAD_SYMBOL(cuDeviceComputeCapability, tcuDeviceComputeCapability, "cuDeviceComputeCapability");
     199           0 :     LOAD_SYMBOL(cuCtxCreate, tcuCtxCreate_v2, "cuCtxCreate_v2");
     200           0 :     LOAD_SYMBOL(cuCtxPushCurrent, tcuCtxPushCurrent_v2, "cuCtxPushCurrent_v2");
     201           0 :     LOAD_SYMBOL(cuCtxPopCurrent, tcuCtxPopCurrent_v2, "cuCtxPopCurrent_v2");
     202           0 :     LOAD_SYMBOL(cuCtxDestroy, tcuCtxDestroy_v2, "cuCtxDestroy_v2");
     203           0 :     LOAD_SYMBOL(cuMemAlloc, tcuMemAlloc_v2, "cuMemAlloc_v2");
     204           0 :     LOAD_SYMBOL(cuMemFree, tcuMemFree_v2, "cuMemFree_v2");
     205           0 :     LOAD_SYMBOL(cuMemcpy2D, tcuMemcpy2D_v2, "cuMemcpy2D_v2");
     206           0 :     LOAD_SYMBOL(cuGetErrorName, tcuGetErrorName, "cuGetErrorName");
     207           0 :     LOAD_SYMBOL(cuGetErrorString, tcuGetErrorString, "cuGetErrorString");
     208             : 
     209           0 :     GENERIC_LOAD_FUNC_FINALE(cuda);
     210             : }
     211             : #endif
     212             : 
     213           0 : static inline int cuvid_load_functions(CuvidFunctions **functions)
     214             : {
     215           0 :     GENERIC_LOAD_FUNC_PREAMBLE(CuvidFunctions, cuvid, NVCUVID_LIBNAME);
     216             : 
     217           0 :     LOAD_SYMBOL_OPT(cuvidGetDecoderCaps, tcuvidGetDecoderCaps, "cuvidGetDecoderCaps");
     218           0 :     LOAD_SYMBOL(cuvidCreateDecoder, tcuvidCreateDecoder, "cuvidCreateDecoder");
     219           0 :     LOAD_SYMBOL(cuvidDestroyDecoder, tcuvidDestroyDecoder, "cuvidDestroyDecoder");
     220           0 :     LOAD_SYMBOL(cuvidDecodePicture, tcuvidDecodePicture, "cuvidDecodePicture");
     221             : #ifdef __CUVID_DEVPTR64
     222           0 :     LOAD_SYMBOL(cuvidMapVideoFrame, tcuvidMapVideoFrame, "cuvidMapVideoFrame64");
     223           0 :     LOAD_SYMBOL(cuvidUnmapVideoFrame, tcuvidUnmapVideoFrame, "cuvidUnmapVideoFrame64");
     224             : #else
     225             :     LOAD_SYMBOL(cuvidMapVideoFrame, tcuvidMapVideoFrame, "cuvidMapVideoFrame");
     226             :     LOAD_SYMBOL(cuvidUnmapVideoFrame, tcuvidUnmapVideoFrame, "cuvidUnmapVideoFrame");
     227             : #endif
     228           0 :     LOAD_SYMBOL(cuvidCtxLockCreate, tcuvidCtxLockCreate, "cuvidCtxLockCreate");
     229           0 :     LOAD_SYMBOL(cuvidCtxLockDestroy, tcuvidCtxLockDestroy, "cuvidCtxLockDestroy");
     230           0 :     LOAD_SYMBOL(cuvidCtxLock, tcuvidCtxLock, "cuvidCtxLock");
     231           0 :     LOAD_SYMBOL(cuvidCtxUnlock, tcuvidCtxUnlock, "cuvidCtxUnlock");
     232             : 
     233           0 :     LOAD_SYMBOL(cuvidCreateVideoSource, tcuvidCreateVideoSource, "cuvidCreateVideoSource");
     234           0 :     LOAD_SYMBOL(cuvidCreateVideoSourceW, tcuvidCreateVideoSourceW, "cuvidCreateVideoSourceW");
     235           0 :     LOAD_SYMBOL(cuvidDestroyVideoSource, tcuvidDestroyVideoSource, "cuvidDestroyVideoSource");
     236           0 :     LOAD_SYMBOL(cuvidSetVideoSourceState, tcuvidSetVideoSourceState, "cuvidSetVideoSourceState");
     237           0 :     LOAD_SYMBOL(cuvidGetVideoSourceState, tcuvidGetVideoSourceState, "cuvidGetVideoSourceState");
     238           0 :     LOAD_SYMBOL(cuvidGetSourceVideoFormat, tcuvidGetSourceVideoFormat, "cuvidGetSourceVideoFormat");
     239           0 :     LOAD_SYMBOL(cuvidGetSourceAudioFormat, tcuvidGetSourceAudioFormat, "cuvidGetSourceAudioFormat");
     240           0 :     LOAD_SYMBOL(cuvidCreateVideoParser, tcuvidCreateVideoParser, "cuvidCreateVideoParser");
     241           0 :     LOAD_SYMBOL(cuvidParseVideoData, tcuvidParseVideoData, "cuvidParseVideoData");
     242           0 :     LOAD_SYMBOL(cuvidDestroyVideoParser, tcuvidDestroyVideoParser, "cuvidDestroyVideoParser");
     243             : 
     244           0 :     GENERIC_LOAD_FUNC_FINALE(cuvid);
     245             : }
     246             : 
     247           0 : static inline int nvenc_load_functions(NvencFunctions **functions)
     248             : {
     249           0 :     GENERIC_LOAD_FUNC_PREAMBLE(NvencFunctions, nvenc, NVENC_LIBNAME);
     250             : 
     251           0 :     LOAD_SYMBOL(NvEncodeAPICreateInstance, tNvEncodeAPICreateInstance, "NvEncodeAPICreateInstance");
     252           0 :     LOAD_SYMBOL(NvEncodeAPIGetMaxSupportedVersion, tNvEncodeAPIGetMaxSupportedVersion, "NvEncodeAPIGetMaxSupportedVersion");
     253             : 
     254           0 :     GENERIC_LOAD_FUNC_FINALE(nvenc);
     255             : }
     256             : 
     257             : #undef GENERIC_LOAD_FUNC_PREAMBLE
     258             : #undef LOAD_LIBRARY
     259             : #undef LOAD_SYMBOL
     260             : #undef GENERIC_LOAD_FUNC_FINALE
     261             : #undef GENERIC_FREE_FUNC
     262             : #undef CUDA_LIBNAME
     263             : #undef NVCUVID_LIBNAME
     264             : #undef NVENC_LIBNAME
     265             : #undef LIB_HANDLE
     266             : 
     267             : #endif
     268             : 

Generated by: LCOV version 1.13