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)
85 #ifdef VK_KHR_shader_expect_assume
86 VkPhysicalDeviceShaderExpectAssumeFeaturesKHR expect_assume;
90 #ifdef VK_KHR_video_maintenance2
91 VkPhysicalDeviceVideoMaintenance2FeaturesKHR video_maintenance_2;
93 #ifdef VK_KHR_video_decode_vp9
94 VkPhysicalDeviceVideoDecodeVP9FeaturesKHR vp9_decode;
96 #ifdef VK_KHR_video_encode_av1
97 VkPhysicalDeviceVideoEncodeAV1FeaturesKHR av1_encode;
105 #ifdef VK_KHR_shader_relaxed_extended_instruction
106 VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR relaxed_extended_instruction;
126 VkPhysicalDeviceExternalMemoryHostPropertiesEXT
hprops;
210 feats->
device = (VkPhysicalDeviceFeatures2) {
211 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
215 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
217 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
219 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
222 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
224 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR);
226 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT);
228 #ifdef VK_KHR_shader_expect_assume
230 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR);
234 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR);
235 #ifdef VK_KHR_video_maintenance2
237 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR);
239 #ifdef VK_KHR_video_decode_vp9
241 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR);
243 #ifdef VK_KHR_video_encode_av1
245 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR);
249 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT);
251 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR);
253 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
255 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
257 #ifdef VK_KHR_shader_relaxed_extended_instruction
259 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR);
266 #define COPY_VAL(VAL) \
268 dst->VAL = src->VAL; \
271 COPY_VAL(device.features.shaderImageGatherExtended);
272 COPY_VAL(device.features.shaderStorageImageReadWithoutFormat);
273 COPY_VAL(device.features.shaderStorageImageWriteWithoutFormat);
274 COPY_VAL(device.features.fragmentStoresAndAtomics);
275 COPY_VAL(device.features.vertexPipelineStoresAndAtomics);
276 COPY_VAL(device.features.shaderInt64);
277 COPY_VAL(device.features.shaderInt16);
278 COPY_VAL(device.features.shaderFloat64);
279 COPY_VAL(device.features.shaderStorageImageReadWithoutFormat);
280 COPY_VAL(device.features.shaderStorageImageWriteWithoutFormat);
282 COPY_VAL(vulkan_1_1.samplerYcbcrConversion);
283 COPY_VAL(vulkan_1_1.storagePushConstant16);
284 COPY_VAL(vulkan_1_1.storageBuffer16BitAccess);
285 COPY_VAL(vulkan_1_1.uniformAndStorageBuffer16BitAccess);
287 COPY_VAL(vulkan_1_2.timelineSemaphore);
288 COPY_VAL(vulkan_1_2.scalarBlockLayout);
289 COPY_VAL(vulkan_1_2.bufferDeviceAddress);
290 COPY_VAL(vulkan_1_2.hostQueryReset);
291 COPY_VAL(vulkan_1_2.storagePushConstant8);
293 COPY_VAL(vulkan_1_2.storageBuffer8BitAccess);
294 COPY_VAL(vulkan_1_2.uniformAndStorageBuffer8BitAccess);
296 COPY_VAL(vulkan_1_2.shaderBufferInt64Atomics);
297 COPY_VAL(vulkan_1_2.shaderSharedInt64Atomics);
298 COPY_VAL(vulkan_1_2.vulkanMemoryModel);
299 COPY_VAL(vulkan_1_2.vulkanMemoryModelDeviceScope);
300 COPY_VAL(vulkan_1_2.uniformBufferStandardLayout);
302 COPY_VAL(vulkan_1_3.dynamicRendering);
304 COPY_VAL(vulkan_1_3.synchronization2);
305 COPY_VAL(vulkan_1_3.computeFullSubgroups);
306 COPY_VAL(vulkan_1_3.subgroupSizeControl);
307 COPY_VAL(vulkan_1_3.shaderZeroInitializeWorkgroupMemory);
308 COPY_VAL(vulkan_1_3.dynamicRendering);
310 COPY_VAL(timeline_semaphore.timelineSemaphore);
311 COPY_VAL(subgroup_rotate.shaderSubgroupRotate);
312 COPY_VAL(host_image_copy.hostImageCopy);
314 COPY_VAL(video_maintenance_1.videoMaintenance1);
315 #ifdef VK_KHR_video_maintenance2
316 COPY_VAL(video_maintenance_2.videoMaintenance2);
319 #ifdef VK_KHR_video_decode_vp9
320 COPY_VAL(vp9_decode.videoDecodeVP9);
323 #ifdef VK_KHR_video_encode_av1
324 COPY_VAL(av1_encode.videoEncodeAV1);
327 COPY_VAL(shader_object.shaderObject);
329 COPY_VAL(cooperative_matrix.cooperativeMatrix);
331 COPY_VAL(descriptor_buffer.descriptorBuffer);
332 COPY_VAL(descriptor_buffer.descriptorBufferPushDescriptors);
334 COPY_VAL(atomic_float.shaderBufferFloat32Atomics);
335 COPY_VAL(atomic_float.shaderBufferFloat32AtomicAdd);
337 #ifdef VK_KHR_shader_relaxed_extended_instruction
338 COPY_VAL(relaxed_extended_instruction.shaderRelaxedExtendedInstruction);
341 #ifdef VK_KHR_shader_expect_assume
342 COPY_VAL(expect_assume.shaderExpectAssume);
348 #define ASPECT_2PLANE (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT)
349 #define ASPECT_3PLANE (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT)
361 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_GRAY8, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8_UNORM } },
362 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY10, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
363 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY12, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
364 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY14, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
365 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY16, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
366 { VK_FORMAT_R32_UINT,
AV_PIX_FMT_GRAY32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32_UINT } },
367 { VK_FORMAT_R32_SFLOAT,
AV_PIX_FMT_GRAYF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32_SFLOAT } },
370 { VK_FORMAT_B8G8R8A8_UNORM,
AV_PIX_FMT_BGRA, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8A8_UNORM } },
371 { VK_FORMAT_R8G8B8A8_UNORM,
AV_PIX_FMT_RGBA, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
372 { VK_FORMAT_R8G8B8_UNORM,
AV_PIX_FMT_RGB24, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8_UNORM } },
373 { VK_FORMAT_B8G8R8_UNORM,
AV_PIX_FMT_BGR24, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8_UNORM } },
374 { VK_FORMAT_R16G16B16_UNORM,
AV_PIX_FMT_RGB48, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16_UNORM } },
375 { VK_FORMAT_R16G16B16A16_UNORM,
AV_PIX_FMT_RGBA64, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
376 { VK_FORMAT_R5G6B5_UNORM_PACK16,
AV_PIX_FMT_RGB565, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R5G6B5_UNORM_PACK16 } },
377 { VK_FORMAT_B5G6R5_UNORM_PACK16,
AV_PIX_FMT_BGR565, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B5G6R5_UNORM_PACK16 } },
378 { VK_FORMAT_B8G8R8A8_UNORM,
AV_PIX_FMT_BGR0, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8A8_UNORM } },
379 { VK_FORMAT_R8G8B8A8_UNORM,
AV_PIX_FMT_RGB0, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
380 { VK_FORMAT_A2R10G10B10_UNORM_PACK32,
AV_PIX_FMT_X2RGB10, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_A2R10G10B10_UNORM_PACK32 } },
381 { VK_FORMAT_A2B10G10R10_UNORM_PACK32,
AV_PIX_FMT_X2BGR10, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_A2B10G10R10_UNORM_PACK32 } },
382 { VK_FORMAT_R32G32B32_SFLOAT,
AV_PIX_FMT_RGBF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32G32B32_SFLOAT } },
383 { VK_FORMAT_R32G32B32A32_SFLOAT,
AV_PIX_FMT_RGBAF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32G32B32A32_SFLOAT } },
384 { VK_FORMAT_R32G32B32_UINT,
AV_PIX_FMT_RGB96, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32G32B32_UINT } },
385 { VK_FORMAT_R32G32B32A32_UINT,
AV_PIX_FMT_RGBA128, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32G32B32A32_UINT } },
388 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_GBRP, VK_IMAGE_ASPECT_COLOR_BIT, 3, 3, 3, { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM } },
389 { 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 } },
390 { 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 } },
391 { 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 } },
392 { 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 } },
393 { 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 } },
396 { 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 } },
397 { 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 } },
398 { 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 } },
399 { 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 } },
400 { 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 } },
401 { 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 } },
402 { 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 } },
409 { 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 } },
410 { 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 } },
415 { 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 } },
416 { 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 } },
421 { 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 } },
422 { 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 } },
440 { VK_FORMAT_G8B8G8R8_422_UNORM,
AV_PIX_FMT_YUYV422, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
441 { VK_FORMAT_B8G8R8G8_422_UNORM,
AV_PIX_FMT_UYVY422, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
442 { VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
AV_PIX_FMT_Y210, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
443 { VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
AV_PIX_FMT_Y212, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
444 { VK_FORMAT_G16B16G16R16_422_UNORM,
AV_PIX_FMT_Y216, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
447 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_YUVA420P, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM } },
448 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_YUVA420P10, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
449 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_YUVA420P16, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
452 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_YUVA422P, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM } },
453 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_YUVA422P10, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
454 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_YUVA422P12, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
455 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_YUVA422P16, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
458 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_YUVA444P, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM } },
459 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_YUVA444P10, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
460 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_YUVA444P12, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
461 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_YUVA444P16, VK_IMAGE_ASPECT_COLOR_BIT, 4, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
464 { VK_FORMAT_B8G8R8A8_UNORM,
AV_PIX_FMT_UYVA, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8A8_UNORM } },
465 { VK_FORMAT_A2R10G10B10_UNORM_PACK32,
AV_PIX_FMT_XV30, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
466 { VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
AV_PIX_FMT_XV36, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
467 { VK_FORMAT_R16G16B16A16_UNORM,
AV_PIX_FMT_XV48, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
488 VkImageTiling tiling,
491 VkImageAspectFlags *
aspect,
492 VkImageUsageFlags *supported_usage,
493 int disable_multiplane,
int need_storage)
499 const VkFormatFeatureFlagBits2 basic_flags = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT |
500 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
501 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
505 VkFormatProperties3 fprops = {
506 .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3,
508 VkFormatProperties2 prop = {
509 .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
512 VkFormatFeatureFlagBits2 feats_primary, feats_secondary;
513 int basics_primary = 0, basics_secondary = 0;
514 int storage_primary = 0, storage_secondary = 0;
516 vk->GetPhysicalDeviceFormatProperties2(hwctx->
phys_dev,
520 feats_primary = tiling == VK_IMAGE_TILING_LINEAR ?
521 fprops.linearTilingFeatures : fprops.optimalTilingFeatures;
522 basics_primary = (feats_primary & basic_flags) == basic_flags;
523 storage_primary = !!(feats_primary & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT);
526 vk->GetPhysicalDeviceFormatProperties2(hwctx->
phys_dev,
529 feats_secondary = tiling == VK_IMAGE_TILING_LINEAR ?
530 fprops.linearTilingFeatures : fprops.optimalTilingFeatures;
531 basics_secondary = (feats_secondary & basic_flags) == basic_flags;
532 storage_secondary = !!(feats_secondary & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT);
534 basics_secondary = basics_primary;
535 storage_secondary = storage_primary;
538 if (basics_primary &&
540 (!need_storage || (need_storage && (storage_primary | storage_secondary)))) {
555 ((need_storage && (storage_primary | storage_secondary)) ?
556 VK_IMAGE_USAGE_STORAGE_BIT : 0);
558 }
else if (basics_secondary &&
559 (!need_storage || (need_storage && storage_secondary))) {
580 #if CONFIG_VULKAN_STATIC
581 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance,
590 #if CONFIG_VULKAN_STATIC
593 static const char *lib_names[] = {
596 #elif defined(__APPLE__)
607 p->
libvulkan = dlopen(lib_names[
i], RTLD_NOW | RTLD_LOCAL);
645 #ifdef VK_KHR_shader_expect_assume
649 #ifdef VK_KHR_video_maintenance2
672 #ifdef VK_KHR_video_decode_vp9
675 #ifdef VK_KHR_video_encode_av1
681 static VkBool32 VKAPI_CALL
vk_dbg_callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
682 VkDebugUtilsMessageTypeFlagsEXT messageType,
683 const VkDebugUtilsMessengerCallbackDataEXT *
data,
690 switch (
data->messageIdNumber) {
701 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: l =
AV_LOG_VERBOSE;
break;
702 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: l =
AV_LOG_INFO;
break;
703 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: l =
AV_LOG_WARNING;
break;
704 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: l =
AV_LOG_ERROR;
break;
709 for (
int i = 0;
i <
data->cmdBufLabelCount;
i++)
715 #define ADD_VAL_TO_LIST(list, count, val) \
717 list = av_realloc_array(list, sizeof(*list), ++count); \
719 err = AVERROR(ENOMEM); \
722 list[count - 1] = av_strdup(val); \
723 if (!list[count - 1]) { \
724 err = AVERROR(ENOMEM); \
729 #define RELEASE_PROPS(props, count) \
731 for (int i = 0; i < count; i++) \
732 av_free((void *)((props)[i])); \
733 av_free((void *)props); \
751 const char *
const **
dst, uint32_t *num,
755 const char **extension_names =
NULL;
759 int err = 0, found, extensions_found = 0;
762 int optional_exts_num;
763 uint32_t sup_ext_count;
764 char *user_exts_str =
NULL;
766 VkExtensionProperties *sup_ext;
776 if (!user_exts_str) {
781 vk->EnumerateInstanceExtensionProperties(
NULL, &sup_ext_count,
NULL);
782 sup_ext =
av_malloc_array(sup_ext_count,
sizeof(VkExtensionProperties));
785 vk->EnumerateInstanceExtensionProperties(
NULL, &sup_ext_count, sup_ext);
793 if (!user_exts_str) {
798 vk->EnumerateDeviceExtensionProperties(hwctx->
phys_dev,
NULL,
799 &sup_ext_count,
NULL);
800 sup_ext =
av_malloc_array(sup_ext_count,
sizeof(VkExtensionProperties));
803 vk->EnumerateDeviceExtensionProperties(hwctx->
phys_dev,
NULL,
804 &sup_ext_count, sup_ext);
807 for (
int i = 0;
i < optional_exts_num;
i++) {
808 tstr = optional_exts[
i].
name;
812 if (p->
dprops.driverID == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA &&
813 !strcmp(tstr, VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME))
820 !strcmp(tstr, VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME)) {
824 for (
int j = 0; j < sup_ext_count; j++) {
825 if (!strcmp(tstr, sup_ext[j].extensionName)) {
842 tstr = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
844 for (
int j = 0; j < sup_ext_count; j++) {
845 if (!strcmp(tstr, sup_ext[j].extensionName)) {
861 #ifdef VK_KHR_shader_relaxed_extended_instruction
864 tstr = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME;
866 for (
int j = 0; j < sup_ext_count; j++) {
867 if (!strcmp(tstr, sup_ext[j].extensionName)) {
885 char *save, *token =
av_strtok(user_exts_str,
"+", &save);
888 for (
int j = 0; j < sup_ext_count; j++) {
889 if (!strcmp(token, sup_ext[j].extensionName)) {
905 *
dst = extension_names;
906 *num = extensions_found;
920 const char *
const **
dst, uint32_t *num,
927 static const char layer_standard_validation[] = {
"VK_LAYER_KHRONOS_validation" };
928 int layer_standard_validation_found = 0;
930 uint32_t sup_layer_count;
931 VkLayerProperties *sup_layers;
934 char *user_layers_str =
NULL;
937 const char **enabled_layers =
NULL;
938 uint32_t enabled_layers_count = 0;
946 vk->EnumerateInstanceLayerProperties(&sup_layer_count,
NULL);
947 sup_layers =
av_malloc_array(sup_layer_count,
sizeof(VkLayerProperties));
950 vk->EnumerateInstanceLayerProperties(&sup_layer_count, sup_layers);
953 for (
int i = 0;
i < sup_layer_count;
i++)
957 if (!debug_opt && !user_layers)
962 if (!strcmp(debug_opt->
value,
"profile")) {
964 }
else if (!strcmp(debug_opt->
value,
"printf")) {
966 }
else if (!strcmp(debug_opt->
value,
"validate")) {
968 }
else if (!strcmp(debug_opt->
value,
"practices")) {
971 char *end_ptr =
NULL;
972 int idx = strtol(debug_opt->
value, &end_ptr, 10);
973 if (end_ptr == debug_opt->
value || end_ptr[0] !=
'\0' ||
988 for (
int i = 0;
i < sup_layer_count;
i++) {
989 if (!strcmp(layer_standard_validation, sup_layers[
i].layerName)) {
991 layer_standard_validation);
992 ADD_VAL_TO_LIST(enabled_layers, enabled_layers_count, layer_standard_validation);
994 layer_standard_validation_found = 1;
998 if (!layer_standard_validation_found) {
1000 "Validation Layer \"%s\" not supported\n", layer_standard_validation);
1013 if (!user_layers_str) {
1018 token =
av_strtok(user_layers_str,
"+", &save);
1023 if (!strcmp(layer_standard_validation, token) && layer_standard_validation_found) {
1029 for (
int j = 0; j < sup_layer_count; j++) {
1030 if (!strcmp(token, sup_layers[j].layerName)) {
1041 if (!strcmp(layer_standard_validation, token))
1045 "Layer \"%s\" not supported\n", token);
1062 *
dst = enabled_layers;
1063 *num = enabled_layers_count;
1078 VkApplicationInfo application_info = {
1079 .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
1080 .pApplicationName =
"ffmpeg",
1084 .pEngineName =
"libavutil",
1085 .apiVersion = VK_API_VERSION_1_3,
1090 VkValidationFeaturesEXT validation_features = {
1091 .sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,
1093 VkInstanceCreateInfo inst_props = {
1094 .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
1095 .pApplicationInfo = &application_info,
1111 &inst_props.enabledLayerCount, debug_mode);
1117 &inst_props.enabledExtensionCount, *debug_mode);
1125 static const VkValidationFeatureEnableEXT feat_list_validate[] = {
1126 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT,
1127 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
1128 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
1130 validation_features.pEnabledValidationFeatures = feat_list_validate;
1131 validation_features.enabledValidationFeatureCount =
FF_ARRAY_ELEMS(feat_list_validate);
1132 inst_props.pNext = &validation_features;
1134 static const VkValidationFeatureEnableEXT feat_list_debug[] = {
1135 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT,
1136 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
1137 VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT,
1139 validation_features.pEnabledValidationFeatures = feat_list_debug;
1140 validation_features.enabledValidationFeatureCount =
FF_ARRAY_ELEMS(feat_list_debug);
1141 inst_props.pNext = &validation_features;
1143 static const VkValidationFeatureEnableEXT feat_list_practices[] = {
1144 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT,
1145 VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT,
1147 validation_features.pEnabledValidationFeatures = feat_list_practices;
1148 validation_features.enabledValidationFeatureCount =
FF_ARRAY_ELEMS(feat_list_practices);
1149 inst_props.pNext = &validation_features;
1153 for (
int i = 0;
i < inst_props.enabledExtensionCount;
i++) {
1154 if (!strcmp(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
1155 inst_props.ppEnabledExtensionNames[
i])) {
1156 inst_props.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
1163 ret = vk->CreateInstance(&inst_props, hwctx->
alloc, &hwctx->
inst);
1166 if (
ret != VK_SUCCESS) {
1183 VkDebugUtilsMessengerCreateInfoEXT dbg = {
1184 .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
1185 .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
1186 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT |
1187 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
1188 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
1189 .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
1190 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
1191 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
1196 vk->CreateDebugUtilsMessengerEXT(hwctx->
inst, &dbg,
1203 RELEASE_PROPS(inst_props.ppEnabledLayerNames, inst_props.enabledLayerCount);
1222 case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
return "integrated";
1223 case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
return "discrete";
1224 case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
return "virtual";
1225 case VK_PHYSICAL_DEVICE_TYPE_CPU:
return "software";
1226 default:
return "unknown";
1233 int err = 0, choice = -1;
1239 VkPhysicalDevice *devices =
NULL;
1240 VkPhysicalDeviceIDProperties *idp =
NULL;
1241 VkPhysicalDeviceProperties2 *prop =
NULL;
1242 VkPhysicalDeviceDriverProperties *driver_prop =
NULL;
1243 VkPhysicalDeviceDrmPropertiesEXT *drm_prop =
NULL;
1245 ret = vk->EnumeratePhysicalDevices(hwctx->
inst, &num,
NULL);
1246 if (
ret != VK_SUCCESS || !num) {
1255 ret = vk->EnumeratePhysicalDevices(hwctx->
inst, &num, devices);
1256 if (
ret != VK_SUCCESS) {
1275 driver_prop =
av_calloc(num,
sizeof(*driver_prop));
1282 drm_prop =
av_calloc(num,
sizeof(*drm_prop));
1290 for (
int i = 0;
i < num;
i++) {
1292 drm_prop[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT;
1293 driver_prop[
i].pNext = &drm_prop[
i];
1295 driver_prop[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
1296 idp[
i].pNext = &driver_prop[
i];
1297 idp[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
1298 prop[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
1299 prop[
i].pNext = &idp[
i];
1301 vk->GetPhysicalDeviceProperties2(devices[
i], &prop[
i]);
1303 prop[
i].properties.deviceName,
1305 prop[
i].properties.deviceID);
1309 for (
int i = 0;
i < num;
i++) {
1310 if (!strncmp(idp[
i].deviceUUID, select->
uuid, VK_UUID_SIZE)) {
1319 for (
int i = 0;
i < num;
i++) {
1320 if ((select->
drm_major == drm_prop[
i].primaryMajor &&
1321 select->
drm_minor == drm_prop[
i].primaryMinor) ||
1322 (select->
drm_major == drm_prop[
i].renderMajor &&
1323 select->
drm_minor == drm_prop[
i].renderMinor)) {
1332 }
else if (select->
name) {
1334 for (
int i = 0;
i < num;
i++) {
1335 if (strstr(prop[
i].properties.deviceName, select->
name)) {
1346 for (
int i = 0;
i < num;
i++) {
1347 if (select->
pci_device == prop[
i].properties.deviceID) {
1358 for (
int i = 0;
i < num;
i++) {
1359 if (select->
vendor_id == prop[
i].properties.vendorID) {
1369 if (select->
index < num) {
1370 choice = select->
index;
1382 choice, prop[choice].properties.deviceName,
1384 prop[choice].properties.deviceID);
1386 p->
props = prop[choice];
1388 p->
dprops = driver_prop[choice];
1403 VkQueueFlagBits
flags)
1406 uint32_t min_score = UINT32_MAX;
1408 for (
int i = 0;
i < num_qf;
i++) {
1409 VkQueueFlagBits qflags = qf[
i].queueFamilyProperties.queueFlags;
1412 if ((
flags & VK_QUEUE_TRANSFER_BIT) &&
1413 (qflags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT)))
1414 qflags |= VK_QUEUE_TRANSFER_BIT;
1416 if (qflags &
flags) {
1417 uint32_t score =
av_popcount(qflags) + qf[
i].queueFamilyProperties.timestampValidBits;
1418 if (score < min_score) {
1426 qf[
index].queueFamilyProperties.timestampValidBits++;
1432 VkQueueFamilyVideoPropertiesKHR *qf_vid, uint32_t num_qf,
1433 VkVideoCodecOperationFlagBitsKHR
flags)
1436 uint32_t min_score = UINT32_MAX;
1438 for (
int i = 0;
i < num_qf;
i++) {
1439 const VkQueueFlagBits qflags = qf[
i].queueFamilyProperties.queueFlags;
1440 const VkQueueFlagBits vflags = qf_vid[
i].videoCodecOperations;
1442 if (!(qflags & (VK_QUEUE_VIDEO_ENCODE_BIT_KHR | VK_QUEUE_VIDEO_DECODE_BIT_KHR)))
1445 if (vflags &
flags) {
1446 uint32_t score =
av_popcount(vflags) + qf[
i].queueFamilyProperties.timestampValidBits;
1447 if (score < min_score) {
1455 qf[
index].queueFamilyProperties.timestampValidBits++;
1467 VkQueueFamilyProperties2 *qf =
NULL;
1468 VkQueueFamilyVideoPropertiesKHR *qf_vid =
NULL;
1471 vk->GetPhysicalDeviceQueueFamilyProperties(hwctx->
phys_dev, &num,
NULL);
1482 qf_vid =
av_malloc_array(num,
sizeof(VkQueueFamilyVideoPropertiesKHR));
1486 for (uint32_t
i = 0;
i < num;
i++) {
1487 qf_vid[
i] = (VkQueueFamilyVideoPropertiesKHR) {
1488 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR,
1490 qf[
i] = (VkQueueFamilyProperties2) {
1491 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
1497 vk->GetPhysicalDeviceQueueFamilyProperties2(hwctx->
phys_dev, &num, qf);
1500 for (
int i = 0;
i < num;
i++) {
1502 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_GRAPHICS_BIT) ?
" graphics" :
"",
1503 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_COMPUTE_BIT) ?
" compute" :
"",
1504 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_TRANSFER_BIT) ?
" transfer" :
"",
1505 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_VIDEO_ENCODE_BIT_KHR) ?
" encode" :
"",
1506 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_VIDEO_DECODE_BIT_KHR) ?
" decode" :
"",
1507 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_SPARSE_BINDING_BIT) ?
" sparse" :
"",
1508 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_OPTICAL_FLOW_BIT_NV) ?
" optical_flow" :
"",
1509 ((qf[
i].queueFamilyProperties.queueFlags) & VK_QUEUE_PROTECTED_BIT) ?
" protected" :
"",
1510 qf[
i].queueFamilyProperties.queueCount);
1514 qf[
i].queueFamilyProperties.timestampValidBits = 0;
1520 #define PICK_QF(type, vid_op) \
1526 idx = pick_video_queue_family(qf, qf_vid, num, vid_op); \
1528 idx = pick_queue_family(qf, num, type); \
1533 for (i = 0; i < hwctx->nb_qf; i++) { \
1534 if (hwctx->qf[i].idx == idx) { \
1535 hwctx->qf[i].flags |= type; \
1536 hwctx->qf[i].video_caps |= vid_op; \
1540 if (i == hwctx->nb_qf) { \
1541 hwctx->qf[i].idx = idx; \
1542 hwctx->qf[i].num = qf[idx].queueFamilyProperties.queueCount; \
1543 if (p->limit_queues || \
1544 p->dprops.driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY) { \
1545 int max = p->limit_queues; \
1546 if (type == VK_QUEUE_GRAPHICS_BIT) \
1547 hwctx->qf[i].num = FFMIN(hwctx->qf[i].num, \
1550 hwctx->qf[i].num = FFMIN(hwctx->qf[i].num, max); \
1552 hwctx->qf[i].flags = type; \
1553 hwctx->qf[i].video_caps = vid_op; \
1558 PICK_QF(VK_QUEUE_GRAPHICS_BIT, VK_VIDEO_CODEC_OPERATION_NONE_KHR);
1559 PICK_QF(VK_QUEUE_COMPUTE_BIT, VK_VIDEO_CODEC_OPERATION_NONE_KHR);
1560 PICK_QF(VK_QUEUE_TRANSFER_BIT, VK_VIDEO_CODEC_OPERATION_NONE_KHR);
1562 PICK_QF(VK_QUEUE_VIDEO_ENCODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR);
1563 PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR);
1565 PICK_QF(VK_QUEUE_VIDEO_ENCODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR);
1566 PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR);
1568 #ifdef VK_KHR_video_decode_vp9
1569 PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR);
1572 #ifdef VK_KHR_video_encode_av1
1573 PICK_QF(VK_QUEUE_VIDEO_ENCODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR);
1575 PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR);
1583 sizeof(VkDeviceQueueCreateInfo));
1584 if (!cd->pQueueCreateInfos)
1587 for (uint32_t
i = 0;
i < hwctx->
nb_qf;
i++) {
1590 VkDeviceQueueCreateInfo *pc;
1591 for (uint32_t j = 0; j < cd->queueCreateInfoCount; j++) {
1592 if (hwctx->
qf[
i].
idx == cd->pQueueCreateInfos[j].queueFamilyIndex) {
1602 for (uint32_t j = 0; j < cd->queueCreateInfoCount; j++)
1603 av_free((
void *)cd->pQueueCreateInfos[
i].pQueuePriorities);
1604 av_free((
void *)cd->pQueueCreateInfos);
1608 for (uint32_t j = 0; j < hwctx->
qf[
i].
num; j++)
1611 pc = (VkDeviceQueueCreateInfo *)cd->pQueueCreateInfos;
1612 pc[cd->queueCreateInfoCount++] = (VkDeviceQueueCreateInfo) {
1613 .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
1614 .queueFamilyIndex = hwctx->
qf[
i].
idx,
1615 .queueCount = hwctx->
qf[
i].
num,
1620 #if FF_API_VULKAN_FIXED_QUEUES
1629 #define SET_OLD_QF(field, nb_field, type) \
1631 if (field < 0 && hwctx->qf[i].flags & type) { \
1632 field = hwctx->qf[i].idx; \
1633 nb_field = hwctx->qf[i].num; \
1637 for (uint32_t
i = 0;
i < hwctx->
nb_qf;
i++) {
1667 vk->DestroyDebugUtilsMessengerEXT(hwctx->
inst, p->
debug_ctx,
1671 vk->DestroyInstance(hwctx->
inst, hwctx->
alloc);
1696 VkDeviceSize max_vram = 0, max_visible_vram = 0;
1699 for (
int i = 0;
i < p->
mprops.memoryTypeCount;
i++) {
1700 const VkMemoryType
type = p->
mprops.memoryTypes[
i];
1701 const VkMemoryHeap heap = p->
mprops.memoryHeaps[
type.heapIndex];
1702 if (!(
type.propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT))
1704 max_vram =
FFMAX(max_vram, heap.size);
1705 if (
type.propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
1706 max_visible_vram =
FFMAX(max_visible_vram, heap.size);
1709 return max_vram - max_visible_vram < 1024;
1714 int disable_multiplane,
1725 VkDeviceCreateInfo dev_info = {
1726 .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
1739 &dev_info.enabledExtensionCount, debug_mode))) {
1740 for (
int i = 0;
i < dev_info.queueCreateInfoCount;
i++)
1741 av_free((
void *)dev_info.pQueueCreateInfos[
i].pQueuePriorities);
1742 av_free((
void *)dev_info.pQueueCreateInfos);
1747 vk->GetPhysicalDeviceMemoryProperties(hwctx->
phys_dev, &p->
mprops);
1751 vk->GetPhysicalDeviceFeatures2(hwctx->
phys_dev, &supported_feats.
device);
1757 dev_info.pEnabledFeatures = &p->
feats.
device.features;
1767 for (
int i = 0;
i < dev_info.queueCreateInfoCount;
i++)
1768 av_free((
void *)dev_info.pQueueCreateInfos[
i].pQueuePriorities);
1769 av_free((
void *)dev_info.pQueueCreateInfos);
1771 if (
ret != VK_SUCCESS) {
1774 for (
int i = 0;
i < dev_info.enabledExtensionCount;
i++)
1775 av_free((
void *)dev_info.ppEnabledExtensionNames[
i]);
1776 av_free((
void *)dev_info.ppEnabledExtensionNames);
1838 VkQueueFamilyProperties2 *qf;
1839 VkQueueFamilyVideoPropertiesKHR *qf_vid;
1840 VkPhysicalDeviceExternalSemaphoreInfo ext_sem_props_info;
1841 int graph_index, comp_index, tx_index, enc_index, dec_index;
1860 p->
props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
1862 p->
hprops.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
1864 p->
dprops.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
1866 vk->GetPhysicalDeviceProperties2(hwctx->
phys_dev, &p->
props);
1868 p->
props.properties.deviceName);
1871 p->
props.properties.limits.optimalBufferCopyRowPitchAlignment);
1873 p->
props.properties.limits.minMemoryMapAlignment);
1875 p->
props.properties.limits.nonCoherentAtomSize);
1878 p->
hprops.minImportedHostPointerAlignment);
1880 vk->GetPhysicalDeviceQueueFamilyProperties(hwctx->
phys_dev, &qf_num,
NULL);
1886 ext_sem_props_info = (VkPhysicalDeviceExternalSemaphoreInfo) {
1887 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
1891 ext_sem_props_info.handleType =
1893 IsWindows8OrGreater()
1894 ? VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
1895 : VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
1897 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
1900 vk->GetPhysicalDeviceExternalSemaphoreProperties(hwctx->
phys_dev,
1901 &ext_sem_props_info,
1908 qf_vid =
av_malloc_array(qf_num,
sizeof(VkQueueFamilyVideoPropertiesKHR));
1914 for (uint32_t
i = 0;
i < qf_num;
i++) {
1915 qf_vid[
i] = (VkQueueFamilyVideoPropertiesKHR) {
1916 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR,
1918 qf[
i] = (VkQueueFamilyProperties2) {
1919 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
1924 vk->GetPhysicalDeviceQueueFamilyProperties2(hwctx->
phys_dev, &qf_num, qf);
1933 for (uint32_t
i = 0;
i < qf_num;
i++) {
1940 for (uint32_t j = 0; j < qf[
i].queueFamilyProperties.queueCount; j++) {
1951 #if FF_API_VULKAN_FIXED_QUEUES
1959 #define CHECK_QUEUE(type, required, fidx, ctx_qf, qc) \
1961 if (ctx_qf < 0 && required) { \
1962 av_log(ctx, AV_LOG_ERROR, "%s queue family is required, but marked as missing" \
1963 " in the context!\n", type); \
1964 err = AVERROR(EINVAL); \
1966 } else if (fidx < 0 || ctx_qf < 0) { \
1968 } else if (ctx_qf >= qf_num) { \
1969 av_log(ctx, AV_LOG_ERROR, "Invalid %s family index %i (device has %i families)!\n", \
1970 type, ctx_qf, qf_num); \
1971 err = AVERROR(EINVAL); \
1975 av_log(ctx, AV_LOG_VERBOSE, "Using queue family %i (queues: %i)" \
1976 " for%s%s%s%s%s\n", \
1978 ctx_qf == graph_index ? " graphics" : "", \
1979 ctx_qf == comp_index ? " compute" : "", \
1980 ctx_qf == tx_index ? " transfers" : "", \
1981 ctx_qf == enc_index ? " encode" : "", \
1982 ctx_qf == dec_index ? " decode" : ""); \
1983 graph_index = (ctx_qf == graph_index) ? -1 : graph_index; \
1984 comp_index = (ctx_qf == comp_index) ? -1 : comp_index; \
1985 tx_index = (ctx_qf == tx_index) ? -1 : tx_index; \
1986 enc_index = (ctx_qf == enc_index) ? -1 : enc_index; \
1987 dec_index = (ctx_qf == dec_index) ? -1 : dec_index; \
2000 if (!hwctx->
nb_qf) {
2001 #define ADD_QUEUE(ctx_qf, qc, flag) \
2003 if (ctx_qf != -1) { \
2004 hwctx->qf[hwctx->nb_qf++] = (AVVulkanDeviceQueueFamily) { \
2022 for (
int i = 0;
i < hwctx->
nb_qf;
i++) {
2024 hwctx->
qf[
i].
flags & (VK_QUEUE_VIDEO_DECODE_BIT_KHR |
2025 VK_QUEUE_VIDEO_ENCODE_BIT_KHR)) {
2032 for (
int i = 0;
i < hwctx->
nb_qf;
i++) {
2036 for (
int j = (
i - 1); j >= 0; j--) {
2052 vk->GetPhysicalDeviceMemoryProperties(hwctx->
phys_dev, &p->
mprops);
2062 vk->GetPhysicalDeviceMemoryProperties(hwctx->
phys_dev, &p->
mprops);
2077 if (device && device[0]) {
2079 dev_select.
index = strtol(device, &end, 10);
2080 if (end == device) {
2081 dev_select.
index = 0;
2082 dev_select.
name = device;
2098 switch(src_ctx->
type) {
2102 VADisplay dpy = src_hwctx->
display;
2103 #if VA_CHECK_VERSION(1, 15, 0)
2105 VADisplayAttribute attr = {
2106 .type = VADisplayPCIID,
2111 #if VA_CHECK_VERSION(1, 15, 0)
2112 vas = vaGetDisplayAttributes(dpy, &attr, 1);
2113 if (vas == VA_STATUS_SUCCESS && attr.flags != VA_DISPLAY_ATTRIB_NOT_SUPPORTED)
2114 dev_select.pci_device = (attr.value & 0xFFFF);
2117 if (!dev_select.pci_device) {
2118 vendor = vaQueryVendorString(dpy);
2124 if (strstr(vendor,
"AMD"))
2125 dev_select.vendor_id = 0x1002;
2134 struct stat drm_node_info;
2135 drmDevice *drm_dev_info;
2138 err = fstat(src_hwctx->
fd, &drm_node_info);
2145 dev_select.drm_major = major(drm_node_info.st_dev);
2146 dev_select.drm_minor = minor(drm_node_info.st_dev);
2147 dev_select.has_drm = 1;
2149 err = drmGetDevice(src_hwctx->
fd, &drm_dev_info);
2156 if (drm_dev_info->bustype == DRM_BUS_PCI)
2157 dev_select.pci_device = drm_dev_info->deviceinfo.pci->device_id;
2159 drmFreeDevice(&drm_dev_info);
2169 CudaFunctions *cu = cu_internal->
cuda_dl;
2171 int ret =
CHECK_CU(cu->cuDeviceGetUuid((CUuuid *)&dev_select.uuid,
2178 dev_select.has_uuid = 1;
2193 const void *hwconfig,
2202 VK_IMAGE_TILING_OPTIMAL,
2215 VK_IMAGE_TILING_OPTIMAL,
2225 constraints->
max_width = p->
props.properties.limits.maxImageDimension2D;
2226 constraints->
max_height = p->
props.properties.limits.maxImageDimension2D;
2239 VkMemoryPropertyFlagBits req_flags,
const void *alloc_extension,
2240 VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
2247 VkMemoryAllocateInfo alloc_info = {
2248 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
2249 .pNext = alloc_extension,
2250 .allocationSize = req->size,
2255 for (
int i = 0;
i < p->
mprops.memoryTypeCount;
i++) {
2256 const VkMemoryType *
type = &p->
mprops.memoryTypes[
i];
2259 if (!(req->memoryTypeBits & (1 <<
i)))
2263 if ((
type->propertyFlags & req_flags) != req_flags)
2267 if (req->size > p->
mprops.memoryHeaps[
type->heapIndex].size)
2281 alloc_info.memoryTypeIndex =
index;
2283 ret = vk->AllocateMemory(dev_hwctx->
act_dev, &alloc_info,
2284 dev_hwctx->
alloc, mem);
2285 if (
ret != VK_SUCCESS) {
2291 *mem_flags |= p->
mprops.memoryTypes[
index].propertyFlags;
2301 if (internal->cuda_fc_ref) {
2307 CudaFunctions *cu = cu_internal->
cuda_dl;
2310 if (internal->cu_sem[
i])
2311 CHECK_CU(cu->cuDestroyExternalSemaphore(internal->cu_sem[
i]));
2312 if (internal->cu_mma[
i])
2313 CHECK_CU(cu->cuMipmappedArrayDestroy(internal->cu_mma[
i]));
2314 if (internal->ext_mem[
i])
2315 CHECK_CU(cu->cuDestroyExternalMemory(internal->ext_mem[
i]));
2317 if (internal->ext_sem_handle[
i])
2318 CloseHandle(internal->ext_sem_handle[
i]);
2319 if (internal->ext_mem_handle[
i])
2320 CloseHandle(internal->ext_mem_handle[
i]);
2345 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
2347 .pSemaphores =
f->sem,
2348 .pValues =
f->sem_value,
2349 .semaphoreCount = nb_sems,
2357 for (
int i = 0;
i < nb_images;
i++) {
2372 void *alloc_pnext,
size_t alloc_pnext_stride)
2374 int img_cnt = 0, err;
2382 while (
f->img[img_cnt]) {
2384 VkImageMemoryRequirementsInfo2 req_desc = {
2385 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
2386 .image =
f->img[img_cnt],
2388 VkMemoryDedicatedAllocateInfo ded_alloc = {
2389 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
2390 .pNext = (
void *)(((uint8_t *)alloc_pnext) + img_cnt*alloc_pnext_stride),
2392 VkMemoryDedicatedRequirements ded_req = {
2393 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
2395 VkMemoryRequirements2 req = {
2396 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
2400 vk->GetImageMemoryRequirements2(hwctx->
act_dev, &req_desc, &req);
2402 if (
f->tiling == VK_IMAGE_TILING_LINEAR)
2403 req.memoryRequirements.size =
FFALIGN(req.memoryRequirements.size,
2404 p->
props.properties.limits.minMemoryMapAlignment);
2407 use_ded_mem = ded_req.prefersDedicatedAllocation |
2408 ded_req.requiresDedicatedAllocation;
2410 ded_alloc.image =
f->img[img_cnt];
2414 f->tiling == VK_IMAGE_TILING_LINEAR ?
2415 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT :
2416 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
2417 use_ded_mem ? &ded_alloc : (
void *)ded_alloc.pNext,
2418 &
f->flags, &
f->mem[img_cnt])))
2421 f->size[img_cnt] = req.memoryRequirements.size;
2422 bind_info[img_cnt].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
2423 bind_info[img_cnt].image =
f->img[img_cnt];
2424 bind_info[img_cnt].memory =
f->mem[img_cnt];
2430 ret = vk->BindImageMemory2(hwctx->
act_dev, img_cnt, bind_info);
2431 if (
ret != VK_SUCCESS) {
2460 VkImageLayout new_layout;
2461 VkAccessFlags2 new_access;
2462 VkPipelineStageFlagBits2 src_stage = VK_PIPELINE_STAGE_2_NONE;
2468 .
data = (uint8_t *)hwfc,
2472 .hw_frames_ctx = &tmp_ref,
2475 VkCommandBuffer cmd_buf;
2477 cmd_buf = exec->
buf;
2481 VK_PIPELINE_STAGE_2_NONE,
2482 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT);
2488 new_layout = VK_IMAGE_LAYOUT_GENERAL;
2489 new_access = VK_ACCESS_TRANSFER_WRITE_BIT;
2492 new_layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
2493 new_access = VK_ACCESS_TRANSFER_WRITE_BIT;
2496 new_layout = VK_IMAGE_LAYOUT_GENERAL;
2497 new_access = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
2500 new_layout = VK_IMAGE_LAYOUT_GENERAL;
2501 new_access = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
2502 dst_qf = VK_QUEUE_FAMILY_EXTERNAL_KHR;
2503 src_stage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
2506 new_layout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR;
2507 new_access = VK_ACCESS_TRANSFER_WRITE_BIT;
2510 new_layout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR;
2511 new_access = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
2514 new_layout = VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR;
2515 new_access = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
2521 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
2522 new_access, new_layout, dst_qf);
2524 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
2525 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
2526 .pImageMemoryBarriers = img_bar,
2527 .imageMemoryBarrierCount = nb_img_bar,
2541 int frame_w,
int frame_h,
int plane)
2558 VkImageTiling tiling, VkImageUsageFlagBits
usage,
2559 VkImageCreateFlags
flags,
int nb_layers,
2571 VkSemaphoreTypeCreateInfo sem_type_info = {
2572 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
2573 .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
2576 VkSemaphoreCreateInfo sem_spawn = {
2577 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
2578 .pNext = &sem_type_info,
2581 VkExportSemaphoreCreateInfo ext_sem_info_opaque = {
2582 .sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
2584 .handleTypes = IsWindows8OrGreater()
2585 ? VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
2586 : VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
2588 .handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
2593 if (p->
ext_sem_props_opaque.externalSemaphoreFeatures & VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT) {
2607 for (
int i = 0; (hwfc_vk->
format[
i] != VK_FORMAT_UNDEFINED);
i++) {
2608 VkImageCreateInfo create_info = {
2609 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
2610 .pNext = create_pnext,
2611 .imageType = VK_IMAGE_TYPE_2D,
2615 .arrayLayers = nb_layers,
2618 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
2620 .samples = VK_SAMPLE_COUNT_1_BIT,
2621 .pQueueFamilyIndices = p->
img_qfs,
2623 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
2624 VK_SHARING_MODE_EXCLUSIVE,
2627 get_plane_wh(&create_info.extent.width, &create_info.extent.height,
2630 ret = vk->CreateImage(hwctx->
act_dev, &create_info,
2632 if (
ret != VK_SUCCESS) {
2640 ret = vk->CreateSemaphore(hwctx->
act_dev, &sem_spawn,
2642 if (
ret != VK_SUCCESS) {
2650 f->layout[
i] = create_info.initialLayout;
2652 f->sem_value[
i] = 0;
2668 VkExternalMemoryHandleTypeFlags *comp_handle_types,
2669 VkExternalMemoryHandleTypeFlagBits *iexp,
2670 VkExternalMemoryHandleTypeFlagBits
exp)
2678 const VkImageDrmFormatModifierListCreateInfoEXT *drm_mod_info =
2680 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
2681 int has_mods = hwctx->
tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT && drm_mod_info;
2684 VkExternalImageFormatProperties eprops = {
2685 .sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
2687 VkImageFormatProperties2 props = {
2688 .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
2691 VkPhysicalDeviceImageDrmFormatModifierInfoEXT phy_dev_mod_info = {
2692 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
2694 .pQueueFamilyIndices = p->
img_qfs,
2696 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
2697 VK_SHARING_MODE_EXCLUSIVE,
2699 VkPhysicalDeviceExternalImageFormatInfo enext = {
2700 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
2702 .pNext = has_mods ? &phy_dev_mod_info :
NULL,
2704 VkPhysicalDeviceImageFormatInfo2 pinfo = {
2705 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
2706 .pNext = !
exp ?
NULL : &enext,
2708 .type = VK_IMAGE_TYPE_2D,
2710 .usage = hwctx->
usage,
2711 .flags = VK_IMAGE_CREATE_ALIAS_BIT,
2714 nb_mods = has_mods ? drm_mod_info->drmFormatModifierCount : 1;
2715 for (
int i = 0;
i < nb_mods;
i++) {
2717 phy_dev_mod_info.drmFormatModifier = drm_mod_info->pDrmFormatModifiers[
i];
2719 ret = vk->GetPhysicalDeviceImageFormatProperties2(dev_hwctx->
phys_dev,
2722 if (
ret == VK_SUCCESS) {
2724 *comp_handle_types |= eprops.externalMemoryProperties.compatibleHandleTypes;
2738 VkExternalMemoryHandleTypeFlags e = 0x0;
2741 VkExternalMemoryImageCreateInfo eiinfo = {
2742 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
2749 ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
2750 : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT);
2754 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT);
2757 hwctx->
tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT)
2759 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
2763 eminfo[
i].sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
2765 eminfo[
i].handleTypes = e;
2778 if ( (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR) &&
2779 !(hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR))
2781 else if (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)
2783 else if (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR)
2785 else if (hwctx->
usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
2840 VkImageUsageFlagBits supported_usage;
2852 (hwctx->
tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT))
2853 hwctx->
tiling = VK_IMAGE_TILING_LINEAR;
2863 if (hwctx->
format[0] != VK_FORMAT_UNDEFINED) {
2868 "for the current sw_format %s!\n",
2880 (hwctx->
usage & VK_IMAGE_USAGE_STORAGE_BIT));
2889 NULL, &supported_usage,
2892 (hwctx->
usage & VK_IMAGE_USAGE_STORAGE_BIT));
2898 if (p->
dprops.driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY &&
2901 supported_usage &= ~VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT;
2904 if (!hwctx->
usage) {
2905 hwctx->
usage = supported_usage & (VK_IMAGE_USAGE_TRANSFER_DST_BIT |
2906 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
2907 VK_IMAGE_USAGE_STORAGE_BIT |
2908 VK_IMAGE_USAGE_SAMPLED_BIT);
2911 hwctx->
usage |= supported_usage & VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT;
2914 if ((supported_usage & VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) &&
2917 hwctx->
usage |= VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR;
2924 int is_lone_dpb = ((hwctx->
usage & VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR) ||
2925 ((hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR) &&
2926 !(hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)));
2927 int sampleable = hwctx->
usage & (VK_IMAGE_USAGE_SAMPLED_BIT |
2928 VK_IMAGE_USAGE_STORAGE_BIT);
2929 hwctx->
img_flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
2930 if (sampleable && !is_lone_dpb) {
2931 hwctx->
img_flags |= VK_IMAGE_CREATE_ALIAS_BIT;
2933 hwctx->
img_flags |= VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
2941 if ((hwctx->
usage & VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) &&
2944 const VkVideoProfileListInfoKHR *pl;
2947 hwctx->
img_flags |= VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR;
2950 for (
i = 0;
i < pl->profileCount;
i++) {
2952 if (pl->pProfiles[
i].videoCodecOperation & 0xFFFF0000)
2955 if (
i == pl->profileCount)
2956 hwctx->
img_flags |= VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR;
2989 VkImageDrmFormatModifierPropertiesEXT drm_mod = {
2990 .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
2992 err = vk->GetImageDrmFormatModifierPropertiesEXT(dev_hwctx->
act_dev,
f->img[0],
2994 if (err != VK_SUCCESS) {
3000 VkDrmFormatModifierPropertiesListEXT modp;
3001 VkFormatProperties2 fmtp;
3002 VkDrmFormatModifierPropertiesEXT *mod_props =
NULL;
3004 modp = (VkDrmFormatModifierPropertiesListEXT) {
3005 .sType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
3007 fmtp = (VkFormatProperties2) {
3008 .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
3013 vk->GetPhysicalDeviceFormatProperties2(dev_hwctx->
phys_dev, fmt->
fallback[
i], &fmtp);
3015 modp.pDrmFormatModifierProperties =
3016 av_calloc(modp.drmFormatModifierCount,
sizeof(*modp.pDrmFormatModifierProperties));
3017 if (!modp.pDrmFormatModifierProperties) {
3021 vk->GetPhysicalDeviceFormatProperties2(dev_hwctx->
phys_dev, fmt->
fallback[
i], &fmtp);
3023 for (uint32_t
i = 0;
i < modp.drmFormatModifierCount; ++
i) {
3024 VkDrmFormatModifierPropertiesEXT *m = &modp.pDrmFormatModifierProperties[
i];
3025 if (m->drmFormatModifier == drm_mod.drmFormatModifier) {
3031 if (mod_props ==
NULL) {
3032 av_log(hwfc,
AV_LOG_ERROR,
"No DRM format modifier properties found for modifier 0x%016"PRIx64
"\n",
3033 drm_mod.drmFormatModifier);
3034 av_free(modp.pDrmFormatModifierProperties);
3040 av_free(modp.pDrmFormatModifierProperties);
3104 static const struct {
3105 uint32_t drm_fourcc;
3107 } vulkan_drm_format_map[] = {
3108 { DRM_FORMAT_R8, VK_FORMAT_R8_UNORM },
3109 { DRM_FORMAT_R16, VK_FORMAT_R16_UNORM },
3110 { DRM_FORMAT_GR88, VK_FORMAT_R8G8_UNORM },
3111 { DRM_FORMAT_RG88, VK_FORMAT_R8G8_UNORM },
3112 { DRM_FORMAT_GR1616, VK_FORMAT_R16G16_UNORM },
3113 { DRM_FORMAT_RG1616, VK_FORMAT_R16G16_UNORM },
3114 { DRM_FORMAT_ARGB8888, VK_FORMAT_B8G8R8A8_UNORM },
3115 { DRM_FORMAT_XRGB8888, VK_FORMAT_B8G8R8A8_UNORM },
3116 { DRM_FORMAT_ABGR8888, VK_FORMAT_R8G8B8A8_UNORM },
3117 { DRM_FORMAT_XBGR8888, VK_FORMAT_R8G8B8A8_UNORM },
3118 { DRM_FORMAT_ARGB2101010, VK_FORMAT_A2B10G10R10_UNORM_PACK32 },
3119 { DRM_FORMAT_ABGR2101010, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
3120 { DRM_FORMAT_XRGB2101010, VK_FORMAT_A2B10G10R10_UNORM_PACK32 },
3121 { DRM_FORMAT_XBGR2101010, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
3124 #ifdef DRM_FORMAT_XYUV8888
3125 { DRM_FORMAT_XYUV8888, VK_FORMAT_R8G8B8A8_UNORM },
3126 { DRM_FORMAT_XVYU2101010, VK_FORMAT_A2R10G10B10_UNORM_PACK32 } ,
3127 { DRM_FORMAT_XVYU12_16161616, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 } ,
3128 { DRM_FORMAT_XVYU16161616, VK_FORMAT_R16G16B16A16_UNORM } ,
3132 static inline VkFormat drm_to_vulkan_fmt(uint32_t drm_fourcc)
3135 if (vulkan_drm_format_map[
i].drm_fourcc == drm_fourcc)
3136 return vulkan_drm_format_map[
i].vk_format;
3137 return VK_FORMAT_UNDEFINED;
3146 int bind_counts = 0;
3156 if (drm_to_vulkan_fmt(
desc->layers[
i].format) == VK_FORMAT_UNDEFINED) {
3158 desc->layers[
i].format);
3169 f->tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
3171 for (
int i = 0;
i <
desc->nb_layers;
i++) {
3175 VkSemaphoreTypeCreateInfo sem_type_info = {
3176 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
3177 .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
3180 VkSemaphoreCreateInfo sem_spawn = {
3181 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
3182 .pNext = &sem_type_info,
3187 VkImageDrmFormatModifierExplicitCreateInfoEXT ext_img_mod_spec = {
3188 .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
3189 .drmFormatModifier =
desc->objects[0].format_modifier,
3190 .drmFormatModifierPlaneCount =
planes,
3191 .pPlaneLayouts = (
const VkSubresourceLayout *)&ext_img_layouts,
3193 VkExternalMemoryImageCreateInfo ext_img_spec = {
3194 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
3195 .pNext = &ext_img_mod_spec,
3196 .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
3198 VkImageCreateInfo create_info = {
3199 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
3200 .pNext = &ext_img_spec,
3201 .imageType = VK_IMAGE_TYPE_2D,
3202 .format = drm_to_vulkan_fmt(
desc->layers[
i].format),
3207 .tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT,
3208 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
3210 .samples = VK_SAMPLE_COUNT_1_BIT,
3211 .pQueueFamilyIndices = p->
img_qfs,
3213 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
3214 VK_SHARING_MODE_EXCLUSIVE,
3218 VkExternalImageFormatProperties ext_props = {
3219 .sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
3221 VkImageFormatProperties2 props_ret = {
3222 .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
3223 .pNext = &ext_props,
3225 VkPhysicalDeviceImageDrmFormatModifierInfoEXT props_drm_mod = {
3226 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
3227 .drmFormatModifier = ext_img_mod_spec.drmFormatModifier,
3228 .pQueueFamilyIndices = create_info.pQueueFamilyIndices,
3229 .queueFamilyIndexCount = create_info.queueFamilyIndexCount,
3230 .sharingMode = create_info.sharingMode,
3232 VkPhysicalDeviceExternalImageFormatInfo props_ext = {
3233 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
3234 .pNext = &props_drm_mod,
3235 .handleType = ext_img_spec.handleTypes,
3237 VkPhysicalDeviceImageFormatInfo2 fmt_props;
3240 create_info.usage |= VK_IMAGE_USAGE_SAMPLED_BIT |
3241 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
3243 create_info.usage |= VK_IMAGE_USAGE_STORAGE_BIT |
3244 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3246 fmt_props = (VkPhysicalDeviceImageFormatInfo2) {
3247 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
3248 .pNext = &props_ext,
3249 .format = create_info.format,
3250 .type = create_info.imageType,
3251 .tiling = create_info.tiling,
3252 .usage = create_info.usage,
3253 .flags = create_info.flags,
3257 ret = vk->GetPhysicalDeviceImageFormatProperties2(hwctx->
phys_dev,
3258 &fmt_props, &props_ret);
3259 if (
ret != VK_SUCCESS) {
3267 get_plane_wh(&create_info.extent.width, &create_info.extent.height,
3271 for (
int j = 0; j <
planes; j++) {
3272 ext_img_layouts[j].offset =
desc->layers[
i].planes[j].offset;
3273 ext_img_layouts[j].rowPitch =
desc->layers[
i].planes[j].pitch;
3274 ext_img_layouts[j].size = 0;
3275 ext_img_layouts[j].arrayPitch = 0;
3276 ext_img_layouts[j].depthPitch = 0;
3280 ret = vk->CreateImage(hwctx->
act_dev, &create_info,
3282 if (
ret != VK_SUCCESS) {
3289 ret = vk->CreateSemaphore(hwctx->
act_dev, &sem_spawn,
3291 if (
ret != VK_SUCCESS) {
3298 f->queue_family[
i] = VK_QUEUE_FAMILY_EXTERNAL;
3299 f->layout[
i] = create_info.initialLayout;
3301 f->sem_value[
i] = 0;
3304 for (
int i = 0;
i <
desc->nb_layers;
i++) {
3306 VkImageMemoryRequirementsInfo2 req_desc = {
3307 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
3310 VkMemoryDedicatedRequirements ded_req = {
3311 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
3313 VkMemoryRequirements2 req2 = {
3314 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
3319 VkMemoryFdPropertiesKHR fdmp = {
3320 .sType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR,
3326 VkImportMemoryFdInfoKHR idesc = {
3327 .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
3328 .fd = dup(
desc->objects[
desc->layers[
i].planes[0].object_index].fd),
3329 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
3331 VkMemoryDedicatedAllocateInfo ded_alloc = {
3332 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
3334 .image = req_desc.image,
3338 ret = vk->GetMemoryFdPropertiesKHR(hwctx->
act_dev,
3339 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
3341 if (
ret != VK_SUCCESS) {
3349 vk->GetImageMemoryRequirements2(hwctx->
act_dev, &req_desc, &req2);
3352 req2.memoryRequirements.memoryTypeBits = fdmp.memoryTypeBits;
3355 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
3356 (ded_req.prefersDedicatedAllocation ||
3357 ded_req.requiresDedicatedAllocation) ?
3358 &ded_alloc : ded_alloc.pNext,
3359 &
f->flags, &
f->mem[
i]);
3365 f->size[
i] = req2.memoryRequirements.size;
3368 for (
int i = 0;
i <
desc->nb_layers;
i++) {
3370 for (
int j = 0; j <
planes; j++) {
3371 VkImageAspectFlagBits aspect = j == 0 ? VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT :
3372 j == 1 ? VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT :
3373 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT;
3375 plane_info[bind_counts].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
3377 plane_info[bind_counts].planeAspect = aspect;
3379 bind_info[bind_counts].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
3381 bind_info[bind_counts].image =
f->img[
i];
3382 bind_info[bind_counts].memory =
f->mem[
i];
3385 bind_info[bind_counts].memoryOffset = 0;
3392 ret = vk->BindImageMemory2(hwctx->
act_dev, bind_counts, bind_info);
3393 if (
ret != VK_SUCCESS) {
3423 #ifdef DMA_BUF_IOCTL_EXPORT_SYNC_FILE
3425 VkCommandBuffer cmd_buf;
3431 for (
int i = 0;
i <
desc->nb_objects;
i++) {
3432 VkSemaphoreTypeCreateInfo sem_type_info = {
3433 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
3434 .semaphoreType = VK_SEMAPHORE_TYPE_BINARY,
3436 VkSemaphoreCreateInfo sem_spawn = {
3437 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
3438 .pNext = &sem_type_info,
3440 VkImportSemaphoreFdInfoKHR import_info;
3441 struct dma_buf_export_sync_file implicit_fd_info = {
3442 .flags = DMA_BUF_SYNC_READ,
3446 if (ioctl(
desc->objects[
i].fd, DMA_BUF_IOCTL_EXPORT_SYNC_FILE,
3447 &implicit_fd_info)) {
3452 vk->DestroySemaphore(hwctx->
act_dev, drm_sync_sem[
i], hwctx->
alloc);
3456 ret = vk->CreateSemaphore(hwctx->
act_dev, &sem_spawn,
3457 hwctx->
alloc, &drm_sync_sem[
i]);
3458 if (
ret != VK_SUCCESS) {
3463 vk->DestroySemaphore(hwctx->
act_dev, drm_sync_sem[
i], hwctx->
alloc);
3467 import_info = (VkImportSemaphoreFdInfoKHR) {
3468 .sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
3469 .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
3470 .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
3471 .semaphore = drm_sync_sem[
i],
3472 .fd = implicit_fd_info.fd,
3475 ret = vk->ImportSemaphoreFdKHR(hwctx->
act_dev, &import_info);
3476 if (
ret != VK_SUCCESS) {
3481 vk->DestroySemaphore(hwctx->
act_dev, drm_sync_sem[
i], hwctx->
alloc);
3487 cmd_buf = exec->
buf;
3493 drm_sync_sem,
desc->nb_objects,
3494 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, 1);
3499 VK_PIPELINE_STAGE_2_NONE,
3500 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT);
3505 VK_PIPELINE_STAGE_2_NONE,
3506 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
3508 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : 0x0) |
3510 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT : 0x0),
3511 VK_IMAGE_LAYOUT_GENERAL,
3514 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
3515 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
3516 .pImageMemoryBarriers = img_bar,
3517 .imageMemoryBarrierCount = nb_img_bar,
3528 "image may be corrupted.\n");
3543 if ((err = vulkan_map_from_drm_frame_desc(hwfc, &
f,
src,
flags)))
3547 dst->data[0] = (uint8_t *)
f;
3549 dst->height =
src->height;
3552 &vulkan_unmap_from_drm,
f);
3556 err = vulkan_map_from_drm_frame_sync(hwfc,
dst,
src,
flags);
3579 VASurfaceID surface_id = (VASurfaceID)(uintptr_t)
src->data[3];
3585 vaSyncSurface(vaapi_ctx->display, surface_id);
3593 err = vulkan_map_from_drm(dst_fc,
dst,
tmp,
flags);
3610 VkDeviceMemory mem,
size_t size)
3618 CUDA_EXTERNAL_MEMORY_HANDLE_DESC ext_desc = {
3619 .type = IsWindows8OrGreater()
3620 ? CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
3621 : CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT,
3624 VkMemoryGetWin32HandleInfoKHR export_info = {
3625 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
3627 .handleType = IsWindows8OrGreater()
3628 ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
3629 : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
3632 ret = vk->GetMemoryWin32HandleKHR(hwctx->
act_dev, &export_info,
3633 &ext_desc.handle.win32.handle);
3634 if (
ret != VK_SUCCESS) {
3639 dst_int->ext_mem_handle[idx] = ext_desc.handle.win32.handle;
3641 CUDA_EXTERNAL_MEMORY_HANDLE_DESC ext_desc = {
3642 .type = CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD,
3645 VkMemoryGetFdInfoKHR export_info = {
3646 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
3648 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
3651 ret = vk->GetMemoryFdKHR(hwctx->
act_dev, &export_info,
3652 &ext_desc.handle.fd);
3653 if (
ret != VK_SUCCESS) {
3660 ret =
CHECK_CU(cu->cuImportExternalMemory(&dst_int->ext_mem[idx], &ext_desc));
3663 close(ext_desc.handle.fd);
3682 VkSemaphoreGetWin32HandleInfoKHR sem_export = {
3683 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
3685 .handleType = IsWindows8OrGreater()
3686 ? VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
3687 : VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
3689 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC ext_sem_desc = {
3693 VkSemaphoreGetFdInfoKHR sem_export = {
3694 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
3696 .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
3698 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC ext_sem_desc = {
3704 ret = vk->GetSemaphoreWin32HandleKHR(hwctx->
act_dev, &sem_export,
3705 &ext_sem_desc.handle.win32.handle);
3707 ret = vk->GetSemaphoreFdKHR(hwctx->
act_dev, &sem_export,
3708 &ext_sem_desc.handle.fd);
3710 if (
ret != VK_SUCCESS) {
3716 dst_int->ext_sem_handle[idx] = ext_sem_desc.handle.win32.handle;
3719 ret =
CHECK_CU(cu->cuImportExternalSemaphore(&dst_int->cu_sem[idx],
3723 close(ext_sem_desc.handle.fd);
3751 CudaFunctions *cu = cu_internal->
cuda_dl;
3752 CUarray_format cufmt =
desc->comp[0].depth > 8 ? CU_AD_FORMAT_UNSIGNED_INT16 :
3753 CU_AD_FORMAT_UNSIGNED_INT8;
3758 if (!dst_int->cuda_fc_ref) {
3762 if (!dst_int->cuda_fc_ref)
3766 for (
int i = 0;
i < nb_images;
i++) {
3767 err = export_mem_to_cuda(
ctx, cuda_cu, cu, dst_int,
i,
3772 err = export_sem_to_cuda(
ctx, cuda_cu, cu, dst_int,
i,
3778 if (nb_images !=
planes) {
3780 VkImageSubresource subres = {
3781 .aspectMask =
i == 2 ? VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT :
3782 i == 1 ? VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT :
3783 VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT
3785 VkSubresourceLayout
layout = { 0 };
3786 vk->GetImageSubresourceLayout(hwctx->
act_dev, dst_f->
img[
FFMIN(
i, nb_images - 1)],
3793 CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC tex_desc = {
3798 .NumChannels = 1 + ((
planes == 2) &&
i),
3806 tex_desc.arrayDesc.Width = p_w;
3807 tex_desc.arrayDesc.Height = p_h;
3809 ret =
CHECK_CU(cu->cuExternalMemoryGetMappedMipmappedArray(&dst_int->cu_mma[
i],
3810 dst_int->ext_mem[
FFMIN(
i, nb_images - 1)],
3817 ret =
CHECK_CU(cu->cuMipmappedArrayGetLevel(&dst_int->cu_array[
i],
3818 dst_int->cu_mma[
i], 0));
3849 CudaFunctions *cu = cu_internal->
cuda_dl;
3859 err =
CHECK_CU(cu->cuCtxPushCurrent(cuda_dev->cuda_ctx));
3863 err = vulkan_export_to_cuda(hwfc,
src->hw_frames_ctx,
dst);
3872 s_w_par[
i].params.fence.value = dst_f->
sem_value[
i] + 0;
3873 s_s_par[
i].params.fence.value = dst_f->
sem_value[
i] + 1;
3876 err =
CHECK_CU(cu->cuWaitExternalSemaphoresAsync(dst_int->cu_sem, s_w_par,
3877 planes, cuda_dev->stream));
3882 CUDA_MEMCPY2D cpy = {
3883 .srcMemoryType = CU_MEMORYTYPE_DEVICE,
3884 .srcDevice = (CUdeviceptr)
src->data[
i],
3885 .srcPitch =
src->linesize[
i],
3888 .dstMemoryType = CU_MEMORYTYPE_ARRAY,
3889 .dstArray = dst_int->cu_array[
i],
3895 cpy.WidthInBytes = p_w *
desc->comp[
i].step;
3898 err =
CHECK_CU(cu->cuMemcpy2DAsync(&cpy, cuda_dev->stream));
3903 err =
CHECK_CU(cu->cuSignalExternalSemaphoresAsync(dst_int->cu_sem, s_s_par,
3904 planes, cuda_dev->stream));
3930 switch (
src->format) {
3935 return vulkan_map_from_vaapi(hwfc,
dst,
src,
flags);
3941 return vulkan_map_from_drm(hwfc,
dst,
src,
flags);
3951 typedef struct VulkanDRMMapping {
3966 static inline uint32_t vulkan_fmt_to_drm(
VkFormat vkfmt)
3969 if (vulkan_drm_format_map[
i].vk_format == vkfmt)
3970 return vulkan_drm_format_map[
i].drm_fourcc;
3971 return DRM_FORMAT_INVALID;
3974 #define MAX_MEMORY_PLANES 4
3975 static VkImageAspectFlags plane_index_to_aspect(
int plane) {
3976 if (plane == 0)
return VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT;
3977 if (plane == 1)
return VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT;
3978 if (plane == 2)
return VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT;
3979 if (plane == 3)
return VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT;
3982 return VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT;
3996 VkImageDrmFormatModifierPropertiesEXT drm_mod = {
3997 .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
3999 VkSemaphoreWaitInfo wait_info = {
4000 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
4002 .semaphoreCount =
planes,
4014 wait_info.pSemaphores =
f->sem;
4015 wait_info.pValues =
f->sem_value;
4017 vk->WaitSemaphores(hwctx->
act_dev, &wait_info, UINT64_MAX);
4023 ret = vk->GetImageDrmFormatModifierPropertiesEXT(hwctx->
act_dev,
f->img[0],
4025 if (
ret != VK_SUCCESS) {
4031 for (
int i = 0; (
i <
planes) && (
f->mem[
i]);
i++) {
4032 VkMemoryGetFdInfoKHR export_info = {
4033 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
4034 .memory =
f->mem[
i],
4035 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
4038 ret = vk->GetMemoryFdKHR(hwctx->
act_dev, &export_info,
4040 if (
ret != VK_SUCCESS) {
4055 drm_desc->
layers[
i].
format = vulkan_fmt_to_drm(plane_vkfmt);
4065 VkSubresourceLayout
layout;
4066 VkImageSubresource sub = {
4067 .aspectMask = plane_index_to_aspect(j),
4072 vk->GetImageSubresourceLayout(hwctx->
act_dev,
f->img[
i], &sub, &
layout);
4084 if (
f->tiling == VK_IMAGE_TILING_OPTIMAL)
4090 dst->height =
src->height;
4091 dst->data[0] = (uint8_t *)drm_desc;
4135 switch (
dst->format) {
4145 return vulkan_map_to_vaapi(hwfc,
dst,
src,
flags);
4157 AVFrame *swf, VkBufferImageCopy *region,
4167 const VkMappedMemoryRange flush_info = {
4168 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
4169 .memory = vkbuf->
mem,
4170 .size = VK_WHOLE_SIZE,
4173 if (!upload && !(vkbuf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
4174 ret = vk->InvalidateMappedMemoryRanges(hwctx->
act_dev, 1,
4176 if (
ret != VK_SUCCESS) {
4186 region[
i].bufferRowLength,
4190 region[
i].imageExtent.height);
4195 vkbuf->mapped_mem + region[
i].bufferOffset,
4196 region[
i].bufferRowLength,
4198 region[
i].imageExtent.height);
4201 if (upload && !(vkbuf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
4202 ret = vk->FlushMappedMemoryRanges(hwctx->
act_dev, 1,
4204 if (
ret != VK_SUCCESS) {
4215 AVFrame *swf, VkBufferImageCopy *region,
int upload)
4222 VkBufferUsageFlags buf_usage = upload ? VK_BUFFER_USAGE_TRANSFER_SRC_BIT :
4223 VK_BUFFER_USAGE_TRANSFER_DST_BIT;
4225 size_t buf_offset = 0;
4229 region[
i] = (VkBufferImageCopy) {
4230 .bufferOffset = buf_offset,
4232 p->
props.properties.limits.optimalBufferCopyRowPitchAlignment),
4233 .bufferImageHeight = p_h,
4234 .imageSubresource.layerCount = 1,
4235 .imageExtent = (VkExtent3D){ p_w, p_h, 1 },
4239 buf_offset +=
FFALIGN(p_h*region[
i].bufferRowLength,
4240 p->
props.properties.limits.optimalBufferCopyOffsetAlignment);
4245 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
4246 VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
4254 AVFrame *swf, VkBufferImageCopy *region,
int upload)
4261 VkBufferUsageFlags buf_usage = upload ? VK_BUFFER_USAGE_TRANSFER_SRC_BIT :
4262 VK_BUFFER_USAGE_TRANSFER_DST_BIT;
4271 while (swf->
buf[nb_src_bufs])
4275 if (nb_src_bufs == 1) {
4286 }
else if (nb_src_bufs ==
planes) {
4305 for (
int i = 0;
i < (*nb_bufs);
i++)
4325 int nb_layout_ch = 0;
4329 for (
int i = 0;
i < nb_images;
i++) {
4340 layout_ch_info[nb_layout_ch] = (VkHostImageLayoutTransitionInfoEXT) {
4341 .sType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT,
4342 .image = hwf_vk->
img[
i],
4343 .oldLayout = hwf_vk->
layout[
i],
4344 .newLayout = VK_IMAGE_LAYOUT_GENERAL,
4345 .subresourceRange = {
4346 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
4352 hwf_vk->
layout[
i] = layout_ch_info[nb_layout_ch].newLayout;
4357 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
4358 .pSemaphores = hwf_vk->
sem,
4360 .semaphoreCount = nb_images,
4366 vk->TransitionImageLayoutEXT(hwctx->
act_dev,
4367 nb_layout_ch, layout_ch_info);
4370 VkMemoryToImageCopyEXT region_info = {
4371 .sType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT,
4372 .imageSubresource = {
4376 VkCopyMemoryToImageInfoEXT copy_info = {
4377 .sType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT,
4378 .flags = VK_HOST_IMAGE_COPY_MEMCPY_EXT,
4380 .pRegions = ®ion_info,
4383 int img_idx =
FFMIN(
i, (nb_images - 1));
4387 region_info.pHostPointer = swf->
data[
i];
4389 region_info.imageExtent = (VkExtent3D){ p_w, p_h, 1 };
4390 copy_info.dstImage = hwf_vk->
img[img_idx];
4391 copy_info.dstImageLayout = hwf_vk->
layout[img_idx];
4393 vk->CopyMemoryToImageEXT(hwctx->
act_dev, ©_info);
4396 VkImageToMemoryCopyEXT region_info = {
4397 .sType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT,
4398 .imageSubresource = {
4402 VkCopyImageToMemoryInfoEXT copy_info = {
4403 .sType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT,
4404 .flags = VK_HOST_IMAGE_COPY_MEMCPY_EXT,
4406 .pRegions = ®ion_info,
4409 int img_idx =
FFMIN(
i, (nb_images - 1));
4413 region_info.pHostPointer = swf->
data[
i];
4415 region_info.imageExtent = (VkExtent3D){ p_w, p_h, 1 };
4416 copy_info.srcImage = hwf_vk->
img[img_idx];
4417 copy_info.srcImageLayout = hwf_vk->
layout[img_idx];
4419 vk->CopyImageToMemoryEXT(hwctx->
act_dev, ©_info);
4438 int host_mapped = 0;
4453 VkCommandBuffer cmd_buf;
4465 if (hwctx->
usage & VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT)
4473 region[
i] = (VkBufferImageCopy) {
4476 .bufferImageHeight = p_h,
4477 .imageSubresource.layerCount = 1,
4478 .imageExtent = (VkExtent3D){ p_w, p_h, 1 },
4504 cmd_buf = exec->
buf;
4510 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
4511 VK_PIPELINE_STAGE_2_TRANSFER_BIT);
4535 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
4536 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,
4537 upload ? VK_ACCESS_TRANSFER_WRITE_BIT :
4538 VK_ACCESS_TRANSFER_READ_BIT,
4539 upload ? VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL :
4540 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4543 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
4544 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
4545 .pImageMemoryBarriers = img_bar,
4546 .imageMemoryBarrierCount = nb_img_bar,
4550 int buf_idx =
FFMIN(
i, (nb_bufs - 1));
4551 int img_idx =
FFMIN(
i, (nb_images - 1));
4554 uint32_t orig_stride = region[
i].bufferRowLength;
4555 region[
i].bufferRowLength /=
desc->comp[
i].step;
4559 vk->CmdCopyBufferToImage(cmd_buf, vkbuf->
buf,
4560 hwf_vk->
img[img_idx],
4561 img_bar[img_idx].newLayout,
4564 vk->CmdCopyImageToBuffer(cmd_buf, hwf_vk->
img[img_idx],
4565 img_bar[img_idx].newLayout,
4569 region[
i].bufferRowLength = orig_stride;
4575 }
else if (!upload) {
4582 for (
int i = 0;
i < nb_bufs;
i++)
4593 switch (
src->format) {
4603 return vulkan_transfer_data_from_cuda(hwfc,
dst,
src);
4606 if (
src->hw_frames_ctx)
4630 CudaFunctions *cu = cu_internal->
cuda_dl;
4641 err =
CHECK_CU(cu->cuCtxPushCurrent(cuda_dev->cuda_ctx));
4645 err = vulkan_export_to_cuda(hwfc,
dst->hw_frames_ctx,
src);
4654 s_w_par[
i].params.fence.value = dst_f->
sem_value[
i] + 0;
4655 s_s_par[
i].params.fence.value = dst_f->
sem_value[
i] + 1;
4658 err =
CHECK_CU(cu->cuWaitExternalSemaphoresAsync(dst_int->cu_sem, s_w_par,
4659 nb_images, cuda_dev->stream));
4664 CUDA_MEMCPY2D cpy = {
4665 .dstMemoryType = CU_MEMORYTYPE_DEVICE,
4666 .dstDevice = (CUdeviceptr)
dst->data[
i],
4667 .dstPitch =
dst->linesize[
i],
4670 .srcMemoryType = CU_MEMORYTYPE_ARRAY,
4671 .srcArray = dst_int->cu_array[
i],
4677 cpy.WidthInBytes =
w *
desc->comp[
i].step;
4680 err =
CHECK_CU(cu->cuMemcpy2DAsync(&cpy, cuda_dev->stream));
4685 err =
CHECK_CU(cu->cuSignalExternalSemaphoresAsync(dst_int->cu_sem, s_s_par,
4686 nb_images, cuda_dev->stream));
4712 switch (
dst->format) {
4722 return vulkan_transfer_data_to_cuda(hwfc,
dst,
src);
4725 if (
dst->hw_frames_ctx)