21 #define VK_NO_PROTOTYPES
22 #define VK_ENABLE_BETA_EXTENSIONS
26 #include <versionhelpers.h>
53 #include <va/va_drmcommon.h>
56 #include <sys/sysmacros.h>
60 #include <drm_fourcc.h>
64 #if HAVE_LINUX_DMA_BUF_H
65 #include <sys/ioctl.h>
66 #include <linux/dma-buf.h>
72 #define CHECK_CU(x) FF_CUDA_CHECK_DL(cuda_cu, cu, x)
83 #ifdef VK_KHR_shader_expect_assume
84 VkPhysicalDeviceShaderExpectAssumeFeaturesKHR expect_assume;
88 #ifdef VK_KHR_video_maintenance2
89 VkPhysicalDeviceVideoMaintenance2FeaturesKHR video_maintenance_2;
99 #ifdef VK_KHR_shader_relaxed_extended_instruction
100 VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR relaxed_extended_instruction;
120 VkPhysicalDeviceExternalMemoryHostPropertiesEXT
hprops;
195 feats->
device = (VkPhysicalDeviceFeatures2) {
196 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
200 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
202 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
204 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
207 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
209 #ifdef VK_KHR_shader_expect_assume
211 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR);
215 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR);
216 #ifdef VK_KHR_video_maintenance2
218 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR);
222 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT);
224 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR);
226 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
228 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
230 #ifdef VK_KHR_shader_relaxed_extended_instruction
232 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR);
236 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
242 #define COPY_VAL(VAL) \
244 dst->VAL = src->VAL; \
247 COPY_VAL(device.features.shaderImageGatherExtended);
248 COPY_VAL(device.features.shaderStorageImageReadWithoutFormat);
249 COPY_VAL(device.features.shaderStorageImageWriteWithoutFormat);
250 COPY_VAL(device.features.fragmentStoresAndAtomics);
251 COPY_VAL(device.features.vertexPipelineStoresAndAtomics);
252 COPY_VAL(device.features.shaderInt64);
253 COPY_VAL(device.features.shaderInt16);
254 COPY_VAL(device.features.shaderFloat64);
255 COPY_VAL(device.features.shaderStorageImageReadWithoutFormat);
256 COPY_VAL(device.features.shaderStorageImageWriteWithoutFormat);
258 COPY_VAL(vulkan_1_1.samplerYcbcrConversion);
259 COPY_VAL(vulkan_1_1.storagePushConstant16);
260 COPY_VAL(vulkan_1_1.storageBuffer16BitAccess);
261 COPY_VAL(vulkan_1_1.uniformAndStorageBuffer16BitAccess);
263 COPY_VAL(vulkan_1_2.timelineSemaphore);
264 COPY_VAL(vulkan_1_2.scalarBlockLayout);
265 COPY_VAL(vulkan_1_2.bufferDeviceAddress);
266 COPY_VAL(vulkan_1_2.hostQueryReset);
267 COPY_VAL(vulkan_1_2.storagePushConstant8);
269 COPY_VAL(vulkan_1_2.storageBuffer8BitAccess);
270 COPY_VAL(vulkan_1_2.uniformAndStorageBuffer8BitAccess);
272 COPY_VAL(vulkan_1_2.shaderBufferInt64Atomics);
273 COPY_VAL(vulkan_1_2.shaderSharedInt64Atomics);
274 COPY_VAL(vulkan_1_2.vulkanMemoryModel);
275 COPY_VAL(vulkan_1_2.vulkanMemoryModelDeviceScope);
277 COPY_VAL(vulkan_1_3.dynamicRendering);
279 COPY_VAL(vulkan_1_3.synchronization2);
280 COPY_VAL(vulkan_1_3.computeFullSubgroups);
281 COPY_VAL(vulkan_1_3.subgroupSizeControl);
282 COPY_VAL(vulkan_1_3.shaderZeroInitializeWorkgroupMemory);
283 COPY_VAL(vulkan_1_3.dynamicRendering);
285 COPY_VAL(timeline_semaphore.timelineSemaphore);
287 COPY_VAL(video_maintenance_1.videoMaintenance1);
288 #ifdef VK_KHR_video_maintenance2
289 COPY_VAL(video_maintenance_2.videoMaintenance2);
292 COPY_VAL(shader_object.shaderObject);
294 COPY_VAL(cooperative_matrix.cooperativeMatrix);
296 COPY_VAL(descriptor_buffer.descriptorBuffer);
297 COPY_VAL(descriptor_buffer.descriptorBufferPushDescriptors);
299 COPY_VAL(atomic_float.shaderBufferFloat32Atomics);
300 COPY_VAL(atomic_float.shaderBufferFloat32AtomicAdd);
302 #ifdef VK_KHR_shader_relaxed_extended_instruction
303 COPY_VAL(relaxed_extended_instruction.shaderRelaxedExtendedInstruction);
306 #ifdef VK_KHR_shader_expect_assume
307 COPY_VAL(expect_assume.shaderExpectAssume);
314 #define ASPECT_2PLANE (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT)
315 #define ASPECT_3PLANE (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT)
327 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_GRAY8, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8_UNORM } },
328 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY10, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
329 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY12, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
330 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY14, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
331 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY16, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
332 { VK_FORMAT_R32_UINT,
AV_PIX_FMT_GRAY32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32_UINT } },
333 { VK_FORMAT_R32_SFLOAT,
AV_PIX_FMT_GRAYF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32_SFLOAT } },
336 { VK_FORMAT_B8G8R8A8_UNORM,
AV_PIX_FMT_BGRA, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8A8_UNORM } },
337 { VK_FORMAT_R8G8B8A8_UNORM,
AV_PIX_FMT_RGBA, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
338 { VK_FORMAT_R8G8B8_UNORM,
AV_PIX_FMT_RGB24, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8_UNORM } },
339 { VK_FORMAT_B8G8R8_UNORM,
AV_PIX_FMT_BGR24, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8_UNORM } },
340 { VK_FORMAT_R16G16B16_UNORM,
AV_PIX_FMT_RGB48, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16_UNORM } },
341 { VK_FORMAT_R16G16B16A16_UNORM,
AV_PIX_FMT_RGBA64, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
342 { VK_FORMAT_R5G6B5_UNORM_PACK16,
AV_PIX_FMT_RGB565, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R5G6B5_UNORM_PACK16 } },
343 { VK_FORMAT_B5G6R5_UNORM_PACK16,
AV_PIX_FMT_BGR565, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B5G6R5_UNORM_PACK16 } },
344 { VK_FORMAT_B8G8R8A8_UNORM,
AV_PIX_FMT_BGR0, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8A8_UNORM } },
345 { VK_FORMAT_R8G8B8A8_UNORM,
AV_PIX_FMT_RGB0, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
346 { VK_FORMAT_A2R10G10B10_UNORM_PACK32,
AV_PIX_FMT_X2RGB10, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_A2R10G10B10_UNORM_PACK32 } },
347 { VK_FORMAT_A2B10G10R10_UNORM_PACK32,
AV_PIX_FMT_X2BGR10, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_A2B10G10R10_UNORM_PACK32 } },
348 { VK_FORMAT_R32G32B32_SFLOAT,
AV_PIX_FMT_RGBF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32G32B32_SFLOAT } },
349 { VK_FORMAT_R32G32B32A32_SFLOAT,
AV_PIX_FMT_RGBAF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32G32B32A32_SFLOAT } },
350 { VK_FORMAT_R32G32B32_UINT,
AV_PIX_FMT_RGB96, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32G32B32_UINT } },
351 { VK_FORMAT_R32G32B32A32_UINT,
AV_PIX_FMT_RGBA128, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32G32B32A32_UINT } },
354 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRP10, VK_IMAGE_ASPECT_COLOR_BIT, 3, 3, 3, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
355 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRP12, VK_IMAGE_ASPECT_COLOR_BIT, 3, 3, 3, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
356 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRP14, VK_IMAGE_ASPECT_COLOR_BIT, 3, 3, 3, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
357 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRP16, VK_IMAGE_ASPECT_COLOR_BIT, 3, 3, 3, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
358 { VK_FORMAT_R32_SFLOAT,
AV_PIX_FMT_GBRPF32, VK_IMAGE_ASPECT_COLOR_BIT, 3, 3, 3, { VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT } },
361 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_GBRAP, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM } },
362 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRAP10, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
363 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRAP12, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
364 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRAP14, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
365 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRAP16, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
366 { VK_FORMAT_R32_UINT,
AV_PIX_FMT_GBRAP32, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R32_UINT, VK_FORMAT_R32_UINT, VK_FORMAT_R32_UINT, VK_FORMAT_R32_UINT } },
367 { VK_FORMAT_R32_SFLOAT,
AV_PIX_FMT_GBRAPF32, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT } },
371 { VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
AV_PIX_FMT_P010,
ASPECT_2PLANE, 2, 1, 2, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM } },
372 { VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
AV_PIX_FMT_P012,
ASPECT_2PLANE, 2, 1, 2, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM } },
377 { VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
AV_PIX_FMT_P210,
ASPECT_2PLANE, 2, 1, 2, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM } },
378 { VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
AV_PIX_FMT_P212,
ASPECT_2PLANE, 2, 1, 2, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM } },
383 { VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16,
AV_PIX_FMT_P410,
ASPECT_2PLANE, 2, 1, 2, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM } },
384 { VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16,
AV_PIX_FMT_P412,
ASPECT_2PLANE, 2, 1, 2, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM } },
402 { VK_FORMAT_G8B8G8R8_422_UNORM,
AV_PIX_FMT_YUYV422, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
403 { VK_FORMAT_B8G8R8G8_422_UNORM,
AV_PIX_FMT_UYVY422, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
404 { VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
AV_PIX_FMT_Y210, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
405 { VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
AV_PIX_FMT_Y212, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
406 { VK_FORMAT_G16B16G16R16_422_UNORM,
AV_PIX_FMT_Y216, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
409 { VK_FORMAT_B8G8R8A8_UNORM,
AV_PIX_FMT_UYVA, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8A8_UNORM } },
410 { VK_FORMAT_A2R10G10B10_UNORM_PACK32,
AV_PIX_FMT_XV30, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
411 { VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
AV_PIX_FMT_XV36, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
412 { VK_FORMAT_R16G16B16A16_UNORM,
AV_PIX_FMT_XV48, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
433 VkImageTiling tiling,
436 VkImageAspectFlags *
aspect,
437 VkImageUsageFlags *supported_usage,
438 int disable_multiplane,
int need_storage)
444 const VkFormatFeatureFlagBits2 basic_flags = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT |
445 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
446 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
450 VkFormatProperties3 fprops = {
451 .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3,
453 VkFormatProperties2 prop = {
454 .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
457 VkFormatFeatureFlagBits2 feats_primary, feats_secondary;
458 int basics_primary = 0, basics_secondary = 0;
459 int storage_primary = 0, storage_secondary = 0;
461 vk->GetPhysicalDeviceFormatProperties2(hwctx->
phys_dev,
465 feats_primary = tiling == VK_IMAGE_TILING_LINEAR ?
466 fprops.linearTilingFeatures : fprops.optimalTilingFeatures;
467 basics_primary = (feats_primary & basic_flags) == basic_flags;
468 storage_primary = !!(feats_primary & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT);
471 vk->GetPhysicalDeviceFormatProperties2(hwctx->
phys_dev,
474 feats_secondary = tiling == VK_IMAGE_TILING_LINEAR ?
475 fprops.linearTilingFeatures : fprops.optimalTilingFeatures;
476 basics_secondary = (feats_secondary & basic_flags) == basic_flags;
477 storage_secondary = !!(feats_secondary & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT);
479 basics_secondary = basics_primary;
480 storage_secondary = storage_primary;
483 if (basics_primary &&
485 (!need_storage || (need_storage && (storage_primary | storage_secondary)))) {
500 ((need_storage && (storage_primary | storage_secondary)) ?
501 VK_IMAGE_USAGE_STORAGE_BIT : 0);
503 }
else if (basics_secondary &&
504 (!need_storage || (need_storage && storage_secondary))) {
525 #if CONFIG_VULKAN_STATIC
526 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance,
535 #if CONFIG_VULKAN_STATIC
538 static const char *lib_names[] = {
541 #elif defined(__APPLE__)
552 p->
libvulkan = dlopen(lib_names[
i], RTLD_NOW | RTLD_LOCAL);
590 #ifdef VK_KHR_shader_expect_assume
594 #ifdef VK_KHR_video_maintenance2
620 static VkBool32 VKAPI_CALL
vk_dbg_callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
621 VkDebugUtilsMessageTypeFlagsEXT messageType,
622 const VkDebugUtilsMessengerCallbackDataEXT *
data,
629 switch (
data->messageIdNumber) {
640 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: l =
AV_LOG_VERBOSE;
break;
641 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: l =
AV_LOG_INFO;
break;
642 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: l =
AV_LOG_WARNING;
break;
643 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: l =
AV_LOG_ERROR;
break;
648 for (
int i = 0;
i <
data->cmdBufLabelCount;
i++)
654 #define ADD_VAL_TO_LIST(list, count, val) \
656 list = av_realloc_array(list, sizeof(*list), ++count); \
658 err = AVERROR(ENOMEM); \
661 list[count - 1] = av_strdup(val); \
662 if (!list[count - 1]) { \
663 err = AVERROR(ENOMEM); \
668 #define RELEASE_PROPS(props, count) \
670 for (int i = 0; i < count; i++) \
671 av_free((void *)((props)[i])); \
672 av_free((void *)props); \
690 const char *
const **
dst, uint32_t *num,
694 const char **extension_names =
NULL;
698 int err = 0, found, extensions_found = 0;
701 int optional_exts_num;
702 uint32_t sup_ext_count;
703 char *user_exts_str =
NULL;
705 VkExtensionProperties *sup_ext;
715 if (!user_exts_str) {
720 vk->EnumerateInstanceExtensionProperties(
NULL, &sup_ext_count,
NULL);
721 sup_ext =
av_malloc_array(sup_ext_count,
sizeof(VkExtensionProperties));
724 vk->EnumerateInstanceExtensionProperties(
NULL, &sup_ext_count, sup_ext);
732 if (!user_exts_str) {
737 vk->EnumerateDeviceExtensionProperties(hwctx->
phys_dev,
NULL,
738 &sup_ext_count,
NULL);
739 sup_ext =
av_malloc_array(sup_ext_count,
sizeof(VkExtensionProperties));
742 vk->EnumerateDeviceExtensionProperties(hwctx->
phys_dev,
NULL,
743 &sup_ext_count, sup_ext);
746 for (
int i = 0;
i < optional_exts_num;
i++) {
747 tstr = optional_exts[
i].
name;
751 if (p->
dprops.driverID == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA &&
752 !strcmp(tstr, VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME))
759 !strcmp(tstr, VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME)) {
763 for (
int j = 0; j < sup_ext_count; j++) {
764 if (!strcmp(tstr, sup_ext[j].extensionName)) {
781 tstr = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
783 for (
int j = 0; j < sup_ext_count; j++) {
784 if (!strcmp(tstr, sup_ext[j].extensionName)) {
800 #ifdef VK_KHR_shader_relaxed_extended_instruction
803 tstr = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME;
805 for (
int j = 0; j < sup_ext_count; j++) {
806 if (!strcmp(tstr, sup_ext[j].extensionName)) {
824 char *save, *token =
av_strtok(user_exts_str,
"+", &save);
827 for (
int j = 0; j < sup_ext_count; j++) {
828 if (!strcmp(token, sup_ext[j].extensionName)) {
844 *
dst = extension_names;
845 *num = extensions_found;
859 const char *
const **
dst, uint32_t *num,
866 static const char layer_standard_validation[] = {
"VK_LAYER_KHRONOS_validation" };
867 int layer_standard_validation_found = 0;
869 uint32_t sup_layer_count;
870 VkLayerProperties *sup_layers;
873 char *user_layers_str =
NULL;
876 const char **enabled_layers =
NULL;
877 uint32_t enabled_layers_count = 0;
885 vk->EnumerateInstanceLayerProperties(&sup_layer_count,
NULL);
886 sup_layers =
av_malloc_array(sup_layer_count,
sizeof(VkLayerProperties));
889 vk->EnumerateInstanceLayerProperties(&sup_layer_count, sup_layers);
892 for (
int i = 0;
i < sup_layer_count;
i++)
896 if (!debug_opt && !user_layers)
901 if (!strcmp(debug_opt->
value,
"profile")) {
903 }
else if (!strcmp(debug_opt->
value,
"printf")) {
905 }
else if (!strcmp(debug_opt->
value,
"validate")) {
907 }
else if (!strcmp(debug_opt->
value,
"practices")) {
910 char *end_ptr =
NULL;
911 int idx = strtol(debug_opt->
value, &end_ptr, 10);
912 if (end_ptr == debug_opt->
value || end_ptr[0] !=
'\0' ||
927 for (
int i = 0;
i < sup_layer_count;
i++) {
928 if (!strcmp(layer_standard_validation, sup_layers[
i].layerName)) {
930 layer_standard_validation);
931 ADD_VAL_TO_LIST(enabled_layers, enabled_layers_count, layer_standard_validation);
933 layer_standard_validation_found = 1;
937 if (!layer_standard_validation_found) {
939 "Validation Layer \"%s\" not supported\n", layer_standard_validation);
952 if (!user_layers_str) {
957 token =
av_strtok(user_layers_str,
"+", &save);
962 if (!strcmp(layer_standard_validation, token) && layer_standard_validation_found) {
968 for (
int j = 0; j < sup_layer_count; j++) {
969 if (!strcmp(token, sup_layers[j].layerName)) {
980 if (!strcmp(layer_standard_validation, token))
984 "Layer \"%s\" not supported\n", token);
1001 *
dst = enabled_layers;
1002 *num = enabled_layers_count;
1017 VkApplicationInfo application_info = {
1018 .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
1019 .pApplicationName =
"ffmpeg",
1023 .pEngineName =
"libavutil",
1024 .apiVersion = VK_API_VERSION_1_3,
1029 VkValidationFeaturesEXT validation_features = {
1030 .sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,
1032 VkInstanceCreateInfo inst_props = {
1033 .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
1034 .pApplicationInfo = &application_info,
1050 &inst_props.enabledLayerCount, debug_mode);
1056 &inst_props.enabledExtensionCount, *debug_mode);
1064 static const VkValidationFeatureEnableEXT feat_list_validate[] = {
1065 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT,
1066 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
1067 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
1069 validation_features.pEnabledValidationFeatures = feat_list_validate;
1070 validation_features.enabledValidationFeatureCount =
FF_ARRAY_ELEMS(feat_list_validate);
1071 inst_props.pNext = &validation_features;
1073 static const VkValidationFeatureEnableEXT feat_list_debug[] = {
1074 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT,
1075 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
1076 VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT,
1078 validation_features.pEnabledValidationFeatures = feat_list_debug;
1079 validation_features.enabledValidationFeatureCount =
FF_ARRAY_ELEMS(feat_list_debug);
1080 inst_props.pNext = &validation_features;
1082 static const VkValidationFeatureEnableEXT feat_list_practices[] = {
1083 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT,
1084 VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT,
1086 validation_features.pEnabledValidationFeatures = feat_list_practices;
1087 validation_features.enabledValidationFeatureCount =
FF_ARRAY_ELEMS(feat_list_practices);
1088 inst_props.pNext = &validation_features;
1092 for (
int i = 0;
i < inst_props.enabledExtensionCount;
i++) {
1093 if (!strcmp(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
1094 inst_props.ppEnabledExtensionNames[
i])) {
1095 inst_props.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
1102 ret = vk->CreateInstance(&inst_props, hwctx->
alloc, &hwctx->
inst);
1105 if (
ret != VK_SUCCESS) {
1122 VkDebugUtilsMessengerCreateInfoEXT dbg = {
1123 .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
1124 .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
1125 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT |
1126 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
1127 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
1128 .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
1129 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
1130 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
1135 vk->CreateDebugUtilsMessengerEXT(hwctx->
inst, &dbg,
1142 RELEASE_PROPS(inst_props.ppEnabledLayerNames, inst_props.enabledLayerCount);
1161 case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
return "integrated";
1162 case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
return "discrete";
1163 case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
return "virtual";
1164 case VK_PHYSICAL_DEVICE_TYPE_CPU:
return "software";
1165 default:
return "unknown";
1172 int err = 0, choice = -1;
1178 VkPhysicalDevice *devices =
NULL;
1179 VkPhysicalDeviceIDProperties *idp =
NULL;
1180 VkPhysicalDeviceProperties2 *prop =
NULL;
1181 VkPhysicalDeviceDriverProperties *driver_prop =
NULL;
1182 VkPhysicalDeviceDrmPropertiesEXT *drm_prop =
NULL;
1184 ret = vk->EnumeratePhysicalDevices(hwctx->
inst, &num,
NULL);
1185 if (
ret != VK_SUCCESS || !num) {
1194 ret = vk->EnumeratePhysicalDevices(hwctx->
inst, &num, devices);
1195 if (
ret != VK_SUCCESS) {
1214 driver_prop =
av_calloc(num,
sizeof(*driver_prop));
1221 drm_prop =
av_calloc(num,
sizeof(*drm_prop));
1229 for (
int i = 0;
i < num;
i++) {
1231 drm_prop[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT;
1232 driver_prop[
i].pNext = &drm_prop[
i];
1234 driver_prop[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
1235 idp[
i].pNext = &driver_prop[
i];
1236 idp[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
1237 prop[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
1238 prop[
i].pNext = &idp[
i];
1240 vk->GetPhysicalDeviceProperties2(devices[
i], &prop[
i]);
1242 prop[
i].properties.deviceName,
1244 prop[
i].properties.deviceID);
1248 for (
int i = 0;
i < num;
i++) {
1249 if (!strncmp(idp[
i].deviceUUID, select->
uuid, VK_UUID_SIZE)) {
1258 for (
int i = 0;
i < num;
i++) {
1259 if ((select->
drm_major == drm_prop[
i].primaryMajor &&
1260 select->
drm_minor == drm_prop[
i].primaryMinor) ||
1261 (select->
drm_major == drm_prop[
i].renderMajor &&
1262 select->
drm_minor == drm_prop[
i].renderMinor)) {
1271 }
else if (select->
name) {
1273 for (
int i = 0;
i < num;
i++) {
1274 if (strstr(prop[
i].properties.deviceName, select->
name)) {
1285 for (
int i = 0;
i < num;
i++) {
1286 if (select->
pci_device == prop[
i].properties.deviceID) {
1297 for (
int i = 0;
i < num;
i++) {
1298 if (select->
vendor_id == prop[
i].properties.vendorID) {
1308 if (select->
index < num) {
1309 choice = select->
index;
1321 choice, prop[choice].properties.deviceName,
1323 prop[choice].properties.deviceID);
1325 p->
props = prop[choice];
1327 p->
dprops = driver_prop[choice];
1342 VkQueueFlagBits
flags)
1345 uint32_t min_score = UINT32_MAX;
1347 for (
int i = 0;
i < num_qf;
i++) {
1348 VkQueueFlagBits qflags = qf[
i].queueFamilyProperties.queueFlags;
1351 if ((
flags & VK_QUEUE_TRANSFER_BIT) &&
1352 (qflags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT)))
1353 qflags |= VK_QUEUE_TRANSFER_BIT;
1355 if (qflags &
flags) {
1356 uint32_t score =
av_popcount(qflags) + qf[
i].queueFamilyProperties.timestampValidBits;
1357 if (score < min_score) {
1365 qf[
index].queueFamilyProperties.timestampValidBits++;
1371 VkQueueFamilyVideoPropertiesKHR *qf_vid, uint32_t num_qf,
1372 VkVideoCodecOperationFlagBitsKHR
flags)
1375 uint32_t min_score = UINT32_MAX;
1377 for (
int i = 0;
i < num_qf;
i++) {
1378 const VkQueueFlagBits qflags = qf[
i].queueFamilyProperties.queueFlags;
1379 const VkQueueFlagBits vflags = qf_vid[
i].videoCodecOperations;
1381 if (!(qflags & (VK_QUEUE_VIDEO_ENCODE_BIT_KHR | VK_QUEUE_VIDEO_DECODE_BIT_KHR)))
1384 if (vflags &
flags) {
1385 uint32_t score =
av_popcount(vflags) + qf[
i].queueFamilyProperties.timestampValidBits;
1386 if (score < min_score) {
1394 qf[
index].queueFamilyProperties.timestampValidBits++;
1406 VkQueueFamilyProperties2 *qf =
NULL;
1407 VkQueueFamilyVideoPropertiesKHR *qf_vid =
NULL;
1410 vk->GetPhysicalDeviceQueueFamilyProperties(hwctx->
phys_dev, &num,
NULL);
1421 qf_vid =
av_malloc_array(num,
sizeof(VkQueueFamilyVideoPropertiesKHR));
1425 for (uint32_t
i = 0;
i < num;
i++) {
1426 qf_vid[
i] = (VkQueueFamilyVideoPropertiesKHR) {
1427 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR,
1429 qf[
i] = (VkQueueFamilyProperties2) {
1430 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
1436 vk->GetPhysicalDeviceQueueFamilyProperties2(hwctx->
phys_dev, &num, qf);
1439 for (
int i = 0;
i < num;
i++) {
1441 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_GRAPHICS_BIT) ?
" graphics" :
"",
1442 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_COMPUTE_BIT) ?
" compute" :
"",
1443 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_TRANSFER_BIT) ?
" transfer" :
"",
1444 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_VIDEO_ENCODE_BIT_KHR) ?
" encode" :
"",
1445 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_VIDEO_DECODE_BIT_KHR) ?
" decode" :
"",
1446 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_SPARSE_BINDING_BIT) ?
" sparse" :
"",
1447 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_OPTICAL_FLOW_BIT_NV) ?
" optical_flow" :
"",
1448 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_PROTECTED_BIT) ?
" protected" :
"",
1449 qf[
i].queueFamilyProperties.queueCount);
1453 qf[
i].queueFamilyProperties.timestampValidBits = 0;
1459 #define PICK_QF(type, vid_op) \
1465 idx = pick_video_queue_family(qf, qf_vid, num, vid_op); \
1467 idx = pick_queue_family(qf, num, type); \
1472 for (i = 0; i < hwctx->nb_qf; i++) { \
1473 if (hwctx->qf[i].idx == idx) { \
1474 hwctx->qf[i].flags |= type; \
1475 hwctx->qf[i].video_caps |= vid_op; \
1479 if (i == hwctx->nb_qf) { \
1480 hwctx->qf[i].idx = idx; \
1481 hwctx->qf[i].num = qf[idx].queueFamilyProperties.queueCount; \
1482 hwctx->qf[i].flags = type; \
1483 hwctx->qf[i].video_caps = vid_op; \
1488 PICK_QF(VK_QUEUE_GRAPHICS_BIT, VK_VIDEO_CODEC_OPERATION_NONE_KHR);
1489 PICK_QF(VK_QUEUE_COMPUTE_BIT, VK_VIDEO_CODEC_OPERATION_NONE_KHR);
1490 PICK_QF(VK_QUEUE_TRANSFER_BIT, VK_VIDEO_CODEC_OPERATION_NONE_KHR);
1491 PICK_QF(VK_QUEUE_OPTICAL_FLOW_BIT_NV, VK_VIDEO_CODEC_OPERATION_NONE_KHR);
1493 PICK_QF(VK_QUEUE_VIDEO_ENCODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR);
1494 PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR);
1496 PICK_QF(VK_QUEUE_VIDEO_ENCODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR);
1497 PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR);
1499 PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR);
1507 sizeof(VkDeviceQueueCreateInfo));
1508 if (!cd->pQueueCreateInfos)
1511 for (uint32_t
i = 0;
i < hwctx->
nb_qf;
i++) {
1514 VkDeviceQueueCreateInfo *pc;
1515 for (uint32_t j = 0; j < cd->queueCreateInfoCount; j++) {
1516 if (hwctx->
qf[
i].
idx == cd->pQueueCreateInfos[j].queueFamilyIndex) {
1526 for (uint32_t j = 0; j < cd->queueCreateInfoCount; j++)
1527 av_free((
void *)cd->pQueueCreateInfos[
i].pQueuePriorities);
1528 av_free((
void *)cd->pQueueCreateInfos);
1532 for (uint32_t j = 0; j < hwctx->
qf[
i].
num; j++)
1535 pc = (VkDeviceQueueCreateInfo *)cd->pQueueCreateInfos;
1536 pc[cd->queueCreateInfoCount++] = (VkDeviceQueueCreateInfo) {
1537 .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
1538 .queueFamilyIndex = hwctx->
qf[
i].
idx,
1539 .queueCount = hwctx->
qf[
i].
num,
1544 #if FF_API_VULKAN_FIXED_QUEUES
1553 #define SET_OLD_QF(field, nb_field, type) \
1555 if (field < 0 && hwctx->qf[i].flags & type) { \
1556 field = hwctx->qf[i].idx; \
1557 nb_field = hwctx->qf[i].num; \
1561 for (uint32_t
i = 0;
i < hwctx->
nb_qf;
i++) {
1591 vk->DestroyDebugUtilsMessengerEXT(hwctx->
inst, p->
debug_ctx,
1595 vk->DestroyInstance(hwctx->
inst, hwctx->
alloc);
1619 int disable_multiplane,
1630 VkDeviceCreateInfo dev_info = {
1631 .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
1644 &dev_info.enabledExtensionCount, debug_mode))) {
1645 for (
int i = 0;
i < dev_info.queueCreateInfoCount;
i++)
1646 av_free((
void *)dev_info.pQueueCreateInfos[
i].pQueuePriorities);
1647 av_free((
void *)dev_info.pQueueCreateInfos);
1653 vk->GetPhysicalDeviceFeatures2(hwctx->
phys_dev, &supported_feats.
device);
1659 dev_info.pEnabledFeatures = &p->
feats.
device.features;
1669 for (
int i = 0;
i < dev_info.queueCreateInfoCount;
i++)
1670 av_free((
void *)dev_info.pQueueCreateInfos[
i].pQueuePriorities);
1671 av_free((
void *)dev_info.pQueueCreateInfos);
1673 if (
ret != VK_SUCCESS) {
1676 for (
int i = 0;
i < dev_info.enabledExtensionCount;
i++)
1677 av_free((
void *)dev_info.ppEnabledExtensionNames[
i]);
1678 av_free((
void *)dev_info.ppEnabledExtensionNames);
1729 VkQueueFamilyProperties2 *qf;
1730 VkQueueFamilyVideoPropertiesKHR *qf_vid;
1731 VkPhysicalDeviceExternalSemaphoreInfo ext_sem_props_info;
1732 int graph_index, comp_index, tx_index, enc_index, dec_index;
1751 p->
props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
1753 p->
hprops.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
1755 vk->GetPhysicalDeviceProperties2(hwctx->
phys_dev, &p->
props);
1757 p->
props.properties.deviceName);
1760 p->
props.properties.limits.optimalBufferCopyRowPitchAlignment);
1762 p->
props.properties.limits.minMemoryMapAlignment);
1764 p->
props.properties.limits.nonCoherentAtomSize);
1767 p->
hprops.minImportedHostPointerAlignment);
1771 vk->GetPhysicalDeviceQueueFamilyProperties(hwctx->
phys_dev, &qf_num,
NULL);
1777 ext_sem_props_info = (VkPhysicalDeviceExternalSemaphoreInfo) {
1778 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
1782 ext_sem_props_info.handleType =
1784 IsWindows8OrGreater()
1785 ? VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
1786 : VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
1788 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
1791 vk->GetPhysicalDeviceExternalSemaphoreProperties(hwctx->
phys_dev,
1792 &ext_sem_props_info,
1799 qf_vid =
av_malloc_array(qf_num,
sizeof(VkQueueFamilyVideoPropertiesKHR));
1805 for (uint32_t
i = 0;
i < qf_num;
i++) {
1806 qf_vid[
i] = (VkQueueFamilyVideoPropertiesKHR) {
1807 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR,
1809 qf[
i] = (VkQueueFamilyProperties2) {
1810 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
1815 vk->GetPhysicalDeviceQueueFamilyProperties2(hwctx->
phys_dev, &qf_num, qf);
1824 for (uint32_t
i = 0;
i < qf_num;
i++) {
1831 for (uint32_t j = 0; j < qf[
i].queueFamilyProperties.queueCount; j++) {
1842 #if FF_API_VULKAN_FIXED_QUEUES
1850 #define CHECK_QUEUE(type, required, fidx, ctx_qf, qc) \
1852 if (ctx_qf < 0 && required) { \
1853 av_log(ctx, AV_LOG_ERROR, "%s queue family is required, but marked as missing" \
1854 " in the context!\n", type); \
1855 err = AVERROR(EINVAL); \
1857 } else if (fidx < 0 || ctx_qf < 0) { \
1859 } else if (ctx_qf >= qf_num) { \
1860 av_log(ctx, AV_LOG_ERROR, "Invalid %s family index %i (device has %i families)!\n", \
1861 type, ctx_qf, qf_num); \
1862 err = AVERROR(EINVAL); \
1866 av_log(ctx, AV_LOG_VERBOSE, "Using queue family %i (queues: %i)" \
1867 " for%s%s%s%s%s\n", \
1869 ctx_qf == graph_index ? " graphics" : "", \
1870 ctx_qf == comp_index ? " compute" : "", \
1871 ctx_qf == tx_index ? " transfers" : "", \
1872 ctx_qf == enc_index ? " encode" : "", \
1873 ctx_qf == dec_index ? " decode" : ""); \
1874 graph_index = (ctx_qf == graph_index) ? -1 : graph_index; \
1875 comp_index = (ctx_qf == comp_index) ? -1 : comp_index; \
1876 tx_index = (ctx_qf == tx_index) ? -1 : tx_index; \
1877 enc_index = (ctx_qf == enc_index) ? -1 : enc_index; \
1878 dec_index = (ctx_qf == dec_index) ? -1 : dec_index; \
1891 if (!hwctx->
nb_qf) {
1892 #define ADD_QUEUE(ctx_qf, qc, flag) \
1894 if (ctx_qf != -1) { \
1895 hwctx->qf[hwctx->nb_qf++] = (AVVulkanDeviceQueueFamily) { \
1913 for (
int i = 0;
i < hwctx->
nb_qf;
i++) {
1915 hwctx->
qf[
i].
flags & (VK_QUEUE_VIDEO_DECODE_BIT_KHR |
1916 VK_QUEUE_VIDEO_ENCODE_BIT_KHR)) {
1923 for (
int i = 0;
i < hwctx->
nb_qf;
i++) {
1927 for (
int j = (
i - 1); j >= 0; j--) {
1943 vk->GetPhysicalDeviceMemoryProperties(hwctx->
phys_dev, &p->
mprops);
1962 if (device && device[0]) {
1964 dev_select.
index = strtol(device, &end, 10);
1965 if (end == device) {
1966 dev_select.
index = 0;
1967 dev_select.
name = device;
1983 switch(src_ctx->
type) {
1987 VADisplay dpy = src_hwctx->
display;
1988 #if VA_CHECK_VERSION(1, 15, 0)
1990 VADisplayAttribute attr = {
1991 .type = VADisplayPCIID,
1996 #if VA_CHECK_VERSION(1, 15, 0)
1997 vas = vaGetDisplayAttributes(dpy, &attr, 1);
1998 if (vas == VA_STATUS_SUCCESS && attr.flags != VA_DISPLAY_ATTRIB_NOT_SUPPORTED)
1999 dev_select.pci_device = (attr.value & 0xFFFF);
2002 if (!dev_select.pci_device) {
2003 vendor = vaQueryVendorString(dpy);
2009 if (strstr(vendor,
"AMD"))
2010 dev_select.vendor_id = 0x1002;
2019 struct stat drm_node_info;
2020 drmDevice *drm_dev_info;
2023 err = fstat(src_hwctx->
fd, &drm_node_info);
2030 dev_select.drm_major = major(drm_node_info.st_dev);
2031 dev_select.drm_minor = minor(drm_node_info.st_dev);
2032 dev_select.has_drm = 1;
2034 err = drmGetDevice(src_hwctx->
fd, &drm_dev_info);
2041 if (drm_dev_info->bustype == DRM_BUS_PCI)
2042 dev_select.pci_device = drm_dev_info->deviceinfo.pci->device_id;
2044 drmFreeDevice(&drm_dev_info);
2054 CudaFunctions *cu = cu_internal->
cuda_dl;
2056 int ret =
CHECK_CU(cu->cuDeviceGetUuid((CUuuid *)&dev_select.uuid,
2063 dev_select.has_uuid = 1;
2078 const void *hwconfig,
2087 VK_IMAGE_TILING_OPTIMAL,
2100 VK_IMAGE_TILING_OPTIMAL,
2110 constraints->
max_width = p->
props.properties.limits.maxImageDimension2D;
2111 constraints->
max_height = p->
props.properties.limits.maxImageDimension2D;
2124 VkMemoryPropertyFlagBits req_flags,
const void *alloc_extension,
2125 VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
2132 VkMemoryAllocateInfo alloc_info = {
2133 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
2134 .pNext = alloc_extension,
2135 .allocationSize = req->size,
2140 for (
int i = 0;
i < p->
mprops.memoryTypeCount;
i++) {
2141 const VkMemoryType *
type = &p->
mprops.memoryTypes[
i];
2144 if (!(req->memoryTypeBits & (1 <<
i)))
2148 if ((
type->propertyFlags & req_flags) != req_flags)
2152 if (req->size > p->
mprops.memoryHeaps[
type->heapIndex].size)
2166 alloc_info.memoryTypeIndex =
index;
2168 ret = vk->AllocateMemory(dev_hwctx->
act_dev, &alloc_info,
2169 dev_hwctx->
alloc, mem);
2170 if (
ret != VK_SUCCESS) {
2176 *mem_flags |= p->
mprops.memoryTypes[
index].propertyFlags;
2186 if (internal->cuda_fc_ref) {
2192 CudaFunctions *cu = cu_internal->
cuda_dl;
2195 if (internal->cu_sem[
i])
2196 CHECK_CU(cu->cuDestroyExternalSemaphore(internal->cu_sem[
i]));
2197 if (internal->cu_mma[
i])
2198 CHECK_CU(cu->cuMipmappedArrayDestroy(internal->cu_mma[
i]));
2199 if (internal->ext_mem[
i])
2200 CHECK_CU(cu->cuDestroyExternalMemory(internal->ext_mem[
i]));
2202 if (internal->ext_sem_handle[
i])
2203 CloseHandle(internal->ext_sem_handle[
i]);
2204 if (internal->ext_mem_handle[
i])
2205 CloseHandle(internal->ext_mem_handle[
i]);
2230 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
2232 .pSemaphores =
f->sem,
2233 .pValues =
f->sem_value,
2234 .semaphoreCount = nb_sems,
2242 for (
int i = 0;
i < nb_images;
i++) {
2257 void *alloc_pnext,
size_t alloc_pnext_stride)
2259 int img_cnt = 0, err;
2267 while (
f->img[img_cnt]) {
2269 VkImageMemoryRequirementsInfo2 req_desc = {
2270 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
2271 .image =
f->img[img_cnt],
2273 VkMemoryDedicatedAllocateInfo ded_alloc = {
2274 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
2275 .pNext = (
void *)(((uint8_t *)alloc_pnext) + img_cnt*alloc_pnext_stride),
2277 VkMemoryDedicatedRequirements ded_req = {
2278 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
2280 VkMemoryRequirements2 req = {
2281 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
2285 vk->GetImageMemoryRequirements2(hwctx->
act_dev, &req_desc, &req);
2287 if (
f->tiling == VK_IMAGE_TILING_LINEAR)
2288 req.memoryRequirements.size =
FFALIGN(req.memoryRequirements.size,
2289 p->
props.properties.limits.minMemoryMapAlignment);
2292 use_ded_mem = ded_req.prefersDedicatedAllocation |
2293 ded_req.requiresDedicatedAllocation;
2295 ded_alloc.image =
f->img[img_cnt];
2299 f->tiling == VK_IMAGE_TILING_LINEAR ?
2300 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT :
2301 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
2302 use_ded_mem ? &ded_alloc : (
void *)ded_alloc.pNext,
2303 &
f->flags, &
f->mem[img_cnt])))
2306 f->size[img_cnt] = req.memoryRequirements.size;
2307 bind_info[img_cnt].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
2308 bind_info[img_cnt].image =
f->img[img_cnt];
2309 bind_info[img_cnt].memory =
f->mem[img_cnt];
2315 ret = vk->BindImageMemory2(hwctx->
act_dev, img_cnt, bind_info);
2316 if (
ret != VK_SUCCESS) {
2344 uint32_t dst_qf = VK_QUEUE_FAMILY_IGNORED;
2345 VkImageLayout new_layout;
2346 VkAccessFlags2 new_access;
2347 VkPipelineStageFlagBits2 src_stage = VK_PIPELINE_STAGE_2_NONE;
2353 .
data = (uint8_t *)hwfc,
2357 .hw_frames_ctx = &tmp_ref,
2360 VkCommandBuffer cmd_buf;
2362 cmd_buf = exec->
buf;
2366 VK_PIPELINE_STAGE_2_NONE,
2367 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT);
2373 new_layout = VK_IMAGE_LAYOUT_GENERAL;
2374 new_access = VK_ACCESS_TRANSFER_WRITE_BIT;
2377 new_layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
2378 new_access = VK_ACCESS_TRANSFER_WRITE_BIT;
2381 new_layout = VK_IMAGE_LAYOUT_GENERAL;
2382 new_access = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
2385 new_layout = VK_IMAGE_LAYOUT_GENERAL;
2386 new_access = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
2387 dst_qf = VK_QUEUE_FAMILY_EXTERNAL_KHR;
2388 src_stage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
2391 new_layout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR;
2392 new_access = VK_ACCESS_TRANSFER_WRITE_BIT;
2395 new_layout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR;
2396 new_access = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
2399 new_layout = VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR;
2400 new_access = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
2406 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
2407 new_access, new_layout, dst_qf);
2409 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
2410 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
2411 .pImageMemoryBarriers = img_bar,
2412 .imageMemoryBarrierCount = nb_img_bar,
2426 int frame_w,
int frame_h,
int plane)
2443 VkImageTiling tiling, VkImageUsageFlagBits
usage,
2444 VkImageCreateFlags
flags,
int nb_layers,
2456 VkSemaphoreTypeCreateInfo sem_type_info = {
2457 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
2458 .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
2461 VkSemaphoreCreateInfo sem_spawn = {
2462 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
2463 .pNext = &sem_type_info,
2466 VkExportSemaphoreCreateInfo ext_sem_info_opaque = {
2467 .sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
2469 .handleTypes = IsWindows8OrGreater()
2470 ? VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
2471 : VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
2473 .handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
2478 if (p->
ext_sem_props_opaque.externalSemaphoreFeatures & VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT) {
2492 for (
int i = 0; (hwfc_vk->
format[
i] != VK_FORMAT_UNDEFINED);
i++) {
2493 VkImageCreateInfo create_info = {
2494 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
2495 .pNext = create_pnext,
2496 .imageType = VK_IMAGE_TYPE_2D,
2500 .arrayLayers = nb_layers,
2503 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
2505 .samples = VK_SAMPLE_COUNT_1_BIT,
2506 .pQueueFamilyIndices = p->
img_qfs,
2508 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
2509 VK_SHARING_MODE_EXCLUSIVE,
2512 get_plane_wh(&create_info.extent.width, &create_info.extent.height,
2515 ret = vk->CreateImage(hwctx->
act_dev, &create_info,
2517 if (
ret != VK_SUCCESS) {
2525 ret = vk->CreateSemaphore(hwctx->
act_dev, &sem_spawn,
2527 if (
ret != VK_SUCCESS) {
2535 f->layout[
i] = create_info.initialLayout;
2537 f->sem_value[
i] = 0;
2553 VkExternalMemoryHandleTypeFlags *comp_handle_types,
2554 VkExternalMemoryHandleTypeFlagBits *iexp,
2555 VkExternalMemoryHandleTypeFlagBits
exp)
2563 const VkImageDrmFormatModifierListCreateInfoEXT *drm_mod_info =
2565 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
2566 int has_mods = hwctx->
tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT && drm_mod_info;
2569 VkExternalImageFormatProperties eprops = {
2570 .sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
2572 VkImageFormatProperties2 props = {
2573 .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
2576 VkPhysicalDeviceImageDrmFormatModifierInfoEXT phy_dev_mod_info = {
2577 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
2579 .pQueueFamilyIndices = p->
img_qfs,
2581 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
2582 VK_SHARING_MODE_EXCLUSIVE,
2584 VkPhysicalDeviceExternalImageFormatInfo enext = {
2585 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
2587 .pNext = has_mods ? &phy_dev_mod_info :
NULL,
2589 VkPhysicalDeviceImageFormatInfo2 pinfo = {
2590 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
2591 .pNext = !
exp ?
NULL : &enext,
2593 .type = VK_IMAGE_TYPE_2D,
2595 .usage = hwctx->
usage,
2596 .flags = VK_IMAGE_CREATE_ALIAS_BIT,
2599 nb_mods = has_mods ? drm_mod_info->drmFormatModifierCount : 1;
2600 for (
int i = 0;
i < nb_mods;
i++) {
2602 phy_dev_mod_info.drmFormatModifier = drm_mod_info->pDrmFormatModifiers[
i];
2604 ret = vk->GetPhysicalDeviceImageFormatProperties2(dev_hwctx->
phys_dev,
2607 if (
ret == VK_SUCCESS) {
2609 *comp_handle_types |= eprops.externalMemoryProperties.compatibleHandleTypes;
2623 VkExternalMemoryHandleTypeFlags e = 0x0;
2626 VkExternalMemoryImageCreateInfo eiinfo = {
2627 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
2634 ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
2635 : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT);
2639 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT);
2644 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
2647 eminfo[
i].sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
2649 eminfo[
i].handleTypes = e;
2662 if ( (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR) &&
2663 !(hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR))
2665 else if (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)
2667 else if (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR)
2669 else if (hwctx->
usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
2723 VkImageUsageFlagBits supported_usage;
2734 (hwctx->
tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT))
2735 hwctx->
tiling = VK_IMAGE_TILING_LINEAR;
2745 if (hwctx->
format[0] != VK_FORMAT_UNDEFINED) {
2750 "for the current sw_format %s!\n",
2762 (hwctx->
usage & VK_IMAGE_USAGE_STORAGE_BIT));
2771 NULL, &supported_usage,
2774 (hwctx->
usage & VK_IMAGE_USAGE_STORAGE_BIT));
2780 if (!hwctx->
usage) {
2781 hwctx->
usage = supported_usage & (VK_BUFFER_USAGE_TRANSFER_DST_BIT |
2782 VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
2783 VK_IMAGE_USAGE_STORAGE_BIT |
2784 VK_IMAGE_USAGE_SAMPLED_BIT);
2787 if ((supported_usage & VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) &&
2790 hwctx->
usage |= VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR;
2797 int is_lone_dpb = ((hwctx->
usage & VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR) ||
2798 ((hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR) &&
2799 !(hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)));
2800 int sampleable = hwctx->
usage & (VK_IMAGE_USAGE_SAMPLED_BIT |
2801 VK_IMAGE_USAGE_STORAGE_BIT);
2802 hwctx->
img_flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
2803 if (sampleable && !is_lone_dpb) {
2804 hwctx->
img_flags |= VK_IMAGE_CREATE_ALIAS_BIT;
2806 hwctx->
img_flags |= VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
2814 if ((hwctx->
usage & VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) &&
2817 const VkVideoProfileListInfoKHR *pl;
2820 hwctx->
img_flags |= VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR;
2823 for (
i = 0;
i < pl->profileCount;
i++) {
2825 if (pl->pProfiles[
i].videoCodecOperation & 0xFFFF0000)
2828 if (
i == pl->profileCount)
2829 hwctx->
img_flags |= VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR;
2920 static const struct {
2921 uint32_t drm_fourcc;
2923 } vulkan_drm_format_map[] = {
2924 { DRM_FORMAT_R8, VK_FORMAT_R8_UNORM },
2925 { DRM_FORMAT_R16, VK_FORMAT_R16_UNORM },
2926 { DRM_FORMAT_GR88, VK_FORMAT_R8G8_UNORM },
2927 { DRM_FORMAT_RG88, VK_FORMAT_R8G8_UNORM },
2928 { DRM_FORMAT_GR1616, VK_FORMAT_R16G16_UNORM },
2929 { DRM_FORMAT_RG1616, VK_FORMAT_R16G16_UNORM },
2930 { DRM_FORMAT_ARGB8888, VK_FORMAT_B8G8R8A8_UNORM },
2931 { DRM_FORMAT_XRGB8888, VK_FORMAT_B8G8R8A8_UNORM },
2932 { DRM_FORMAT_ABGR8888, VK_FORMAT_R8G8B8A8_UNORM },
2933 { DRM_FORMAT_XBGR8888, VK_FORMAT_R8G8B8A8_UNORM },
2934 { DRM_FORMAT_ARGB2101010, VK_FORMAT_A2B10G10R10_UNORM_PACK32 },
2935 { DRM_FORMAT_ABGR2101010, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
2936 { DRM_FORMAT_XRGB2101010, VK_FORMAT_A2B10G10R10_UNORM_PACK32 },
2937 { DRM_FORMAT_XBGR2101010, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
2940 #ifdef DRM_FORMAT_XYUV8888
2941 { DRM_FORMAT_XYUV8888, VK_FORMAT_R8G8B8A8_UNORM },
2942 { DRM_FORMAT_XVYU2101010, VK_FORMAT_A2R10G10B10_UNORM_PACK32 } ,
2943 { DRM_FORMAT_XVYU12_16161616, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 } ,
2944 { DRM_FORMAT_XVYU16161616, VK_FORMAT_R16G16B16A16_UNORM } ,
2948 static inline VkFormat drm_to_vulkan_fmt(uint32_t drm_fourcc)
2951 if (vulkan_drm_format_map[
i].drm_fourcc == drm_fourcc)
2952 return vulkan_drm_format_map[
i].vk_format;
2953 return VK_FORMAT_UNDEFINED;
2962 int bind_counts = 0;
2972 if (drm_to_vulkan_fmt(
desc->layers[
i].format) == VK_FORMAT_UNDEFINED) {
2974 desc->layers[
i].format);
2985 f->tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
2987 for (
int i = 0;
i <
desc->nb_layers;
i++) {
2991 VkSemaphoreTypeCreateInfo sem_type_info = {
2992 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
2993 .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
2996 VkSemaphoreCreateInfo sem_spawn = {
2997 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
2998 .pNext = &sem_type_info,
3003 VkImageDrmFormatModifierExplicitCreateInfoEXT ext_img_mod_spec = {
3004 .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
3005 .drmFormatModifier =
desc->objects[0].format_modifier,
3006 .drmFormatModifierPlaneCount =
planes,
3007 .pPlaneLayouts = (
const VkSubresourceLayout *)&ext_img_layouts,
3009 VkExternalMemoryImageCreateInfo ext_img_spec = {
3010 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
3011 .pNext = &ext_img_mod_spec,
3012 .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
3014 VkImageCreateInfo create_info = {
3015 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
3016 .pNext = &ext_img_spec,
3017 .imageType = VK_IMAGE_TYPE_2D,
3018 .format = drm_to_vulkan_fmt(
desc->layers[
i].format),
3023 .tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT,
3024 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
3026 .samples = VK_SAMPLE_COUNT_1_BIT,
3027 .pQueueFamilyIndices = p->
img_qfs,
3029 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
3030 VK_SHARING_MODE_EXCLUSIVE,
3034 VkExternalImageFormatProperties ext_props = {
3035 .sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
3037 VkImageFormatProperties2 props_ret = {
3038 .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
3039 .pNext = &ext_props,
3041 VkPhysicalDeviceImageDrmFormatModifierInfoEXT props_drm_mod = {
3042 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
3043 .drmFormatModifier = ext_img_mod_spec.drmFormatModifier,
3044 .pQueueFamilyIndices = create_info.pQueueFamilyIndices,
3045 .queueFamilyIndexCount = create_info.queueFamilyIndexCount,
3046 .sharingMode = create_info.sharingMode,
3048 VkPhysicalDeviceExternalImageFormatInfo props_ext = {
3049 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
3050 .pNext = &props_drm_mod,
3051 .handleType = ext_img_spec.handleTypes,
3053 VkPhysicalDeviceImageFormatInfo2 fmt_props;
3056 create_info.usage |= VK_IMAGE_USAGE_SAMPLED_BIT |
3057 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
3059 create_info.usage |= VK_IMAGE_USAGE_STORAGE_BIT |
3060 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3062 fmt_props = (VkPhysicalDeviceImageFormatInfo2) {
3063 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
3064 .pNext = &props_ext,
3065 .format = create_info.format,
3066 .type = create_info.imageType,
3067 .tiling = create_info.tiling,
3068 .usage = create_info.usage,
3069 .flags = create_info.flags,
3073 ret = vk->GetPhysicalDeviceImageFormatProperties2(hwctx->
phys_dev,
3074 &fmt_props, &props_ret);
3075 if (
ret != VK_SUCCESS) {
3083 get_plane_wh(&create_info.extent.width, &create_info.extent.height,
3087 for (
int j = 0; j <
planes; j++) {
3088 ext_img_layouts[j].offset =
desc->layers[
i].planes[j].offset;
3089 ext_img_layouts[j].rowPitch =
desc->layers[
i].planes[j].pitch;
3090 ext_img_layouts[j].size = 0;
3091 ext_img_layouts[j].arrayPitch = 0;
3092 ext_img_layouts[j].depthPitch = 0;
3096 ret = vk->CreateImage(hwctx->
act_dev, &create_info,
3098 if (
ret != VK_SUCCESS) {
3105 ret = vk->CreateSemaphore(hwctx->
act_dev, &sem_spawn,
3107 if (
ret != VK_SUCCESS) {
3114 f->queue_family[
i] = VK_QUEUE_FAMILY_EXTERNAL;
3115 f->layout[
i] = create_info.initialLayout;
3117 f->sem_value[
i] = 0;
3120 for (
int i = 0;
i <
desc->nb_layers;
i++) {
3122 VkImageMemoryRequirementsInfo2 req_desc = {
3123 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
3126 VkMemoryDedicatedRequirements ded_req = {
3127 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
3129 VkMemoryRequirements2 req2 = {
3130 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
3135 VkMemoryFdPropertiesKHR fdmp = {
3136 .sType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR,
3142 VkImportMemoryFdInfoKHR idesc = {
3143 .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
3144 .fd = dup(
desc->objects[
desc->layers[
i].planes[0].object_index].fd),
3145 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
3147 VkMemoryDedicatedAllocateInfo ded_alloc = {
3148 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
3150 .image = req_desc.image,
3154 ret = vk->GetMemoryFdPropertiesKHR(hwctx->
act_dev,
3155 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
3157 if (
ret != VK_SUCCESS) {
3165 vk->GetImageMemoryRequirements2(hwctx->
act_dev, &req_desc, &req2);
3168 req2.memoryRequirements.memoryTypeBits = fdmp.memoryTypeBits;
3171 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
3172 (ded_req.prefersDedicatedAllocation ||
3173 ded_req.requiresDedicatedAllocation) ?
3174 &ded_alloc : ded_alloc.pNext,
3175 &
f->flags, &
f->mem[
i]);
3181 f->size[
i] = req2.memoryRequirements.size;
3184 for (
int i = 0;
i <
desc->nb_layers;
i++) {
3186 for (
int j = 0; j <
planes; j++) {
3187 VkImageAspectFlagBits aspect = j == 0 ? VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT :
3188 j == 1 ? VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT :
3189 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT;
3191 plane_info[bind_counts].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
3193 plane_info[bind_counts].planeAspect = aspect;
3195 bind_info[bind_counts].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
3197 bind_info[bind_counts].image =
f->img[
i];
3198 bind_info[bind_counts].memory =
f->mem[
i];
3201 bind_info[bind_counts].memoryOffset = 0;
3208 ret = vk->BindImageMemory2(hwctx->
act_dev, bind_counts, bind_info);
3209 if (
ret != VK_SUCCESS) {
3239 #ifdef DMA_BUF_IOCTL_EXPORT_SYNC_FILE
3241 VkCommandBuffer cmd_buf;
3247 for (
int i = 0;
i <
desc->nb_objects;
i++) {
3248 VkSemaphoreTypeCreateInfo sem_type_info = {
3249 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
3250 .semaphoreType = VK_SEMAPHORE_TYPE_BINARY,
3252 VkSemaphoreCreateInfo sem_spawn = {
3253 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
3254 .pNext = &sem_type_info,
3256 VkImportSemaphoreFdInfoKHR import_info;
3257 struct dma_buf_export_sync_file implicit_fd_info = {
3258 .flags = DMA_BUF_SYNC_READ,
3262 if (ioctl(
desc->objects[
i].fd, DMA_BUF_IOCTL_EXPORT_SYNC_FILE,
3263 &implicit_fd_info)) {
3268 vk->DestroySemaphore(hwctx->
act_dev, drm_sync_sem[
i], hwctx->
alloc);
3272 ret = vk->CreateSemaphore(hwctx->
act_dev, &sem_spawn,
3273 hwctx->
alloc, &drm_sync_sem[
i]);
3274 if (
ret != VK_SUCCESS) {
3279 vk->DestroySemaphore(hwctx->
act_dev, drm_sync_sem[
i], hwctx->
alloc);
3283 import_info = (VkImportSemaphoreFdInfoKHR) {
3284 .sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
3285 .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
3286 .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
3287 .semaphore = drm_sync_sem[
i],
3288 .fd = implicit_fd_info.fd,
3291 ret = vk->ImportSemaphoreFdKHR(hwctx->
act_dev, &import_info);
3292 if (
ret != VK_SUCCESS) {
3297 vk->DestroySemaphore(hwctx->
act_dev, drm_sync_sem[
i], hwctx->
alloc);
3303 cmd_buf = exec->
buf;
3309 drm_sync_sem,
desc->nb_objects,
3310 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, 1);
3315 VK_PIPELINE_STAGE_2_NONE,
3316 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT);
3321 VK_PIPELINE_STAGE_2_NONE,
3322 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
3324 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : 0x0) |
3326 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT : 0x0),
3327 VK_IMAGE_LAYOUT_GENERAL,
3328 VK_QUEUE_FAMILY_IGNORED);
3330 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
3331 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
3332 .pImageMemoryBarriers = img_bar,
3333 .imageMemoryBarrierCount = nb_img_bar,
3344 "image may be corrupted.\n");
3359 if ((err = vulkan_map_from_drm_frame_desc(hwfc, &
f,
src,
flags)))
3363 dst->data[0] = (uint8_t *)
f;
3365 dst->height =
src->height;
3368 &vulkan_unmap_from_drm,
f);
3372 err = vulkan_map_from_drm_frame_sync(hwfc,
dst,
src,
flags);
3395 VASurfaceID surface_id = (VASurfaceID)(uintptr_t)
src->data[3];
3401 vaSyncSurface(vaapi_ctx->display, surface_id);
3409 err = vulkan_map_from_drm(dst_fc,
dst,
tmp,
flags);
3426 VkDeviceMemory mem,
size_t size)
3434 CUDA_EXTERNAL_MEMORY_HANDLE_DESC ext_desc = {
3435 .type = IsWindows8OrGreater()
3436 ? CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
3437 : CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT,
3440 VkMemoryGetWin32HandleInfoKHR export_info = {
3441 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
3443 .handleType = IsWindows8OrGreater()
3444 ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
3445 : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
3448 ret = vk->GetMemoryWin32HandleKHR(hwctx->
act_dev, &export_info,
3449 &ext_desc.handle.win32.handle);
3450 if (
ret != VK_SUCCESS) {
3455 dst_int->ext_mem_handle[idx] = ext_desc.handle.win32.handle;
3457 CUDA_EXTERNAL_MEMORY_HANDLE_DESC ext_desc = {
3458 .type = CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD,
3461 VkMemoryGetFdInfoKHR export_info = {
3462 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
3464 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
3467 ret = vk->GetMemoryFdKHR(hwctx->
act_dev, &export_info,
3468 &ext_desc.handle.fd);
3469 if (
ret != VK_SUCCESS) {
3476 ret =
CHECK_CU(cu->cuImportExternalMemory(&dst_int->ext_mem[idx], &ext_desc));
3479 close(ext_desc.handle.fd);
3498 VkSemaphoreGetWin32HandleInfoKHR sem_export = {
3499 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
3501 .handleType = IsWindows8OrGreater()
3502 ? VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
3503 : VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
3505 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC ext_sem_desc = {
3509 VkSemaphoreGetFdInfoKHR sem_export = {
3510 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
3512 .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
3514 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC ext_sem_desc = {
3520 ret = vk->GetSemaphoreWin32HandleKHR(hwctx->
act_dev, &sem_export,
3521 &ext_sem_desc.handle.win32.handle);
3523 ret = vk->GetSemaphoreFdKHR(hwctx->
act_dev, &sem_export,
3524 &ext_sem_desc.handle.fd);
3526 if (
ret != VK_SUCCESS) {
3532 dst_int->ext_sem_handle[idx] = ext_sem_desc.handle.win32.handle;
3535 ret =
CHECK_CU(cu->cuImportExternalSemaphore(&dst_int->cu_sem[idx],
3539 close(ext_sem_desc.handle.fd);
3567 CudaFunctions *cu = cu_internal->
cuda_dl;
3568 CUarray_format cufmt =
desc->comp[0].depth > 8 ? CU_AD_FORMAT_UNSIGNED_INT16 :
3569 CU_AD_FORMAT_UNSIGNED_INT8;
3574 if (!dst_int->cuda_fc_ref) {
3578 if (!dst_int->cuda_fc_ref)
3582 for (
int i = 0;
i < nb_images;
i++) {
3583 err = export_mem_to_cuda(
ctx, cuda_cu, cu, dst_int,
i,
3588 err = export_sem_to_cuda(
ctx, cuda_cu, cu, dst_int,
i,
3594 if (nb_images !=
planes) {
3596 VkImageSubresource subres = {
3597 .aspectMask =
i == 2 ? VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT :
3598 i == 1 ? VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT :
3599 VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT
3601 VkSubresourceLayout
layout = { 0 };
3602 vk->GetImageSubresourceLayout(hwctx->
act_dev, dst_f->
img[
FFMIN(
i, nb_images - 1)],
3609 CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC tex_desc = {
3614 .NumChannels = 1 + ((
planes == 2) &&
i),
3622 tex_desc.arrayDesc.Width = p_w;
3623 tex_desc.arrayDesc.Height = p_h;
3625 ret =
CHECK_CU(cu->cuExternalMemoryGetMappedMipmappedArray(&dst_int->cu_mma[
i],
3626 dst_int->ext_mem[
FFMIN(
i, nb_images - 1)],
3633 ret =
CHECK_CU(cu->cuMipmappedArrayGetLevel(&dst_int->cu_array[
i],
3634 dst_int->cu_mma[
i], 0));
3665 CudaFunctions *cu = cu_internal->
cuda_dl;
3675 err =
CHECK_CU(cu->cuCtxPushCurrent(cuda_dev->cuda_ctx));
3679 err = vulkan_export_to_cuda(hwfc,
src->hw_frames_ctx,
dst);
3688 s_w_par[
i].params.fence.value = dst_f->
sem_value[
i] + 0;
3689 s_s_par[
i].params.fence.value = dst_f->
sem_value[
i] + 1;
3692 err =
CHECK_CU(cu->cuWaitExternalSemaphoresAsync(dst_int->cu_sem, s_w_par,
3693 planes, cuda_dev->stream));
3698 CUDA_MEMCPY2D cpy = {
3699 .srcMemoryType = CU_MEMORYTYPE_DEVICE,
3700 .srcDevice = (CUdeviceptr)
src->data[
i],
3701 .srcPitch =
src->linesize[
i],
3704 .dstMemoryType = CU_MEMORYTYPE_ARRAY,
3705 .dstArray = dst_int->cu_array[
i],
3711 cpy.WidthInBytes = p_w *
desc->comp[
i].step;
3714 err =
CHECK_CU(cu->cuMemcpy2DAsync(&cpy, cuda_dev->stream));
3719 err =
CHECK_CU(cu->cuSignalExternalSemaphoresAsync(dst_int->cu_sem, s_s_par,
3720 planes, cuda_dev->stream));
3746 switch (
src->format) {
3751 return vulkan_map_from_vaapi(hwfc,
dst,
src,
flags);
3757 return vulkan_map_from_drm(hwfc,
dst,
src,
flags);
3767 typedef struct VulkanDRMMapping {
3782 static inline uint32_t vulkan_fmt_to_drm(
VkFormat vkfmt)
3785 if (vulkan_drm_format_map[
i].vk_format == vkfmt)
3786 return vulkan_drm_format_map[
i].drm_fourcc;
3787 return DRM_FORMAT_INVALID;
3801 VkImageDrmFormatModifierPropertiesEXT drm_mod = {
3802 .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
3804 VkSemaphoreWaitInfo wait_info = {
3805 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
3807 .semaphoreCount =
planes,
3819 wait_info.pSemaphores =
f->sem;
3820 wait_info.pValues =
f->sem_value;
3822 vk->WaitSemaphores(hwctx->
act_dev, &wait_info, UINT64_MAX);
3828 ret = vk->GetImageDrmFormatModifierPropertiesEXT(hwctx->
act_dev,
f->img[0],
3830 if (
ret != VK_SUCCESS) {
3836 for (
int i = 0; (
i <
planes) && (
f->mem[
i]);
i++) {
3837 VkMemoryGetFdInfoKHR export_info = {
3838 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
3839 .memory =
f->mem[
i],
3840 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
3843 ret = vk->GetMemoryFdKHR(hwctx->
act_dev, &export_info,
3845 if (
ret != VK_SUCCESS) {
3858 VkSubresourceLayout
layout;
3859 VkImageSubresource sub = {
3860 .aspectMask = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT,
3864 drm_desc->
layers[
i].
format = vulkan_fmt_to_drm(plane_vkfmt);
3875 if (
f->tiling == VK_IMAGE_TILING_OPTIMAL)
3878 vk->GetImageSubresourceLayout(hwctx->
act_dev,
f->img[
i], &sub, &
layout);
3884 dst->height =
src->height;
3885 dst->data[0] = (uint8_t *)drm_desc;
3929 switch (
dst->format) {
3939 return vulkan_map_to_vaapi(hwfc,
dst,
src,
flags);
3951 AVFrame *swf, VkBufferImageCopy *region,
3961 const VkMappedMemoryRange flush_info = {
3962 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
3963 .memory = vkbuf->
mem,
3964 .size = VK_WHOLE_SIZE,
3967 if (!upload && !(vkbuf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
3968 ret = vk->InvalidateMappedMemoryRanges(hwctx->
act_dev, 1,
3970 if (
ret != VK_SUCCESS) {
3980 region[
i].bufferRowLength,
3984 region[
i].imageExtent.height);
3989 vkbuf->mapped_mem + region[
i].bufferOffset,
3990 region[
i].bufferRowLength,
3992 region[
i].imageExtent.height);
3995 if (upload && !(vkbuf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
3996 ret = vk->FlushMappedMemoryRanges(hwctx->
act_dev, 1,
3998 if (
ret != VK_SUCCESS) {
4009 AVFrame *swf, VkBufferImageCopy *region,
int upload)
4016 VkBufferUsageFlags buf_usage = upload ? VK_BUFFER_USAGE_TRANSFER_SRC_BIT :
4017 VK_BUFFER_USAGE_TRANSFER_DST_BIT;
4019 size_t buf_offset = 0;
4023 region[
i] = (VkBufferImageCopy) {
4024 .bufferOffset = buf_offset,
4026 p->
props.properties.limits.optimalBufferCopyRowPitchAlignment),
4027 .bufferImageHeight = p_h,
4028 .imageSubresource.layerCount = 1,
4029 .imageExtent = (VkExtent3D){ p_w, p_h, 1 },
4033 buf_offset +=
FFALIGN(p_h*region[
i].bufferRowLength,
4034 p->
props.properties.limits.optimalBufferCopyOffsetAlignment);
4039 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
4040 VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
4048 AVFrame *swf, VkBufferImageCopy *region,
int upload)
4055 VkBufferUsageFlags buf_usage = upload ? VK_BUFFER_USAGE_TRANSFER_SRC_BIT :
4056 VK_BUFFER_USAGE_TRANSFER_DST_BIT;
4065 while (swf->
buf[nb_src_bufs])
4069 if (nb_src_bufs == 1) {
4080 }
else if (nb_src_bufs ==
planes) {
4099 for (
int i = 0;
i < (*nb_bufs);
i++)
4113 int host_mapped = 0;
4128 VkCommandBuffer cmd_buf;
4145 region[
i] = (VkBufferImageCopy) {
4148 .bufferImageHeight = p_h,
4149 .imageSubresource.layerCount = 1,
4150 .imageExtent = (VkExtent3D){ p_w, p_h, 1 },
4176 cmd_buf = exec->
buf;
4182 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
4183 VK_PIPELINE_STAGE_2_TRANSFER_BIT);
4207 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
4208 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,
4209 upload ? VK_ACCESS_TRANSFER_WRITE_BIT :
4210 VK_ACCESS_TRANSFER_READ_BIT,
4211 upload ? VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL :
4212 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4213 VK_QUEUE_FAMILY_IGNORED);
4215 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
4216 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
4217 .pImageMemoryBarriers = img_bar,
4218 .imageMemoryBarrierCount = nb_img_bar,
4222 int buf_idx =
FFMIN(
i, (nb_bufs - 1));
4223 int img_idx =
FFMIN(
i, (nb_images - 1));
4226 uint32_t orig_stride = region[
i].bufferRowLength;
4227 region[
i].bufferRowLength /=
desc->comp[
i].step;
4231 vk->CmdCopyBufferToImage(cmd_buf, vkbuf->
buf,
4232 hwf_vk->
img[img_idx],
4233 img_bar[img_idx].newLayout,
4236 vk->CmdCopyImageToBuffer(cmd_buf, hwf_vk->
img[img_idx],
4237 img_bar[img_idx].newLayout,
4241 region[
i].bufferRowLength = orig_stride;
4247 }
else if (!upload) {
4254 for (
int i = 0;
i < nb_bufs;
i++)
4265 switch (
src->format) {
4275 return vulkan_transfer_data_from_cuda(hwfc,
dst,
src);
4278 if (
src->hw_frames_ctx)
4302 CudaFunctions *cu = cu_internal->
cuda_dl;
4313 err =
CHECK_CU(cu->cuCtxPushCurrent(cuda_dev->cuda_ctx));
4317 err = vulkan_export_to_cuda(hwfc,
dst->hw_frames_ctx,
src);
4326 s_w_par[
i].params.fence.value = dst_f->
sem_value[
i] + 0;
4327 s_s_par[
i].params.fence.value = dst_f->
sem_value[
i] + 1;
4330 err =
CHECK_CU(cu->cuWaitExternalSemaphoresAsync(dst_int->cu_sem, s_w_par,
4331 nb_images, cuda_dev->stream));
4336 CUDA_MEMCPY2D cpy = {
4337 .dstMemoryType = CU_MEMORYTYPE_DEVICE,
4338 .dstDevice = (CUdeviceptr)
dst->data[
i],
4339 .dstPitch =
dst->linesize[
i],
4342 .srcMemoryType = CU_MEMORYTYPE_ARRAY,
4343 .srcArray = dst_int->cu_array[
i],
4349 cpy.WidthInBytes =
w *
desc->comp[
i].step;
4352 err =
CHECK_CU(cu->cuMemcpy2DAsync(&cpy, cuda_dev->stream));
4357 err =
CHECK_CU(cu->cuSignalExternalSemaphoresAsync(dst_int->cu_sem, s_s_par,
4358 nb_images, cuda_dev->stream));
4384 switch (
dst->format) {
4394 return vulkan_transfer_data_to_cuda(hwfc,
dst,
src);
4397 if (
dst->hw_frames_ctx)