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>
67 #define CHECK_CU(x) FF_CUDA_CHECK_DL(cuda_cu, cu, x)
92 VkPhysicalDeviceProperties2
props;
93 VkPhysicalDeviceMemoryProperties
mprops;
94 VkPhysicalDeviceExternalMemoryHostPropertiesEXT
hprops;
156 #define ASPECT_2PLANE (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT)
157 #define ASPECT_3PLANE (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT)
169 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_GRAY8, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8_UNORM } },
170 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GRAY16, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16_UNORM } },
171 { VK_FORMAT_R32_SFLOAT,
AV_PIX_FMT_GRAYF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R32_SFLOAT } },
174 { VK_FORMAT_R16G16B16A16_UNORM,
AV_PIX_FMT_XV36, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
175 { VK_FORMAT_B8G8R8A8_UNORM,
AV_PIX_FMT_BGRA, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8A8_UNORM } },
176 { VK_FORMAT_R8G8B8A8_UNORM,
AV_PIX_FMT_RGBA, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
177 { VK_FORMAT_R8G8B8_UNORM,
AV_PIX_FMT_RGB24, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8_UNORM } },
178 { VK_FORMAT_B8G8R8_UNORM,
AV_PIX_FMT_BGR24, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8_UNORM } },
179 { VK_FORMAT_R16G16B16_UNORM,
AV_PIX_FMT_RGB48, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16_UNORM } },
180 { VK_FORMAT_R16G16B16A16_UNORM,
AV_PIX_FMT_RGBA64, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
181 { VK_FORMAT_R5G6B5_UNORM_PACK16,
AV_PIX_FMT_RGB565, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R5G6B5_UNORM_PACK16 } },
182 { VK_FORMAT_B5G6R5_UNORM_PACK16,
AV_PIX_FMT_BGR565, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B5G6R5_UNORM_PACK16 } },
183 { VK_FORMAT_B8G8R8A8_UNORM,
AV_PIX_FMT_BGR0, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_B8G8R8A8_UNORM } },
184 { VK_FORMAT_R8G8B8A8_UNORM,
AV_PIX_FMT_RGB0, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
185 { VK_FORMAT_A2R10G10B10_UNORM_PACK32,
AV_PIX_FMT_X2RGB10, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_A2R10G10B10_UNORM_PACK32 } },
188 { VK_FORMAT_R8_UNORM,
AV_PIX_FMT_GBRAP, VK_IMAGE_ASPECT_COLOR_BIT, 1, 4, 4, { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM } },
189 { VK_FORMAT_R16_UNORM,
AV_PIX_FMT_GBRAP16, VK_IMAGE_ASPECT_COLOR_BIT, 1, 4, 4, { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM } },
190 { VK_FORMAT_R32_SFLOAT,
AV_PIX_FMT_GBRPF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 3, 3, { VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT } },
191 { VK_FORMAT_R32_SFLOAT,
AV_PIX_FMT_GBRAPF32, VK_IMAGE_ASPECT_COLOR_BIT, 1, 4, 4, { VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT } },
195 { 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 } },
196 { 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 } },
201 { 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 } },
202 { 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 } },
207 { 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 } },
208 { 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 } },
226 { VK_FORMAT_G8B8G8R8_422_UNORM,
AV_PIX_FMT_YUYV422, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
227 { VK_FORMAT_B8G8R8G8_422_UNORM,
AV_PIX_FMT_UYVY422, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R8G8B8A8_UNORM } },
228 { VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
AV_PIX_FMT_Y210, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
229 { VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
AV_PIX_FMT_Y212, VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 1, { VK_FORMAT_R16G16B16A16_UNORM } },
250 #define FN_MAP_TO(dst_t, dst_name, src_t, src_name) \
251 static av_unused dst_t map_ ##src_name## _to_ ##dst_name(src_t src) \
254 MAP_TO(VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, \
255 VK_IMAGE_USAGE_SAMPLED_BIT); \
256 MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, \
257 VK_IMAGE_USAGE_TRANSFER_SRC_BIT); \
258 MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, \
259 VK_IMAGE_USAGE_TRANSFER_DST_BIT); \
260 MAP_TO(VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, \
261 VK_IMAGE_USAGE_STORAGE_BIT); \
262 MAP_TO(VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, \
263 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); \
264 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR, \
265 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR); \
266 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR, \
267 VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR); \
268 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, \
269 VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR); \
270 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, \
271 VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR); \
275 #define MAP_TO(flag1, flag2) if (src & flag2) dst |= flag1;
276 FN_MAP_TO(VkFormatFeatureFlagBits2, feats, VkImageUsageFlags,
usage)
278 #define MAP_TO(flag1, flag2) if (src & flag1) dst |= flag2;
279 FN_MAP_TO(VkImageUsageFlags,
usage, VkFormatFeatureFlagBits2, feats)
284 VkImageTiling tiling,
287 VkImageUsageFlags *supported_usage,
int disable_multiplane)
293 const VkFormatFeatureFlagBits2 basic_flags = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT |
294 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
295 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
299 VkFormatProperties2 prop = {
300 .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
302 VkFormatFeatureFlagBits2 feats_primary, feats_secondary;
303 int basics_primary = 0, basics_secondary = 0;
305 vk->GetPhysicalDeviceFormatProperties2(hwctx->
phys_dev,
309 feats_primary = tiling == VK_IMAGE_TILING_LINEAR ?
310 prop.formatProperties.linearTilingFeatures :
311 prop.formatProperties.optimalTilingFeatures;
312 basics_primary = (feats_primary & basic_flags) == basic_flags;
315 vk->GetPhysicalDeviceFormatProperties2(hwctx->
phys_dev,
318 feats_secondary = tiling == VK_IMAGE_TILING_LINEAR ?
319 prop.formatProperties.linearTilingFeatures :
320 prop.formatProperties.optimalTilingFeatures;
321 basics_secondary = (feats_secondary & basic_flags) == basic_flags;
323 basics_secondary = basics_primary;
334 *supported_usage = map_feats_to_usage(feats_primary);
336 }
else if (basics_secondary) {
346 *supported_usage = map_feats_to_usage(feats_secondary);
362 static const char *lib_names[] = {
365 #elif defined(__APPLE__)
376 p->
libvulkan = dlopen(lib_names[
i], RTLD_NOW | RTLD_LOCAL);
418 { VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_WIN32_MEMORY },
419 { VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_WIN32_SEM },
430 static VkBool32 VKAPI_CALL
vk_dbg_callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
431 VkDebugUtilsMessageTypeFlagsEXT messageType,
432 const VkDebugUtilsMessengerCallbackDataEXT *
data,
439 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: l =
AV_LOG_VERBOSE;
break;
440 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: l =
AV_LOG_INFO;
break;
441 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: l =
AV_LOG_WARNING;
break;
442 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: l =
AV_LOG_ERROR;
break;
447 for (
int i = 0;
i <
data->cmdBufLabelCount;
i++)
453 #define ADD_VAL_TO_LIST(list, count, val) \
455 list = av_realloc_array(list, sizeof(*list), ++count); \
457 err = AVERROR(ENOMEM); \
460 list[count - 1] = av_strdup(val); \
461 if (!list[count - 1]) { \
462 err = AVERROR(ENOMEM); \
467 #define RELEASE_PROPS(props, count) \
469 for (int i = 0; i < count; i++) \
470 av_free((void *)((props)[i])); \
471 av_free((void *)props); \
475 const char *
const **dst, uint32_t *num,
int debug)
478 const char **extension_names =
NULL;
482 int err = 0, found, extensions_found = 0;
485 int optional_exts_num;
486 uint32_t sup_ext_count;
487 char *user_exts_str =
NULL;
489 VkExtensionProperties *sup_ext;
499 if (!user_exts_str) {
504 vk->EnumerateInstanceExtensionProperties(
NULL, &sup_ext_count,
NULL);
505 sup_ext =
av_malloc_array(sup_ext_count,
sizeof(VkExtensionProperties));
508 vk->EnumerateInstanceExtensionProperties(
NULL, &sup_ext_count, sup_ext);
516 if (!user_exts_str) {
521 vk->EnumerateDeviceExtensionProperties(hwctx->
phys_dev,
NULL,
522 &sup_ext_count,
NULL);
523 sup_ext =
av_malloc_array(sup_ext_count,
sizeof(VkExtensionProperties));
526 vk->EnumerateDeviceExtensionProperties(hwctx->
phys_dev,
NULL,
527 &sup_ext_count, sup_ext);
530 for (
int i = 0;
i < optional_exts_num;
i++) {
531 tstr = optional_exts[
i].
name;
533 for (
int j = 0; j < sup_ext_count; j++) {
534 if (!strcmp(tstr, sup_ext[j].extensionName)) {
548 tstr = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
550 for (
int j = 0; j < sup_ext_count; j++) {
551 if (!strcmp(tstr, sup_ext[j].extensionName)) {
569 char *save, *token =
av_strtok(user_exts_str,
"+", &save);
572 for (
int j = 0; j < sup_ext_count; j++) {
573 if (!strcmp(token, sup_ext[j].extensionName)) {
589 *dst = extension_names;
590 *num = extensions_found;
604 const char *
const **dst, uint32_t *num,
607 static const char default_layer[] = {
"VK_LAYER_KHRONOS_validation" };
609 int found = 0, err = 0;
613 uint32_t sup_layer_count;
614 VkLayerProperties *sup_layers;
617 char *user_layers_str =
NULL;
620 const char **enabled_layers =
NULL;
621 uint32_t enabled_layers_count = 0;
624 int debug = debug_opt && strtol(debug_opt->
value,
NULL, 10);
627 if (debug_opt && !debug)
630 vk->EnumerateInstanceLayerProperties(&sup_layer_count,
NULL);
631 sup_layers =
av_malloc_array(sup_layer_count,
sizeof(VkLayerProperties));
634 vk->EnumerateInstanceLayerProperties(&sup_layer_count, sup_layers);
637 for (
int i = 0;
i < sup_layer_count;
i++)
643 for (
int i = 0;
i < sup_layer_count;
i++) {
644 if (!strcmp(default_layer, sup_layers[
i].layerName)) {
659 if (!user_layers_str) {
664 token =
av_strtok(user_layers_str,
"+", &save);
667 if (!strcmp(default_layer, token)) {
677 for (
int j = 0; j < sup_layer_count; j++) {
678 if (!strcmp(token, sup_layers[j].layerName)) {
688 "Validation Layer \"%s\" not support.\n", token);
700 *dst = enabled_layers;
701 *num = enabled_layers_count;
715 int err = 0, debug_mode = 0;
720 VkApplicationInfo application_info = {
721 .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
722 .pApplicationName =
"ffmpeg",
726 .pEngineName =
"libavutil",
727 .apiVersion = VK_API_VERSION_1_3,
732 VkValidationFeaturesEXT validation_features = {
733 .sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,
735 VkInstanceCreateInfo inst_props = {
736 .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
737 .pApplicationInfo = &application_info,
753 &inst_props.enabledLayerCount, &debug_mode);
759 &inst_props.enabledExtensionCount, debug_mode);
766 VkValidationFeatureEnableEXT feat_list[] = {
767 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
768 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
769 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT,
771 validation_features.pEnabledValidationFeatures = feat_list;
772 validation_features.enabledValidationFeatureCount =
FF_ARRAY_ELEMS(feat_list);
773 inst_props.pNext = &validation_features;
777 ret = vk->CreateInstance(&inst_props, hwctx->
alloc, &hwctx->
inst);
780 if (
ret != VK_SUCCESS) {
794 VkDebugUtilsMessengerCreateInfoEXT dbg = {
795 .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
796 .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
797 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT |
798 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
799 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
800 .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
801 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
802 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
807 vk->CreateDebugUtilsMessengerEXT(hwctx->
inst, &dbg,
814 RELEASE_PROPS(inst_props.ppEnabledLayerNames, inst_props.enabledLayerCount);
833 case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
return "integrated";
834 case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
return "discrete";
835 case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
return "virtual";
836 case VK_PHYSICAL_DEVICE_TYPE_CPU:
return "software";
837 default:
return "unknown";
844 int err = 0, choice = -1;
849 VkPhysicalDevice *devices =
NULL;
850 VkPhysicalDeviceIDProperties *idp =
NULL;
851 VkPhysicalDeviceProperties2 *prop =
NULL;
852 VkPhysicalDeviceDrmPropertiesEXT *drm_prop =
NULL;
855 ret = vk->EnumeratePhysicalDevices(hwctx->
inst, &num,
NULL);
856 if (
ret != VK_SUCCESS || !num) {
865 ret = vk->EnumeratePhysicalDevices(hwctx->
inst, &num, devices);
866 if (
ret != VK_SUCCESS) {
886 drm_prop =
av_calloc(num,
sizeof(*drm_prop));
894 for (
int i = 0;
i < num;
i++) {
896 drm_prop[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT;
897 idp[
i].pNext = &drm_prop[
i];
899 idp[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
900 prop[
i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
901 prop[
i].pNext = &idp[
i];
903 vk->GetPhysicalDeviceProperties2(devices[
i], &prop[
i]);
905 prop[
i].properties.deviceName,
907 prop[
i].properties.deviceID);
911 for (
int i = 0;
i < num;
i++) {
912 if (!strncmp(idp[
i].deviceUUID, select->
uuid, VK_UUID_SIZE)) {
921 for (
int i = 0;
i < num;
i++) {
922 if ((select->
drm_major == drm_prop[
i].primaryMajor &&
923 select->
drm_minor == drm_prop[
i].primaryMinor) ||
924 (select->
drm_major == drm_prop[
i].renderMajor &&
925 select->
drm_minor == drm_prop[
i].renderMinor)) {
934 }
else if (select->
name) {
936 for (
int i = 0;
i < num;
i++) {
937 if (strstr(prop[
i].properties.deviceName, select->
name)) {
948 for (
int i = 0;
i < num;
i++) {
949 if (select->
pci_device == prop[
i].properties.deviceID) {
960 for (
int i = 0;
i < num;
i++) {
961 if (select->
vendor_id == prop[
i].properties.vendorID) {
971 if (select->
index < num) {
972 choice = select->
index;
984 choice, prop[choice].properties.deviceName,
986 prop[choice].properties.deviceID);
1000 VkQueueFlagBits
flags)
1003 uint32_t min_score = UINT32_MAX;
1005 for (
int i = 0;
i < num_qf;
i++) {
1006 const VkQueueFlagBits qflags = qf[
i].queueFlags;
1007 if (qflags &
flags) {
1008 uint32_t score =
av_popcount(qflags) + qf[
i].timestampValidBits;
1009 if (score < min_score) {
1017 qf[
index].timestampValidBits++;
1026 VkQueueFamilyProperties *qf =
NULL;
1030 int graph_index, comp_index, tx_index, enc_index, dec_index;
1033 vk->GetPhysicalDeviceQueueFamilyProperties(hwctx->
phys_dev, &num,
NULL);
1045 vk->GetPhysicalDeviceQueueFamilyProperties(hwctx->
phys_dev, &num, qf);
1048 for (
int i = 0;
i < num;
i++) {
1050 ((qf[
i].queueFlags) & VK_QUEUE_GRAPHICS_BIT) ?
" graphics" :
"",
1051 ((qf[
i].queueFlags) & VK_QUEUE_COMPUTE_BIT) ?
" compute" :
"",
1052 ((qf[
i].queueFlags) & VK_QUEUE_TRANSFER_BIT) ?
" transfer" :
"",
1053 ((qf[
i].queueFlags) & VK_QUEUE_VIDEO_ENCODE_BIT_KHR) ?
" encode" :
"",
1054 ((qf[
i].queueFlags) & VK_QUEUE_VIDEO_DECODE_BIT_KHR) ?
" decode" :
"",
1055 ((qf[
i].queueFlags) & VK_QUEUE_SPARSE_BINDING_BIT) ?
" sparse" :
"",
1056 ((qf[
i].queueFlags) & VK_QUEUE_PROTECTED_BIT) ?
" protected" :
"",
1061 qf[
i].timestampValidBits = 0;
1084 #define SETUP_QUEUE(qf_idx) \
1085 if (qf_idx > -1) { \
1086 int fidx = qf_idx; \
1087 int qc = qf[fidx].queueCount; \
1088 VkDeviceQueueCreateInfo *pc; \
1090 if (fidx == graph_index) { \
1091 hwctx->queue_family_index = fidx; \
1092 hwctx->nb_graphics_queues = qc; \
1095 if (fidx == comp_index) { \
1096 hwctx->queue_family_comp_index = fidx; \
1097 hwctx->nb_comp_queues = qc; \
1100 if (fidx == tx_index) { \
1101 hwctx->queue_family_tx_index = fidx; \
1102 hwctx->nb_tx_queues = qc; \
1105 if (fidx == enc_index) { \
1106 hwctx->queue_family_encode_index = fidx; \
1107 hwctx->nb_encode_queues = qc; \
1110 if (fidx == dec_index) { \
1111 hwctx->queue_family_decode_index = fidx; \
1112 hwctx->nb_decode_queues = qc; \
1116 pc = av_realloc((void *)cd->pQueueCreateInfos, \
1117 sizeof(*pc) * (cd->queueCreateInfoCount + 1)); \
1120 return AVERROR(ENOMEM); \
1122 cd->pQueueCreateInfos = pc; \
1123 pc = &pc[cd->queueCreateInfoCount]; \
1125 weights = av_malloc(qc * sizeof(float)); \
1128 return AVERROR(ENOMEM); \
1131 memset(pc, 0, sizeof(*pc)); \
1132 pc->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; \
1133 pc->queueFamilyIndex = fidx; \
1134 pc->queueCount = qc; \
1135 pc->pQueuePriorities = weights; \
1137 for (int i = 0; i < qc; i++) \
1138 weights[i] = 1.0f / qc; \
1140 cd->queueCreateInfoCount++; \
1166 vk->DestroyDebugUtilsMessengerEXT(hwctx->
inst, p->
debug_ctx,
1170 vk->DestroyInstance(hwctx->
inst, hwctx->
alloc);
1189 int disable_multiplane,
1204 VkPhysicalDeviceTimelineSemaphoreFeatures timeline_features = {
1205 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
1207 VkPhysicalDeviceCooperativeMatrixFeaturesKHR coop_matrix_features = {
1208 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR,
1209 .pNext = &timeline_features,
1211 VkPhysicalDeviceShaderAtomicFloatFeaturesEXT atomic_float_features = {
1212 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
1213 .pNext = &coop_matrix_features,
1215 VkPhysicalDeviceDescriptorBufferFeaturesEXT desc_buf_features = {
1216 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT,
1217 .pNext = &atomic_float_features,
1219 VkPhysicalDeviceVulkan13Features dev_features_1_3 = {
1220 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
1221 .pNext = &desc_buf_features,
1223 VkPhysicalDeviceVulkan12Features dev_features_1_2 = {
1224 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
1225 .pNext = &dev_features_1_3,
1227 VkPhysicalDeviceVulkan11Features dev_features_1_1 = {
1228 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
1229 .pNext = &dev_features_1_2,
1231 VkPhysicalDeviceFeatures2 dev_features = {
1232 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
1233 .pNext = &dev_features_1_1,
1236 VkDeviceCreateInfo dev_info = {
1237 .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
1240 hwctx->
device_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
1248 p->
desc_buf_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
1250 p->
atomic_float_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
1252 p->
coop_matrix_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
1265 vk->GetPhysicalDeviceFeatures2(hwctx->
phys_dev, &dev_features);
1268 #define COPY_FEATURE(DST, NAME) (DST).features.NAME = dev_features.features.NAME;
1280 if (!timeline_features.timelineSemaphore) {
1294 p->
device_features_1_2.storageBuffer8BitAccess = dev_features_1_2.storageBuffer8BitAccess;
1295 p->
device_features_1_2.uniformAndStorageBuffer8BitAccess = dev_features_1_2.uniformAndStorageBuffer8BitAccess;
1297 p->
device_features_1_2.shaderSharedInt64Atomics = dev_features_1_2.shaderSharedInt64Atomics;
1299 p->
device_features_1_2.vulkanMemoryModelDeviceScope = dev_features_1_2.vulkanMemoryModelDeviceScope;
1306 p->
device_features_1_3.shaderZeroInitializeWorkgroupMemory = dev_features_1_3.shaderZeroInitializeWorkgroupMemory;
1310 p->
desc_buf_features.descriptorBufferPushDescriptors = desc_buf_features.descriptorBufferPushDescriptors;
1312 p->
atomic_float_features.shaderBufferFloat32Atomics = atomic_float_features.shaderBufferFloat32Atomics;
1313 p->
atomic_float_features.shaderBufferFloat32AtomicAdd = atomic_float_features.shaderBufferFloat32AtomicAdd;
1324 &dev_info.enabledExtensionCount, 0))) {
1325 for (
int i = 0;
i < dev_info.queueCreateInfoCount;
i++)
1326 av_free((
void *)dev_info.pQueueCreateInfos[
i].pQueuePriorities);
1327 av_free((
void *)dev_info.pQueueCreateInfos);
1334 for (
int i = 0;
i < dev_info.queueCreateInfoCount;
i++)
1335 av_free((
void *)dev_info.pQueueCreateInfos[
i].pQueuePriorities);
1336 av_free((
void *)dev_info.pQueueCreateInfos);
1338 if (
ret != VK_SUCCESS) {
1341 for (
int i = 0;
i < dev_info.enabledExtensionCount;
i++)
1342 av_free((
void *)dev_info.ppEnabledExtensionNames[
i]);
1343 av_free((
void *)dev_info.ppEnabledExtensionNames);
1389 VkQueueFamilyProperties *qf;
1390 int graph_index, comp_index, tx_index, enc_index, dec_index;
1409 p->
props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
1411 p->
hprops.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
1413 vk->GetPhysicalDeviceProperties2(hwctx->
phys_dev, &p->
props);
1415 p->
props.properties.deviceName);
1418 p->
props.properties.limits.optimalBufferCopyRowPitchAlignment);
1420 p->
props.properties.limits.minMemoryMapAlignment);
1422 p->
props.properties.limits.nonCoherentAtomSize);
1425 p->
hprops.minImportedHostPointerAlignment);
1429 vk->GetPhysicalDeviceQueueFamilyProperties(hwctx->
phys_dev, &qf_num,
NULL);
1439 vk->GetPhysicalDeviceQueueFamilyProperties(hwctx->
phys_dev, &qf_num, qf);
1448 for (uint32_t
i = 0;
i < qf_num;
i++) {
1454 for (uint32_t j = 0; j < qf[
i].queueCount; j++) {
1473 #define CHECK_QUEUE(type, required, fidx, ctx_qf, qc) \
1475 if (ctx_qf < 0 && required) { \
1476 av_log(ctx, AV_LOG_ERROR, "%s queue family is required, but marked as missing" \
1477 " in the context!\n", type); \
1478 return AVERROR(EINVAL); \
1479 } else if (fidx < 0 || ctx_qf < 0) { \
1481 } else if (ctx_qf >= qf_num) { \
1482 av_log(ctx, AV_LOG_ERROR, "Invalid %s family index %i (device has %i families)!\n", \
1483 type, ctx_qf, qf_num); \
1484 return AVERROR(EINVAL); \
1487 av_log(ctx, AV_LOG_VERBOSE, "Using queue family %i (queues: %i)" \
1488 " for%s%s%s%s%s\n", \
1490 ctx_qf == graph_index ? " graphics" : "", \
1491 ctx_qf == comp_index ? " compute" : "", \
1492 ctx_qf == tx_index ? " transfers" : "", \
1493 ctx_qf == enc_index ? " encode" : "", \
1494 ctx_qf == dec_index ? " decode" : ""); \
1495 graph_index = (ctx_qf == graph_index) ? -1 : graph_index; \
1496 comp_index = (ctx_qf == comp_index) ? -1 : comp_index; \
1497 tx_index = (ctx_qf == tx_index) ? -1 : tx_index; \
1498 enc_index = (ctx_qf == enc_index) ? -1 : enc_index; \
1499 dec_index = (ctx_qf == dec_index) ? -1 : dec_index; \
1500 p->img_qfs[p->nb_img_qfs++] = ctx_qf; \
1517 vk->GetPhysicalDeviceMemoryProperties(hwctx->
phys_dev, &p->
mprops);
1533 if (device && device[0]) {
1535 dev_select.
index = strtol(device, &end, 10);
1536 if (end == device) {
1537 dev_select.
index = 0;
1538 dev_select.
name = device;
1554 switch(src_ctx->
type) {
1559 const char *vendor = vaQueryVendorString(src_hwctx->
display);
1565 if (strstr(vendor,
"AMD"))
1566 dev_select.vendor_id = 0x1002;
1574 struct stat drm_node_info;
1575 drmDevice *drm_dev_info;
1578 err = fstat(src_hwctx->
fd, &drm_node_info);
1585 dev_select.drm_major = major(drm_node_info.st_dev);
1586 dev_select.drm_minor = minor(drm_node_info.st_dev);
1587 dev_select.has_drm = 1;
1589 err = drmGetDevice(src_hwctx->
fd, &drm_dev_info);
1596 if (drm_dev_info->bustype == DRM_BUS_PCI)
1597 dev_select.pci_device = drm_dev_info->deviceinfo.pci->device_id;
1599 drmFreeDevice(&drm_dev_info);
1609 CudaFunctions *cu = cu_internal->
cuda_dl;
1611 int ret =
CHECK_CU(cu->cuDeviceGetUuid((CUuuid *)&dev_select.uuid,
1618 dev_select.has_uuid = 1;
1633 const void *hwconfig,
1642 VK_IMAGE_TILING_OPTIMAL,
1660 VK_IMAGE_TILING_OPTIMAL,
1674 constraints->
max_width = p->
props.properties.limits.maxImageDimension2D;
1675 constraints->
max_height = p->
props.properties.limits.maxImageDimension2D;
1688 VkMemoryPropertyFlagBits req_flags,
const void *alloc_extension,
1689 VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
1696 VkMemoryAllocateInfo alloc_info = {
1697 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
1698 .pNext = alloc_extension,
1699 .allocationSize = req->size,
1704 for (
int i = 0;
i < p->
mprops.memoryTypeCount;
i++) {
1705 const VkMemoryType *
type = &p->
mprops.memoryTypes[
i];
1708 if (!(req->memoryTypeBits & (1 <<
i)))
1712 if ((
type->propertyFlags & req_flags) != req_flags)
1716 if (req->size > p->
mprops.memoryHeaps[
type->heapIndex].size)
1730 alloc_info.memoryTypeIndex =
index;
1732 ret = vk->AllocateMemory(dev_hwctx->
act_dev, &alloc_info,
1733 dev_hwctx->
alloc, mem);
1734 if (
ret != VK_SUCCESS) {
1740 *mem_flags |= p->
mprops.memoryTypes[
index].propertyFlags;
1750 if (internal->cuda_fc_ref) {
1756 CudaFunctions *cu = cu_internal->
cuda_dl;
1759 if (internal->cu_sem[
i])
1760 CHECK_CU(cu->cuDestroyExternalSemaphore(internal->cu_sem[
i]));
1761 if (internal->cu_mma[
i])
1762 CHECK_CU(cu->cuMipmappedArrayDestroy(internal->cu_mma[
i]));
1763 if (internal->ext_mem[
i])
1764 CHECK_CU(cu->cuDestroyExternalMemory(internal->ext_mem[
i]));
1766 if (internal->ext_sem_handle[
i])
1767 CloseHandle(internal->ext_sem_handle[
i]);
1768 if (internal->ext_mem_handle[
i])
1769 CloseHandle(internal->ext_mem_handle[
i]);
1789 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
1791 .pSemaphores =
f->sem,
1792 .pValues =
f->sem_value,
1793 .semaphoreCount = nb_images,
1800 for (
int i = 0;
i < nb_images;
i++) {
1815 void *alloc_pnext,
size_t alloc_pnext_stride)
1817 int img_cnt = 0, err;
1826 while (
f->img[img_cnt]) {
1828 VkImageMemoryRequirementsInfo2 req_desc = {
1829 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
1830 .image =
f->img[img_cnt],
1832 VkMemoryDedicatedAllocateInfo ded_alloc = {
1833 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
1834 .pNext = (
void *)(((uint8_t *)alloc_pnext) + img_cnt*alloc_pnext_stride),
1836 VkMemoryDedicatedRequirements ded_req = {
1837 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
1839 VkMemoryRequirements2 req = {
1840 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
1844 vk->GetImageMemoryRequirements2(hwctx->
act_dev, &req_desc, &req);
1846 if (
f->tiling == VK_IMAGE_TILING_LINEAR)
1847 req.memoryRequirements.size =
FFALIGN(req.memoryRequirements.size,
1848 p->
props.properties.limits.minMemoryMapAlignment);
1851 use_ded_mem = ded_req.prefersDedicatedAllocation |
1852 ded_req.requiresDedicatedAllocation;
1854 ded_alloc.image =
f->img[img_cnt];
1858 f->tiling == VK_IMAGE_TILING_LINEAR ?
1859 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT :
1860 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
1861 use_ded_mem ? &ded_alloc : (
void *)ded_alloc.pNext,
1862 &
f->flags, &
f->mem[img_cnt])))
1865 f->size[img_cnt] = req.memoryRequirements.size;
1866 bind_info[img_cnt].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
1867 bind_info[img_cnt].image =
f->img[img_cnt];
1868 bind_info[img_cnt].memory =
f->mem[img_cnt];
1874 ret = vk->BindImageMemory2(hwctx->
act_dev, img_cnt, bind_info);
1875 if (
ret != VK_SUCCESS) {
1901 uint32_t dst_qf = VK_QUEUE_FAMILY_IGNORED;
1902 VkImageLayout new_layout;
1903 VkAccessFlags2 new_access;
1904 VkPipelineStageFlagBits2 src_stage = VK_PIPELINE_STAGE_2_NONE;
1910 .
data = (uint8_t *)hwfc,
1914 .hw_frames_ctx = &tmp_ref,
1917 VkCommandBuffer cmd_buf;
1919 cmd_buf = exec->
buf;
1923 VK_PIPELINE_STAGE_2_NONE,
1924 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT);
1930 new_layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
1931 new_access = VK_ACCESS_TRANSFER_WRITE_BIT;
1934 new_layout = VK_IMAGE_LAYOUT_GENERAL;
1935 new_access = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
1938 new_layout = VK_IMAGE_LAYOUT_GENERAL;
1939 new_access = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
1940 dst_qf = VK_QUEUE_FAMILY_EXTERNAL_KHR;
1941 src_stage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
1944 new_layout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR;
1945 new_access = VK_ACCESS_TRANSFER_WRITE_BIT;
1948 new_layout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR;
1949 new_access = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
1955 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
1956 new_access, new_layout, dst_qf);
1958 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
1959 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
1960 .pImageMemoryBarriers = img_bar,
1961 .imageMemoryBarrierCount = nb_img_bar,
1975 int frame_w,
int frame_h,
int plane)
1992 VkImageTiling tiling, VkImageUsageFlagBits
usage,
1993 VkImageCreateFlags
flags,
int nb_layers,
2004 VkExportSemaphoreCreateInfo ext_sem_info = {
2005 .sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
2007 .handleTypes = IsWindows8OrGreater()
2008 ? VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
2009 : VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
2011 .handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
2015 VkSemaphoreTypeCreateInfo sem_type_info = {
2016 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
2022 .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
2026 VkSemaphoreCreateInfo sem_spawn = {
2027 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
2028 .pNext = &sem_type_info,
2040 for (
int i = 0; (hwfc_vk->
format[
i] != VK_FORMAT_UNDEFINED);
i++) {
2041 VkImageCreateInfo create_info = {
2042 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
2043 .pNext = create_pnext,
2044 .imageType = VK_IMAGE_TYPE_2D,
2048 .arrayLayers = nb_layers,
2051 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
2053 .samples = VK_SAMPLE_COUNT_1_BIT,
2054 .pQueueFamilyIndices = p->
img_qfs,
2056 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
2057 VK_SHARING_MODE_EXCLUSIVE,
2060 get_plane_wh(&create_info.extent.width, &create_info.extent.height,
2063 ret = vk->CreateImage(hwctx->
act_dev, &create_info,
2065 if (
ret != VK_SUCCESS) {
2073 ret = vk->CreateSemaphore(hwctx->
act_dev, &sem_spawn,
2075 if (
ret != VK_SUCCESS) {
2082 f->layout[
i] = create_info.initialLayout;
2084 f->sem_value[
i] = 0;
2100 VkExternalMemoryHandleTypeFlags *comp_handle_types,
2101 VkExternalMemoryHandleTypeFlagBits *iexp,
2102 VkExternalMemoryHandleTypeFlagBits
exp)
2110 const VkImageDrmFormatModifierListCreateInfoEXT *drm_mod_info =
2112 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
2113 int has_mods = hwctx->
tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT && drm_mod_info;
2116 VkExternalImageFormatProperties eprops = {
2117 .sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
2119 VkImageFormatProperties2 props = {
2120 .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
2123 VkPhysicalDeviceImageDrmFormatModifierInfoEXT phy_dev_mod_info = {
2124 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
2126 .pQueueFamilyIndices = p->
img_qfs,
2128 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
2129 VK_SHARING_MODE_EXCLUSIVE,
2131 VkPhysicalDeviceExternalImageFormatInfo enext = {
2132 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
2134 .pNext = has_mods ? &phy_dev_mod_info :
NULL,
2136 VkPhysicalDeviceImageFormatInfo2 pinfo = {
2137 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
2138 .pNext = !
exp ?
NULL : &enext,
2140 .type = VK_IMAGE_TYPE_2D,
2142 .usage = hwctx->
usage,
2143 .flags = VK_IMAGE_CREATE_ALIAS_BIT,
2146 nb_mods = has_mods ? drm_mod_info->drmFormatModifierCount : 1;
2147 for (
int i = 0;
i < nb_mods;
i++) {
2149 phy_dev_mod_info.drmFormatModifier = drm_mod_info->pDrmFormatModifiers[
i];
2151 ret = vk->GetPhysicalDeviceImageFormatProperties2(dev_hwctx->
phys_dev,
2154 if (
ret == VK_SUCCESS) {
2156 *comp_handle_types |= eprops.externalMemoryProperties.compatibleHandleTypes;
2170 VkExternalMemoryHandleTypeFlags e = 0x0;
2173 VkExternalMemoryImageCreateInfo eiinfo = {
2174 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
2181 ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
2182 : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT);
2186 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT);
2190 eminfo[
i].sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
2192 eminfo[
i].handleTypes = e;
2205 if ( (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR) &&
2206 !(hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR))
2208 else if (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)
2242 if (
fp->modifier_info) {
2243 if (
fp->modifier_info->pDrmFormatModifiers)
2244 av_freep(&
fp->modifier_info->pDrmFormatModifiers);
2260 VkImageUsageFlagBits supported_usage;
2271 (hwctx->
tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT))
2272 hwctx->
tiling = VK_IMAGE_TILING_LINEAR;
2282 if (hwctx->
format[0] != VK_FORMAT_UNDEFINED) {
2287 "for the current sw_format %s!\n",
2306 NULL, &supported_usage,
2307 disable_multiplane);
2313 if (!hwctx->
usage) {
2314 hwctx->
usage = supported_usage & (VK_BUFFER_USAGE_TRANSFER_DST_BIT |
2315 VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
2316 VK_IMAGE_USAGE_STORAGE_BIT |
2317 VK_IMAGE_USAGE_SAMPLED_BIT |
2318 VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR);
2325 int is_lone_dpb = (hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR) &&
2326 !(hwctx->
usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR);
2327 int sampleable = hwctx->
usage & (VK_IMAGE_USAGE_SAMPLED_BIT |
2328 VK_IMAGE_USAGE_STORAGE_BIT);
2329 if (sampleable && !is_lone_dpb) {
2330 hwctx->
img_flags = VK_IMAGE_CREATE_ALIAS_BIT;
2332 hwctx->
img_flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
2333 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
2414 static const struct {
2415 uint32_t drm_fourcc;
2417 } vulkan_drm_format_map[] = {
2418 { DRM_FORMAT_R8, VK_FORMAT_R8_UNORM },
2419 { DRM_FORMAT_R16, VK_FORMAT_R16_UNORM },
2420 { DRM_FORMAT_GR88, VK_FORMAT_R8G8_UNORM },
2421 { DRM_FORMAT_RG88, VK_FORMAT_R8G8_UNORM },
2422 { DRM_FORMAT_GR1616, VK_FORMAT_R16G16_UNORM },
2423 { DRM_FORMAT_RG1616, VK_FORMAT_R16G16_UNORM },
2424 { DRM_FORMAT_ARGB8888, VK_FORMAT_B8G8R8A8_UNORM },
2425 { DRM_FORMAT_XRGB8888, VK_FORMAT_B8G8R8A8_UNORM },
2426 { DRM_FORMAT_ABGR8888, VK_FORMAT_R8G8B8A8_UNORM },
2427 { DRM_FORMAT_XBGR8888, VK_FORMAT_R8G8B8A8_UNORM },
2430 #ifdef DRM_FORMAT_XYUV8888
2431 { DRM_FORMAT_XYUV8888, VK_FORMAT_R8G8B8A8_UNORM },
2432 { DRM_FORMAT_XVYU12_16161616, VK_FORMAT_R16G16B16A16_UNORM} ,
2435 { DRM_FORMAT_Y416, VK_FORMAT_R16G16B16A16_UNORM },
2439 static inline VkFormat drm_to_vulkan_fmt(uint32_t drm_fourcc)
2442 if (vulkan_drm_format_map[
i].drm_fourcc == drm_fourcc)
2443 return vulkan_drm_format_map[
i].vk_format;
2444 return VK_FORMAT_UNDEFINED;
2453 int bind_counts = 0;
2464 if (drm_to_vulkan_fmt(
desc->layers[
i].format) == VK_FORMAT_UNDEFINED) {
2466 desc->layers[
i].format);
2477 f->tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
2479 for (
int i = 0;
i <
desc->nb_layers;
i++) {
2483 VkSemaphoreTypeCreateInfo sem_type_info = {
2484 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
2485 .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
2488 VkSemaphoreCreateInfo sem_spawn = {
2489 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
2490 .pNext = &sem_type_info,
2495 VkImageDrmFormatModifierExplicitCreateInfoEXT ext_img_mod_spec = {
2496 .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
2497 .drmFormatModifier =
desc->objects[0].format_modifier,
2498 .drmFormatModifierPlaneCount =
planes,
2499 .pPlaneLayouts = (
const VkSubresourceLayout *)&ext_img_layouts,
2501 VkExternalMemoryImageCreateInfo ext_img_spec = {
2502 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
2503 .pNext = &ext_img_mod_spec,
2504 .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
2506 VkImageCreateInfo create_info = {
2507 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
2508 .pNext = &ext_img_spec,
2509 .imageType = VK_IMAGE_TYPE_2D,
2510 .format = drm_to_vulkan_fmt(
desc->layers[
i].format),
2515 .tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT,
2516 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
2517 .usage = VK_IMAGE_USAGE_SAMPLED_BIT |
2518 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
2519 .samples = VK_SAMPLE_COUNT_1_BIT,
2520 .pQueueFamilyIndices = p->
img_qfs,
2522 .sharingMode = p->
nb_img_qfs > 1 ? VK_SHARING_MODE_CONCURRENT :
2523 VK_SHARING_MODE_EXCLUSIVE,
2527 VkExternalImageFormatProperties ext_props = {
2528 .sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
2530 VkImageFormatProperties2 props_ret = {
2531 .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
2532 .pNext = &ext_props,
2534 VkPhysicalDeviceImageDrmFormatModifierInfoEXT props_drm_mod = {
2535 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
2536 .drmFormatModifier = ext_img_mod_spec.drmFormatModifier,
2537 .pQueueFamilyIndices = create_info.pQueueFamilyIndices,
2538 .queueFamilyIndexCount = create_info.queueFamilyIndexCount,
2539 .sharingMode = create_info.sharingMode,
2541 VkPhysicalDeviceExternalImageFormatInfo props_ext = {
2542 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
2543 .pNext = &props_drm_mod,
2544 .handleType = ext_img_spec.handleTypes,
2546 VkPhysicalDeviceImageFormatInfo2 fmt_props = {
2547 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
2548 .pNext = &props_ext,
2549 .format = create_info.format,
2550 .type = create_info.imageType,
2551 .tiling = create_info.tiling,
2552 .usage = create_info.usage,
2553 .flags = create_info.flags,
2557 ret = vk->GetPhysicalDeviceImageFormatProperties2(hwctx->
phys_dev,
2558 &fmt_props, &props_ret);
2559 if (
ret != VK_SUCCESS) {
2567 get_plane_wh(&create_info.extent.width, &create_info.extent.height,
2571 for (
int j = 0; j <
planes; j++) {
2572 ext_img_layouts[j].offset =
desc->layers[
i].planes[j].offset;
2573 ext_img_layouts[j].rowPitch =
desc->layers[
i].planes[j].pitch;
2574 ext_img_layouts[j].size = 0;
2575 ext_img_layouts[j].arrayPitch = 0;
2576 ext_img_layouts[j].depthPitch = 0;
2580 ret = vk->CreateImage(hwctx->
act_dev, &create_info,
2582 if (
ret != VK_SUCCESS) {
2589 ret = vk->CreateSemaphore(hwctx->
act_dev, &sem_spawn,
2591 if (
ret != VK_SUCCESS) {
2603 f->layout[
i] = create_info.initialLayout;
2605 f->sem_value[
i] = 0;
2608 for (
int i = 0;
i <
desc->nb_layers;
i++) {
2610 VkImageMemoryRequirementsInfo2 req_desc = {
2611 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
2614 VkMemoryDedicatedRequirements ded_req = {
2615 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
2617 VkMemoryRequirements2 req2 = {
2618 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
2623 VkMemoryFdPropertiesKHR fdmp = {
2624 .sType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR,
2630 VkImportMemoryFdInfoKHR idesc = {
2631 .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
2632 .fd = dup(
desc->objects[
desc->layers[
i].planes[0].object_index].fd),
2633 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
2635 VkMemoryDedicatedAllocateInfo ded_alloc = {
2636 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
2638 .image = req_desc.image,
2642 ret = vk->GetMemoryFdPropertiesKHR(hwctx->
act_dev,
2643 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
2645 if (
ret != VK_SUCCESS) {
2653 vk->GetImageMemoryRequirements2(hwctx->
act_dev, &req_desc, &req2);
2656 req2.memoryRequirements.memoryTypeBits = fdmp.memoryTypeBits;
2659 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
2660 (ded_req.prefersDedicatedAllocation ||
2661 ded_req.requiresDedicatedAllocation) ?
2662 &ded_alloc : ded_alloc.pNext,
2663 &
f->flags, &
f->mem[
i]);
2669 f->size[
i] = req2.memoryRequirements.size;
2672 for (
int i = 0;
i <
desc->nb_layers;
i++) {
2674 for (
int j = 0; j <
planes; j++) {
2675 VkImageAspectFlagBits aspect = j == 0 ? VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT :
2676 j == 1 ? VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT :
2677 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT;
2679 plane_info[bind_counts].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
2681 plane_info[bind_counts].planeAspect = aspect;
2683 bind_info[bind_counts].sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
2685 bind_info[bind_counts].image =
f->img[
i];
2686 bind_info[bind_counts].memory =
f->mem[
i];
2689 bind_info[bind_counts].memoryOffset = 0;
2696 ret = vk->BindImageMemory2(hwctx->
act_dev, bind_counts, bind_info);
2697 if (
ret != VK_SUCCESS) {
2713 for (
int i = 0;
i <
desc->nb_layers;
i++) {
2717 for (
int i = 0;
i <
desc->nb_objects;
i++)
2731 if ((err = vulkan_map_from_drm_frame_desc(hwfc, &
f,
src)))
2735 dst->
data[0] = (uint8_t *)
f;
2740 &vulkan_unmap_from_drm,
f);
2763 VASurfaceID surface_id = (VASurfaceID)(uintptr_t)
src->data[3];
2769 vaSyncSurface(vaapi_ctx->display, surface_id);
2777 err = vulkan_map_from_drm(dst_fc, dst,
tmp,
flags);
2810 CudaFunctions *cu = cu_internal->
cuda_dl;
2811 CUarray_format cufmt =
desc->comp[0].depth > 8 ? CU_AD_FORMAT_UNSIGNED_INT16 :
2812 CU_AD_FORMAT_UNSIGNED_INT8;
2817 if (!dst_int->cuda_fc_ref) {
2819 if (!dst_int->cuda_fc_ref)
2823 CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC tex_desc = {
2828 .NumChannels = 1 + ((
planes == 2) &&
i),
2836 CUDA_EXTERNAL_MEMORY_HANDLE_DESC ext_desc = {
2837 .type = IsWindows8OrGreater()
2838 ? CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
2839 : CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT,
2840 .size = dst_f->
size[
i],
2842 VkMemoryGetWin32HandleInfoKHR export_info = {
2843 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
2844 .memory = dst_f->
mem[
i],
2845 .handleType = IsWindows8OrGreater()
2846 ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
2847 : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
2849 VkSemaphoreGetWin32HandleInfoKHR sem_export = {
2850 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
2851 .semaphore = dst_f->
sem[
i],
2852 .handleType = IsWindows8OrGreater()
2853 ? VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
2854 : VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
2856 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC ext_sem_desc = {
2860 ret = vk->GetMemoryWin32HandleKHR(hwctx->
act_dev, &export_info,
2861 &ext_desc.handle.win32.handle);
2862 if (
ret != VK_SUCCESS) {
2868 dst_int->ext_mem_handle[
i] = ext_desc.handle.win32.handle;
2870 CUDA_EXTERNAL_MEMORY_HANDLE_DESC ext_desc = {
2871 .type = CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD,
2872 .size = dst_f->
size[
i],
2874 VkMemoryGetFdInfoKHR export_info = {
2875 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
2876 .memory = dst_f->
mem[
i],
2877 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
2879 VkSemaphoreGetFdInfoKHR sem_export = {
2880 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
2881 .semaphore = dst_f->
sem[
i],
2882 .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
2884 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC ext_sem_desc = {
2888 ret = vk->GetMemoryFdKHR(hwctx->
act_dev, &export_info,
2889 &ext_desc.handle.fd);
2890 if (
ret != VK_SUCCESS) {
2898 ret =
CHECK_CU(cu->cuImportExternalMemory(&dst_int->ext_mem[
i], &ext_desc));
2901 close(ext_desc.handle.fd);
2908 tex_desc.arrayDesc.Width = p_w;
2909 tex_desc.arrayDesc.Height = p_h;
2911 ret =
CHECK_CU(cu->cuExternalMemoryGetMappedMipmappedArray(&dst_int->cu_mma[
i],
2912 dst_int->ext_mem[
i],
2919 ret =
CHECK_CU(cu->cuMipmappedArrayGetLevel(&dst_int->cu_array[
i],
2920 dst_int->cu_mma[
i], 0));
2927 ret = vk->GetSemaphoreWin32HandleKHR(hwctx->
act_dev, &sem_export,
2928 &ext_sem_desc.handle.win32.handle);
2930 ret = vk->GetSemaphoreFdKHR(hwctx->
act_dev, &sem_export,
2931 &ext_sem_desc.handle.fd);
2933 if (
ret != VK_SUCCESS) {
2940 dst_int->ext_sem_handle[
i] = ext_sem_desc.handle.win32.handle;
2943 ret =
CHECK_CU(cu->cuImportExternalSemaphore(&dst_int->cu_sem[
i],
2947 close(ext_sem_desc.handle.fd);
2977 CudaFunctions *cu = cu_internal->
cuda_dl;
2987 err =
CHECK_CU(cu->cuCtxPushCurrent(cuda_dev->cuda_ctx));
2991 err = vulkan_export_to_cuda(hwfc,
src->hw_frames_ctx, dst);
3000 s_w_par[
i].params.fence.value = dst_f->
sem_value[
i] + 0;
3001 s_s_par[
i].params.fence.value = dst_f->
sem_value[
i] + 1;
3004 err =
CHECK_CU(cu->cuWaitExternalSemaphoresAsync(dst_int->cu_sem, s_w_par,
3005 planes, cuda_dev->stream));
3010 CUDA_MEMCPY2D cpy = {
3011 .srcMemoryType = CU_MEMORYTYPE_DEVICE,
3012 .srcDevice = (CUdeviceptr)
src->data[
i],
3013 .srcPitch =
src->linesize[
i],
3016 .dstMemoryType = CU_MEMORYTYPE_ARRAY,
3017 .dstArray = dst_int->cu_array[
i],
3023 cpy.WidthInBytes = p_w *
desc->comp[
i].step;
3026 err =
CHECK_CU(cu->cuMemcpy2DAsync(&cpy, cuda_dev->stream));
3031 err =
CHECK_CU(cu->cuSignalExternalSemaphoresAsync(dst_int->cu_sem, s_s_par,
3032 planes, cuda_dev->stream));
3058 switch (
src->format) {
3063 return vulkan_map_from_vaapi(hwfc, dst,
src,
flags);
3069 return vulkan_map_from_drm(hwfc, dst,
src,
flags);
3079 typedef struct VulkanDRMMapping {
3094 static inline uint32_t vulkan_fmt_to_drm(
VkFormat vkfmt)
3097 if (vulkan_drm_format_map[
i].vk_format == vkfmt)
3098 return vulkan_drm_format_map[
i].drm_fourcc;
3099 return DRM_FORMAT_INVALID;
3114 VkImageDrmFormatModifierPropertiesEXT drm_mod = {
3115 .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
3117 VkSemaphoreWaitInfo wait_info = {
3118 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
3120 .semaphoreCount =
planes,
3132 wait_info.pSemaphores =
f->sem;
3133 wait_info.pValues =
f->sem_value;
3135 vk->WaitSemaphores(hwctx->
act_dev, &wait_info, UINT64_MAX);
3141 ret = vk->GetImageDrmFormatModifierPropertiesEXT(hwctx->
act_dev,
f->img[0],
3143 if (
ret != VK_SUCCESS) {
3149 for (
int i = 0; (
i <
planes) && (
f->mem[
i]);
i++) {
3150 VkMemoryGetFdInfoKHR export_info = {
3151 .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
3152 .memory =
f->mem[
i],
3153 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
3156 ret = vk->GetMemoryFdKHR(hwctx->
act_dev, &export_info,
3158 if (
ret != VK_SUCCESS) {
3171 VkSubresourceLayout
layout;
3172 VkImageSubresource sub = {
3173 .aspectMask = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT,
3177 drm_desc->
layers[
i].
format = vulkan_fmt_to_drm(plane_vkfmt);
3188 if (
f->tiling == VK_IMAGE_TILING_OPTIMAL)
3191 vk->GetImageSubresourceLayout(hwctx->
act_dev,
f->img[
i], &sub, &
layout);
3201 dst->
data[0] = (uint8_t *)drm_desc;
3249 return vulkan_map_to_drm(hwfc, dst,
src,
flags);
3255 return vulkan_map_to_vaapi(hwfc, dst,
src,
flags);
3277 const int *buf_stride,
int w,
3292 VkCommandBuffer cmd_buf;
3295 cmd_buf = exec->
buf;
3303 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
3304 VK_PIPELINE_STAGE_2_TRANSFER_BIT);
3309 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
3310 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,
3311 to_buf ? VK_ACCESS_TRANSFER_READ_BIT :
3312 VK_ACCESS_TRANSFER_WRITE_BIT,
3313 to_buf ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL :
3314 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
3315 VK_QUEUE_FAMILY_IGNORED);
3317 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
3318 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
3319 .pImageMemoryBarriers = img_bar,
3320 .imageMemoryBarrierCount = nb_img_bar,
3324 for (
int i = 0;
i < pixfmt_planes;
i++) {
3325 int idx =
FFMIN(
i, nb_images - 1);
3326 VkImageAspectFlags plane_aspect[] = { VK_IMAGE_ASPECT_COLOR_BIT,
3327 VK_IMAGE_ASPECT_PLANE_0_BIT,
3328 VK_IMAGE_ASPECT_PLANE_1_BIT,
3329 VK_IMAGE_ASPECT_PLANE_2_BIT, };
3332 VkBufferImageCopy buf_reg = {
3333 .bufferOffset = buf_offsets[
i],
3334 .bufferRowLength = buf_stride[
i] /
desc->comp[
i].step,
3335 .imageSubresource.layerCount = 1,
3336 .imageSubresource.aspectMask = plane_aspect[(pixfmt_planes != nb_images) +
3337 i*(pixfmt_planes != nb_images)],
3338 .imageOffset = { 0, 0, 0, },
3344 buf_reg.bufferImageHeight = p_h;
3345 buf_reg.imageExtent = (VkExtent3D){ p_w, p_h, 1, };
3348 vk->CmdCopyImageToBuffer(cmd_buf,
frame->img[idx],
3349 img_bar[0].newLayout,
3353 vk->CmdCopyBufferToImage(cmd_buf, vkbuf->
buf,
frame->img[idx],
3354 img_bar[0].newLayout,
3402 VkExternalMemoryBufferCreateInfo create_desc = {
3403 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
3404 .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
3407 VkImportMemoryHostPointerInfoEXT import_desc = {
3408 .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
3409 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
3412 VkMemoryHostPointerPropertiesEXT p_props = {
3413 .sType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
3423 offs = (uintptr_t)swf->
data[
i] % p->
hprops.minImportedHostPointerAlignment;
3424 import_desc.pHostPointer = swf->
data[
i] - offs;
3429 p->
hprops.minImportedHostPointerAlignment);
3431 ret = vk->GetMemoryHostPointerPropertiesEXT(hwctx->
act_dev,
3432 import_desc.handleType,
3433 import_desc.pHostPointer,
3435 if (
ret == VK_SUCCESS && p_props.memoryTypeBits) {
3437 buf_offsets[
i] = offs;
3441 if (!host_mapped[
i])
3445 host_mapped[
i] ? &create_desc :
NULL,
3446 host_mapped[
i] ? &import_desc :
NULL,
3447 from ? VK_BUFFER_USAGE_TRANSFER_DST_BIT :
3448 VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
3449 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
3451 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT : 0x0));
3496 (
const uint8_t *)
tmp.data[
i],
tmp.linesize[
i],
3517 switch (
src->format) {
3521 if ((p->vkctx.extensions & FF_VK_EXT_EXTERNAL_WIN32_MEMORY) &&
3522 (p->vkctx.extensions & FF_VK_EXT_EXTERNAL_WIN32_SEM))
3527 return vulkan_transfer_data_from_cuda(hwfc, dst,
src);
3530 if (
src->hw_frames_ctx)
3553 CudaFunctions *cu = cu_internal->
cuda_dl;
3563 err =
CHECK_CU(cu->cuCtxPushCurrent(cuda_dev->cuda_ctx));
3576 s_w_par[
i].params.fence.value = dst_f->
sem_value[
i] + 0;
3577 s_s_par[
i].params.fence.value = dst_f->
sem_value[
i] + 1;
3580 err =
CHECK_CU(cu->cuWaitExternalSemaphoresAsync(dst_int->cu_sem, s_w_par,
3581 planes, cuda_dev->stream));
3586 CUDA_MEMCPY2D cpy = {
3587 .dstMemoryType = CU_MEMORYTYPE_DEVICE,
3588 .dstDevice = (CUdeviceptr)dst->
data[
i],
3592 .srcMemoryType = CU_MEMORYTYPE_ARRAY,
3593 .srcArray = dst_int->cu_array[
i],
3599 cpy.WidthInBytes =
w *
desc->comp[
i].step;
3602 err =
CHECK_CU(cu->cuMemcpy2DAsync(&cpy, cuda_dev->stream));
3607 err =
CHECK_CU(cu->cuSignalExternalSemaphoresAsync(dst_int->cu_sem, s_s_par,
3608 planes, cuda_dev->stream));
3638 if ((p->vkctx.extensions & FF_VK_EXT_EXTERNAL_WIN32_MEMORY) &&
3639 (p->vkctx.extensions & FF_VK_EXT_EXTERNAL_WIN32_SEM))
3644 return vulkan_transfer_data_to_cuda(hwfc, dst,
src);