28 .r = VK_COMPONENT_SWIZZLE_IDENTITY,
29 .g = VK_COMPONENT_SWIZZLE_IDENTITY,
30 .b = VK_COMPONENT_SWIZZLE_IDENTITY,
31 .a = VK_COMPONENT_SWIZZLE_IDENTITY,
37 #define CASE(VAL) case VAL: return #VAL
45 CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
46 CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
47 CASE(VK_ERROR_INITIALIZATION_FAILED);
48 CASE(VK_ERROR_DEVICE_LOST);
49 CASE(VK_ERROR_MEMORY_MAP_FAILED);
50 CASE(VK_ERROR_LAYER_NOT_PRESENT);
51 CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
52 CASE(VK_ERROR_FEATURE_NOT_PRESENT);
53 CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
54 CASE(VK_ERROR_TOO_MANY_OBJECTS);
55 CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
56 CASE(VK_ERROR_FRAGMENTED_POOL);
57 CASE(VK_ERROR_UNKNOWN);
58 CASE(VK_ERROR_OUT_OF_POOL_MEMORY);
59 CASE(VK_ERROR_INVALID_EXTERNAL_HANDLE);
60 CASE(VK_ERROR_FRAGMENTATION);
61 CASE(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS);
62 CASE(VK_PIPELINE_COMPILE_REQUIRED);
63 CASE(VK_ERROR_SURFACE_LOST_KHR);
64 CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
65 CASE(VK_SUBOPTIMAL_KHR);
66 CASE(VK_ERROR_OUT_OF_DATE_KHR);
67 CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
68 CASE(VK_ERROR_VALIDATION_FAILED_EXT);
69 CASE(VK_ERROR_INVALID_SHADER_NV);
70 CASE(VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR);
71 CASE(VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR);
72 CASE(VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR);
73 CASE(VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR);
74 CASE(VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR);
75 CASE(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
76 CASE(VK_ERROR_NOT_PERMITTED_KHR);
77 CASE(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
78 CASE(VK_THREAD_IDLE_KHR);
79 CASE(VK_THREAD_DONE_KHR);
80 CASE(VK_OPERATION_DEFERRED_KHR);
81 CASE(VK_OPERATION_NOT_DEFERRED_KHR);
82 default:
return "Unknown error";
88 #define FN_MAP_TO(dst_t, dst_name, src_t, src_name) \
89 dst_t ff_vk_map_ ##src_name## _to_ ##dst_name(src_t src) \
92 MAP_TO(VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, \
93 VK_IMAGE_USAGE_SAMPLED_BIT); \
94 MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, \
95 VK_IMAGE_USAGE_TRANSFER_SRC_BIT); \
96 MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, \
97 VK_IMAGE_USAGE_TRANSFER_DST_BIT); \
98 MAP_TO(VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, \
99 VK_IMAGE_USAGE_STORAGE_BIT); \
100 MAP_TO(VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, \
101 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); \
102 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR, \
103 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR); \
104 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR, \
105 VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR); \
106 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, \
107 VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR); \
108 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, \
109 VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR); \
113 #define MAP_TO(flag1, flag2) if (src & flag2) dst |= flag1;
114 FN_MAP_TO(VkFormatFeatureFlagBits2, feats, VkImageUsageFlags,
usage)
116 #define MAP_TO(flag1, flag2) if (src & flag1) dst |= flag2;
117 FN_MAP_TO(VkImageUsageFlags,
usage, VkFormatFeatureFlagBits2, feats)
124 for (
int i = 0;
i <
s->hwctx->nb_qf;
i++) {
127 for (
int j = 0; j <
s->nb_qfs; j++) {
128 if (
s->qfs[j] ==
s->hwctx->qf[
i].idx) {
136 s->qfs[
s->nb_qfs++] =
s->hwctx->qf[
i].idx;
144 s->props = (VkPhysicalDeviceProperties2) {
145 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
149 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
151 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
153 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
156 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
158 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
160 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR);
162 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
164 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
166 s->feats = (VkPhysicalDeviceFeatures2) {
167 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
171 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
173 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
175 vk->GetPhysicalDeviceProperties2(
s->hwctx->phys_dev, &
s->props);
176 vk->GetPhysicalDeviceMemoryProperties(
s->hwctx->phys_dev, &
s->mprops);
177 vk->GetPhysicalDeviceFeatures2(
s->hwctx->phys_dev, &
s->feats);
184 vk->GetPhysicalDeviceQueueFamilyProperties2(
s->hwctx->phys_dev, &
s->tot_nb_qfs,
NULL);
186 s->qf_props =
av_calloc(
s->tot_nb_qfs,
sizeof(*
s->qf_props));
190 s->query_props =
av_calloc(
s->tot_nb_qfs,
sizeof(*
s->query_props));
196 s->video_props =
av_calloc(
s->tot_nb_qfs,
sizeof(*
s->video_props));
197 if (!
s->video_props) {
203 for (uint32_t
i = 0;
i <
s->tot_nb_qfs;
i++) {
204 s->qf_props[
i] = (VkQueueFamilyProperties2) {
205 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
209 VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR);
211 VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR);
214 vk->GetPhysicalDeviceQueueFamilyProperties2(
s->hwctx->phys_dev, &
s->tot_nb_qfs,
s->qf_props);
217 vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(
s->hwctx->phys_dev,
218 &
s->coop_mat_props_nb,
NULL);
220 if (
s->coop_mat_props_nb) {
222 sizeof(VkCooperativeMatrixPropertiesKHR));
223 for (
int i = 0;
i <
s->coop_mat_props_nb;
i++) {
224 s->coop_mat_props[
i] = (VkCooperativeMatrixPropertiesKHR) {
225 .sType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
229 vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(
s->hwctx->phys_dev,
230 &
s->coop_mat_props_nb,
239 VkQueueFlagBits dev_family,
240 VkVideoCodecOperationFlagBitsKHR vid_ops)
242 for (
int i = 0;
i <
s->hwctx->nb_qf;
i++) {
243 if ((
s->hwctx->qf[
i].flags & dev_family) &&
244 (
s->hwctx->qf[
i].video_caps & vid_ops) == vid_ops) {
245 return &
s->hwctx->qf[
i];
260 vk->WaitForFences(
s->hwctx->act_dev, 1, &e->
fence, VK_TRUE, UINT64_MAX);
261 vk->DestroyFence(
s->hwctx->act_dev, e->
fence,
s->hwctx->alloc);
293 vk->DestroyDescriptorPool(
s->hwctx->act_dev, sd->
desc_pool,
307 vk->DestroyCommandPool(
s->hwctx->act_dev, pool->
cmd_buf_pools[
i],
s->hwctx->alloc);
310 vk->DestroyQueryPool(
s->hwctx->act_dev, pool->
query_pool,
s->hwctx->alloc);
320 int nb_queries, VkQueryType query_type,
int query_64bit,
321 const void *query_create_pnext)
328 VkCommandBufferAllocateInfo cbuf_create;
330 const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *ef =
NULL;
334 if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
336 VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR);
355 for (
int i = 0;
i < nb_contexts;
i++) {
358 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
359 .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT |
360 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
361 .queueFamilyIndex = qf->
idx,
366 if (
ret != VK_SUCCESS) {
374 cbuf_create = (VkCommandBufferAllocateInfo) {
375 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
376 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
378 .commandBufferCount = 1,
380 ret = vk->AllocateCommandBuffers(
s->hwctx->act_dev, &cbuf_create,
382 if (
ret != VK_SUCCESS) {
392 VkQueryPoolCreateInfo query_pool_info = {
393 .sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
394 .pNext = query_create_pnext,
395 .queryType = query_type,
396 .queryCount = nb_queries*nb_contexts,
398 ret = vk->CreateQueryPool(
s->hwctx->act_dev, &query_pool_info,
400 if (
ret != VK_SUCCESS) {
413 if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
414 int nb_results =
av_popcount(ef->encodeFeedbackFlags);
417 }
else if (query_type == VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR) {
444 VkFenceCreateInfo fence_create = {
445 .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
446 .flags = VK_FENCE_CREATE_SIGNALED_BIT,
450 ret = vk->CreateFence(
s->hwctx->act_dev, &fence_create,
s->hwctx->alloc,
452 if (
ret != VK_SUCCESS) {
471 vk->GetDeviceQueue(
s->hwctx->act_dev, qf->
idx, e->
qi, &e->
queue);
482 void **
data, VkQueryResultFlagBits
flags)
486 VkQueryResultFlags qf =
flags & ~(VK_QUERY_RESULT_64_BIT |
487 VK_QUERY_RESULT_WITH_STATUS_BIT_KHR);
491 return VK_INCOMPLETE;
495 VK_QUERY_RESULT_64_BIT : 0x0;
497 VK_QUERY_RESULT_WITH_STATUS_BIT_KHR : 0x0;
502 return vk->GetQueryPoolResults(
s->hwctx->act_dev, pool->
query_pool,
517 vk->WaitForFences(
s->hwctx->act_dev, 1, &e->
fence, VK_TRUE, UINT64_MAX);
527 VkCommandBufferBeginInfo cmd_start = {
528 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
529 .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
533 vk->WaitForFences(
s->hwctx->act_dev, 1, &e->
fence, VK_TRUE, UINT64_MAX);
534 vk->ResetFences(
s->hwctx->act_dev, 1, &e->
fence);
539 ret = vk->BeginCommandBuffer(e->
buf, &cmd_start);
540 if (
ret != VK_SUCCESS) {
569 vkfc->unlock_frame(hwfc, vkf);
593 for (
int i = 0;
i < nb_deps;
i++) {
631 #define ARR_REALLOC(str, arr, alloc_s, cnt) \
633 arr = av_fast_realloc(str->arr, alloc_s, (cnt + 1)*sizeof(*arr)); \
635 ff_vk_exec_discard_deps(s, e); \
636 return AVERROR(ENOMEM); \
653 vk->DestroySemaphore(
s->hwctx->act_dev, ts->
sem[
i],
s->hwctx->alloc);
659 VkSemaphore sem, uint64_t
val,
660 VkPipelineStageFlagBits2 stage)
666 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
676 VkSemaphore *sem,
int nb,
677 VkPipelineStageFlagBits2 stage,
689 for (
int i = 0;
i < nb;
i++) {
690 VkSemaphoreSubmitInfo *sem_sig;
694 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
703 buf_size =
sizeof(*ts) +
sizeof(VkSemaphore)*nb;
710 memcpy(ts->sem, sem, nb*
sizeof(*sem));
726 for (
int i = 0;
i < nb;
i++) {
735 for (
int i = 0;
i < nb;
i++)
736 vk->DestroySemaphore(
s->hwctx->act_dev, sem[
i],
s->hwctx->alloc);
742 VkPipelineStageFlagBits2 wait_stage,
743 VkPipelineStageFlagBits2 signal_stage)
745 uint8_t *frame_locked;
746 uint8_t *frame_update;
749 VkImageLayout *layout_dst;
750 uint32_t *queue_family_dst;
751 VkAccessFlagBits *access_dst;
786 vkfc->lock_frame(hwfc, vkf);
791 for (
int i = 0;
i < nb_images;
i++) {
793 VkSemaphoreSubmitInfo *sem_sig;
794 uint64_t **sem_sig_val_dst;
801 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
802 .semaphore = vkf->sem[
i],
803 .value = vkf->sem_value[
i],
804 .stageMask = wait_stage,
808 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
809 .semaphore = vkf->sem[
i],
810 .value = vkf->sem_value[
i] + 1,
811 .stageMask = signal_stage,
822 VkImageMemoryBarrier2 *bar, uint32_t *nb_img_bar)
841 VkSemaphore *
dst, uint64_t *dst_val,
844 uint64_t **sem_sig_val_dst;
870 VkCommandBufferSubmitInfo cmd_buf_info = (VkCommandBufferSubmitInfo) {
871 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
872 .commandBuffer = e->
buf,
874 VkSubmitInfo2 submit_info = (VkSubmitInfo2) {
875 .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
876 .pCommandBufferInfos = &cmd_buf_info,
877 .commandBufferInfoCount = 1,
880 .pSignalSemaphoreInfos = e->
sem_sig,
884 ret = vk->EndCommandBuffer(e->
buf);
885 if (
ret != VK_SUCCESS) {
892 s->hwctx->lock_queue(
s->device, e->
qf, e->
qi);
894 s->hwctx->unlock_queue(
s->device, e->
qf, e->
qi);
896 if (
ret != VK_SUCCESS) {
916 for (
int i = 0;
i < nb_images;
i++) {
922 vkfc->unlock_frame(hwfc, vkf);
933 VkMemoryPropertyFlagBits req_flags,
void *alloc_extension,
934 VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
940 VkMemoryAllocateInfo alloc_info = {
941 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
942 .pNext = alloc_extension,
945 alloc_info.allocationSize = req->size;
949 for (
int i = 0;
i <
s->mprops.memoryTypeCount;
i++) {
951 if (!(req->memoryTypeBits & (1 <<
i)))
955 if ((req_flags != UINT32_MAX) &&
956 ((
s->mprops.memoryTypes[
i].propertyFlags & req_flags) != req_flags))
970 alloc_info.memoryTypeIndex =
index;
972 ret = vk->AllocateMemory(
s->hwctx->act_dev, &alloc_info,
973 s->hwctx->alloc, mem);
974 if (
ret != VK_SUCCESS)
978 *mem_flags |=
s->mprops.memoryTypes[
index].propertyFlags;
984 void *pNext,
void *alloc_pNext,
985 VkBufferUsageFlags
usage, VkMemoryPropertyFlagBits
flags)
992 VkBufferCreateInfo buf_spawn = {
993 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
996 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
997 .size =
flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ?
998 FFALIGN(
size,
s->props.properties.limits.minMemoryMapAlignment) :
1002 VkMemoryAllocateFlagsInfo alloc_flags = {
1003 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
1004 .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
1006 VkBufferMemoryRequirementsInfo2 req_desc = {
1007 .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
1009 VkMemoryDedicatedAllocateInfo ded_alloc = {
1010 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
1011 .pNext = alloc_pNext,
1013 VkMemoryDedicatedRequirements ded_req = {
1014 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
1016 VkMemoryRequirements2 req = {
1017 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
1022 "usage: 0x%x, flags: 0x%x\n",
1025 ret = vk->CreateBuffer(
s->hwctx->act_dev, &buf_spawn,
s->hwctx->alloc, &buf->
buf);
1026 if (
ret != VK_SUCCESS) {
1032 req_desc.buffer = buf->
buf;
1034 vk->GetBufferMemoryRequirements2(
s->hwctx->act_dev, &req_desc, &req);
1037 use_ded_mem = ded_req.prefersDedicatedAllocation |
1038 ded_req.requiresDedicatedAllocation;
1040 ded_alloc.buffer = buf->
buf;
1041 ded_alloc.pNext = alloc_pNext;
1042 alloc_pNext = &ded_alloc;
1045 if (
usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1046 alloc_flags.pNext = alloc_pNext;
1047 alloc_pNext = &alloc_flags;
1055 ret = vk->BindBufferMemory(
s->hwctx->act_dev, buf->
buf, buf->
mem, 0);
1056 if (
ret != VK_SUCCESS) {
1062 if (
usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1063 VkBufferDeviceAddressInfo address_info = {
1064 .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
1067 buf->
address = vk->GetBufferDeviceAddress(
s->hwctx->act_dev, &address_info);
1076 int nb_buffers,
int invalidate)
1080 VkMappedMemoryRange inval_list[64];
1081 int inval_count = 0;
1083 for (
int i = 0;
i < nb_buffers;
i++) {
1085 ret = vk->MapMemory(
s->hwctx->act_dev, buf[
i]->
mem, 0,
1086 VK_WHOLE_SIZE, 0, &
dst);
1087 if (
ret != VK_SUCCESS) {
1098 for (
int i = 0;
i < nb_buffers;
i++) {
1099 const VkMappedMemoryRange ival_buf = {
1100 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1101 .memory = buf[
i]->
mem,
1102 .size = VK_WHOLE_SIZE,
1104 if (buf[
i]->
flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
1106 inval_list[inval_count++] = ival_buf;
1110 ret = vk->InvalidateMappedMemoryRanges(
s->hwctx->act_dev, inval_count,
1112 if (
ret != VK_SUCCESS) {
1128 VkMappedMemoryRange flush_list[64];
1129 int flush_count = 0;
1132 for (
int i = 0;
i < nb_buffers;
i++) {
1133 const VkMappedMemoryRange flush_buf = {
1134 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1135 .memory = buf[
i]->
mem,
1136 .size = VK_WHOLE_SIZE,
1140 if (buf[
i]->
flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
1142 flush_list[flush_count++] = flush_buf;
1147 ret = vk->FlushMappedMemoryRanges(
s->hwctx->act_dev, flush_count,
1149 if (
ret != VK_SUCCESS) {
1156 for (
int i = 0;
i < nb_buffers;
i++) {
1157 vk->UnmapMemory(
s->hwctx->act_dev, buf[
i]->
mem);
1168 if (!buf || !
s->hwctx)
1173 if (buf->
buf != VK_NULL_HANDLE)
1174 vk->DestroyBuffer(
s->hwctx->act_dev, buf->
buf,
s->hwctx->alloc);
1175 if (buf->
mem != VK_NULL_HANDLE)
1176 vk->FreeMemory(
s->hwctx->act_dev, buf->
mem,
s->hwctx->alloc);
1180 buf->
buf = VK_NULL_HANDLE;
1181 buf->
mem = VK_NULL_HANDLE;
1208 void *create_pNext,
size_t size,
1209 VkMemoryPropertyFlagBits mem_props)
1229 data->stage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
1230 data->access = VK_ACCESS_2_NONE;
1247 if (mem_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
1262 VkExternalMemoryBufferCreateInfo *create_desc,
1263 VkImportMemoryHostPointerInfoEXT *import_desc,
1264 VkMemoryHostPointerPropertiesEXT props)
1270 VkBufferCreateInfo buf_spawn = {
1271 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1272 .pNext = create_desc,
1274 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
1277 VkMemoryRequirements req = {
1279 .alignment =
s->hprops.minImportedHostPointerAlignment,
1280 .memoryTypeBits = props.memoryTypeBits,
1284 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
1285 import_desc, &vkb->
flags, &vkb->
mem);
1289 ret = vk->CreateBuffer(
s->hwctx->act_dev, &buf_spawn,
s->hwctx->alloc, &vkb->
buf);
1290 if (
ret != VK_SUCCESS) {
1291 vk->FreeMemory(
s->hwctx->act_dev, vkb->
mem,
s->hwctx->alloc);
1295 ret = vk->BindBufferMemory(
s->hwctx->act_dev, vkb->
buf, vkb->
mem, 0);
1296 if (
ret != VK_SUCCESS) {
1297 vk->FreeMemory(
s->hwctx->act_dev, vkb->
mem,
s->hwctx->alloc);
1298 vk->DestroyBuffer(
s->hwctx->act_dev, vkb->
buf,
s->hwctx->alloc);
1315 VkBufferUsageFlags
usage)
1321 VkExternalMemoryBufferCreateInfo create_desc = {
1322 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
1323 .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
1325 VkMemoryAllocateFlagsInfo alloc_flags = {
1326 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
1327 .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
1329 VkImportMemoryHostPointerInfoEXT import_desc = {
1330 .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
1331 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
1332 .pNext =
usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT ? &alloc_flags :
NULL,
1334 VkMemoryHostPointerPropertiesEXT props;
1344 offs = (uintptr_t)src_data %
s->hprops.minImportedHostPointerAlignment;
1345 import_desc.pHostPointer = src_data - offs;
1347 props = (VkMemoryHostPointerPropertiesEXT) {
1348 VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
1350 ret = vk->GetMemoryHostPointerPropertiesEXT(
s->hwctx->act_dev,
1351 import_desc.handleType,
1352 import_desc.pHostPointer,
1354 if (!(
ret == VK_SUCCESS && props.memoryTypeBits))
1363 buffer_size = offs + src_buf->
size;
1364 buffer_size =
FFALIGN(buffer_size,
s->props.properties.limits.minMemoryMapAlignment);
1365 buffer_size =
FFALIGN(buffer_size,
s->hprops.minImportedHostPointerAlignment);
1375 buffer_size, &create_desc, &import_desc,
1383 if (
usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1384 VkBufferDeviceAddressInfo address_info = {
1385 .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
1388 vkb->
address = vk->GetBufferDeviceAddress(
s->hwctx->act_dev, &address_info);
1395 vkb->
size = buffer_size - offs;
1396 vkb->
flags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
1411 VkShaderStageFlagBits stage)
1413 VkPushConstantRange *pc;
1422 memset(pc, 0,
sizeof(*pc));
1424 pc->stageFlags = stage;
1432 int unnorm_coords, VkFilter
filt)
1437 VkSamplerCreateInfo sampler_info = {
1438 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
1440 .minFilter = sampler_info.magFilter,
1441 .mipmapMode = unnorm_coords ? VK_SAMPLER_MIPMAP_MODE_NEAREST :
1442 VK_SAMPLER_MIPMAP_MODE_LINEAR,
1443 .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1444 .addressModeV = sampler_info.addressModeU,
1445 .addressModeW = sampler_info.addressModeU,
1446 .anisotropyEnable = VK_FALSE,
1447 .compareOp = VK_COMPARE_OP_NEVER,
1448 .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
1449 .unnormalizedCoordinates = unnorm_coords,
1452 ret = vk->CreateSampler(
s->hwctx->act_dev, &sampler_info,
1453 s->hwctx->alloc, sampler);
1454 if (
ret != VK_SUCCESS) {
1470 static const VkImageAspectFlags plane_aspect[] = { VK_IMAGE_ASPECT_PLANE_0_BIT,
1471 VK_IMAGE_ASPECT_PLANE_1_BIT,
1472 VK_IMAGE_ASPECT_PLANE_2_BIT, };
1475 return VK_IMAGE_ASPECT_COLOR_BIT;
1477 return plane_aspect[p];
1531 int lut_tmp[4] = { lut[0], lut[1], lut[2], lut[3] };
1532 for (
int i = 0;
i < 4;
i++)
1533 lut[lut_tmp[
i]] =
i;
1554 const char *rep_tab[] = {
1560 return rep_tab[rep_fmt];
1566 const char *rep_tab[] = {
1572 return rep_tab[rep_fmt];
1580 const char *rep_tab[] = {
1586 return rep_tab[rep_fmt];
1590 const char *rep_tab[] = {
1596 return rep_tab[rep_fmt];
1600 const char *rep_tab[] = {
1606 return rep_tab[rep_fmt];
1613 const char *rep_tab[] = {
1619 return rep_tab[rep_fmt];
1642 const char *rep_tab[] = {
1648 return rep_tab[rep_fmt];
1654 const char *rep_tab[] = {
1660 return rep_tab[rep_fmt];
1663 const char *rep_tab[] = {
1669 return rep_tab[rep_fmt];
1674 const char *rep_tab[] = {
1680 return rep_tab[rep_fmt];
1685 const char *rep_tab[] = {
1691 return rep_tab[rep_fmt];
1699 const char *rep_tab[] = {
1705 return rep_tab[rep_fmt];
1724 vk->DestroyImageView(
s->hwctx->act_dev, iv->
views[
i],
s->hwctx->alloc);
1731 #define REPS_FMT(fmt) \
1732 [FF_VK_REP_NATIVE] = fmt ## _UINT, \
1733 [FF_VK_REP_FLOAT] = fmt ## _UNORM, \
1734 [FF_VK_REP_INT] = fmt ## _SINT, \
1735 [FF_VK_REP_UINT] = fmt ## _UINT,
1737 #define REPS_FMT_PACK(fmt, num) \
1738 [FF_VK_REP_NATIVE] = fmt ## _UINT_PACK ## num, \
1739 [FF_VK_REP_FLOAT] = fmt ## _UNORM_PACK ## num, \
1740 [FF_VK_REP_INT] = fmt ## _SINT_PACK ## num, \
1741 [FF_VK_REP_UINT] = fmt ## _UINT_PACK ## num,
1747 VK_FORMAT_B5G6R5_UNORM_PACK16,
1748 VK_FORMAT_B5G6R5_UNORM_PACK16,
1749 VK_FORMAT_UNDEFINED,
1750 VK_FORMAT_UNDEFINED,
1753 VK_FORMAT_R5G6B5_UNORM_PACK16,
1754 VK_FORMAT_R5G6B5_UNORM_PACK16,
1755 VK_FORMAT_UNDEFINED,
1756 VK_FORMAT_UNDEFINED,
1767 {
REPS_FMT(VK_FORMAT_R16G16B16A16) },
1770 VK_FORMAT_R32_SFLOAT,
1775 VK_FORMAT_R32G32B32_SFLOAT,
1776 VK_FORMAT_R32G32B32_SFLOAT,
1777 VK_FORMAT_UNDEFINED,
1778 VK_FORMAT_UNDEFINED,
1781 VK_FORMAT_R32G32B32A32_SFLOAT,
1782 VK_FORMAT_R32G32B32A32_SFLOAT,
1783 VK_FORMAT_UNDEFINED,
1784 VK_FORMAT_UNDEFINED,
1787 VK_FORMAT_R32G32B32_UINT,
1788 VK_FORMAT_UNDEFINED,
1789 VK_FORMAT_R32G32B32_SINT,
1790 VK_FORMAT_R32G32B32_UINT,
1793 VK_FORMAT_R32G32B32A32_UINT,
1794 VK_FORMAT_UNDEFINED,
1795 VK_FORMAT_R32G32B32A32_SINT,
1796 VK_FORMAT_R32G32B32A32_UINT,
1799 #undef REPS_FMT_PACK
1802 if (fmt == VK_FORMAT_UNDEFINED)
1803 return VK_FORMAT_UNDEFINED;
1810 return fmts_map[
i][rep_fmt];
1813 return VK_FORMAT_UNDEFINED;
1817 VkImageView *img_view, VkImageAspectFlags *aspect,
1828 VkImageViewUsageCreateInfo view_usage_info = {
1829 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
1830 .usage = vkfc->usage &
1831 (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
1832 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
1834 VkImageViewCreateInfo view_create_info = {
1835 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1836 .pNext = &view_usage_info,
1837 .image = vkf->
img[
FFMIN(plane, nb_images - 1)],
1838 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1841 .subresourceRange = {
1847 if (view_create_info.format == VK_FORMAT_UNDEFINED) {
1849 "of format %i and mode %i\n",
1850 rep_fmts[plane], rep_fmt);
1854 ret = vk->CreateImageView(
s->hwctx->act_dev, &view_create_info,
1855 s->hwctx->alloc, img_view);
1856 if (
ret != VK_SUCCESS) {
1862 *aspect = view_create_info.subresourceRange.aspectMask;
1883 const size_t buf_size =
sizeof(*iv) + nb_planes*
sizeof(VkImageView);
1888 for (
int i = 0;
i < nb_planes;
i++) {
1889 VkImageViewUsageCreateInfo view_usage_info = {
1890 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
1891 .usage = vkfc->usage &
1892 (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
1893 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
1895 VkImageViewCreateInfo view_create_info = {
1896 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1897 .pNext = &view_usage_info,
1898 .image = vkf->
img[
FFMIN(
i, nb_images - 1)],
1899 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1902 .subresourceRange = {
1908 if (view_create_info.format == VK_FORMAT_UNDEFINED) {
1910 "of format %i and mode %i\n",
1911 rep_fmts[
i], rep_fmt);
1916 ret = vk->CreateImageView(
s->hwctx->act_dev, &view_create_info,
1917 s->hwctx->alloc, &iv->views[
i]);
1918 if (
ret != VK_SUCCESS) {
1939 memcpy(views, iv->views, nb_planes*
sizeof(*views));
1944 for (
int i = 0;
i < iv->nb_views;
i++)
1945 vk->DestroyImageView(
s->hwctx->act_dev, iv->views[
i],
s->hwctx->alloc);
1951 AVFrame *pic, VkImageMemoryBarrier2 *bar,
int *nb_bar,
1952 VkPipelineStageFlags src_stage,
1953 VkPipelineStageFlags dst_stage,
1954 VkAccessFlagBits new_access,
1955 VkImageLayout new_layout,
1968 for (
int i = 0;
i < nb_images;
i++) {
1969 bar[*nb_bar] = (VkImageMemoryBarrier2) {
1970 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
1972 .srcStageMask = src_stage,
1973 .dstStageMask = dst_stage,
1975 .dstAccessMask = new_access,
1977 .newLayout = new_layout,
1979 .dstQueueFamilyIndex = new_qf,
1980 .image = vkf->
img[
i],
1981 .subresourceRange = (VkImageSubresourceRange) {
1982 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
1994 VkPipelineStageFlags stage,
1995 const char *extensions[],
int nb_extensions,
1996 int lg_x,
int lg_y,
int lg_z,
1997 uint32_t required_subgroup_size)
2007 switch (shd->
stage) {
2008 case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
2009 case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
2010 case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
2011 case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
2012 case VK_SHADER_STAGE_MISS_BIT_KHR:
2013 case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
2014 shd->
bind_point = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
2016 case VK_SHADER_STAGE_COMPUTE_BIT:
2017 shd->
bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
2020 shd->
bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS;
2024 if (required_subgroup_size) {
2025 shd->
subgroup_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
2026 shd->
subgroup_info.requiredSubgroupSize = required_subgroup_size;
2030 (stage == VK_SHADER_STAGE_TASK_BIT_EXT ||
2031 stage == VK_SHADER_STAGE_MESH_BIT_EXT) ?
2033 (shd->
bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR) ?
2035 (shd->
bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) ?
2036 "Compute" :
"Graphics",
2042 GLSLC(0, #define IS_WITHIN(v1, v2) ((v1.x < v2.x) && (v1.y < v2.y)) );
2044 GLSLC(0, #extension GL_EXT_scalar_block_layout : require );
2045 GLSLC(0, #extension GL_EXT_shader_explicit_arithmetic_types : require );
2046 GLSLC(0, #extension GL_EXT_control_flow_attributes : require );
2047 GLSLC(0, #extension GL_EXT_shader_image_load_formatted : require );
2049 GLSLC(0, #extension GL_EXT_expect_assume : require );
2051 GLSLC(0, #define assumeEXT(x) (x) );
2052 GLSLC(0, #define expectEXT(x,
c) (x) );
2056 GLSLC(0, #extension GL_EXT_debug_printf : require );
2060 if (stage == VK_SHADER_STAGE_TASK_BIT_EXT ||
2061 stage == VK_SHADER_STAGE_MESH_BIT_EXT)
2062 GLSLC(0, #extension GL_EXT_mesh_shader : require );
2064 for (
int i = 0;
i < nb_extensions;
i++)
2065 GLSLF(0, #extension %
s : %
s ,extensions[
i],
"require");
2068 GLSLF(0,
layout (local_size_x = %
i, local_size_y = %
i, local_size_z = %
i) in;
2078 const char *p = shd->
src.str;
2079 const char *start = p;
2080 const size_t len = strlen(p);
2085 for (
int i = 0;
i <
len;
i++) {
2101 VkPipelineLayoutCreateInfo pipeline_layout_info;
2104 pipeline_layout_info = (VkPipelineLayoutCreateInfo) {
2105 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
2112 ret = vk->CreatePipelineLayout(
s->hwctx->act_dev, &pipeline_layout_info,
2114 if (
ret != VK_SUCCESS) {
2124 VkShaderModule *
mod,
2125 uint8_t *spirv,
size_t spirv_len)
2130 VkShaderModuleCreateInfo shader_module_info = {
2131 .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
2134 .pCode = (
void *)spirv,
2135 .codeSize = spirv_len,
2138 ret = vk->CreateShaderModule(
s->hwctx->act_dev, &shader_module_info,
2139 s->hwctx->alloc,
mod);
2140 if (
ret != VK_SUCCESS) {
2150 VkShaderModule
mod,
const char *entrypoint)
2155 VkComputePipelineCreateInfo pipeline_create_info = {
2156 .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
2158 VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT : 0x0,
2160 .stage = (VkPipelineShaderStageCreateInfo) {
2161 .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2164 .pName = entrypoint,
2166 VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT : 0x0,
2167 .stage = shd->
stage,
2172 ret = vk->CreateComputePipelines(
s->hwctx->act_dev, VK_NULL_HANDLE, 1,
2173 &pipeline_create_info,
2175 if (
ret != VK_SUCCESS) {
2185 uint8_t *spirv,
size_t spirv_len,
2186 const char *entrypoint)
2190 size_t shader_size = 0;
2192 VkShaderCreateInfoEXT shader_obj_create = {
2193 .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
2195 VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT : 0x0,
2196 .stage = shd->
stage,
2198 .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
2200 .codeSize = spirv_len,
2201 .pName = entrypoint,
2206 .pSpecializationInfo =
NULL,
2209 ret = vk->CreateShadersEXT(
s->hwctx->act_dev, 1, &shader_obj_create,
2210 s->hwctx->alloc, &shd->
object);
2211 if (
ret != VK_SUCCESS) {
2217 if (vk->GetShaderBinaryDataEXT(
s->hwctx->act_dev, shd->
object,
2218 &shader_size,
NULL) == VK_SUCCESS)
2220 shd->
name, shader_size, spirv_len);
2236 int has_singular = 0;
2237 int max_descriptors = 0;
2244 (max_descriptors <= s->push_desc_props.maxPushDescriptors) &&
2246 (has_singular == 0);
2251 VkDescriptorSetLayoutCreateInfo desc_layout_create = {
2252 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
2253 .bindingCount =
set->nb_bindings,
2254 .pBindings =
set->binding,
2256 VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT :
2258 VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR :
2262 ret = vk->CreateDescriptorSetLayout(
s->hwctx->act_dev,
2263 &desc_layout_create,
2266 if (
ret != VK_SUCCESS) {
2273 vk->GetDescriptorSetLayoutSizeEXT(
s->hwctx->act_dev, shd->
desc_layout[
i],
2277 s->desc_buf_props.descriptorBufferOffsetAlignment);
2279 for (
int j = 0; j <
set->nb_bindings; j++)
2280 vk->GetDescriptorSetLayoutBindingOffsetEXT(
s->hwctx->act_dev,
2283 &
set->binding_offset[j]);
2291 uint8_t *spirv,
size_t spirv_len,
2292 const char *entrypoint)
2326 case VK_PIPELINE_BIND_POINT_COMPUTE:
2336 vk->DestroyShaderModule(
s->hwctx->act_dev,
mod,
s->hwctx->alloc);
2352 [VK_DESCRIPTOR_TYPE_SAMPLER] = {
sizeof(VkDescriptorImageInfo),
"sampler", 1, 0, 0, 0, },
2353 [VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE] = {
sizeof(VkDescriptorImageInfo),
"texture", 1, 0, 1, 0, },
2354 [VK_DESCRIPTOR_TYPE_STORAGE_IMAGE] = {
sizeof(VkDescriptorImageInfo),
"image", 1, 1, 1, 0, },
2355 [VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT] = {
sizeof(VkDescriptorImageInfo),
"subpassInput", 1, 0, 0, 0, },
2356 [VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER] = {
sizeof(VkDescriptorImageInfo),
"sampler", 1, 0, 1, 0, },
2357 [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER] = {
sizeof(VkDescriptorBufferInfo),
NULL, 1, 0, 0, 1, },
2358 [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] = {
sizeof(VkDescriptorBufferInfo),
"buffer", 0, 1, 0, 1, },
2359 [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC] = {
sizeof(VkDescriptorBufferInfo),
NULL, 1, 0, 0, 1, },
2360 [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC] = {
sizeof(VkDescriptorBufferInfo),
"buffer", 0, 1, 0, 1, },
2361 [VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER] = {
sizeof(VkBufferView),
"samplerBuffer", 1, 0, 0, 0, },
2362 [VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER] = {
sizeof(VkBufferView),
"imageBuffer", 1, 0, 0, 0, },
2367 int singular,
int print_to_shader_only)
2369 int has_sampler = 0;
2372 if (print_to_shader_only)
2384 memset(
set, 0,
sizeof(*
set));
2391 if (!
set->binding_offset) {
2396 for (
int i = 0;
i < nb;
i++) {
2397 set->binding[
i].binding =
i;
2398 set->binding[
i].descriptorType =
desc[
i].type;
2400 set->binding[
i].stageFlags =
desc[
i].stages;
2401 set->binding[
i].pImmutableSamplers =
desc[
i].samplers;
2403 if (
desc[
i].
type == VK_DESCRIPTOR_TYPE_SAMPLER ||
2404 desc[
i].
type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
2408 set->usage = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT |
2409 VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
2411 set->usage |= VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT;
2414 for (
int i = 0;
i < nb;
i++) {
2416 VkDescriptorPoolSize *desc_pool_size;
2422 sizeof(*desc_pool_size),
2424 if (!desc_pool_size)
2429 memset(&desc_pool_size[j], 0,
sizeof(VkDescriptorPoolSize));
2436 set->singular = singular;
2437 set->nb_bindings = nb;
2442 for (
int i = 0;
i < nb;
i++) {
2446 if (
desc[
i].mem_layout &&
2447 (
desc[
i].
type != VK_DESCRIPTOR_TYPE_STORAGE_IMAGE))
2460 if (
desc[
i].
type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
2461 if (
desc[
i].mem_layout) {
2462 int len = strlen(
desc[
i].mem_layout);
2463 if (
desc[
i].mem_layout[
len - 1] ==
'i' &&
2464 desc[
i].mem_layout[
len - 2] ==
'u') {
2466 }
else if (
desc[
i].mem_layout[
len - 1] ==
'i') {
2481 if (
desc[
i].buf_elems) {
2488 }
else if (
desc[
i].elems > 0) {
2517 memset(sd, 0,
sizeof(*sd));
2537 set->aligned_size*nb,
2539 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
2540 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
2541 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
2549 sd->
desc_bind[
i] = (VkDescriptorBufferBindingInfoEXT) {
2550 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT,
2551 .usage =
set->usage,
2558 VkDescriptorSetLayout *tmp_layouts;
2559 VkDescriptorSetAllocateInfo set_alloc_info;
2560 VkDescriptorPoolCreateInfo pool_create_info;
2565 pool_create_info = (VkDescriptorPoolCreateInfo) {
2566 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2573 ret = vk->CreateDescriptorPool(
s->hwctx->act_dev, &pool_create_info,
2575 if (
ret != VK_SUCCESS) {
2581 tmp_layouts =
av_malloc_array(pool_create_info.maxSets,
sizeof(*tmp_layouts));
2590 set_alloc_info = (VkDescriptorSetAllocateInfo) {
2591 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2593 .pSetLayouts = tmp_layouts,
2594 .descriptorSetCount = pool_create_info.maxSets,
2598 sizeof(*tmp_layouts));
2603 ret = vk->AllocateDescriptorSets(
s->hwctx->act_dev, &set_alloc_info,
2606 if (
ret != VK_SUCCESS) {
2628 int bind_idx,
int array_idx,
2629 VkDescriptorGetInfoEXT *desc_get_info,
2640 array_idx*desc_size;
2642 vk->GetDescriptorEXT(
s->hwctx->act_dev, desc_get_info, desc_size,
desc);
2647 VkWriteDescriptorSet *write_info)
2656 vk->UpdateDescriptorSets(
s->hwctx->act_dev, 1, write_info, 0,
NULL);
2660 vk->CmdPushDescriptorSetKHR(e->
buf,
2667 vk->UpdateDescriptorSets(
s->hwctx->act_dev, 1, write_info, 0,
NULL);
2674 VkImageView view, VkImageLayout
layout,
2680 VkDescriptorGetInfoEXT desc_get_info = {
2681 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
2682 .type = desc_set->
binding[bind].descriptorType,
2684 VkDescriptorImageInfo desc_img_info = {
2691 switch (desc_get_info.type) {
2692 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
2693 desc_get_info.
data.pSampledImage = &desc_img_info;
2694 desc_size =
s->desc_buf_props.sampledImageDescriptorSize;
2696 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
2697 desc_get_info.data.pStorageImage = &desc_img_info;
2698 desc_size =
s->desc_buf_props.storageImageDescriptorSize;
2700 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
2701 desc_get_info.data.pInputAttachmentImage = &desc_img_info;
2702 desc_size =
s->desc_buf_props.inputAttachmentDescriptorSize;
2704 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
2705 desc_get_info.data.pCombinedImageSampler = &desc_img_info;
2706 desc_size =
s->desc_buf_props.combinedImageSamplerDescriptorSize;
2710 set, bind, desc_get_info.type);
2716 &desc_get_info, desc_size);
2718 VkDescriptorImageInfo desc_pool_write_info_img = {
2723 VkWriteDescriptorSet desc_pool_write_info = {
2724 .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2726 .descriptorCount = 1,
2727 .dstArrayElement = offs,
2728 .descriptorType = desc_set->
binding[bind].descriptorType,
2729 .pImageInfo = &desc_pool_write_info_img,
2739 VkImageView *views,
int set,
int binding,
2740 VkImageLayout
layout, VkSampler sampler)
2745 for (
int i = 0;
i < nb_planes;
i++)
2752 int set,
int bind,
int elem,
2759 VkDescriptorGetInfoEXT desc_get_info = {
2760 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
2761 .type = desc_set->
binding[bind].descriptorType,
2763 VkDescriptorAddressInfoEXT desc_buf_info = {
2764 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT,
2771 switch (desc_get_info.type) {
2772 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
2773 desc_get_info.data.pUniformBuffer = &desc_buf_info;
2774 desc_size =
s->desc_buf_props.uniformBufferDescriptorSize;
2776 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
2777 desc_get_info.data.pStorageBuffer = &desc_buf_info;
2778 desc_size =
s->desc_buf_props.storageBufferDescriptorSize;
2780 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
2781 desc_get_info.data.pUniformTexelBuffer = &desc_buf_info;
2782 desc_size =
s->desc_buf_props.uniformTexelBufferDescriptorSize;
2784 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
2785 desc_get_info.data.pStorageTexelBuffer = &desc_buf_info;
2786 desc_size =
s->desc_buf_props.storageTexelBufferDescriptorSize;
2790 set, bind, desc_get_info.type);
2797 VkDescriptorBufferInfo desc_pool_write_info_buf = {
2802 VkWriteDescriptorSet desc_pool_write_info = {
2803 .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2805 .descriptorCount = 1,
2806 .dstArrayElement = elem,
2807 .descriptorType = desc_set->
binding[bind].descriptorType,
2808 .pBufferInfo = &desc_pool_write_info_buf,
2818 VkShaderStageFlagBits stage,
2834 VkShaderStageFlagBits stages = shd->
stage;
2835 vk->CmdBindShadersEXT(e->
buf, 1, &stages, &shd->
object);
2867 if (shd->shader.module)
2868 vk->DestroyShaderModule(
s->hwctx->act_dev, shd->shader.module,
2873 vk->DestroyShaderEXT(
s->hwctx->act_dev, shd->
object,
s->hwctx->alloc);
2875 vk->DestroyPipeline(
s->hwctx->act_dev, shd->
pipeline,
s->hwctx->alloc);
2889 vk->DestroyDescriptorSetLayout(
s->hwctx->act_dev, shd->
desc_layout[
i],
2917 static const AVClass vulkan_context_class = {
2923 memset(
s, 0,
sizeof(*
s));
2924 s->log_parent = log_parent;
2925 s->class = &vulkan_context_class;
2933 s->hwfc =
s->frames->hwctx;
2935 device_ref =
s->frames->device_ref;
2939 if (!
s->device_ref) {
2945 s->hwctx =
s->device->hwctx;
2948 s->hwctx->nb_enabled_dev_extensions);
2950 s->hwctx->nb_enabled_inst_extensions);