git.sesse.net Git - ffmpeg/blob - compat/cuda/dynlink_loader.h

   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 static inline void cuda_free_functions(CudaFunctions **functions)
 174 {
 175     GENERIC_FREE_FUNC();
 176 }
 177 #endif
 178
 179 static inline void cuvid_free_functions(CuvidFunctions **functions)
 180 {
 181     GENERIC_FREE_FUNC();
 182 }
 183
 184 static inline void nvenc_free_functions(NvencFunctions **functions)
 185 {
 186     GENERIC_FREE_FUNC();
 187 }
 188
 189 #ifdef AV_COMPAT_DYNLINK_CUDA_H
 190 static inline int cuda_load_functions(CudaFunctions **functions)
 191 {
 192     GENERIC_LOAD_FUNC_PREAMBLE(CudaFunctions, cuda, CUDA_LIBNAME);
 193
 194     LOAD_SYMBOL(cuInit, tcuInit, "cuInit");
 195     LOAD_SYMBOL(cuDeviceGetCount, tcuDeviceGetCount, "cuDeviceGetCount");
 196     LOAD_SYMBOL(cuDeviceGet, tcuDeviceGet, "cuDeviceGet");
 197     LOAD_SYMBOL(cuDeviceGetName, tcuDeviceGetName, "cuDeviceGetName");
 198     LOAD_SYMBOL(cuDeviceComputeCapability, tcuDeviceComputeCapability, "cuDeviceComputeCapability");
 199     LOAD_SYMBOL(cuCtxCreate, tcuCtxCreate_v2, "cuCtxCreate_v2");
 200     LOAD_SYMBOL(cuCtxPushCurrent, tcuCtxPushCurrent_v2, "cuCtxPushCurrent_v2");
 201     LOAD_SYMBOL(cuCtxPopCurrent, tcuCtxPopCurrent_v2, "cuCtxPopCurrent_v2");
 202     LOAD_SYMBOL(cuCtxDestroy, tcuCtxDestroy_v2, "cuCtxDestroy_v2");
 203     LOAD_SYMBOL(cuMemAlloc, tcuMemAlloc_v2, "cuMemAlloc_v2");
 204     LOAD_SYMBOL(cuMemFree, tcuMemFree_v2, "cuMemFree_v2");
 205     LOAD_SYMBOL(cuMemcpy2D, tcuMemcpy2D_v2, "cuMemcpy2D_v2");
 206     LOAD_SYMBOL(cuGetErrorName, tcuGetErrorName, "cuGetErrorName");
 207     LOAD_SYMBOL(cuGetErrorString, tcuGetErrorString, "cuGetErrorString");
 208
 209     GENERIC_LOAD_FUNC_FINALE(cuda);
 210 }
 211 #endif
 212
 213 static inline int cuvid_load_functions(CuvidFunctions **functions)
 214 {
 215     GENERIC_LOAD_FUNC_PREAMBLE(CuvidFunctions, cuvid, NVCUVID_LIBNAME);
 216
 217     LOAD_SYMBOL_OPT(cuvidGetDecoderCaps, tcuvidGetDecoderCaps, "cuvidGetDecoderCaps");
 218     LOAD_SYMBOL(cuvidCreateDecoder, tcuvidCreateDecoder, "cuvidCreateDecoder");
 219     LOAD_SYMBOL(cuvidDestroyDecoder, tcuvidDestroyDecoder, "cuvidDestroyDecoder");
 220     LOAD_SYMBOL(cuvidDecodePicture, tcuvidDecodePicture, "cuvidDecodePicture");
 221 #ifdef __CUVID_DEVPTR64
 222     LOAD_SYMBOL(cuvidMapVideoFrame, tcuvidMapVideoFrame, "cuvidMapVideoFrame64");
 223     LOAD_SYMBOL(cuvidUnmapVideoFrame, tcuvidUnmapVideoFrame, "cuvidUnmapVideoFrame64");
 224 #else
 225     LOAD_SYMBOL(cuvidMapVideoFrame, tcuvidMapVideoFrame, "cuvidMapVideoFrame");
 226     LOAD_SYMBOL(cuvidUnmapVideoFrame, tcuvidUnmapVideoFrame, "cuvidUnmapVideoFrame");
 227 #endif
 228     LOAD_SYMBOL(cuvidCtxLockCreate, tcuvidCtxLockCreate, "cuvidCtxLockCreate");
 229     LOAD_SYMBOL(cuvidCtxLockDestroy, tcuvidCtxLockDestroy, "cuvidCtxLockDestroy");
 230     LOAD_SYMBOL(cuvidCtxLock, tcuvidCtxLock, "cuvidCtxLock");
 231     LOAD_SYMBOL(cuvidCtxUnlock, tcuvidCtxUnlock, "cuvidCtxUnlock");
 232
 233     LOAD_SYMBOL(cuvidCreateVideoSource, tcuvidCreateVideoSource, "cuvidCreateVideoSource");
 234     LOAD_SYMBOL(cuvidCreateVideoSourceW, tcuvidCreateVideoSourceW, "cuvidCreateVideoSourceW");
 235     LOAD_SYMBOL(cuvidDestroyVideoSource, tcuvidDestroyVideoSource, "cuvidDestroyVideoSource");
 236     LOAD_SYMBOL(cuvidSetVideoSourceState, tcuvidSetVideoSourceState, "cuvidSetVideoSourceState");
 237     LOAD_SYMBOL(cuvidGetVideoSourceState, tcuvidGetVideoSourceState, "cuvidGetVideoSourceState");
 238     LOAD_SYMBOL(cuvidGetSourceVideoFormat, tcuvidGetSourceVideoFormat, "cuvidGetSourceVideoFormat");
 239     LOAD_SYMBOL(cuvidGetSourceAudioFormat, tcuvidGetSourceAudioFormat, "cuvidGetSourceAudioFormat");
 240     LOAD_SYMBOL(cuvidCreateVideoParser, tcuvidCreateVideoParser, "cuvidCreateVideoParser");
 241     LOAD_SYMBOL(cuvidParseVideoData, tcuvidParseVideoData, "cuvidParseVideoData");
 242     LOAD_SYMBOL(cuvidDestroyVideoParser, tcuvidDestroyVideoParser, "cuvidDestroyVideoParser");
 243
 244     GENERIC_LOAD_FUNC_FINALE(cuvid);
 245 }
 246
 247 static inline int nvenc_load_functions(NvencFunctions **functions)
 248 {
 249     GENERIC_LOAD_FUNC_PREAMBLE(NvencFunctions, nvenc, NVENC_LIBNAME);
 250
 251     LOAD_SYMBOL(NvEncodeAPICreateInstance, tNvEncodeAPICreateInstance, "NvEncodeAPICreateInstance");
 252     LOAD_SYMBOL(NvEncodeAPIGetMaxSupportedVersion, tNvEncodeAPIGetMaxSupportedVersion, "NvEncodeAPIGetMaxSupportedVersion");
 253
 254     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