| /* | |
| * This file is part of FFmpeg. | |
| * | |
| * FFmpeg is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * FFmpeg is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with FFmpeg; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
| */ | |
| #ifndef AVUTIL_VULKAN_LOADER_H | |
| #define AVUTIL_VULKAN_LOADER_H | |
| #include <stdio.h> | |
| #include "avassert.h" | |
| #include "vulkan_functions.h" | |
| /* Macro to turn a function name into a loader struct */ | |
| #define PFN_LOAD_INFO(req_inst, req_dev, ext_flag, name) \ | |
| { \ | |
| req_inst, \ | |
| req_dev, \ | |
| offsetof(FFVulkanFunctions, name), \ | |
| ext_flag, \ | |
| }, | |
| static inline uint64_t ff_vk_extensions_to_mask(const char * const *extensions, | |
| int nb_extensions) | |
| { | |
| static const struct ExtensionMap { | |
| const char *name; | |
| FFVulkanExtensions flag; | |
| } extension_map[] = { | |
| { VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_DMABUF_MEMORY }, | |
| { VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME, FF_VK_EXT_DRM_MODIFIER_FLAGS }, | |
| { VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_FD_MEMORY }, | |
| { VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_FD_SEM }, | |
| { VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_HOST_MEMORY }, | |
| { VK_EXT_DEBUG_UTILS_EXTENSION_NAME, FF_VK_EXT_DEBUG_UTILS }, | |
| { VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME, FF_VK_EXT_DEVICE_DRM }, | |
| { VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME, FF_VK_EXT_ATOMIC_FLOAT }, | |
| { VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME, FF_VK_EXT_COOP_MATRIX }, | |
| #ifdef _WIN32 | |
| { VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_WIN32_MEMORY }, | |
| { VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_WIN32_SEM }, | |
| #endif | |
| { VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME, FF_VK_EXT_DESCRIPTOR_BUFFER, }, | |
| { VK_KHR_VIDEO_QUEUE_EXTENSION_NAME, FF_VK_EXT_VIDEO_QUEUE }, | |
| { VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME, FF_VK_EXT_VIDEO_DECODE_QUEUE }, | |
| { VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME, FF_VK_EXT_VIDEO_DECODE_H264 }, | |
| { VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME, FF_VK_EXT_VIDEO_DECODE_H265 }, | |
| { VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME, FF_VK_EXT_VIDEO_DECODE_AV1 }, | |
| }; | |
| FFVulkanExtensions mask = 0x0; | |
| for (int i = 0; i < nb_extensions; i++) { | |
| for (int j = 0; j < FF_ARRAY_ELEMS(extension_map); j++) { | |
| if (!strcmp(extensions[i], extension_map[j].name)) { | |
| mask |= extension_map[j].flag; | |
| continue; | |
| } | |
| } | |
| } | |
| return mask; | |
| } | |
| /** | |
| * Function loader. | |
| * Vulkan function from scratch loading happens in 3 stages - the first one | |
| * is before any initialization has happened, and you have neither an instance | |
| * structure nor a device structure. At this stage, you can only get the bare | |
| * minimals to initialize an instance. | |
| * The second stage is when you have an instance. At this stage, you can | |
| * initialize a VkDevice, and have an idea of what extensions each device | |
| * supports. | |
| * Finally, in the third stage, you can proceed and load all core functions, | |
| * plus you can be sure that any extensions you've enabled during device | |
| * initialization will be available. | |
| */ | |
| static inline int ff_vk_load_functions(AVHWDeviceContext *ctx, | |
| FFVulkanFunctions *vk, | |
| uint64_t extensions_mask, | |
| int has_inst, int has_dev) | |
| { | |
| AVVulkanDeviceContext *hwctx = ctx->hwctx; | |
| static const struct FunctionLoadInfo { | |
| char req_inst; | |
| char req_dev; | |
| uint16_t struct_offset; | |
| FFVulkanExtensions ext_flag; | |
| } vk_load_info[] = { | |
| FN_LIST(PFN_LOAD_INFO) | |
| #ifdef _WIN32 | |
| FN_LIST_WIN32(PFN_LOAD_INFO) | |
| #endif | |
| }; | |
| // Concatenate the names to avoid relocations. The resulting string | |
| // will end with \0\0 | |
| #define FUNC_NAME(req_inst, req_dev, ext_flag, name) "vk"#name"\0" | |
| const char *name = | |
| FN_LIST(FUNC_NAME) | |
| #ifdef _WIN32 | |
| FN_LIST_WIN32(FUNC_NAME) | |
| #endif | |
| ; | |
| #undef FUNC_NAME | |
| for (int i = 0; i < FF_ARRAY_ELEMS(vk_load_info); name += strlen(name) + 1, i++) { | |
| const struct FunctionLoadInfo *load = &vk_load_info[i]; | |
| static const char extensions[][4] = { "", "EXT", "KHR" }; | |
| PFN_vkVoidFunction fn; | |
| if (load->req_dev && !has_dev) | |
| continue; | |
| if (load->req_inst && !has_inst) | |
| continue; | |
| for (int j = 0; j < FF_ARRAY_ELEMS(extensions); j++) { | |
| char ext_name[128]; | |
| av_unused int n; | |
| n = snprintf(ext_name, sizeof(ext_name), "%s%s", name, extensions[j]); | |
| av_assert1(n < sizeof(ext_name)); | |
| if (load->req_dev) | |
| fn = vk->GetDeviceProcAddr(hwctx->act_dev, ext_name); | |
| else if (load->req_inst) | |
| fn = hwctx->get_proc_addr(hwctx->inst, ext_name); | |
| else | |
| fn = hwctx->get_proc_addr(NULL, ext_name); | |
| if (fn) | |
| break; | |
| } | |
| if (!fn && ((extensions_mask &~ FF_VK_EXT_NO_FLAG) & load->ext_flag)) { | |
| av_log(ctx, AV_LOG_ERROR, "Loader error, function \"%s\" indicated " | |
| "as supported, but got NULL function pointer!\n", name); | |
| return AVERROR_EXTERNAL; | |
| } | |
| *(PFN_vkVoidFunction *)((uint8_t *)vk + load->struct_offset) = fn; | |
| } | |
| av_assert1(*name == '\0'); | |
| return 0; | |
| } | |
| #endif /* AVUTIL_VULKAN_LOADER_H */ |