27 .r = VK_COMPONENT_SWIZZLE_IDENTITY,
28 .g = VK_COMPONENT_SWIZZLE_IDENTITY,
29 .b = VK_COMPONENT_SWIZZLE_IDENTITY,
30 .a = VK_COMPONENT_SWIZZLE_IDENTITY,
36 #define CASE(VAL) case VAL: return #VAL
44 CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
45 CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
46 CASE(VK_ERROR_INITIALIZATION_FAILED);
47 CASE(VK_ERROR_DEVICE_LOST);
48 CASE(VK_ERROR_MEMORY_MAP_FAILED);
49 CASE(VK_ERROR_LAYER_NOT_PRESENT);
50 CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
51 CASE(VK_ERROR_FEATURE_NOT_PRESENT);
52 CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
53 CASE(VK_ERROR_TOO_MANY_OBJECTS);
54 CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
55 CASE(VK_ERROR_FRAGMENTED_POOL);
56 CASE(VK_ERROR_UNKNOWN);
57 CASE(VK_ERROR_OUT_OF_POOL_MEMORY);
58 CASE(VK_ERROR_INVALID_EXTERNAL_HANDLE);
59 CASE(VK_ERROR_FRAGMENTATION);
60 CASE(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS);
61 CASE(VK_PIPELINE_COMPILE_REQUIRED);
62 CASE(VK_ERROR_SURFACE_LOST_KHR);
63 CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
64 CASE(VK_SUBOPTIMAL_KHR);
65 CASE(VK_ERROR_OUT_OF_DATE_KHR);
66 CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
67 CASE(VK_ERROR_VALIDATION_FAILED_EXT);
68 CASE(VK_ERROR_INVALID_SHADER_NV);
69 CASE(VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR);
70 CASE(VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR);
71 CASE(VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR);
72 CASE(VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR);
73 CASE(VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR);
74 CASE(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
75 CASE(VK_ERROR_NOT_PERMITTED_KHR);
76 CASE(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
77 CASE(VK_THREAD_IDLE_KHR);
78 CASE(VK_THREAD_DONE_KHR);
79 CASE(VK_OPERATION_DEFERRED_KHR);
80 CASE(VK_OPERATION_NOT_DEFERRED_KHR);
81 default:
return "Unknown error";
90 s->hprops = (VkPhysicalDeviceExternalMemoryHostPropertiesEXT) {
91 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
93 s->coop_matrix_props = (VkPhysicalDeviceCooperativeMatrixPropertiesKHR) {
94 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
97 s->subgroup_props = (VkPhysicalDeviceSubgroupSizeControlProperties) {
98 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES,
99 .pNext = &
s->coop_matrix_props,
101 s->desc_buf_props = (VkPhysicalDeviceDescriptorBufferPropertiesEXT) {
102 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT,
103 .pNext = &
s->subgroup_props,
105 s->driver_props = (VkPhysicalDeviceDriverProperties) {
106 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
107 .pNext = &
s->desc_buf_props,
109 s->props = (VkPhysicalDeviceProperties2) {
110 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
111 .pNext = &
s->driver_props,
114 s->atomic_float_feats = (VkPhysicalDeviceShaderAtomicFloatFeaturesEXT) {
115 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
117 s->feats_12 = (VkPhysicalDeviceVulkan12Features) {
118 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
119 .pNext = &
s->atomic_float_feats,
121 s->feats = (VkPhysicalDeviceFeatures2) {
122 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
123 .pNext = &
s->feats_12,
126 vk->GetPhysicalDeviceProperties2(
s->hwctx->phys_dev, &
s->props);
127 vk->GetPhysicalDeviceMemoryProperties(
s->hwctx->phys_dev, &
s->mprops);
128 vk->GetPhysicalDeviceFeatures2(
s->hwctx->phys_dev, &
s->feats);
133 vk->GetPhysicalDeviceQueueFamilyProperties2(
s->hwctx->phys_dev, &
s->tot_nb_qfs,
NULL);
135 s->qf_props =
av_calloc(
s->tot_nb_qfs,
sizeof(*
s->qf_props));
139 s->query_props =
av_calloc(
s->tot_nb_qfs,
sizeof(*
s->query_props));
145 s->video_props =
av_calloc(
s->tot_nb_qfs,
sizeof(*
s->video_props));
146 if (!
s->video_props) {
152 for (uint32_t
i = 0;
i <
s->tot_nb_qfs;
i++) {
153 s->query_props[
i] = (VkQueueFamilyQueryResultStatusPropertiesKHR) {
154 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR,
156 s->video_props[
i] = (VkQueueFamilyVideoPropertiesKHR) {
157 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR,
158 .pNext = &
s->query_props[
i],
160 s->qf_props[
i] = (VkQueueFamilyProperties2) {
161 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
162 .pNext = &
s->video_props[
i],
166 vk->GetPhysicalDeviceQueueFamilyProperties2(
s->hwctx->phys_dev, &
s->tot_nb_qfs,
s->qf_props);
169 vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(
s->hwctx->phys_dev,
170 &
s->coop_mat_props_nb,
NULL);
172 if (
s->coop_mat_props_nb) {
174 sizeof(VkCooperativeMatrixPropertiesKHR));
175 for (
int i = 0;
i <
s->coop_mat_props_nb;
i++) {
176 s->coop_mat_props[
i] = (VkCooperativeMatrixPropertiesKHR) {
177 .sType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
181 vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(
s->hwctx->phys_dev,
182 &
s->coop_mat_props_nb,
194 switch (dev_family) {
195 case VK_QUEUE_GRAPHICS_BIT:
196 ret =
s->hwctx->queue_family_index;
197 num =
s->hwctx->nb_graphics_queues;
199 case VK_QUEUE_COMPUTE_BIT:
200 ret =
s->hwctx->queue_family_comp_index;
201 num =
s->hwctx->nb_comp_queues;
203 case VK_QUEUE_TRANSFER_BIT:
204 ret =
s->hwctx->queue_family_tx_index;
205 num =
s->hwctx->nb_tx_queues;
207 case VK_QUEUE_VIDEO_ENCODE_BIT_KHR:
208 ret =
s->hwctx->queue_family_encode_index;
209 num =
s->hwctx->nb_encode_queues;
211 case VK_QUEUE_VIDEO_DECODE_BIT_KHR:
212 ret =
s->hwctx->queue_family_decode_index;
213 num =
s->hwctx->nb_decode_queues;
226 VkQueueFlagBits dev_family)
233 if (
s->hwctx->queue_family_index >= 0)
234 s->qfs[
s->nb_qfs++] =
s->hwctx->queue_family_index;
235 if (!
s->nb_qfs ||
s->qfs[0] !=
s->hwctx->queue_family_tx_index)
236 s->qfs[
s->nb_qfs++] =
s->hwctx->queue_family_tx_index;
237 if (!
s->nb_qfs || (
s->qfs[0] !=
s->hwctx->queue_family_comp_index &&
238 s->qfs[1] !=
s->hwctx->queue_family_comp_index))
239 s->qfs[
s->nb_qfs++] =
s->hwctx->queue_family_comp_index;
240 if (
s->hwctx->queue_family_decode_index >= 0 &&
241 (
s->qfs[0] !=
s->hwctx->queue_family_decode_index &&
242 s->qfs[1] !=
s->hwctx->queue_family_decode_index &&
243 s->qfs[2] !=
s->hwctx->queue_family_decode_index))
244 s->qfs[
s->nb_qfs++] =
s->hwctx->queue_family_decode_index;
245 if (
s->hwctx->queue_family_encode_index >= 0 &&
246 (
s->qfs[0] !=
s->hwctx->queue_family_encode_index &&
247 s->qfs[1] !=
s->hwctx->queue_family_encode_index &&
248 s->qfs[2] !=
s->hwctx->queue_family_encode_index &&
249 s->qfs[3] !=
s->hwctx->queue_family_encode_index))
250 s->qfs[
s->nb_qfs++] =
s->hwctx->queue_family_encode_index;
264 vk->WaitForFences(
s->hwctx->act_dev, 1, &e->
fence, VK_TRUE, UINT64_MAX);
265 vk->DestroyFence(
s->hwctx->act_dev, e->
fence,
s->hwctx->alloc);
284 vk->FreeCommandBuffers(
s->hwctx->act_dev, pool->
cmd_buf_pool,
287 vk->DestroyCommandPool(
s->hwctx->act_dev, pool->
cmd_buf_pool,
s->hwctx->alloc);
289 vk->DestroyQueryPool(
s->hwctx->act_dev, pool->
query_pool,
s->hwctx->alloc);
298 int nb_queries, VkQueryType query_type,
int query_64bit,
299 const void *query_create_pnext)
306 VkCommandBufferAllocateInfo cbuf_create;
310 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
311 .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT |
312 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
317 if (
ret != VK_SUCCESS) {
332 cbuf_create = (VkCommandBufferAllocateInfo) {
333 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
334 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
336 .commandBufferCount = nb_contexts,
338 ret = vk->AllocateCommandBuffers(
s->hwctx->act_dev, &cbuf_create,
340 if (
ret != VK_SUCCESS) {
349 VkQueryPoolCreateInfo query_pool_info = {
350 .sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
351 .pNext = query_create_pnext,
352 .queryType = query_type,
353 .queryCount = nb_queries*nb_contexts,
355 ret = vk->CreateQueryPool(
s->hwctx->act_dev, &query_pool_info,
357 if (
ret != VK_SUCCESS) {
371 if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
376 if (query_type == VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR) {
404 VkFenceCreateInfo fence_create = {
405 .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
406 .flags = VK_FENCE_CREATE_SIGNALED_BIT,
415 ret = vk->CreateFence(
s->hwctx->act_dev, &fence_create,
s->hwctx->alloc,
417 if (
ret != VK_SUCCESS) {
457 VkQueryResultFlags qf = 0;
460 VK_QUERY_RESULT_64_BIT : 0x0;
462 VK_QUERY_RESULT_WITH_STATUS_BIT_KHR : 0x0;
464 ret = vk->GetQueryPoolResults(
s->hwctx->act_dev, pool->
query_pool,
469 if (
ret != VK_SUCCESS)
474 res = (res64[
i] < res) || (res >= 0 && res64[
i] > res) ?
480 res = (res32[
i] < res) || (res >= 0 && res32[
i] > res) ?
496 uint32_t idx = pool->
idx++;
505 vk->WaitForFences(
s->hwctx->act_dev, 1, &e->
fence, VK_TRUE, UINT64_MAX);
516 VkCommandBufferBeginInfo cmd_start = {
517 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
518 .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
522 vk->WaitForFences(
s->hwctx->act_dev, 1, &e->
fence, VK_TRUE, UINT64_MAX);
526 vk->ResetFences(
s->hwctx->act_dev, 1, &e->
fence);
532 ret = vk->BeginCommandBuffer(e->
buf, &cmd_start);
533 if (
ret != VK_SUCCESS) {
558 vkfc->unlock_frame(hwfc, vkf);
584 for (
int i = 0;
i < nb_deps;
i++) {
597 VkPipelineStageFlagBits2 wait_stage,
598 VkPipelineStageFlagBits2 signal_stage)
600 uint8_t *frame_locked;
601 uint8_t *frame_update;
603 VkImageLayout *layout_dst;
604 uint32_t *queue_family_dst;
605 VkAccessFlagBits *access_dst;
617 #define ARR_REALLOC(str, arr, alloc_s, cnt) \
619 arr = av_fast_realloc(str->arr, alloc_s, (cnt + 1)*sizeof(*arr)); \
621 ff_vk_exec_discard_deps(s, e); \
622 return AVERROR(ENOMEM); \
641 vkfc->lock_frame(hwfc, vkf);
646 for (
int i = 0;
i < nb_images;
i++) {
648 VkSemaphoreSubmitInfo *sem_sig;
649 uint64_t **sem_sig_val_dst;
656 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
657 .semaphore = vkf->sem[
i],
658 .value = vkf->sem_value[
i],
659 .stageMask = wait_stage,
663 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
664 .semaphore = vkf->sem[
i],
665 .value = vkf->sem_value[
i] + 1,
666 .stageMask = signal_stage,
677 VkImageMemoryBarrier2 *bar, uint32_t *nb_img_bar)
696 VkSemaphore *dst, uint64_t *dst_val,
699 uint64_t **sem_sig_val_dst;
725 VkCommandBufferSubmitInfo cmd_buf_info = (VkCommandBufferSubmitInfo) {
726 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
727 .commandBuffer = e->
buf,
729 VkSubmitInfo2 submit_info = (VkSubmitInfo2) {
730 .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
731 .pCommandBufferInfos = &cmd_buf_info,
732 .commandBufferInfoCount = 1,
735 .pSignalSemaphoreInfos = e->
sem_sig,
739 ret = vk->EndCommandBuffer(e->
buf);
740 if (
ret != VK_SUCCESS) {
747 s->hwctx->lock_queue(
s->device, e->
qf, e->
qi);
749 s->hwctx->unlock_queue(
s->device, e->
qf, e->
qi);
751 if (
ret != VK_SUCCESS) {
771 for (
int i = 0;
i < nb_images;
i++) {
777 vkfc->unlock_frame(hwfc, vkf);
786 VkMemoryPropertyFlagBits req_flags,
void *alloc_extension,
787 VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
793 VkMemoryAllocateInfo alloc_info = {
794 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
795 .pNext = alloc_extension,
799 if ((req_flags != UINT32_MAX) && req_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
800 req->size =
FFALIGN(req->size,
s->props.properties.limits.minMemoryMapAlignment);
802 alloc_info.allocationSize = req->size;
806 for (
int i = 0;
i <
s->mprops.memoryTypeCount;
i++) {
808 if (!(req->memoryTypeBits & (1 <<
i)))
812 if ((req_flags != UINT32_MAX) &&
813 ((
s->mprops.memoryTypes[
i].propertyFlags & req_flags) != req_flags))
827 alloc_info.memoryTypeIndex =
index;
829 ret = vk->AllocateMemory(
s->hwctx->act_dev, &alloc_info,
830 s->hwctx->alloc, mem);
831 if (
ret != VK_SUCCESS) {
838 *mem_flags |=
s->mprops.memoryTypes[
index].propertyFlags;
844 void *pNext,
void *alloc_pNext,
845 VkBufferUsageFlags
usage, VkMemoryPropertyFlagBits
flags)
852 VkBufferCreateInfo buf_spawn = {
853 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
856 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
861 VkMemoryAllocateFlagsInfo alloc_flags = {
862 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
863 .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
865 VkBufferMemoryRequirementsInfo2 req_desc = {
866 .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
868 VkMemoryDedicatedAllocateInfo ded_alloc = {
869 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
870 .pNext = alloc_pNext,
872 VkMemoryDedicatedRequirements ded_req = {
873 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
875 VkMemoryRequirements2 req = {
876 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
880 ret = vk->CreateBuffer(
s->hwctx->act_dev, &buf_spawn,
NULL, &buf->
buf);
881 if (
ret != VK_SUCCESS) {
887 req_desc.buffer = buf->
buf;
889 vk->GetBufferMemoryRequirements2(
s->hwctx->act_dev, &req_desc, &req);
892 use_ded_mem = ded_req.prefersDedicatedAllocation |
893 ded_req.requiresDedicatedAllocation;
895 ded_alloc.buffer = buf->
buf;
896 ded_alloc.pNext = alloc_pNext;
897 alloc_pNext = &ded_alloc;
900 if (
usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
901 alloc_flags.pNext = alloc_pNext;
902 alloc_pNext = &alloc_flags;
910 ret = vk->BindBufferMemory(
s->hwctx->act_dev, buf->
buf, buf->
mem, 0);
911 if (
ret != VK_SUCCESS) {
917 if (
usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
918 VkBufferDeviceAddressInfo address_info = {
919 .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
922 buf->
address = vk->GetBufferDeviceAddress(
s->hwctx->act_dev, &address_info);
939 void *pNext,
void *alloc_pNext,
940 VkBufferUsageFlags
usage, VkMemoryPropertyFlagBits
flags)
966 int nb_buffers,
int invalidate)
970 VkMappedMemoryRange inval_list[64];
973 for (
int i = 0;
i < nb_buffers;
i++) {
975 ret = vk->MapMemory(
s->hwctx->act_dev, buf[
i]->
mem, 0,
976 VK_WHOLE_SIZE, 0, &dst);
977 if (
ret != VK_SUCCESS) {
988 for (
int i = 0;
i < nb_buffers;
i++) {
989 const VkMappedMemoryRange ival_buf = {
990 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
991 .memory = buf[
i]->
mem,
992 .size = VK_WHOLE_SIZE,
994 if (buf[
i]->
flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
996 inval_list[inval_count++] = ival_buf;
1000 ret = vk->InvalidateMappedMemoryRanges(
s->hwctx->act_dev, inval_count,
1002 if (
ret != VK_SUCCESS) {
1018 VkMappedMemoryRange flush_list[64];
1019 int flush_count = 0;
1022 for (
int i = 0;
i < nb_buffers;
i++) {
1023 const VkMappedMemoryRange flush_buf = {
1024 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1025 .memory = buf[
i]->
mem,
1026 .size = VK_WHOLE_SIZE,
1028 if (buf[
i]->
flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
1030 flush_list[flush_count++] = flush_buf;
1035 ret = vk->FlushMappedMemoryRanges(
s->hwctx->act_dev, flush_count,
1037 if (
ret != VK_SUCCESS) {
1044 for (
int i = 0;
i < nb_buffers;
i++)
1045 vk->UnmapMemory(
s->hwctx->act_dev, buf[
i]->
mem);
1054 if (!buf || !
s->hwctx)
1059 if (buf->
buf != VK_NULL_HANDLE)
1060 vk->DestroyBuffer(
s->hwctx->act_dev, buf->
buf,
s->hwctx->alloc);
1061 if (buf->
mem != VK_NULL_HANDLE)
1062 vk->FreeMemory(
s->hwctx->act_dev, buf->
mem,
s->hwctx->alloc);
1088 void *create_pNext,
size_t size,
1089 VkMemoryPropertyFlagBits mem_props)
1107 data->stage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
1108 data->access = VK_ACCESS_2_NONE;
1127 if (mem_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
1139 VkShaderStageFlagBits stage)
1141 VkPushConstantRange *pc;
1149 memset(pc, 0,
sizeof(*pc));
1151 pc->stageFlags = stage;
1159 int unnorm_coords, VkFilter
filt)
1164 VkSamplerCreateInfo sampler_info = {
1165 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
1167 .minFilter = sampler_info.magFilter,
1168 .mipmapMode = unnorm_coords ? VK_SAMPLER_MIPMAP_MODE_NEAREST :
1169 VK_SAMPLER_MIPMAP_MODE_LINEAR,
1170 .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1171 .addressModeV = sampler_info.addressModeU,
1172 .addressModeW = sampler_info.addressModeU,
1173 .anisotropyEnable = VK_FALSE,
1174 .compareOp = VK_COMPARE_OP_NEVER,
1175 .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
1176 .unnormalizedCoordinates = unnorm_coords,
1179 ret = vk->CreateSampler(
s->hwctx->act_dev, &sampler_info,
1180 s->hwctx->alloc, sampler);
1181 if (
ret != VK_SUCCESS) {
1205 const int high =
desc->comp[0].depth > 8;
1206 return high ?
"rgba16f" :
"rgba8";
1221 vk->DestroyImageView(
s->hwctx->act_dev, iv->
views[
i],
s->hwctx->alloc);
1244 for (
int i = 0;
i < nb_planes;
i++) {
1245 VkImageAspectFlags plane_aspect[] = { VK_IMAGE_ASPECT_COLOR_BIT,
1246 VK_IMAGE_ASPECT_PLANE_0_BIT,
1247 VK_IMAGE_ASPECT_PLANE_1_BIT,
1248 VK_IMAGE_ASPECT_PLANE_2_BIT, };
1250 VkImageViewCreateInfo view_create_info = {
1251 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1253 .image = vkf->
img[
FFMIN(
i, nb_images - 1)],
1254 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1255 .format = rep_fmts[
i],
1257 .subresourceRange = {
1258 .aspectMask = plane_aspect[(nb_planes != nb_images) +
1259 i*(nb_planes != nb_images)],
1265 ret = vk->CreateImageView(
s->hwctx->act_dev, &view_create_info,
1266 s->hwctx->alloc, &iv->
views[
i]);
1267 if (
ret != VK_SUCCESS) {
1288 memcpy(views, iv->views, nb_planes*
sizeof(*views));
1293 for (
int i = 0;
i < iv->nb_views;
i++)
1294 vk->DestroyImageView(
s->hwctx->act_dev, iv->views[
i],
s->hwctx->alloc);
1300 AVFrame *pic, VkImageMemoryBarrier2 *bar,
int *nb_bar,
1301 VkPipelineStageFlags src_stage,
1302 VkPipelineStageFlags dst_stage,
1303 VkAccessFlagBits new_access,
1304 VkImageLayout new_layout,
1315 for (
int i = 0;
i < nb_images;
i++) {
1316 bar[*nb_bar] = (VkImageMemoryBarrier2) {
1317 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
1319 .srcStageMask = src_stage,
1320 .dstStageMask = dst_stage,
1322 .dstAccessMask = new_access,
1324 .newLayout = new_layout,
1326 .dstQueueFamilyIndex = new_qf,
1327 .image = vkf->
img[
i],
1328 .subresourceRange = (VkImageSubresourceRange) {
1329 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
1341 VkShaderStageFlags stage, uint32_t required_subgroup_size)
1345 shd->
shader.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
1346 shd->
shader.stage = stage;
1348 if (required_subgroup_size) {
1349 shd->
shader.flags |= VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT;
1351 shd->
subgroup_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
1352 shd->
subgroup_info.requiredSubgroupSize = required_subgroup_size;
1358 GLSLC(0, #define IS_WITHIN(v1, v2) ((v1.x < v2.x) && (v1.y < v2.y)) );
1360 GLSLC(0, #extension GL_EXT_buffer_reference : require );
1361 GLSLC(0, #extension GL_EXT_buffer_reference2 : require );
1373 "local_size_y = %i, local_size_z = %i) in;\n\n",
1380 const char *p = shd->
src.str;
1381 const char *start = p;
1382 const size_t len = strlen(p);
1387 for (
int i = 0;
i <
len;
i++) {
1405 vk->DestroyShaderModule(
s->hwctx->act_dev, shd->
shader.module,
s->hwctx->alloc);
1409 uint8_t *spirv,
size_t spirv_size,
const char *entrypoint)
1413 VkShaderModuleCreateInfo shader_create;
1415 shd->
shader.pName = entrypoint;
1418 shd->
name, spirv_size);
1420 shader_create.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
1421 shader_create.pNext =
NULL;
1422 shader_create.codeSize = spirv_size;
1423 shader_create.flags = 0;
1424 shader_create.pCode = (
void *)spirv;
1426 ret = vk->CreateShaderModule(
s->hwctx->act_dev, &shader_create,
NULL,
1428 if (
ret != VK_SUCCESS) {
1445 [VK_DESCRIPTOR_TYPE_SAMPLER] = {
sizeof(VkDescriptorImageInfo),
"sampler", 1, 0, 0, 0, },
1446 [VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE] = {
sizeof(VkDescriptorImageInfo),
"texture", 1, 0, 1, 0, },
1447 [VK_DESCRIPTOR_TYPE_STORAGE_IMAGE] = {
sizeof(VkDescriptorImageInfo),
"image", 1, 1, 1, 0, },
1448 [VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT] = {
sizeof(VkDescriptorImageInfo),
"subpassInput", 1, 0, 0, 0, },
1449 [VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER] = {
sizeof(VkDescriptorImageInfo),
"sampler", 1, 0, 1, 0, },
1450 [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER] = {
sizeof(VkDescriptorBufferInfo),
NULL, 1, 0, 0, 1, },
1451 [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] = {
sizeof(VkDescriptorBufferInfo),
"buffer", 0, 1, 0, 1, },
1452 [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC] = {
sizeof(VkDescriptorBufferInfo),
NULL, 1, 0, 0, 1, },
1453 [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC] = {
sizeof(VkDescriptorBufferInfo),
"buffer", 0, 1, 0, 1, },
1454 [VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER] = {
sizeof(VkBufferView),
"samplerBuffer", 1, 0, 0, 0, },
1455 [VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER] = {
sizeof(VkBufferView),
"imageBuffer", 1, 0, 0, 0, },
1461 int read_only,
int print_to_shader_only)
1464 int has_sampler = 0;
1467 VkDescriptorSetLayoutCreateInfo desc_create_layout;
1469 if (print_to_shader_only)
1479 memset(
set, 0,
sizeof(*
set));
1486 if (!
set->binding_offset) {
1491 desc_create_layout = (VkDescriptorSetLayoutCreateInfo) {
1492 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
1494 .pBindings =
set->binding,
1495 .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT,
1498 for (
int i = 0;
i < nb;
i++) {
1499 set->binding[
i].binding =
i;
1500 set->binding[
i].descriptorType =
desc[
i].type;
1502 set->binding[
i].stageFlags =
desc[
i].stages;
1503 set->binding[
i].pImmutableSamplers =
desc[
i].samplers;
1505 if (
desc[
i].
type == VK_DESCRIPTOR_TYPE_SAMPLER ||
1506 desc[
i].
type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
1510 set->usage = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT |
1511 VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
1513 set->usage |= VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT;
1515 ret = vk->CreateDescriptorSetLayout(
s->hwctx->act_dev, &desc_create_layout,
1516 s->hwctx->alloc, &
set->layout);
1517 if (
ret != VK_SUCCESS) {
1523 vk->GetDescriptorSetLayoutSizeEXT(
s->hwctx->act_dev,
set->layout, &
set->layout_size);
1525 set->aligned_size =
FFALIGN(
set->layout_size,
s->desc_buf_props.descriptorBufferOffsetAlignment);
1527 for (
int i = 0;
i < nb;
i++)
1528 vk->GetDescriptorSetLayoutBindingOffsetEXT(
s->hwctx->act_dev,
set->layout,
1529 i, &
set->binding_offset[
i]);
1531 set->read_only = read_only;
1532 set->nb_bindings = nb;
1537 for (
int i = 0;
i < nb;
i++) {
1541 if (
desc[
i].mem_layout)
1561 else if (
desc[
i].elems > 0)
1592 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
1593 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
1601 pl->
desc_bind[
i] = (VkDescriptorBufferBindingInfoEXT) {
1602 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT,
1603 .usage =
set->usage,
1604 .address =
set->buf.address,
1615 int bind_idx,
int array_idx,
1616 VkDescriptorGetInfoEXT *desc_get_info,
1620 const size_t exec_offset =
set->read_only ? 0 :
set->aligned_size*e->
idx;
1623 set->binding_offset[bind_idx] +
1624 array_idx*desc_size;
1626 vk->GetDescriptorEXT(
s->hwctx->act_dev, desc_get_info, desc_size,
desc);
1634 VkDescriptorGetInfoEXT desc_get_info = {
1635 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
1636 .type = desc_set->
binding[bind].descriptorType,
1639 switch (desc_get_info.type) {
1640 case VK_DESCRIPTOR_TYPE_SAMPLER:
1641 desc_get_info.data.pSampler = sampler;
1645 set, bind, desc_get_info.type);
1651 s->desc_buf_props.samplerDescriptorSize);
1658 VkImageView view, VkImageLayout
layout, VkSampler sampler)
1661 VkDescriptorGetInfoEXT desc_get_info = {
1662 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
1663 .type = desc_set->
binding[bind].descriptorType,
1665 VkDescriptorImageInfo desc_img_info = {
1672 switch (desc_get_info.type) {
1673 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1674 desc_get_info.
data.pSampledImage = &desc_img_info;
1675 desc_size =
s->desc_buf_props.sampledImageDescriptorSize;
1677 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1678 desc_get_info.data.pStorageImage = &desc_img_info;
1679 desc_size =
s->desc_buf_props.storageImageDescriptorSize;
1681 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1682 desc_get_info.data.pInputAttachmentImage = &desc_img_info;
1683 desc_size =
s->desc_buf_props.inputAttachmentDescriptorSize;
1685 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1686 desc_get_info.data.pCombinedImageSampler = &desc_img_info;
1687 desc_size =
s->desc_buf_props.combinedImageSamplerDescriptorSize;
1691 set, bind, desc_get_info.type);
1703 VkDeviceAddress addr, VkDeviceSize
len,
VkFormat fmt)
1706 VkDescriptorGetInfoEXT desc_get_info = {
1707 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
1708 .type = desc_set->
binding[bind].descriptorType,
1710 VkDescriptorAddressInfoEXT desc_buf_info = {
1717 switch (desc_get_info.type) {
1718 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1719 desc_get_info.data.pUniformBuffer = &desc_buf_info;
1720 desc_size =
s->desc_buf_props.uniformBufferDescriptorSize;
1722 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1723 desc_get_info.data.pStorageBuffer = &desc_buf_info;
1724 desc_size =
s->desc_buf_props.storageBufferDescriptorSize;
1726 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1727 desc_get_info.data.pUniformTexelBuffer = &desc_buf_info;
1728 desc_size =
s->desc_buf_props.uniformTexelBufferDescriptorSize;
1730 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1731 desc_get_info.data.pStorageTexelBuffer = &desc_buf_info;
1732 desc_size =
s->desc_buf_props.storageTexelBufferDescriptorSize;
1736 set, bind, desc_get_info.type);
1748 VkImageView *views,
int set,
int binding,
1749 VkImageLayout
layout, VkSampler sampler)
1754 for (
int i = 0;
i < nb_planes;
i++)
1761 VkShaderStageFlagBits stage,
1773 VkPipelineLayoutCreateInfo pipeline_layout_info;
1776 sizeof(desc_layouts));
1784 pipeline_layout_info = (VkPipelineLayoutCreateInfo) {
1785 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1786 .pSetLayouts = desc_layouts,
1792 ret = vk->CreatePipelineLayout(
s->hwctx->act_dev, &pipeline_layout_info,
1795 if (
ret != VK_SUCCESS) {
1811 VkComputePipelineCreateInfo pipeline_create_info;
1817 pipeline_create_info = (VkComputePipelineCreateInfo) {
1818 .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
1819 .flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT,
1824 ret = vk->CreateComputePipelines(
s->hwctx->act_dev, VK_NULL_HANDLE, 1,
1825 &pipeline_create_info,
1827 if (
ret != VK_SUCCESS) {
1833 pl->
bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
1868 vk->DestroyPipeline(
s->hwctx->act_dev, pl->
pipeline,
s->hwctx->alloc);
1879 vk->DestroyDescriptorSetLayout(
s->hwctx->act_dev,
set->layout,