/* * 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 #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 }, { VK_NV_OPTICAL_FLOW_EXTENSION_NAME, FF_VK_EXT_OPTICAL_FLOW }, { VK_EXT_SHADER_OBJECT_EXTENSION_NAME, FF_VK_EXT_SHADER_OBJECT }, { VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME, FF_VK_EXT_VIDEO_MAINTENANCE_1 }, #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_ENCODE_QUEUE_EXTENSION_NAME, FF_VK_EXT_VIDEO_ENCODE_QUEUE }, { VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME, FF_VK_EXT_VIDEO_DECODE_QUEUE }, { VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME, FF_VK_EXT_VIDEO_ENCODE_H264 }, { VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME, FF_VK_EXT_VIDEO_DECODE_H264 }, { VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME, FF_VK_EXT_VIDEO_ENCODE_H265 }, { 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 */