FFmpeg
Loading...
Searching...
No Matches
vulkan.c
Go to the documentation of this file.
1/*
2 * Copyright (c) Lynne
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21#include "config.h"
22#include "avassert.h"
23#include "mem.h"
24#include "random_seed.h"
25#include "refstruct.h"
26
27#include "vulkan.h"
29
30#if CONFIG_SHADER_COMPRESSION
32#endif
33
34const VkComponentMapping ff_comp_identity_map = {
35 .r = VK_COMPONENT_SWIZZLE_IDENTITY,
36 .g = VK_COMPONENT_SWIZZLE_IDENTITY,
37 .b = VK_COMPONENT_SWIZZLE_IDENTITY,
38 .a = VK_COMPONENT_SWIZZLE_IDENTITY,
39};
40
41/* Converts return values to strings */
42const char *ff_vk_ret2str(VkResult res)
43{
44#define CASE(VAL) case VAL: return #VAL
45 switch (res) {
46 CASE(VK_SUCCESS);
47 CASE(VK_NOT_READY);
48 CASE(VK_TIMEOUT);
49 CASE(VK_EVENT_SET);
50 CASE(VK_EVENT_RESET);
51 CASE(VK_INCOMPLETE);
52 CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
53 CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
54 CASE(VK_ERROR_INITIALIZATION_FAILED);
55 CASE(VK_ERROR_DEVICE_LOST);
56 CASE(VK_ERROR_MEMORY_MAP_FAILED);
57 CASE(VK_ERROR_LAYER_NOT_PRESENT);
58 CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
59 CASE(VK_ERROR_FEATURE_NOT_PRESENT);
60 CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
61 CASE(VK_ERROR_TOO_MANY_OBJECTS);
62 CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
63 CASE(VK_ERROR_FRAGMENTED_POOL);
64 CASE(VK_ERROR_UNKNOWN);
65 CASE(VK_ERROR_OUT_OF_POOL_MEMORY);
66 CASE(VK_ERROR_INVALID_EXTERNAL_HANDLE);
67 CASE(VK_ERROR_FRAGMENTATION);
68 CASE(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS);
69 CASE(VK_PIPELINE_COMPILE_REQUIRED);
70 CASE(VK_ERROR_SURFACE_LOST_KHR);
71 CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
72 CASE(VK_SUBOPTIMAL_KHR);
73 CASE(VK_ERROR_OUT_OF_DATE_KHR);
74 CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
75 CASE(VK_ERROR_VALIDATION_FAILED_EXT);
76 CASE(VK_ERROR_INVALID_SHADER_NV);
77 CASE(VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR);
78 CASE(VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR);
79 CASE(VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR);
80 CASE(VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR);
81 CASE(VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR);
82 CASE(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
83 CASE(VK_ERROR_NOT_PERMITTED_KHR);
84 CASE(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
85 CASE(VK_THREAD_IDLE_KHR);
86 CASE(VK_THREAD_DONE_KHR);
87 CASE(VK_OPERATION_DEFERRED_KHR);
88 CASE(VK_OPERATION_NOT_DEFERRED_KHR);
89 default: return "Unknown error";
90 }
91#undef CASE
92}
93
94/* Malitia pura, Khronos */
95#define FN_MAP_TO(dst_t, dst_name, src_t, src_name) \
96 dst_t ff_vk_map_ ##src_name## _to_ ##dst_name(src_t src) \
97 { \
98 dst_t dst = 0x0; \
99 MAP_TO(VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, \
100 VK_IMAGE_USAGE_SAMPLED_BIT); \
101 MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, \
102 VK_IMAGE_USAGE_TRANSFER_SRC_BIT); \
103 MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, \
104 VK_IMAGE_USAGE_TRANSFER_DST_BIT); \
105 MAP_TO(VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, \
106 VK_IMAGE_USAGE_STORAGE_BIT); \
107 MAP_TO(VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, \
108 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); \
109 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR, \
110 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR); \
111 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR, \
112 VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR); \
113 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, \
114 VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR); \
115 MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, \
116 VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR); \
117 MAP_TO(VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT, \
118 VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT); \
119 return dst; \
120 }
121
122#define MAP_TO(flag1, flag2) if (src & flag2) dst |= flag1;
123FN_MAP_TO(VkFormatFeatureFlagBits2, feats, VkImageUsageFlags, usage)
124#undef MAP_TO
125#define MAP_TO(flag1, flag2) if (src & flag1) dst |= flag2;
126FN_MAP_TO(VkImageUsageFlags, usage, VkFormatFeatureFlagBits2, feats)
127#undef MAP_TO
128#undef FN_MAP_TO
129
131{
132 s->nb_qfs = 0;
133 for (int i = 0; i < s->hwctx->nb_qf; i++) {
134 /* Skip duplicates */
135 int skip = 0;
136 for (int j = 0; j < s->nb_qfs; j++) {
137 if (s->qfs[j] == s->hwctx->qf[i].idx) {
138 skip = 1;
139 break;
140 }
141 }
142 if (skip)
143 continue;
144
145 s->qfs[s->nb_qfs++] = s->hwctx->qf[i].idx;
146 }
147}
148
149static void reset_imageviews(AVRefStructOpaque unused, void *obj);
150
152{
153 FFVulkanFunctions *vk = &s->vkfn;
154
155 s->props = (VkPhysicalDeviceProperties2) {
156 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
157 };
158
159 FF_VK_STRUCT_EXT(s, &s->props, &s->props_11, FF_VK_EXT_NO_FLAG,
160 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
161 FF_VK_STRUCT_EXT(s, &s->props, &s->driver_props, FF_VK_EXT_NO_FLAG,
162 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
163 FF_VK_STRUCT_EXT(s, &s->props, &s->subgroup_props, FF_VK_EXT_NO_FLAG,
164 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
165
166 FF_VK_STRUCT_EXT(s, &s->props, &s->push_desc_props, FF_VK_EXT_PUSH_DESCRIPTOR,
167 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
169 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
170 FF_VK_STRUCT_EXT(s, &s->props, &s->coop_matrix_props, FF_VK_EXT_COOP_MATRIX,
171 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR);
172 FF_VK_STRUCT_EXT(s, &s->props, &s->optical_flow_props, FF_VK_EXT_OPTICAL_FLOW,
173 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
174 FF_VK_STRUCT_EXT(s, &s->props, &s->host_image_props, FF_VK_EXT_HOST_IMAGE_COPY,
175 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT);
176
177#ifdef VK_EXT_shader_long_vector
178 FF_VK_STRUCT_EXT(s, &s->props, &s->long_vector_props, FF_VK_EXT_LONG_VECTOR,
179 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT);
180#endif
181
182 s->feats = (VkPhysicalDeviceFeatures2) {
183 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
184 };
185
186 FF_VK_STRUCT_EXT(s, &s->feats, &s->feats_12, FF_VK_EXT_NO_FLAG,
187 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
188 FF_VK_STRUCT_EXT(s, &s->feats, &s->atomic_float_feats, FF_VK_EXT_ATOMIC_FLOAT,
189 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
190#ifdef VK_KHR_unified_image_layouts
191 FF_VK_STRUCT_EXT(s, &s->feats, &s->unified_layout_feats, FF_VK_EXT_UNIFIED_IMAGE_LAYOUTS,
192 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR);
193#endif
194#ifdef VK_KHR_maintenance11
195 FF_VK_STRUCT_EXT(s, &s->feats, &s->maintenance_11_feats, FF_VK_EXT_MAINTENANCE_11,
196 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR);
197#endif
198
199 if (!s->imageviews_pool) {
200 s->imageviews_pool = av_refstruct_pool_alloc_ext(sizeof(FFVkImageViews), 0,
202 NULL, NULL);
203 if (!s->imageviews_pool)
204 return AVERROR(ENOMEM);
205 }
206
207 /* Try allocating 1024 layouts */
208 s->host_image_copy_layouts = av_malloc(sizeof(*s->host_image_copy_layouts)*1024);
209 s->host_image_props.pCopySrcLayouts = s->host_image_copy_layouts;
210 s->host_image_props.copySrcLayoutCount = 512;
211 s->host_image_props.pCopyDstLayouts = s->host_image_copy_layouts + 512;
212 s->host_image_props.copyDstLayoutCount = 512;
213
214 vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);
215
216 /* Check if we had enough memory for all layouts */
217 if (s->host_image_props.copySrcLayoutCount == 512 ||
218 s->host_image_props.copyDstLayoutCount == 512) {
219 VkImageLayout *new_array;
220 size_t new_size;
221 s->host_image_props.pCopySrcLayouts =
222 s->host_image_props.pCopyDstLayouts = NULL;
223 s->host_image_props.copySrcLayoutCount =
224 s->host_image_props.copyDstLayoutCount = 0;
225 vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);
226
227 new_size = s->host_image_props.copySrcLayoutCount +
228 s->host_image_props.copyDstLayoutCount;
229 new_size *= sizeof(*s->host_image_copy_layouts);
230 new_array = av_realloc(s->host_image_copy_layouts, new_size);
231 if (!new_array)
232 return AVERROR(ENOMEM);
233
234 s->host_image_copy_layouts = new_array;
235 s->host_image_props.pCopySrcLayouts = new_array;
236 s->host_image_props.pCopyDstLayouts = new_array + s->host_image_props.copySrcLayoutCount;
237 vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);
238 }
239
240 vk->GetPhysicalDeviceMemoryProperties(s->hwctx->phys_dev, &s->mprops);
241 vk->GetPhysicalDeviceFeatures2(s->hwctx->phys_dev, &s->feats);
242
243 for (int i = 0; i < s->mprops.memoryTypeCount; i++)
244 s->host_cached_flag |= s->mprops.memoryTypes[i].propertyFlags &
245 VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
246
248
249 if (s->qf_props)
250 return 0;
251
252 vk->GetPhysicalDeviceQueueFamilyProperties2(s->hwctx->phys_dev, &s->tot_nb_qfs, NULL);
253
254 s->qf_props = av_calloc(s->tot_nb_qfs, sizeof(*s->qf_props));
255 if (!s->qf_props)
256 return AVERROR(ENOMEM);
257
258 s->query_props = av_calloc(s->tot_nb_qfs, sizeof(*s->query_props));
259 if (!s->qf_props) {
260 av_freep(&s->qf_props);
261 return AVERROR(ENOMEM);
262 }
263
264 s->video_props = av_calloc(s->tot_nb_qfs, sizeof(*s->video_props));
265 if (!s->video_props) {
266 av_freep(&s->qf_props);
267 av_freep(&s->query_props);
268 return AVERROR(ENOMEM);
269 }
270
271#ifdef VK_KHR_maintenance9
272 s->ownership_props = av_calloc(s->tot_nb_qfs, sizeof(*s->ownership_props));
273 if (!s->ownership_props) {
274 av_freep(&s->qf_props);
275 av_freep(&s->query_props);
276 av_freep(&s->video_props);
277 return AVERROR(ENOMEM);
278 }
279#endif
280
281 for (uint32_t i = 0; i < s->tot_nb_qfs; i++) {
282 s->qf_props[i] = (VkQueueFamilyProperties2) {
283 .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
284 };
285
286 FF_VK_STRUCT_EXT(s, &s->qf_props[i], &s->query_props[i], FF_VK_EXT_VIDEO_QUEUE,
287 VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR);
288 FF_VK_STRUCT_EXT(s, &s->qf_props[i], &s->video_props[i], FF_VK_EXT_VIDEO_QUEUE,
289 VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR);
290#ifdef VK_KHR_maintenance9
291 FF_VK_STRUCT_EXT(s, &s->qf_props[i], &s->ownership_props[i], FF_VK_EXT_MAINTENANCE_9,
292 VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR);
293#endif
294 }
295
296 vk->GetPhysicalDeviceQueueFamilyProperties2(s->hwctx->phys_dev, &s->tot_nb_qfs, s->qf_props);
297
298 if (s->extensions & FF_VK_EXT_COOP_MATRIX) {
299 vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(s->hwctx->phys_dev,
300 &s->coop_mat_props_nb, NULL);
301
302 if (s->coop_mat_props_nb) {
303 s->coop_mat_props = av_malloc_array(s->coop_mat_props_nb,
304 sizeof(VkCooperativeMatrixPropertiesKHR));
305 for (int i = 0; i < s->coop_mat_props_nb; i++) {
306 s->coop_mat_props[i] = (VkCooperativeMatrixPropertiesKHR) {
307 .sType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
308 };
309 }
310
311 vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(s->hwctx->phys_dev,
312 &s->coop_mat_props_nb,
313 s->coop_mat_props);
314 }
315 }
316
317 return 0;
318}
319
321 VkQueueFlagBits dev_family,
322 VkVideoCodecOperationFlagBitsKHR vid_ops)
323{
324 for (int i = 0; i < s->hwctx->nb_qf; i++) {
325 if ((s->hwctx->qf[i].flags & dev_family) &&
326 (s->hwctx->qf[i].video_caps & vid_ops) == vid_ops) {
327 return &s->hwctx->qf[i];
328 }
329 }
330 return NULL;
331}
332
334
336{
337 FFVulkanFunctions *vk = &s->vkfn;
338
339 for (int i = 0; i < pool->pool_size; i++) {
340 FFVkExecContext *e = &pool->contexts[i];
341
342 if (e->sem) {
343 VkSemaphoreWaitInfo sem_wait_info = {
344 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
345 .semaphoreCount = 1,
346 .pSemaphores = &e->sem,
347 .pValues = &e->sem_value,
348 };
349 vk->WaitSemaphores(s->hwctx->act_dev, &sem_wait_info, UINT64_MAX);
350 vk->DestroySemaphore(s->hwctx->act_dev, e->sem, s->hwctx->alloc);
351 }
352
355 }
356
357 /* Free shader-specific data */
358 for (int i = 0; i < pool->nb_reg_shd; i++) {
359 FFVulkanShaderData *sd = &pool->reg_shd[i];
360
361 if (sd->desc_pool)
362 vk->DestroyDescriptorPool(s->hwctx->act_dev, sd->desc_pool,
363 s->hwctx->alloc);
364
365 av_freep(&sd->desc_sets);
366 }
367 pool->nb_reg_shd = 0;
368
369 for (int i = 0; i < pool->pool_size; i++) {
370 if (pool->cmd_buf_pools[i])
371 vk->FreeCommandBuffers(s->hwctx->act_dev, pool->cmd_buf_pools[i],
372 1, &pool->cmd_bufs[i]);
373
374 if (pool->cmd_buf_pools[i])
375 vk->DestroyCommandPool(s->hwctx->act_dev, pool->cmd_buf_pools[i], s->hwctx->alloc);
376 }
377 if (pool->query_pool)
378 vk->DestroyQueryPool(s->hwctx->act_dev, pool->query_pool, s->hwctx->alloc);
379
380 av_free(pool->query_data);
381 av_free(pool->cmd_buf_pools);
382 av_free(pool->cmd_bufs);
383 av_free(pool->contexts);
384 pool->pool_size = 0;
385}
386
387/* Per-family, per-library queue selection phases; each library links its own
388 * copy, and pools which benefit from spreading are created by the same one */
391
392static void exec_pool_phase_seed(void)
393{
394 uint32_t seed = av_get_random_seed();
395 for (int i = 0; i < FF_ARRAY_ELEMS(exec_pool_phase); i++)
397}
398
400 FFVkExecPool *pool, int nb_contexts,
401 int nb_queries, VkQueryType query_type, int query_64bit,
402 const void *query_create_pnext)
403{
404 int err;
405 VkResult ret;
406 FFVulkanFunctions *vk = &s->vkfn;
407
408 VkCommandPoolCreateInfo cqueue_create;
409 VkCommandBufferAllocateInfo cbuf_create;
410
411 const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *ef = NULL;
412
413 atomic_init(&pool->idx, 0);
414
415 if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
416 ef = ff_vk_find_struct(query_create_pnext,
417 VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR);
418 if (!ef)
419 return AVERROR(EINVAL);
420 }
421
422 /* Allocate space for command buffer pools */
423 pool->cmd_buf_pools = av_malloc(nb_contexts*sizeof(*pool->cmd_buf_pools));
424 if (!pool->cmd_buf_pools) {
425 err = AVERROR(ENOMEM);
426 goto fail;
427 }
428
429 /* Allocate space for command buffers */
430 pool->cmd_bufs = av_malloc(nb_contexts*sizeof(*pool->cmd_bufs));
431 if (!pool->cmd_bufs) {
432 err = AVERROR(ENOMEM);
433 goto fail;
434 }
435
436 for (int i = 0; i < nb_contexts; i++) {
437 /* Create command pool */
438 cqueue_create = (VkCommandPoolCreateInfo) {
439 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
440 .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT |
441 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
442 .queueFamilyIndex = qf->idx,
443 };
444
445 ret = vk->CreateCommandPool(s->hwctx->act_dev, &cqueue_create,
446 s->hwctx->alloc, &pool->cmd_buf_pools[i]);
447 if (ret != VK_SUCCESS) {
448 av_log(s, AV_LOG_ERROR, "Command pool creation failure: %s\n",
450 err = AVERROR_EXTERNAL;
451 goto fail;
452 }
453
454 /* Allocate command buffer */
455 cbuf_create = (VkCommandBufferAllocateInfo) {
456 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
457 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
458 .commandPool = pool->cmd_buf_pools[i],
459 .commandBufferCount = 1,
460 };
461 ret = vk->AllocateCommandBuffers(s->hwctx->act_dev, &cbuf_create,
462 &pool->cmd_bufs[i]);
463 if (ret != VK_SUCCESS) {
464 av_log(s, AV_LOG_ERROR, "Command buffer alloc failure: %s\n",
466 err = AVERROR_EXTERNAL;
467 goto fail;
468 }
469 }
470
471 /* Query pool */
472 if (nb_queries) {
473 VkQueryPoolCreateInfo query_pool_info = {
474 .sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
475 .pNext = query_create_pnext,
476 .queryType = query_type,
477 .queryCount = nb_queries*nb_contexts,
478 };
479 ret = vk->CreateQueryPool(s->hwctx->act_dev, &query_pool_info,
480 s->hwctx->alloc, &pool->query_pool);
481 if (ret != VK_SUCCESS) {
482 av_log(s, AV_LOG_ERROR, "Query pool alloc failure: %s\n",
484 err = AVERROR_EXTERNAL;
485 goto fail;
486 }
487
488 pool->nb_queries = nb_queries;
489 pool->query_status_stride = 1 + 1; /* One result, one status by default */
490 pool->query_results = nb_queries;
491 pool->query_statuses = nb_queries;
492
493 /* Video encode queries produce two results per query */
494 if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
495 int nb_results = av_popcount(ef->encodeFeedbackFlags);
496 pool->query_status_stride = nb_results + 1;
497 pool->query_results *= nb_results;
498 } else if (query_type == VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR) {
499 pool->query_status_stride = 1;
500 pool->query_results = 0;
501 }
502
503 pool->qd_size = (pool->query_results + pool->query_statuses)*(query_64bit ? 8 : 4);
504
505 /* Allocate space for the query data */
506 pool->query_data = av_calloc(nb_contexts, pool->qd_size);
507 if (!pool->query_data) {
508 err = AVERROR(ENOMEM);
509 goto fail;
510 }
511 }
512
513 /* Allocate space for the contexts */
514 pool->contexts = av_calloc(nb_contexts, sizeof(*pool->contexts));
515 if (!pool->contexts) {
516 err = AVERROR(ENOMEM);
517 goto fail;
518 }
519
520 pool->pool_size = nb_contexts;
521
522 for (int i = 0; i < pool->pool_size; i++)
524
525#ifdef VK_KHR_internally_synchronized_queues
526 /* Check if the extension and its flag are actually enabled */
527 int internal_queue_sync = 0;
528 if (s->extensions & FF_VK_EXT_INTERNAL_QUEUE_SYNC) {
529 const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *iqs;
530 iqs = ff_vk_find_struct(s->hwctx->device_features.pNext,
531 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR);
532 internal_queue_sync = iqs && iqs->internallySynchronizedQueues;
533 }
534#endif
535
536 /* Video pools are pinned to the phase-picked queue (sessions order their
537 * execution anyway); all other pools rotate starting from it, so pools
538 * advancing in lockstep do not collide. */
541 uint32_t phase = atomic_fetch_add(&exec_pool_phase[qf->idx], 1);
542 int pin_queue = qf->flags & (VK_QUEUE_VIDEO_DECODE_BIT_KHR |
543 VK_QUEUE_VIDEO_ENCODE_BIT_KHR);
544
545 /* Init contexts */
546 for (int i = 0; i < pool->pool_size; i++) {
547 FFVkExecContext *e = &pool->contexts[i];
548 VkSemaphoreTypeCreateInfo sem_type = {
549 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
550 .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
551 };
552 VkSemaphoreCreateInfo sem_create = {
553 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
554 .pNext = &sem_type,
555 };
556
557 /* Timeline semaphore carrying the busy state */
558 ret = vk->CreateSemaphore(s->hwctx->act_dev, &sem_create, s->hwctx->alloc,
559 &e->sem);
560 if (ret != VK_SUCCESS) {
561 av_log(s, AV_LOG_ERROR, "Failed to create submission semaphore: %s\n",
563 return AVERROR_EXTERNAL;
564 }
565
566 e->idx = i;
567 e->parent = pool;
568
569 /* Query data */
570 e->query_data = ((uint8_t *)pool->query_data) + pool->qd_size*i;
571 e->query_idx = nb_queries*i;
572
573 /* Command buffer */
574 e->buf = pool->cmd_bufs[i];
575
576 /* Queue index distribution */
577 e->qi = pin_queue ? phase % qf->num : (i + phase) % qf->num;
578 e->qf = qf->idx;
579 VkDeviceQueueInfo2 qinfo = {
580 .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
581#ifdef VK_KHR_internally_synchronized_queues
582 .flags = internal_queue_sync ?
583 VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR : 0,
584#endif
585 .queueFamilyIndex = qf->idx,
586 .queueIndex = e->qi,
587 };
588 if (!vk->GetDeviceQueue2) {
589 av_log(s, AV_LOG_ERROR, "vkGetDeviceQueue2 is unavailable on this device\n");
590 return AVERROR_EXTERNAL;
591 }
592 vk->GetDeviceQueue2(s->hwctx->act_dev, &qinfo, &e->queue);
593 }
594
595 return 0;
596
597fail:
598 ff_vk_exec_pool_free(s, pool);
599 return err;
600}
601
603 void **data, VkQueryResultFlagBits flags)
604{
605 FFVulkanFunctions *vk = &s->vkfn;
606 const FFVkExecPool *pool = e->parent;
607 VkQueryResultFlags qf = flags & ~(VK_QUERY_RESULT_64_BIT |
608 VK_QUERY_RESULT_WITH_STATUS_BIT_KHR);
609
610 if (!e->query_data) {
611 av_log(s, AV_LOG_ERROR, "Requested a query with a NULL query_data pointer!\n");
612 return VK_INCOMPLETE;
613 }
614
615 qf |= pool->query_64bit ?
616 VK_QUERY_RESULT_64_BIT : 0x0;
617 qf |= pool->query_statuses ?
618 VK_QUERY_RESULT_WITH_STATUS_BIT_KHR : 0x0;
619
620 if (data)
621 *data = e->query_data;
622
623 return vk->GetQueryPoolResults(s->hwctx->act_dev, pool->query_pool,
624 e->query_idx,
625 pool->nb_queries,
626 pool->qd_size, e->query_data,
627 pool->qd_size, qf);
628}
629
631{
632 FFVulkanFunctions *vk = &s->vkfn;
633
634 /* Release the dependencies of every completed context, rather than leaving them held until reuse */
635 for (int i = 0; i < pool->pool_size; i++) {
636 uint64_t sem_val;
637 FFVkExecContext *e = &pool->contexts[i];
639 continue; /* In use by a recording or submitting thread */
640 /* Busy contexts (counter below sem_value) are claimed or executing:
641 * their dependency lists are off-limits */
642 if (vk->GetSemaphoreCounterValue(s->hwctx->act_dev, e->sem, &sem_val) == VK_SUCCESS &&
643 sem_val >= e->sem_value &&
644 (e->nb_buf_deps || e->nb_refstruct_deps || e->nb_obj_deps ||
648 }
649
650 return &pool->contexts[atomic_fetch_add(&pool->idx, 1) % pool->pool_size];
651}
652
654{
655 FFVulkanFunctions *vk = &s->vkfn;
656 VkSemaphoreWaitInfo sem_wait_info = {
657 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
658 .semaphoreCount = 1,
659 .pSemaphores = &e->sem,
660 .pValues = &e->sem_value,
661 };
663 vk->WaitSemaphores(s->hwctx->act_dev, &sem_wait_info, UINT64_MAX);
666}
667
669{
670 VkResult ret;
671 FFVulkanFunctions *vk = &s->vkfn;
672 const FFVkExecPool *pool = e->parent;
673
674 VkCommandBufferBeginInfo cmd_start = {
675 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
676 .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
677 };
678 VkSemaphoreWaitInfo sem_wait_info = {
679 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
680 .semaphoreCount = 1,
681 .pSemaphores = &e->sem,
682 .pValues = &e->sem_value,
683 };
684
686
687 /* Wait out the context's previous execution */
688 vk->WaitSemaphores(s->hwctx->act_dev, &sem_wait_info, UINT64_MAX);
689
690 /* Discard queue dependencies */
692
693 ret = vk->BeginCommandBuffer(e->buf, &cmd_start);
694 if (ret != VK_SUCCESS) {
695 av_log(s, AV_LOG_ERROR, "Failed to start command recoding: %s\n",
698 return AVERROR_EXTERNAL;
699 }
700
701 if (pool->nb_queries)
702 vk->CmdResetQueryPool(e->buf, pool->query_pool,
703 e->query_idx, pool->nb_queries);
704
705 /* Claim: the semaphore stays below this value until submission completes
706 * or the recording is discarded, keeping every other user away */
707 e->sem_value++;
708 e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
709 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
710 .semaphore = e->sem,
711 .value = e->sem_value,
712 .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
713 };
714
716
717 return 0;
718}
719
721{
722 FFVulkanFunctions *vk = &s->vkfn;
723
724 for (int j = 0; j < e->nb_buf_deps; j++)
726 e->nb_buf_deps = 0;
727
728 for (int j = 0; j < e->nb_refstruct_deps; j++)
730 e->nb_refstruct_deps = 0;
731
732 for (int j = 0; j < e->nb_obj_deps; j++) {
733 FFVkExecObjDep *od = &e->obj_deps[j];
734 switch (od->type) {
735 case VK_OBJECT_TYPE_IMAGE_VIEW:
736 vk->DestroyImageView(s->hwctx->act_dev,
737 (VkImageView)od->obj, s->hwctx->alloc);
738 break;
739 case VK_OBJECT_TYPE_SEMAPHORE:
740 vk->DestroySemaphore(s->hwctx->act_dev,
741 (VkSemaphore)od->obj, s->hwctx->alloc);
742 break;
743 default:
744 av_assert1(0);
745 }
746 }
747 e->nb_obj_deps = 0;
748
749 for (int j = 0; j < e->nb_sw_frame_deps; j++)
751 e->nb_sw_frame_deps = 0;
752
753 for (int j = 0; j < e->nb_frame_deps; j++) {
754 AVFrame *f = e->frame_deps[j];
755 if (e->frame_locked[j]) {
756 AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
757 AVVulkanFramesContext *vkfc = hwfc->hwctx;
758 AVVkFrame *vkf = (AVVkFrame *)f->data[0];
759 vkfc->unlock_frame(hwfc, vkf);
760 e->frame_locked[j] = 0;
761 }
762 e->frame_update[j] = 0;
763 }
764 e->nb_frame_deps = 0;
765
766 e->sem_wait_cnt = 0;
767 e->sem_sig_cnt = 0;
768 e->sem_sig_val_dst_cnt = 0;
769}
770
772{
773 FFVulkanFunctions *vk = &s->vkfn;
774 VkSemaphoreSignalInfo sig_info = {
775 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,
776 .semaphore = e->sem,
777 .value = e->sem_value,
778 };
779
780 /* An abandoned recording is exclusively the claimer's: free everything
781 * without the mutex, and un-claim last by signalling the burnt generation */
783 vk->ResetCommandBuffer(e->buf, 0);
784 vk->SignalSemaphore(s->hwctx->act_dev, &sig_info);
785}
786
793
795 void *obj)
796{
797 void **ptr = obj;
798
800
801 for (int i = 0; i < e->nb_refstruct_deps; i++) {
802 if (e->refstruct_deps[i] == *ptr) {
804 return;
805 }
806 }
807
808 e->refstruct_deps[e->nb_refstruct_deps++] = *ptr;
809 *ptr = NULL;
810}
811
818
832
834 VkSemaphore sem, uint64_t val,
835 VkPipelineStageFlagBits2 stage)
836{
838
839 e->sem_wait[e->sem_wait_cnt++] = (VkSemaphoreSubmitInfo) {
840 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
841 .semaphore = sem,
842 .value = val,
843 .stageMask = stage,
844 };
845}
846
848 VkSemaphore sem, uint64_t val,
849 VkPipelineStageFlagBits2 stage)
850{
852
853 e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
854 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
855 .semaphore = sem,
856 .value = val,
857 .stageMask = stage,
858 };
859}
860
862 VkSemaphore *sem, int nb,
863 VkPipelineStageFlagBits2 stage,
864 int wait)
865{
866 /* Do not transfer ownership if we're signalling a binary semaphore,
867 * since we're probably exporting it. */
868 if (!wait) {
870 for (int i = 0; i < nb; i++) {
871 e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
872 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
873 .semaphore = sem[i],
874 .stageMask = stage,
875 };
876 }
877
878 return;
879 }
880
881 /* Ownership of each semaphore passes to the execution */
882 for (int i = 0; i < nb; i++) {
883 ff_vk_exec_add_dep_obj(s, e, VK_OBJECT_TYPE_SEMAPHORE,
884 (uint64_t)sem[i]);
885 ff_vk_exec_add_dep_wait_sem(s, e, sem[i], 0, stage);
886 }
887}
888
890 VkPipelineStageFlagBits2 wait_stage,
891 VkPipelineStageFlagBits2 signal_stage)
892{
893 AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
894 AVVulkanFramesContext *vkfc = hwfc->hwctx;
895 AVVkFrame *vkf = (AVVkFrame *)f->data[0];
896 int nb_images = ff_vk_count_images(vkf);
897
898 /* Don't add duplicates */
899 for (int i = 0; i < e->nb_frame_deps; i++)
900 if (e->frame_deps[i]->data[0] == f->data[0])
901 return 1;
902
905 av_assert1((e->sem_sig_cnt + nb_images) <= FF_VK_EXEC_MAX_SEM_OPS);
906
907 /* prepare_frame in hwcontext_vulkan.c uses the regular frame management
908 * code but has no frame yet, and it doesn't need to actually store a ref
909 * to the frame. */
910 if (f->buf[0]) {
912 e->buf_deps[e->nb_buf_deps] = av_buffer_ref(f->buf[0]);
913 if (!e->buf_deps[e->nb_buf_deps])
914 return AVERROR(ENOMEM);
915 e->nb_buf_deps++;
916 }
917
918 e->frame_deps[e->nb_frame_deps] = f;
919
920 vkfc->lock_frame(hwfc, vkf);
921 e->frame_locked[e->nb_frame_deps] = 1;
922 e->frame_update[e->nb_frame_deps] = 0;
923 e->nb_frame_deps++;
924
925 for (int i = 0; i < nb_images; i++) {
926 e->sem_wait[e->sem_wait_cnt++] = (VkSemaphoreSubmitInfo) {
927 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
928 .semaphore = vkf->sem[i],
929 .value = vkf->sem_value[i],
930 .stageMask = wait_stage,
931 };
932
933 e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
934 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
935 .semaphore = vkf->sem[i],
936 .value = vkf->sem_value[i] + 1,
937 .stageMask = signal_stage,
938 };
939
942 }
943
944 return 0;
945}
946
948 VkImageMemoryBarrier2 *bar, uint32_t *nb_img_bar)
949{
950 int i;
951 for (i = 0; i < e->nb_frame_deps; i++)
952 if (e->frame_deps[i]->data[0] == f->data[0])
953 break;
954 av_assert0(i < e->nb_frame_deps);
955
956 /* Don't update duplicates */
957 if (nb_img_bar && !e->frame_update[i])
958 (*nb_img_bar)++;
959
960 e->queue_family_dst[i] = bar->dstQueueFamilyIndex;
961 e->access_dst[i] = bar->dstAccessMask;
962 e->layout_dst[i] = bar->newLayout;
963 e->frame_update[i] = 1;
964}
965
967 VkSemaphore *dst, uint64_t *dst_val,
968 AVFrame *f)
969{
970 AVVkFrame *vkf = (AVVkFrame *)f->data[0];
971
972 /* Reject unknown frames */
973 int i;
974 for (i = 0; i < e->nb_frame_deps; i++)
975 if (e->frame_deps[i]->data[0] == f->data[0])
976 break;
977 if (i == e->nb_frame_deps)
978 return AVERROR(EINVAL);
979
981
982 *dst = vkf->sem[0];
983 *dst_val = vkf->sem_value[0];
984
985 e->sem_sig_val_dst[e->sem_sig_val_dst_cnt] = dst_val;
987
988 return 0;
989}
990
992{
993 VkResult ret;
994 FFVulkanFunctions *vk = &s->vkfn;
995 VkCommandBufferSubmitInfo cmd_buf_info = (VkCommandBufferSubmitInfo) {
996 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
997 .commandBuffer = e->buf,
998 };
999 VkSubmitInfo2 submit_info = (VkSubmitInfo2) {
1000 .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
1001 .pCommandBufferInfos = &cmd_buf_info,
1002 .commandBufferInfoCount = 1,
1003 .pWaitSemaphoreInfos = e->sem_wait,
1004 .waitSemaphoreInfoCount = e->sem_wait_cnt,
1005 .pSignalSemaphoreInfos = e->sem_sig,
1006 .signalSemaphoreInfoCount = e->sem_sig_cnt,
1007 };
1008
1009 ret = vk->EndCommandBuffer(e->buf);
1010 if (ret != VK_SUCCESS) {
1011 av_log(s, AV_LOG_ERROR, "Unable to finish command buffer: %s\n",
1014 return AVERROR_EXTERNAL;
1015 }
1016
1017#if FF_API_VULKAN_SYNC_QUEUES
1019 s->hwctx->lock_queue(s->device, e->qf, e->qi);
1021#endif
1022 ret = vk->QueueSubmit2(e->queue, 1, &submit_info, VK_NULL_HANDLE);
1023#if FF_API_VULKAN_SYNC_QUEUES
1025 s->hwctx->unlock_queue(s->device, e->qf, e->qi);
1027#endif
1028
1029 if (ret != VK_SUCCESS) {
1030 av_log(s, AV_LOG_ERROR, "Unable to submit command buffer: %s\n",
1032 /* This also un-claims the context by signalling its semaphore */
1034 return AVERROR_EXTERNAL;
1035 }
1036
1037 for (int i = 0; i < e->sem_sig_val_dst_cnt; i++)
1038 *e->sem_sig_val_dst[i] += 1;
1039
1040 /* Unlock all frames */
1041 for (int j = 0; j < e->nb_frame_deps; j++) {
1042 if (e->frame_locked[j]) {
1043 AVFrame *f = e->frame_deps[j];
1044 AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
1045 AVVulkanFramesContext *vkfc = hwfc->hwctx;
1046 AVVkFrame *vkf = (AVVkFrame *)f->data[0];
1047
1048 if (e->frame_update[j]) {
1049 int nb_images = ff_vk_count_images(vkf);
1050 for (int i = 0; i < nb_images; i++) {
1051 vkf->layout[i] = e->layout_dst[j];
1052 vkf->access[i] = e->access_dst[j];
1053 vkf->queue_family[i] = e->queue_family_dst[j];
1054 }
1055 }
1056 vkfc->unlock_frame(hwfc, vkf);
1057 e->frame_locked[j] = 0;
1058 }
1059 }
1060
1061 e->had_submission = 1;
1062
1063 return 0;
1064}
1065
1066int ff_vk_alloc_mem(FFVulkanContext *s, VkMemoryRequirements *req,
1067 VkMemoryPropertyFlagBits req_flags, void *alloc_extension,
1068 VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
1069{
1070 VkResult ret;
1071 int index = -1;
1072 FFVulkanFunctions *vk = &s->vkfn;
1073
1074 VkMemoryAllocateInfo alloc_info = {
1075 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
1076 .pNext = alloc_extension,
1077 };
1078
1079 alloc_info.allocationSize = req->size;
1080
1081 /* The vulkan spec requires memory types to be sorted in the "optimal"
1082 * order, so the first matching type we find will be the best/fastest one */
1083 for (int i = 0; i < s->mprops.memoryTypeCount; i++) {
1084 /* The memory type must be supported by the requirements (bitfield) */
1085 if (!(req->memoryTypeBits & (1 << i)))
1086 continue;
1087
1088 /* The memory type flags must include our properties */
1089 if ((req_flags != UINT32_MAX) &&
1090 ((s->mprops.memoryTypes[i].propertyFlags & req_flags) != req_flags))
1091 continue;
1092
1093 /* Found a suitable memory type */
1094 index = i;
1095 break;
1096 }
1097
1098 if (index < 0) {
1099 av_log(s, AV_LOG_ERROR, "No memory type found for flags 0x%x\n",
1100 req_flags);
1101 return AVERROR(EINVAL);
1102 }
1103
1104 alloc_info.memoryTypeIndex = index;
1105
1106 ret = vk->AllocateMemory(s->hwctx->act_dev, &alloc_info,
1107 s->hwctx->alloc, mem);
1108 if (ret != VK_SUCCESS)
1109 return AVERROR(ENOMEM);
1110
1111 if (mem_flags)
1112 *mem_flags |= s->mprops.memoryTypes[index].propertyFlags;
1113
1114 return 0;
1115}
1116
1117int ff_vk_image_create(FFVulkanContext *s, VkImage *img, VkDeviceMemory *mem,
1118 int width, int height, VkFormat format, int nb_layers,
1119 VkImageTiling tiling, VkImageUsageFlags usage,
1120 VkImageCreateFlags flags, void *create_pnext)
1121{
1122 int err;
1123 VkResult ret;
1124 FFVulkanFunctions *vk = &s->vkfn;
1125 VkMemoryPropertyFlagBits mem_flags;
1126
1127 VkImageCreateInfo create_info = {
1128 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1129 .pNext = create_pnext,
1130 .flags = flags,
1131 .imageType = VK_IMAGE_TYPE_2D,
1132 .format = format,
1133 .extent = { width, height, 1 },
1134 .mipLevels = 1,
1135 .arrayLayers = nb_layers,
1136 .tiling = tiling,
1137 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
1138 .usage = usage,
1139 .samples = VK_SAMPLE_COUNT_1_BIT,
1140 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
1141 };
1142 VkMemoryDedicatedAllocateInfo ded_alloc = {
1143 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
1144 };
1145 VkMemoryRequirements2 req = {
1146 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
1147 };
1148 VkImageMemoryRequirementsInfo2 req_desc = {
1149 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
1150 };
1151 VkBindImageMemoryInfo bind_info = {
1152 .sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
1153 };
1154
1155 *img = VK_NULL_HANDLE;
1156 *mem = VK_NULL_HANDLE;
1157
1158 ret = vk->CreateImage(s->hwctx->act_dev, &create_info,
1159 s->hwctx->alloc, img);
1160 if (ret != VK_SUCCESS) {
1161 av_log(s, AV_LOG_ERROR, "Image creation failure: %s\n",
1163 return AVERROR_EXTERNAL;
1164 }
1165
1166 req_desc.image = *img;
1167 vk->GetImageMemoryRequirements2(s->hwctx->act_dev, &req_desc, &req);
1168
1169 /* Never shared with another image, so always dedicated */
1170 ded_alloc.image = *img;
1171 err = ff_vk_alloc_mem(s, &req.memoryRequirements,
1172 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
1173 &ded_alloc, &mem_flags, mem);
1174 if (err < 0)
1175 goto fail;
1176
1177 bind_info.image = *img;
1178 bind_info.memory = *mem;
1179 ret = vk->BindImageMemory2(s->hwctx->act_dev, 1, &bind_info);
1180 if (ret != VK_SUCCESS) {
1181 av_log(s, AV_LOG_ERROR, "Failed to bind image memory: %s\n",
1183 err = AVERROR_EXTERNAL;
1184 goto fail;
1185 }
1186
1187 return 0;
1188
1189fail:
1190 ff_vk_image_free(s, img, mem);
1191 return err;
1192}
1193
1194void ff_vk_image_free(FFVulkanContext *s, VkImage *img, VkDeviceMemory *mem)
1195{
1196 FFVulkanFunctions *vk = &s->vkfn;
1197
1198 if (*img) {
1199 vk->DestroyImage(s->hwctx->act_dev, *img, s->hwctx->alloc);
1200 *img = VK_NULL_HANDLE;
1201 }
1202 if (*mem) {
1203 vk->FreeMemory(s->hwctx->act_dev, *mem, s->hwctx->alloc);
1204 *mem = VK_NULL_HANDLE;
1205 }
1206}
1207
1209 void *pNext, void *alloc_pNext,
1210 VkBufferUsageFlags usage, VkMemoryPropertyFlagBits flags)
1211{
1212 int err;
1213 VkResult ret;
1214 int use_ded_mem;
1215 FFVulkanFunctions *vk = &s->vkfn;
1216
1217 VkBufferCreateInfo buf_spawn = {
1218 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1219 .pNext = pNext,
1220 .usage = usage,
1221 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
1222 .size = flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ?
1223 FFALIGN(size, s->props.properties.limits.minMemoryMapAlignment) :
1224 size,
1225 };
1226
1227 VkMemoryAllocateFlagsInfo alloc_flags = {
1228 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
1229 .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
1230 };
1231 VkBufferMemoryRequirementsInfo2 req_desc = {
1232 .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
1233 };
1234 VkMemoryDedicatedAllocateInfo ded_alloc = {
1235 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
1236 .pNext = alloc_pNext,
1237 };
1238 VkMemoryDedicatedRequirements ded_req = {
1239 .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
1240 };
1241 VkMemoryRequirements2 req = {
1242 .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
1243 .pNext = &ded_req,
1244 };
1245
1246 av_log(s, AV_LOG_DEBUG, "Creating a buffer of %zu bytes, "
1247 "usage: 0x%x, flags: 0x%x\n",
1248 size, usage, flags);
1249
1250 ret = vk->CreateBuffer(s->hwctx->act_dev, &buf_spawn, s->hwctx->alloc, &buf->buf);
1251 if (ret != VK_SUCCESS) {
1252 av_log(s, AV_LOG_ERROR, "Failed to create buffer: %s\n",
1254 return AVERROR_EXTERNAL;
1255 }
1256
1257 req_desc.buffer = buf->buf;
1258
1259 vk->GetBufferMemoryRequirements2(s->hwctx->act_dev, &req_desc, &req);
1260
1261 /* In case the implementation prefers/requires dedicated allocation */
1262 use_ded_mem = ded_req.prefersDedicatedAllocation |
1263 ded_req.requiresDedicatedAllocation;
1264 if (use_ded_mem) {
1265 ded_alloc.buffer = buf->buf;
1266 ded_alloc.pNext = alloc_pNext;
1267 alloc_pNext = &ded_alloc;
1268 }
1269
1270 if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1271 alloc_flags.pNext = alloc_pNext;
1272 alloc_pNext = &alloc_flags;
1273 }
1274
1275 err = ff_vk_alloc_mem(s, &req.memoryRequirements, flags, alloc_pNext,
1276 &buf->flags, &buf->mem);
1277 if (err)
1278 return err;
1279
1280 ret = vk->BindBufferMemory(s->hwctx->act_dev, buf->buf, buf->mem, 0);
1281 if (ret != VK_SUCCESS) {
1282 av_log(s, AV_LOG_ERROR, "Failed to bind memory to buffer: %s\n",
1284 return AVERROR_EXTERNAL;
1285 }
1286
1287 if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1288 VkBufferDeviceAddressInfo address_info = {
1289 .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
1290 .buffer = buf->buf,
1291 };
1292 buf->address = vk->GetBufferDeviceAddress(s->hwctx->act_dev, &address_info);
1293 }
1294
1295 buf->size = size;
1296
1297 return 0;
1298}
1299
1300int ff_vk_map_buffers(FFVulkanContext *s, FFVkBuffer **buf, uint8_t *mem[],
1301 int nb_buffers, int invalidate)
1302{
1303 VkResult ret;
1304 FFVulkanFunctions *vk = &s->vkfn;
1305 VkMappedMemoryRange inval_list[64];
1306 int inval_count = 0;
1307
1308 for (int i = 0; i < nb_buffers; i++) {
1309 void *dst;
1310 ret = vk->MapMemory(s->hwctx->act_dev, buf[i]->mem, 0,
1311 VK_WHOLE_SIZE, 0, &dst);
1312 if (ret != VK_SUCCESS) {
1313 av_log(s, AV_LOG_ERROR, "Failed to map buffer memory: %s\n",
1315 return AVERROR_EXTERNAL;
1316 }
1317 buf[i]->mapped_mem = dst;
1318 if (mem)
1319 mem[i] = dst;
1320 }
1321
1322 if (!invalidate)
1323 return 0;
1324
1325 for (int i = 0; i < nb_buffers; i++) {
1326 const VkMappedMemoryRange ival_buf = {
1327 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1328 .memory = buf[i]->mem,
1329 .size = VK_WHOLE_SIZE,
1330 };
1331 if (buf[i]->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
1332 continue;
1333 inval_list[inval_count++] = ival_buf;
1334 }
1335
1336 if (inval_count) {
1337 ret = vk->InvalidateMappedMemoryRanges(s->hwctx->act_dev, inval_count,
1338 inval_list);
1339 if (ret != VK_SUCCESS) {
1340 av_log(s, AV_LOG_ERROR, "Failed to invalidate memory: %s\n",
1342 return AVERROR_EXTERNAL;
1343 }
1344 }
1345
1346 return 0;
1347}
1348
1350 VkDeviceSize offset, VkDeviceSize mem_size,
1351 int flush)
1352{
1353 VkResult ret;
1354 FFVulkanFunctions *vk = &s->vkfn;
1355
1356 if (buf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
1357 return 0;
1358
1359 const VkMappedMemoryRange flush_data = {
1360 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1361 .memory = buf->mem,
1362 .offset = offset,
1363 .size = mem_size,
1364 };
1365
1366 if (flush)
1367 ret = vk->FlushMappedMemoryRanges(s->hwctx->act_dev, 1, &flush_data);
1368 else
1369 ret = vk->InvalidateMappedMemoryRanges(s->hwctx->act_dev, 1, &flush_data);
1370
1371 if (ret != VK_SUCCESS) {
1372 av_log(s, AV_LOG_ERROR, "Failed to flush memory: %s\n",
1374 return AVERROR_EXTERNAL;
1375 }
1376
1377 return 0;
1378}
1379
1381 int flush)
1382{
1383 int err = 0;
1384 VkResult ret;
1385 FFVulkanFunctions *vk = &s->vkfn;
1386 VkMappedMemoryRange flush_list[64];
1387 int flush_count = 0;
1388
1389 if (flush) {
1390 for (int i = 0; i < nb_buffers; i++) {
1391 const VkMappedMemoryRange flush_buf = {
1392 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1393 .memory = buf[i]->mem,
1394 .size = VK_WHOLE_SIZE,
1395 };
1396
1397 av_assert0(!buf[i]->host_ref);
1398 if (buf[i]->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
1399 continue;
1400 flush_list[flush_count++] = flush_buf;
1401 }
1402 }
1403
1404 if (flush_count) {
1405 ret = vk->FlushMappedMemoryRanges(s->hwctx->act_dev, flush_count,
1406 flush_list);
1407 if (ret != VK_SUCCESS) {
1408 av_log(s, AV_LOG_ERROR, "Failed to flush memory: %s\n",
1410 err = AVERROR_EXTERNAL; /* We still want to try to unmap them */
1411 }
1412 }
1413
1414 for (int i = 0; i < nb_buffers; i++) {
1415 vk->UnmapMemory(s->hwctx->act_dev, buf[i]->mem);
1416 buf[i]->mapped_mem = NULL;
1417 }
1418
1419 return err;
1420}
1421
1423{
1424 FFVulkanFunctions *vk = &s->vkfn;
1425
1426 if (!buf || !s->hwctx)
1427 return;
1428
1429 if (buf->mapped_mem && !buf->host_ref)
1430 ff_vk_unmap_buffer(s, buf, 0);
1431 if (buf->buf != VK_NULL_HANDLE)
1432 vk->DestroyBuffer(s->hwctx->act_dev, buf->buf, s->hwctx->alloc);
1433 if (buf->mem != VK_NULL_HANDLE)
1434 vk->FreeMemory(s->hwctx->act_dev, buf->mem, s->hwctx->alloc);
1435 if (buf->host_ref)
1437
1438 buf->buf = VK_NULL_HANDLE;
1439 buf->mem = VK_NULL_HANDLE;
1440 buf->mapped_mem = NULL;
1441}
1442
1443static void pooled_buf_free(AVRefStructOpaque opaque, void *obj)
1444{
1445 ff_vk_free_buf(opaque.nc, obj);
1446}
1447
1449 FFVkBuffer **buf, VkBufferUsageFlags usage,
1450 void *create_pNext, size_t size,
1451 VkMemoryPropertyFlagBits mem_props)
1452{
1453 int err;
1455
1456 if (!(*buf_pool)) {
1457 *buf_pool = av_refstruct_pool_alloc_ext(sizeof(FFVkBuffer), 0, ctx,
1459 NULL);
1460 if (!(*buf_pool))
1461 return AVERROR(ENOMEM);
1462 }
1463
1464 *buf = data = av_refstruct_pool_get(*buf_pool);
1465 if (!data)
1466 return AVERROR(ENOMEM);
1467
1468 if (data->size >= size)
1469 return 0;
1470
1472 memset(data, 0, sizeof(*data));
1473
1474 err = ff_vk_create_buf(ctx, data, size,
1475 create_pNext, NULL, usage,
1476 mem_props);
1477 if (err < 0) {
1478 av_refstruct_unref(buf);
1479 return err;
1480 }
1481
1482 if (mem_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
1483 err = ff_vk_map_buffer(ctx, data, &data->mapped_mem, 0);
1484 if (err < 0) {
1485 av_refstruct_unref(buf);
1486 return err;
1487 }
1488 }
1489
1490 return 0;
1491}
1492
1494 FFVkBuffer *vkb, VkBufferUsageFlags usage,
1495 size_t size,
1496 VkExternalMemoryBufferCreateInfo *create_desc,
1497 VkImportMemoryHostPointerInfoEXT *import_desc,
1498 VkMemoryHostPointerPropertiesEXT props)
1499{
1500 int err;
1501 VkResult ret;
1502 FFVulkanFunctions *vk = &s->vkfn;
1503
1504 VkBufferCreateInfo buf_spawn = {
1505 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1506 .pNext = create_desc,
1507 .usage = usage,
1508 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
1509 .size = size,
1510 };
1511 VkMemoryRequirements req = {
1512 .size = size,
1513 .alignment = s->hprops.minImportedHostPointerAlignment,
1514 .memoryTypeBits = props.memoryTypeBits,
1515 };
1516
1517 err = ff_vk_alloc_mem(s, &req,
1518 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
1519 import_desc, &vkb->flags, &vkb->mem);
1520 if (err < 0)
1521 return err;
1522
1523 ret = vk->CreateBuffer(s->hwctx->act_dev, &buf_spawn, s->hwctx->alloc, &vkb->buf);
1524 if (ret != VK_SUCCESS) {
1525 vk->FreeMemory(s->hwctx->act_dev, vkb->mem, s->hwctx->alloc);
1526 return AVERROR_EXTERNAL;
1527 }
1528
1529 ret = vk->BindBufferMemory(s->hwctx->act_dev, vkb->buf, vkb->mem, 0);
1530 if (ret != VK_SUCCESS) {
1531 vk->FreeMemory(s->hwctx->act_dev, vkb->mem, s->hwctx->alloc);
1532 vk->DestroyBuffer(s->hwctx->act_dev, vkb->buf, s->hwctx->alloc);
1533 return AVERROR_EXTERNAL;
1534 }
1535
1536 return 0;
1537}
1538
1539static void host_map_free(AVRefStructOpaque opaque, void *obj)
1540{
1541 ff_vk_free_buf(opaque.nc, obj);
1542}
1543
1545 uint8_t *src_data, VkDeviceSize size,
1546 const AVBufferRef *src_buf,
1547 VkBufferUsageFlags usage)
1548{
1549 int err;
1550 VkResult ret;
1551 FFVulkanFunctions *vk = &s->vkfn;
1552
1553 VkExternalMemoryBufferCreateInfo create_desc = {
1554 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
1555 .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
1556 };
1557 VkMemoryAllocateFlagsInfo alloc_flags = {
1558 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
1559 .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
1560 };
1561 VkImportMemoryHostPointerInfoEXT import_desc = {
1562 .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
1563 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
1564 .pNext = usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT ? &alloc_flags : NULL,
1565 };
1566 VkMemoryHostPointerPropertiesEXT props;
1567
1569 FFVkBuffer *vkb;
1570 size_t offs;
1571 size_t buffer_size;
1572
1573 *dst = NULL;
1574
1575 /* Get the previous point at which mapping was possible and use it */
1576 offs = (uintptr_t)src_data % s->hprops.minImportedHostPointerAlignment;
1577 import_desc.pHostPointer = src_data - offs;
1578
1579 props = (VkMemoryHostPointerPropertiesEXT) {
1580 VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
1581 };
1582 ret = vk->GetMemoryHostPointerPropertiesEXT(s->hwctx->act_dev,
1583 import_desc.handleType,
1584 import_desc.pHostPointer,
1585 &props);
1586 if (!(ret == VK_SUCCESS && props.memoryTypeBits))
1587 return AVERROR(EINVAL);
1588
1589 /* Ref the source buffer */
1590 ref = av_buffer_ref(src_buf);
1591 if (!ref)
1592 return AVERROR(ENOMEM);
1593
1594 /* Add the offset at the start, which gets ignored. */
1595 const VkDeviceSize src_avail = src_buf->size - (src_data - src_buf->data);
1596 buffer_size = offs + FFMIN(size, src_avail);
1597 buffer_size = FFALIGN(buffer_size, s->props.properties.limits.minMemoryMapAlignment);
1598 buffer_size = FFALIGN(buffer_size, s->hprops.minImportedHostPointerAlignment);
1599
1600 /* Create a buffer struct */
1601 vkb = av_refstruct_alloc_ext(sizeof(*vkb), 0, s, host_map_free);
1602 if (!vkb) {
1604 return AVERROR(ENOMEM);
1605 }
1606
1607 err = create_mapped_buffer(s, vkb, usage,
1608 buffer_size, &create_desc, &import_desc,
1609 props);
1610 if (err < 0) {
1612 av_refstruct_unref(&vkb);
1613 return err;
1614 }
1615
1616 if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1617 VkBufferDeviceAddressInfo address_info = {
1618 .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
1619 .buffer = vkb->buf,
1620 };
1621 vkb->address = vk->GetBufferDeviceAddress(s->hwctx->act_dev, &address_info);
1622 }
1623
1624 vkb->host_ref = ref;
1625 vkb->virtual_offset = offs;
1626 vkb->address += offs;
1627 vkb->mapped_mem = src_data;
1628 vkb->size = buffer_size - offs;
1629
1630 *dst = vkb;
1631
1632 return 0;
1633}
1634
1636 VkShaderStageFlagBits stage)
1637{
1638 VkPushConstantRange *pc = &shd->push_consts[shd->push_consts_num++];
1640 pc->stageFlags = stage;
1641 pc->offset = offset;
1642 pc->size = size;
1643 return 0;
1644}
1645
1646int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler,
1647 int unnorm_coords, VkFilter filt)
1648{
1649 VkResult ret;
1650 FFVulkanFunctions *vk = &s->vkfn;
1651
1652 VkSamplerCreateInfo sampler_info = {
1653 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
1654 .magFilter = filt,
1655 .minFilter = sampler_info.magFilter,
1656 .mipmapMode = (unnorm_coords || filt == VK_FILTER_NEAREST) ?
1657 VK_SAMPLER_MIPMAP_MODE_NEAREST :
1658 VK_SAMPLER_MIPMAP_MODE_LINEAR,
1659 .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1660 .addressModeV = sampler_info.addressModeU,
1661 .addressModeW = sampler_info.addressModeU,
1662 .anisotropyEnable = VK_FALSE,
1663 .compareOp = VK_COMPARE_OP_NEVER,
1664 .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
1665 .unnormalizedCoordinates = unnorm_coords,
1666 };
1667
1668 ret = vk->CreateSampler(s->hwctx->act_dev, &sampler_info,
1669 s->hwctx->alloc, sampler);
1670 if (ret != VK_SUCCESS) {
1671 av_log(s, AV_LOG_ERROR, "Unable to init sampler: %s\n",
1673 return AVERROR_EXTERNAL;
1674 }
1675
1676 return 0;
1677}
1678
1679VkImageAspectFlags ff_vk_aspect_flag(AVFrame *f, int p)
1680{
1681 AVVkFrame *vkf = (AVVkFrame *)f->data[0];
1682 AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
1683 int nb_images = ff_vk_count_images(vkf);
1684 int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
1685
1686 static const VkImageAspectFlags plane_aspect[] = { VK_IMAGE_ASPECT_PLANE_0_BIT,
1687 VK_IMAGE_ASPECT_PLANE_1_BIT,
1688 VK_IMAGE_ASPECT_PLANE_2_BIT, };
1689
1690 if (ff_vk_mt_is_np_rgb(hwfc->sw_format) || (nb_planes == nb_images))
1691 return VK_IMAGE_ASPECT_COLOR_BIT;
1692
1693 return plane_aspect[p];
1694}
1695
1719
1720void ff_vk_set_perm(enum AVPixelFormat pix_fmt, int lut[4], int inv)
1721{
1722 switch (pix_fmt) {
1723 case AV_PIX_FMT_GBRP:
1724 case AV_PIX_FMT_GBRAP:
1725 case AV_PIX_FMT_GBRAP10:
1726 case AV_PIX_FMT_GBRAP12:
1727 case AV_PIX_FMT_GBRAP14:
1728 case AV_PIX_FMT_GBRAP16:
1730 case AV_PIX_FMT_GBRP10:
1731 case AV_PIX_FMT_GBRP12:
1732 case AV_PIX_FMT_GBRP14:
1733 case AV_PIX_FMT_GBRP16:
1734 case AV_PIX_FMT_GBRPF16:
1735 case AV_PIX_FMT_GBRPF32:
1736 case AV_PIX_FMT_GBRAP32:
1738 lut[0] = 1;
1739 lut[1] = 2;
1740 lut[2] = 0;
1741 lut[3] = 3;
1742 break;
1743 case AV_PIX_FMT_X2BGR10:
1744 lut[0] = 0;
1745 lut[1] = 2;
1746 lut[2] = 1;
1747 lut[3] = 3;
1748 break;
1749 case AV_PIX_FMT_BGRA:
1750 case AV_PIX_FMT_BGR0:
1751 /* Stored in RGBA images, so reverse them */
1752 lut[0] = 2;
1753 lut[1] = 1;
1754 lut[2] = 0;
1755 lut[3] = 3;
1756 break;
1757 default:
1758 lut[0] = 0;
1759 lut[1] = 1;
1760 lut[2] = 2;
1761 lut[3] = 3;
1762 break;
1763 }
1764
1765 if (inv) {
1766 int lut_tmp[4] = { lut[0], lut[1], lut[2], lut[3] };
1767 for (int i = 0; i < 4; i++)
1768 lut[lut_tmp[i]] = i;
1769 }
1770
1771 return;
1772}
1773
1775 enum FFVkShaderRepFormat rep_fmt)
1776{
1777 switch (pix_fmt) {
1778 case AV_PIX_FMT_RGBA:
1779 case AV_PIX_FMT_BGRA:
1780 case AV_PIX_FMT_RGB24:
1781 case AV_PIX_FMT_BGR24:
1782 case AV_PIX_FMT_BGR0:
1783 case AV_PIX_FMT_RGB0:
1784 case AV_PIX_FMT_RGB565:
1785 case AV_PIX_FMT_BGR565:
1786 case AV_PIX_FMT_UYVA:
1787 case AV_PIX_FMT_YUYV422:
1788 case AV_PIX_FMT_UYVY422: {
1789 const char *rep_tab[] = {
1790 [FF_VK_REP_NATIVE] = "rgba8ui",
1791 [FF_VK_REP_FLOAT] = "rgba8",
1792 [FF_VK_REP_INT] = "rgba8i",
1793 [FF_VK_REP_UINT] = "rgba8ui",
1794 };
1795 return rep_tab[rep_fmt];
1796 }
1797 case AV_PIX_FMT_X2RGB10:
1798 case AV_PIX_FMT_X2BGR10:
1799 case AV_PIX_FMT_Y210:
1800 case AV_PIX_FMT_XV30: {
1801 const char *rep_tab[] = {
1802 [FF_VK_REP_NATIVE] = "rgb10_a2ui",
1803 [FF_VK_REP_FLOAT] = "rgb10_a2",
1804 [FF_VK_REP_INT] = NULL,
1805 [FF_VK_REP_UINT] = "rgb10_a2ui",
1806 };
1807 return rep_tab[rep_fmt];
1808 }
1809 case AV_PIX_FMT_RGB48:
1810 case AV_PIX_FMT_RGBA64:
1811 case AV_PIX_FMT_Y212:
1812 case AV_PIX_FMT_Y216:
1813 case AV_PIX_FMT_XV36:
1814 case AV_PIX_FMT_XV48: {
1815 const char *rep_tab[] = {
1816 [FF_VK_REP_NATIVE] = "rgba16ui",
1817 [FF_VK_REP_FLOAT] = "rgba16",
1818 [FF_VK_REP_INT] = "rgba16i",
1819 [FF_VK_REP_UINT] = "rgba16ui",
1820 };
1821 return rep_tab[rep_fmt];
1822 }
1823 case AV_PIX_FMT_RGBAF16: {
1824 const char *rep_tab[] = {
1825 [FF_VK_REP_NATIVE] = "rgba16f",
1826 [FF_VK_REP_FLOAT] = "rgba16f",
1827 [FF_VK_REP_INT] = "rgba32i",
1828 [FF_VK_REP_UINT] = "rgba16u",
1829 };
1830 return rep_tab[rep_fmt];
1831 }
1832 case AV_PIX_FMT_RGBF32:
1833 case AV_PIX_FMT_RGBAF32: {
1834 const char *rep_tab[] = {
1835 [FF_VK_REP_NATIVE] = "rgba32f",
1836 [FF_VK_REP_FLOAT] = "rgba32f",
1837 [FF_VK_REP_INT] = "rgba32i",
1838 [FF_VK_REP_UINT] = "rgba32ui",
1839 };
1840 return rep_tab[rep_fmt];
1841 }
1842 case AV_PIX_FMT_RGB96:
1843 case AV_PIX_FMT_RGBA128: {
1844 const char *rep_tab[] = {
1845 [FF_VK_REP_NATIVE] = "rgba32ui",
1847 [FF_VK_REP_INT] = "rgba32i",
1848 [FF_VK_REP_UINT] = "rgba32ui",
1849 };
1850 return rep_tab[rep_fmt];
1851 }
1852 case AV_PIX_FMT_GBRP:
1853 case AV_PIX_FMT_GRAY8:
1854 case AV_PIX_FMT_GBRAP:
1855 case AV_PIX_FMT_YUV420P:
1856 case AV_PIX_FMT_YUV422P:
1857 case AV_PIX_FMT_YUV444P:
1860 case AV_PIX_FMT_YUVA444P: {
1861 const char *rep_tab[] = {
1862 [FF_VK_REP_NATIVE] = "r8ui",
1863 [FF_VK_REP_FLOAT] = "r8",
1864 [FF_VK_REP_INT] = "r8i",
1865 [FF_VK_REP_UINT] = "r8ui",
1866 };
1867 return rep_tab[rep_fmt];
1868 };
1869 case AV_PIX_FMT_GRAY10:
1870 case AV_PIX_FMT_GRAY12:
1871 case AV_PIX_FMT_GRAY14:
1872 case AV_PIX_FMT_GRAY16:
1873 case AV_PIX_FMT_GBRAP10:
1874 case AV_PIX_FMT_GBRAP12:
1875 case AV_PIX_FMT_GBRAP14:
1876 case AV_PIX_FMT_GBRAP16:
1878 case AV_PIX_FMT_GBRP10:
1879 case AV_PIX_FMT_GBRP12:
1880 case AV_PIX_FMT_GBRP14:
1881 case AV_PIX_FMT_GBRP16:
1882 case AV_PIX_FMT_GBRPF16:
1883 case AV_PIX_FMT_XYZP12:
1902 const char *rep_tab[] = {
1903 [FF_VK_REP_NATIVE] = "r16ui",
1904 [FF_VK_REP_FLOAT] = "r16f",
1905 [FF_VK_REP_INT] = "r16i",
1906 [FF_VK_REP_UINT] = "r16ui",
1907 };
1908 return rep_tab[rep_fmt];
1909 };
1910 case AV_PIX_FMT_GRAY32:
1911 case AV_PIX_FMT_GRAYF32:
1912 case AV_PIX_FMT_GBRPF32:
1913 case AV_PIX_FMT_GBRAPF32: {
1914 const char *rep_tab[] = {
1915 [FF_VK_REP_NATIVE] = "r32f",
1916 [FF_VK_REP_FLOAT] = "r32f",
1917 [FF_VK_REP_INT] = "r32i",
1918 [FF_VK_REP_UINT] = "r32ui",
1919 };
1920 return rep_tab[rep_fmt];
1921 };
1922 case AV_PIX_FMT_GBRAP32: {
1923 const char *rep_tab[] = {
1924 [FF_VK_REP_NATIVE] = "r32ui",
1926 [FF_VK_REP_INT] = "r32i",
1927 [FF_VK_REP_UINT] = "r32ui",
1928 };
1929 return rep_tab[rep_fmt];
1930 };
1931 case AV_PIX_FMT_NV12:
1932 case AV_PIX_FMT_NV16:
1933 case AV_PIX_FMT_NV24: {
1934 const char *rep_tab[] = {
1935 [FF_VK_REP_NATIVE] = "rg8ui",
1936 [FF_VK_REP_FLOAT] = "rg8",
1937 [FF_VK_REP_INT] = "rg8i",
1938 [FF_VK_REP_UINT] = "rg8ui",
1939 };
1940 return rep_tab[rep_fmt];
1941 };
1942 case AV_PIX_FMT_P010:
1943 case AV_PIX_FMT_P210:
1944 case AV_PIX_FMT_P410: {
1945 const char *rep_tab[] = {
1946 [FF_VK_REP_NATIVE] = "rgb10_a2ui",
1947 [FF_VK_REP_FLOAT] = "rgb10_a2",
1948 [FF_VK_REP_INT] = NULL,
1949 [FF_VK_REP_UINT] = "rgb10_a2ui",
1950 };
1951 return rep_tab[rep_fmt];
1952 };
1953 case AV_PIX_FMT_P012:
1954 case AV_PIX_FMT_P016:
1955 case AV_PIX_FMT_P212:
1956 case AV_PIX_FMT_P216:
1957 case AV_PIX_FMT_P412:
1958 case AV_PIX_FMT_P416: {
1959 const char *rep_tab[] = {
1960 [FF_VK_REP_NATIVE] = "rg16ui",
1961 [FF_VK_REP_FLOAT] = "rg16",
1962 [FF_VK_REP_INT] = "rg16i",
1963 [FF_VK_REP_UINT] = "rg16ui",
1964 };
1965 return rep_tab[rep_fmt];
1966 };
1967 default:
1968 return "rgba32f";
1969 }
1970}
1971
1972static void reset_imageviews(AVRefStructOpaque unused, void *obj)
1973{
1974 FFVkImageViews *iv = obj;
1975
1976 for (int i = 0; i < iv->nb_views; i++) {
1977 if (iv->views[i])
1978 iv->destroy_image_view(iv->dev, iv->views[i], iv->alloc);
1979 }
1980
1981 memset(iv->views, 0, sizeof(iv->views));
1982}
1983
1985{
1986 FFVulkanFunctions *vk = &s->vkfn;
1987 FFVkImageViews *iv;
1988
1989 av_assert1(nb_views <= AV_NUM_DATA_POINTERS);
1990
1991 iv = av_refstruct_pool_get(s->imageviews_pool);
1992 if (!iv)
1993 return NULL;
1994
1995 iv->nb_views = nb_views;
1996 iv->dev = s->hwctx->act_dev;
1997 iv->alloc = s->hwctx->alloc;
1998 iv->destroy_image_view = vk->DestroyImageView;
1999
2000 return iv;
2001}
2002
2004{
2005#define REPS_FMT(fmt) \
2006 [FF_VK_REP_NATIVE] = fmt ## _UINT, \
2007 [FF_VK_REP_FLOAT] = fmt ## _UNORM, \
2008 [FF_VK_REP_INT] = fmt ## _SINT, \
2009 [FF_VK_REP_UINT] = fmt ## _UINT,
2010
2011#define REPS_FMT_PACK(fmt, num) \
2012 [FF_VK_REP_NATIVE] = fmt ## _UINT_PACK ## num, \
2013 [FF_VK_REP_FLOAT] = fmt ## _UNORM_PACK ## num, \
2014 [FF_VK_REP_INT] = fmt ## _SINT_PACK ## num, \
2015 [FF_VK_REP_UINT] = fmt ## _UINT_PACK ## num,
2016
2017 const VkFormat fmts_map[][4] = {
2018 { REPS_FMT_PACK(VK_FORMAT_A2B10G10R10, 32) },
2019 { REPS_FMT_PACK(VK_FORMAT_A2R10G10B10, 32) },
2020 {
2021 VK_FORMAT_B5G6R5_UNORM_PACK16,
2022 VK_FORMAT_B5G6R5_UNORM_PACK16,
2023 VK_FORMAT_UNDEFINED,
2024 VK_FORMAT_UNDEFINED,
2025 },
2026 {
2027 VK_FORMAT_R5G6B5_UNORM_PACK16,
2028 VK_FORMAT_R5G6B5_UNORM_PACK16,
2029 VK_FORMAT_UNDEFINED,
2030 VK_FORMAT_UNDEFINED,
2031 },
2032 { REPS_FMT(VK_FORMAT_B8G8R8) },
2033 { REPS_FMT(VK_FORMAT_B8G8R8A8) },
2034 { REPS_FMT(VK_FORMAT_R8) },
2035 { REPS_FMT(VK_FORMAT_R8G8) },
2036 { REPS_FMT(VK_FORMAT_R8G8B8) },
2037 { REPS_FMT(VK_FORMAT_R8G8B8A8) },
2038 { REPS_FMT(VK_FORMAT_R16) },
2039 { REPS_FMT(VK_FORMAT_R16G16) },
2040 { REPS_FMT(VK_FORMAT_R16G16B16) },
2041 { REPS_FMT(VK_FORMAT_R16G16B16A16) },
2042 {
2043 VK_FORMAT_R32_UINT,
2044 VK_FORMAT_R32_SFLOAT,
2045 VK_FORMAT_R32_SINT,
2046 VK_FORMAT_R32_UINT,
2047 },
2048 {
2049 VK_FORMAT_R32G32B32_SFLOAT,
2050 VK_FORMAT_R32G32B32_SFLOAT,
2051 VK_FORMAT_UNDEFINED,
2052 VK_FORMAT_UNDEFINED,
2053 },
2054 {
2055 VK_FORMAT_R16G16B16A16_SFLOAT,
2056 VK_FORMAT_R16G16B16A16_SFLOAT,
2057 VK_FORMAT_UNDEFINED,
2058 VK_FORMAT_UNDEFINED,
2059 },
2060 {
2061 VK_FORMAT_R32G32B32A32_SFLOAT,
2062 VK_FORMAT_R32G32B32A32_SFLOAT,
2063 VK_FORMAT_UNDEFINED,
2064 VK_FORMAT_UNDEFINED,
2065 },
2066 {
2067 VK_FORMAT_R32G32B32_UINT,
2068 VK_FORMAT_UNDEFINED,
2069 VK_FORMAT_R32G32B32_SINT,
2070 VK_FORMAT_R32G32B32_UINT,
2071 },
2072 {
2073 VK_FORMAT_R32G32B32A32_UINT,
2074 VK_FORMAT_UNDEFINED,
2075 VK_FORMAT_R32G32B32A32_SINT,
2076 VK_FORMAT_R32G32B32A32_UINT,
2077 },
2078 {
2079 VK_FORMAT_R16_SFLOAT,
2080 VK_FORMAT_R16_SFLOAT,
2081 VK_FORMAT_R16_SINT,
2082 VK_FORMAT_R16_UINT,
2083 },
2084 };
2085#undef REPS_FMT_PACK
2086#undef REPS_FMT
2087
2088 if (fmt == VK_FORMAT_UNDEFINED)
2089 return VK_FORMAT_UNDEFINED;
2090
2091 for (int i = 0; i < FF_ARRAY_ELEMS(fmts_map); i++) {
2092 if (fmts_map[i][FF_VK_REP_NATIVE] == fmt ||
2093 fmts_map[i][FF_VK_REP_FLOAT] == fmt ||
2094 fmts_map[i][FF_VK_REP_INT] == fmt ||
2095 fmts_map[i][FF_VK_REP_UINT] == fmt)
2096 return fmts_map[i][rep_fmt];
2097 }
2098
2099 return VK_FORMAT_UNDEFINED;
2100}
2101
2103 VkImageView *img_view, VkImageAspectFlags *aspect,
2104 AVFrame *f, int plane, enum FFVkShaderRepFormat rep_fmt)
2105{
2106 VkResult ret;
2107 FFVulkanFunctions *vk = &s->vkfn;
2108 AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
2109 AVVulkanFramesContext *vkfc = hwfc->hwctx;
2110 const VkFormat *rep_fmts = av_vkfmt_from_pixfmt(hwfc->sw_format);
2111 AVVkFrame *vkf = (AVVkFrame *)f->data[0];
2112 const int nb_images = ff_vk_count_images(vkf);
2113
2114 VkImageViewUsageCreateInfo view_usage_info = {
2115 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
2116 .usage = vkfc->usage &
2117 (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
2118 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
2119 };
2120 VkImageViewCreateInfo view_create_info = {
2121 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
2122 .pNext = &view_usage_info,
2123 .image = vkf->img[FFMIN(plane, nb_images - 1)],
2124 .viewType = VK_IMAGE_VIEW_TYPE_2D,
2125 .format = ff_vk_map_fmt_to_rep(rep_fmts[plane], rep_fmt),
2126 .components = ff_comp_identity_map,
2127 .subresourceRange = {
2128 .aspectMask = ff_vk_aspect_flag(f, plane),
2129 .levelCount = 1,
2130 .layerCount = 1,
2131 },
2132 };
2133 if (view_create_info.format == VK_FORMAT_UNDEFINED) {
2134 av_log(s, AV_LOG_ERROR, "Unable to find a compatible representation "
2135 "of format %i and mode %i\n",
2136 rep_fmts[plane], rep_fmt);
2137 return AVERROR(EINVAL);
2138 }
2139
2140 ret = vk->CreateImageView(s->hwctx->act_dev, &view_create_info,
2141 s->hwctx->alloc, img_view);
2142 if (ret != VK_SUCCESS) {
2143 av_log(s, AV_LOG_ERROR, "Failed to create imageview: %s\n",
2145 return AVERROR_EXTERNAL;
2146 }
2147
2148 *aspect = view_create_info.subresourceRange.aspectMask;
2149
2150 return 0;
2151}
2152
2154 VkImageView views[AV_NUM_DATA_POINTERS],
2155 AVFrame *f,
2156 const VkFormat fmts[AV_NUM_DATA_POINTERS])
2157{
2158 int err = 0;
2159 VkResult ret;
2160 FFVulkanFunctions *vk = &s->vkfn;
2161 AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
2162 AVVulkanFramesContext *vkfc = hwfc->hwctx;
2163 AVVkFrame *vkf = (AVVkFrame *)f->data[0];
2164 const int nb_images = ff_vk_count_images(vkf);
2165 const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
2166 VkImageView tmp_views[AV_NUM_DATA_POINTERS] = { 0 };
2167
2168 for (int i = 0; i < nb_planes; i++) {
2169 VkImageViewUsageCreateInfo view_usage_info = {
2170 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
2171 .usage = vkfc->usage &
2172 (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
2173 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
2174 };
2175 VkImageViewCreateInfo view_create_info = {
2176 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
2177 .pNext = &view_usage_info,
2178 .image = vkf->img[FFMIN(i, nb_images - 1)],
2179 .viewType = VK_IMAGE_VIEW_TYPE_2D,
2180 .format = fmts[i],
2181 .components = ff_comp_identity_map,
2182 .subresourceRange = {
2183 .aspectMask = ff_vk_aspect_flag(f, i),
2184 .levelCount = 1,
2185 .layerCount = 1,
2186 },
2187 };
2188
2189 ret = vk->CreateImageView(s->hwctx->act_dev, &view_create_info,
2190 s->hwctx->alloc, &tmp_views[i]);
2191 if (ret != VK_SUCCESS) {
2192 av_log(s, AV_LOG_ERROR, "Failed to create imageview: %s\n",
2194 err = AVERROR_EXTERNAL;
2195 goto fail;
2196 }
2197 }
2198
2199 /* The execution context owns the views, destroying them on completion */
2200 for (int i = 0; i < nb_planes; i++)
2201 ff_vk_exec_add_dep_obj(s, e, VK_OBJECT_TYPE_IMAGE_VIEW,
2202 (uint64_t)tmp_views[i]);
2203
2204 memcpy(views, tmp_views, nb_planes*sizeof(*views));
2205
2206 return 0;
2207
2208fail:
2209 for (int i = 0; i < nb_planes; i++)
2210 if (tmp_views[i])
2211 vk->DestroyImageView(s->hwctx->act_dev, tmp_views[i], s->hwctx->alloc);
2212 return err;
2213}
2214
2216 VkImageView views[AV_NUM_DATA_POINTERS],
2217 AVFrame *f, enum FFVkShaderRepFormat rep_fmt)
2218{
2219 AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
2220 const VkFormat *rep_fmts = av_vkfmt_from_pixfmt(hwfc->sw_format);
2221 const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
2222 VkFormat fmts[AV_NUM_DATA_POINTERS] = { 0 };
2223
2224 for (int i = 0; i < nb_planes; i++) {
2225 fmts[i] = ff_vk_map_fmt_to_rep(rep_fmts[i], rep_fmt);
2226 if (fmts[i] == VK_FORMAT_UNDEFINED) {
2227 av_log(s, AV_LOG_ERROR, "Unable to find a compatible representation "
2228 "of format %i and mode %i\n",
2229 rep_fmts[i], rep_fmt);
2230 return AVERROR(EINVAL);
2231 }
2232 }
2233
2234 return ff_vk_create_imageviews_fmt(s, e, views, f, fmts);
2235}
2236
2238 AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar,
2239 VkPipelineStageFlags2 src_stage,
2240 VkPipelineStageFlags2 dst_stage,
2241 VkAccessFlagBits2 new_access,
2242 VkImageLayout new_layout,
2243 uint32_t new_qf)
2244{
2245 int found = -1;
2246 AVVkFrame *vkf = (AVVkFrame *)pic->data[0];
2247 const int nb_images = ff_vk_count_images(vkf);
2248 for (int i = 0; i < e->nb_frame_deps; i++)
2249 if (e->frame_deps[i]->data[0] == pic->data[0]) {
2250 if (e->frame_update[i])
2251 found = i;
2252 break;
2253 }
2254
2255 /* Earlier submissions are ordered by the frame's semaphore, which makes
2256 * their writes available and visible, so only accesses recorded in this
2257 * command buffer belong in the source scope. */
2258 for (int i = 0; i < nb_images; i++) {
2259 bar[*nb_bar] = (VkImageMemoryBarrier2) {
2260 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
2261 .pNext = NULL,
2262 .srcStageMask = src_stage,
2263 .dstStageMask = dst_stage,
2264 .srcAccessMask = found >= 0 ? e->access_dst[found] : VK_ACCESS_2_NONE,
2265 .dstAccessMask = new_access,
2266 .oldLayout = found >= 0 ? e->layout_dst[found] : vkf->layout[0],
2267 .newLayout = new_layout,
2268 .srcQueueFamilyIndex = found >= 0 ? e->queue_family_dst[found] : vkf->queue_family[0],
2269 .dstQueueFamilyIndex = new_qf,
2270 .image = vkf->img[i],
2271 .subresourceRange = (VkImageSubresourceRange) {
2272 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
2273 .layerCount = 1,
2274 .levelCount = 1,
2275 },
2276 };
2277 *nb_bar += 1;
2278 }
2279
2280 ff_vk_exec_update_frame(s, e, pic, &bar[*nb_bar - nb_images], NULL);
2281}
2282
2284 VkPipelineStageFlags stage, VkSpecializationInfo *spec,
2285 uint32_t wg_size[3], uint32_t required_subgroup_size)
2286{
2287 shd->stage = stage;
2288 shd->precompiled = 1;
2289 shd->specialization_info = spec;
2290 memcpy(shd->lg_size, wg_size, 3*sizeof(uint32_t));
2291
2292 shd->subgroup_info = (VkPipelineShaderStageRequiredSubgroupSizeCreateInfo) {
2293 .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,
2294 .requiredSubgroupSize = required_subgroup_size,
2295 };
2296
2297 switch (shd->stage) {
2298 case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
2299 case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
2300 case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
2301 case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
2302 case VK_SHADER_STAGE_MISS_BIT_KHR:
2303 case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
2304 shd->bind_point = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
2305 break;
2306 case VK_SHADER_STAGE_COMPUTE_BIT:
2307 shd->bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
2308 break;
2309 default:
2310 shd->bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS;
2311 break;
2312 };
2313
2314 return 0;
2315}
2316
2318{
2319 VkResult ret;
2320 FFVulkanFunctions *vk = &s->vkfn;
2321 VkPipelineLayoutCreateInfo pipeline_layout_info;
2322
2323 /* Finally create the pipeline layout */
2324 pipeline_layout_info = (VkPipelineLayoutCreateInfo) {
2325 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
2326 .pSetLayouts = shd->desc_layout,
2327 .setLayoutCount = shd->nb_descriptor_sets,
2328 .pushConstantRangeCount = shd->push_consts_num,
2329 .pPushConstantRanges = shd->push_consts,
2330 };
2331
2332 ret = vk->CreatePipelineLayout(s->hwctx->act_dev, &pipeline_layout_info,
2333 s->hwctx->alloc, &shd->pipeline_layout);
2334 if (ret != VK_SUCCESS) {
2335 av_log(s, AV_LOG_ERROR, "Unable to init pipeline layout: %s\n",
2337 return AVERROR_EXTERNAL;
2338 }
2339
2340 return 0;
2341}
2342
2344 VkShaderModule *mod,
2345 const uint8_t *spirv, size_t spirv_len)
2346{
2347 VkResult ret;
2348 FFVulkanFunctions *vk = &s->vkfn;
2349
2350 VkShaderModuleCreateInfo shader_module_info = {
2351 .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
2352 .pNext = NULL,
2353 .flags = 0x0,
2354 .pCode = (void *)spirv,
2355 .codeSize = spirv_len,
2356 };
2357
2358 ret = vk->CreateShaderModule(s->hwctx->act_dev, &shader_module_info,
2359 s->hwctx->alloc, mod);
2360 if (ret != VK_SUCCESS) {
2361 av_log(s, AV_LOG_ERROR, "Error creating shader module: %s\n",
2363 return AVERROR_EXTERNAL;
2364 }
2365
2366 return 0;
2367}
2368
2370 VkShaderModule mod, const char *entrypoint)
2371{
2372 VkResult ret;
2373 FFVulkanFunctions *vk = &s->vkfn;
2374
2375 VkComputePipelineCreateInfo pipeline_create_info = {
2376 .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
2377 .flags = 0x0,
2378 .layout = shd->pipeline_layout,
2379 .stage = (VkPipelineShaderStageCreateInfo) {
2380 .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2381 .pNext = shd->subgroup_info.requiredSubgroupSize ?
2382 &shd->subgroup_info : NULL,
2383 .pName = entrypoint,
2384 .flags = shd->subgroup_info.requiredSubgroupSize ?
2385 VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT : 0x0,
2386 .stage = shd->stage,
2387 .module = mod,
2388 .pSpecializationInfo = shd->specialization_info,
2389 },
2390 };
2391
2392 ret = vk->CreateComputePipelines(s->hwctx->act_dev, VK_NULL_HANDLE, 1,
2393 &pipeline_create_info,
2394 s->hwctx->alloc, &shd->pipeline);
2395 if (ret != VK_SUCCESS) {
2396 av_log(s, AV_LOG_ERROR, "Unable to init compute pipeline: %s\n",
2398 return AVERROR_EXTERNAL;
2399 }
2400
2401 return 0;
2402}
2403
2405{
2406 VkResult ret;
2407 FFVulkanFunctions *vk = &s->vkfn;
2408
2409 int has_singular = 0;
2410 int max_descriptors = 0;
2411 for (int i = 0; i < shd->nb_descriptor_sets; i++) {
2412 max_descriptors = FFMAX(max_descriptors, shd->desc_set[i].nb_bindings);
2413 if (shd->desc_set[i].singular)
2414 has_singular = 1;
2415 }
2416 shd->use_push = (s->extensions & FF_VK_EXT_PUSH_DESCRIPTOR) &&
2417 (max_descriptors <= s->push_desc_props.maxPushDescriptors) &&
2418 (shd->nb_descriptor_sets == 1) &&
2419 (has_singular == 0);
2420
2421 for (int i = 0; i < shd->nb_descriptor_sets; i++) {
2423 VkDescriptorSetLayoutCreateInfo desc_layout_create = {
2424 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
2425 .bindingCount = set->nb_bindings,
2426 .pBindings = set->binding,
2427 .flags = (shd->use_push) ?
2428 VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR :
2429 0x0,
2430 };
2431
2432 ret = vk->CreateDescriptorSetLayout(s->hwctx->act_dev,
2433 &desc_layout_create,
2434 s->hwctx->alloc,
2435 &shd->desc_layout[i]);
2436 if (ret != VK_SUCCESS) {
2437 av_log(s, AV_LOG_ERROR, "Unable to create descriptor set layout: %s",
2439 return AVERROR_EXTERNAL;
2440 }
2441 }
2442
2443 return 0;
2444}
2445
2447 const char *spirv, size_t spirv_len,
2448 const char *entrypoint)
2449{
2450 int err;
2451 FFVulkanFunctions *vk = &s->vkfn;
2452 VkSpecializationMapEntry spec_entries[3];
2453 VkSpecializationInfo spec_info;
2454 VkShaderModule mod;
2455 size_t input_size = spirv_len;
2456
2457 if (shd->precompiled) {
2458 if (!shd->specialization_info) {
2459 spec_info = (VkSpecializationInfo) {
2460 .pMapEntries = spec_entries,
2461 .mapEntryCount = 0,
2462 .pData = shd->lg_size,
2463 .dataSize = 0,
2464 };
2465 shd->specialization_info = &spec_info;
2466 }
2467
2468 VkSpecializationMapEntry *spe = (void *)shd->specialization_info->pMapEntries;
2469 for (int i = 0; i < 3; i++) {
2470 spe[shd->specialization_info->mapEntryCount++] = (VkSpecializationMapEntry) {
2471 .constantID = 253 + i,
2472 .offset = shd->specialization_info->dataSize + i*sizeof(uint32_t),
2473 .size = sizeof(uint32_t),
2474 };
2475 }
2476
2477 uint8_t *spd = (uint8_t *)shd->specialization_info->pData;
2478 memcpy(&spd[shd->specialization_info->dataSize],
2479 shd->lg_size, 3*sizeof(uint32_t));
2480 shd->specialization_info->dataSize += 3*sizeof(uint32_t);
2481
2482#if CONFIG_SHADER_COMPRESSION
2483 uint8_t *out;
2484 size_t out_len;
2485 int ret = ff_zlib_expand(s, &out, &out_len, spirv, spirv_len);
2486 if (ret < 0)
2487 return ret;
2488 spirv = out;
2489 spirv_len = out_len;
2490#endif
2491 }
2492
2493 err = init_descriptors(s, shd);
2494 if (err < 0)
2495 goto end;
2496
2497 err = init_pipeline_layout(s, shd);
2498 if (err < 0)
2499 goto end;
2500
2501 err = create_shader_module(s, shd, &mod, spirv, spirv_len);
2502 if (err < 0)
2503 goto end;
2504
2505 switch (shd->bind_point) {
2506 case VK_PIPELINE_BIND_POINT_COMPUTE:
2507 err = init_compute_pipeline(s, shd, mod, entrypoint);
2508 break;
2509 default:
2510 av_log(s, AV_LOG_ERROR, "Unsupported shader type: %i\n",
2511 shd->bind_point);
2512 err = AVERROR(EINVAL);
2513 goto end;
2514 break;
2515 };
2516
2517 vk->DestroyShaderModule(s->hwctx->act_dev, mod, s->hwctx->alloc);
2518 if (err < 0)
2519 goto end;
2520
2521 if (shd->name)
2522 av_log(s, AV_LOG_VERBOSE, "Shader %s linked, size:", shd->name);
2523 else
2524 av_log(s, AV_LOG_VERBOSE, "Shader linked, size:");
2525
2526 if (input_size != spirv_len)
2527 av_log(s, AV_LOG_VERBOSE, " %zu compressed,", input_size);
2528 av_log(s, AV_LOG_VERBOSE, " %zu SPIR-V\n", spirv_len);
2529
2530end:
2531 if (shd->precompiled) {
2532 shd->specialization_info->mapEntryCount -= 3;
2533 shd->specialization_info->dataSize -= 3*sizeof(uint32_t);
2534 }
2535#if CONFIG_SHADER_COMPRESSION
2536 if (shd->precompiled)
2537 av_free((void *)spirv);
2538#endif
2539 return err;
2540}
2541
2543 const FFVulkanDescriptorSetBinding *desc, int nb,
2544 int singular)
2545{
2549
2550 for (int i = 0; i < nb; i++) {
2551 set->binding[i].binding = i;
2552 set->binding[i].descriptorType = desc[i].type;
2553 set->binding[i].descriptorCount = FFMAX(desc[i].elems, 1);
2554 set->binding[i].stageFlags = desc[i].stages;
2555 set->binding[i].pImmutableSamplers = desc[i].samplers;
2556 }
2557
2558 for (int i = 0; i < nb; i++) {
2559 int j;
2560 for (j = 0; j < shd->nb_desc_pool_size; j++)
2561 if (shd->desc_pool_size[j].type == desc[i].type)
2562 break;
2563 if (j >= shd->nb_desc_pool_size) {
2564 shd->nb_desc_pool_size++;
2566 }
2567
2568 shd->desc_pool_size[j].type = desc[i].type;
2569 shd->desc_pool_size[j].descriptorCount += FFMAX(desc[i].elems, 1);
2570 }
2571
2572 set->singular = singular;
2573 set->nb_bindings = nb;
2574}
2575
2577 FFVulkanShader *shd)
2578{
2579 if (!shd->nb_descriptor_sets)
2580 return 0;
2581
2582 FFVulkanShaderData *sd = &pool->reg_shd[pool->nb_reg_shd++];
2584
2585 sd->shd = shd;
2587
2588 if (!shd->use_push) {
2589 VkResult ret;
2590 FFVulkanFunctions *vk = &s->vkfn;
2591 VkDescriptorSetLayout *tmp_layouts;
2592 VkDescriptorSetAllocateInfo set_alloc_info;
2593 VkDescriptorPoolCreateInfo pool_create_info;
2594
2595 for (int i = 0; i < shd->nb_desc_pool_size; i++)
2596 shd->desc_pool_size[i].descriptorCount *= pool->pool_size;
2597
2598 pool_create_info = (VkDescriptorPoolCreateInfo) {
2599 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2600 .flags = 0,
2601 .pPoolSizes = shd->desc_pool_size,
2602 .poolSizeCount = shd->nb_desc_pool_size,
2603 .maxSets = sd->nb_descriptor_sets*pool->pool_size,
2604 };
2605
2606 ret = vk->CreateDescriptorPool(s->hwctx->act_dev, &pool_create_info,
2607 s->hwctx->alloc, &sd->desc_pool);
2608 if (ret != VK_SUCCESS) {
2609 av_log(s, AV_LOG_ERROR, "Unable to create descriptor pool: %s\n",
2611 return AVERROR_EXTERNAL;
2612 }
2613
2614 tmp_layouts = av_malloc_array(pool_create_info.maxSets, sizeof(*tmp_layouts));
2615 if (!tmp_layouts)
2616 return AVERROR(ENOMEM);
2617
2618 /* Colate each execution context's descriptor set layouts */
2619 for (int i = 0; i < pool->pool_size; i++)
2620 for (int j = 0; j < sd->nb_descriptor_sets; j++)
2621 tmp_layouts[i*sd->nb_descriptor_sets + j] = shd->desc_layout[j];
2622
2623 set_alloc_info = (VkDescriptorSetAllocateInfo) {
2624 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2625 .descriptorPool = sd->desc_pool,
2626 .pSetLayouts = tmp_layouts,
2627 .descriptorSetCount = pool_create_info.maxSets,
2628 };
2629
2630 sd->desc_sets = av_malloc_array(pool_create_info.maxSets,
2631 sizeof(*tmp_layouts));
2632 if (!sd->desc_sets) {
2633 av_free(tmp_layouts);
2634 return AVERROR(ENOMEM);
2635 }
2636 ret = vk->AllocateDescriptorSets(s->hwctx->act_dev, &set_alloc_info,
2637 sd->desc_sets);
2638 av_free(tmp_layouts);
2639 if (ret != VK_SUCCESS) {
2640 av_log(s, AV_LOG_ERROR, "Unable to allocate descriptor set: %s\n",
2642 av_freep(&sd->desc_sets);
2643 return AVERROR_EXTERNAL;
2644 }
2645 }
2646
2647 return 0;
2648}
2649
2651 const FFVulkanShader *shd)
2652{
2653 for (int i = 0; i < e->parent->nb_reg_shd; i++)
2654 if (e->parent->reg_shd[i].shd == shd)
2655 return &e->parent->reg_shd[i];
2656 return NULL;
2657}
2658
2660 FFVulkanShader *shd, int set,
2661 VkWriteDescriptorSet *write_info)
2662{
2663 FFVulkanFunctions *vk = &s->vkfn;
2664 FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2665 const FFVulkanShaderData *sd = get_shd_data(e, shd);
2666
2667 if (desc_set->singular) {
2668 for (int i = 0; i < e->parent->pool_size; i++) {
2669 write_info->dstSet = sd->desc_sets[i*sd->nb_descriptor_sets + set];
2670 vk->UpdateDescriptorSets(s->hwctx->act_dev, 1, write_info, 0, NULL);
2671 }
2672 } else {
2673 if (shd->use_push) {
2674 vk->CmdPushDescriptorSetKHR(e->buf,
2675 shd->bind_point,
2676 shd->pipeline_layout,
2677 set, 1,
2678 write_info);
2679 } else {
2680 write_info->dstSet = sd->desc_sets[e->idx*sd->nb_descriptor_sets + set];
2681 vk->UpdateDescriptorSets(s->hwctx->act_dev, 1, write_info, 0, NULL);
2682 }
2683 }
2684}
2685
2687 FFVulkanShader *shd, int set, int bind, int offs,
2688 VkImageView view, VkImageLayout layout,
2689 VkSampler sampler)
2690{
2691 FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2692
2693 VkDescriptorImageInfo desc_pool_write_info_img = {
2694 .sampler = sampler,
2695 .imageView = view,
2696 .imageLayout = layout,
2697 };
2698 VkWriteDescriptorSet desc_pool_write_info = {
2699 .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2700 .dstBinding = bind,
2701 .descriptorCount = 1,
2702 .dstArrayElement = offs,
2703 .descriptorType = desc_set->binding[bind].descriptorType,
2704 .pImageInfo = &desc_pool_write_info_img,
2705 };
2706 update_set_pool_write(s, e, shd, set, &desc_pool_write_info);
2707
2708 return 0;
2709}
2710
2712 FFVulkanShader *shd, AVFrame *f,
2713 VkImageView *views, int set, int binding,
2714 VkImageLayout layout, VkSampler sampler)
2715{
2716 AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
2717 const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
2718
2719 for (int i = 0; i < nb_planes; i++)
2720 ff_vk_shader_update_img(s, e, shd, set, binding, i,
2721 views[i], layout, sampler);
2722}
2723
2725 FFVulkanShader *shd,
2726 int set, int bind, int elem,
2727 FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize len,
2728 VkFormat fmt)
2729{
2730 FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2731
2732 VkDescriptorBufferInfo desc_pool_write_info_buf = {
2733 .buffer = buf->buf,
2734 .offset = buf->virtual_offset + offset,
2735 .range = len,
2736 };
2737 VkWriteDescriptorSet desc_pool_write_info = {
2738 .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2739 .dstBinding = bind,
2740 .descriptorCount = 1,
2741 .dstArrayElement = elem,
2742 .descriptorType = desc_set->binding[bind].descriptorType,
2743 .pBufferInfo = &desc_pool_write_info_buf,
2744 };
2745 update_set_pool_write(s, e, shd, set, &desc_pool_write_info);
2746
2747 return 0;
2748}
2749
2751 FFVulkanShader *shd,
2752 VkShaderStageFlagBits stage,
2753 int offset, size_t size, void *src)
2754{
2755 FFVulkanFunctions *vk = &s->vkfn;
2756 vk->CmdPushConstants(e->buf, shd->pipeline_layout,
2757 stage, offset, size, src);
2758}
2759
2761 const FFVulkanShader *shd)
2762{
2763 FFVulkanFunctions *vk = &s->vkfn;
2764 const FFVulkanShaderData *sd = get_shd_data(e, shd);
2765
2766 vk->CmdBindPipeline(e->buf, shd->bind_point, shd->pipeline);
2767
2768 if (sd && sd->nb_descriptor_sets) {
2769 if (!shd->use_push) {
2770 vk->CmdBindDescriptorSets(e->buf, shd->bind_point, shd->pipeline_layout,
2771 0, sd->nb_descriptor_sets,
2772 &sd->desc_sets[e->idx*sd->nb_descriptor_sets],
2773 0, NULL);
2774 }
2775 }
2776}
2777
2779{
2780 FFVulkanFunctions *vk = &s->vkfn;
2781
2782#if 0
2783 if (shd->shader.module)
2784 vk->DestroyShaderModule(s->hwctx->act_dev, shd->shader.module,
2785 s->hwctx->alloc);
2786#endif
2787
2788 if (shd->pipeline)
2789 vk->DestroyPipeline(s->hwctx->act_dev, shd->pipeline, s->hwctx->alloc);
2790 if (shd->pipeline_layout)
2791 vk->DestroyPipelineLayout(s->hwctx->act_dev, shd->pipeline_layout,
2792 s->hwctx->alloc);
2793
2794 for (int i = 0; i < shd->nb_descriptor_sets; i++)
2795 if (shd->desc_layout[i])
2796 vk->DestroyDescriptorSetLayout(s->hwctx->act_dev, shd->desc_layout[i],
2797 s->hwctx->alloc);
2798}
2799
2801{
2802 av_freep(&s->query_props);
2803 av_freep(&s->qf_props);
2804 av_freep(&s->video_props);
2805#ifdef VK_KHR_maintenance9
2806 av_freep(&s->ownership_props);
2807#endif
2808 av_freep(&s->coop_mat_props);
2809 av_freep(&s->host_image_copy_layouts);
2810 av_refstruct_pool_uninit(&s->imageviews_pool);
2811
2812 av_buffer_unref(&s->device_ref);
2813 av_buffer_unref(&s->frames_ref);
2814}
2815
2816int ff_vk_init(FFVulkanContext *s, void *log_parent,
2817 AVBufferRef *device_ref, AVBufferRef *frames_ref)
2818{
2819 int err;
2820
2821 static const AVClass vulkan_context_class = {
2822 .class_name = "vk",
2823 .version = LIBAVUTIL_VERSION_INT,
2824 .parent_log_context_offset = offsetof(FFVulkanContext, log_parent),
2825 };
2826
2827 memset(s, 0, sizeof(*s));
2828 s->log_parent = log_parent;
2829 s->class = &vulkan_context_class;
2830
2831 if (frames_ref) {
2832 s->frames_ref = av_buffer_ref(frames_ref);
2833 if (!s->frames_ref)
2834 return AVERROR(ENOMEM);
2835
2836 s->frames = (AVHWFramesContext *)s->frames_ref->data;
2837 s->hwfc = s->frames->hwctx;
2838
2839 device_ref = s->frames->device_ref;
2840 }
2841
2842 s->device_ref = av_buffer_ref(device_ref);
2843 if (!s->device_ref) {
2844 ff_vk_uninit(s);
2845 return AVERROR(ENOMEM);
2846 }
2847
2848 s->device = (AVHWDeviceContext *)s->device_ref->data;
2849 s->hwctx = s->device->hwctx;
2850
2851 s->extensions = ff_vk_extensions_to_mask(s->hwctx->enabled_dev_extensions,
2852 s->hwctx->nb_enabled_dev_extensions);
2853 s->extensions |= ff_vk_extensions_to_mask(s->hwctx->enabled_inst_extensions,
2854 s->hwctx->nb_enabled_inst_extensions);
2855
2856 err = ff_vk_load_functions(s->device, &s->vkfn, s->extensions, 1, 1);
2857 if (err < 0) {
2858 ff_vk_uninit(s);
2859 return err;
2860 }
2861
2862 err = ff_vk_load_props(s);
2863 if (err < 0) {
2864 ff_vk_uninit(s);
2865 return err;
2866 }
2867
2868 return 0;
2869}
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:97
static double val(void *priv, double ch)
Definition aeval.c:77
static const char *const format[]
Definition af_aiir.c:445
static cqueue * cqueue_create(int size, int max_size)
static const int8_t filt[NUMTAPS *2]
Definition af_earwax.c:40
static FILE * out
static AVFormatContext * ctx
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition avassert.h:58
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
static void BS_FUNC skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
#define flags(name, subs,...)
Definition cbs_h264.c:74
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define f(width, name)
Definition cbs_vp8.c:236
#define s(width, name)
Definition cbs_vp9.c:198
#define av_popcount
Definition common.h:154
#define NULL
Definition coverity.c:32
static enum AVPixelFormat pix_fmt
void(* flush)(AVBSFContext *ctx)
Definition dts2pts.c:615
int ret
Definition ffplay.c:391
const char * usage
#define AV_NUM_DATA_POINTERS
Definition frame.h:480
#define fail
Definition test.h:479
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition buffer.c:140
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition buffer.c:104
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition error.h:59
#define AVERROR(e)
Definition error.h:45
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition frame.c:65
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition frame.c:486
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
#define AV_LOG_VERBOSE
Detailed information.
Definition log.h:226
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
#define LIBAVUTIL_VERSION_INT
Definition version.h:85
int index
Definition gxfenc.c:90
const VkFormat * av_vkfmt_from_pixfmt(enum AVPixelFormat p)
Returns the optimal per-plane Vulkan format for a given sw_format, one for each plane.
enum VkFormat VkFormat
enum MPFType type
Definition jpegmpfenc.c:55
unsigned offset
Definition libaomenc.c:763
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition internal.h:71
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition internal.h:72
#define AVOnce
Definition thread.h:202
static int ff_thread_once(char *control, void(*routine)(void))
Definition thread.h:205
#define AV_ONCE_INIT
Definition thread.h:203
void ff_vk_set_perm(enum AVPixelFormat pix_fmt, int lut[4], int inv)
Since storage images may not be swizzled, we have to do this in the shader itself.
Definition vulkan.c:1720
static int init_pipeline_layout(FFVulkanContext *s, FFVulkanShader *shd)
Definition vulkan.c:2317
void ff_vk_shader_update_img_array(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, AVFrame *f, VkImageView *views, int set, int binding, VkImageLayout layout, VkSampler sampler)
Update a descriptor in a buffer with an image array.
Definition vulkan.c:2711
#define REPS_FMT(fmt)
#define REPS_FMT_PACK(fmt, num)
int ff_vk_shader_load(FFVulkanShader *shd, VkPipelineStageFlags stage, VkSpecializationInfo *spec, uint32_t wg_size[3], uint32_t required_subgroup_size)
Initialize a shader object.
Definition vulkan.c:2283
#define CASE(VAL)
void ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd, const FFVulkanDescriptorSetBinding *desc, int nb, int singular)
Add descriptor to a shader.
Definition vulkan.c:2542
void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
Definition vulkan.c:335
const char * ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt, enum FFVkShaderRepFormat rep_fmt)
Definition vulkan.c:1774
int ff_vk_unmap_buffers(FFVulkanContext *s, FFVkBuffer **buf, int nb_buffers, int flush)
Definition vulkan.c:1380
VkImageAspectFlags ff_vk_aspect_flag(AVFrame *f, int p)
Get the aspect flag for a plane from an image.
Definition vulkan.c:1679
int ff_vk_create_buf(FFVulkanContext *s, FFVkBuffer *buf, size_t size, void *pNext, void *alloc_pNext, VkBufferUsageFlags usage, VkMemoryPropertyFlagBits flags)
Definition vulkan.c:1208
static void exec_pool_phase_seed(void)
Definition vulkan.c:392
int ff_vk_exec_pool_init(FFVulkanContext *s, AVVulkanDeviceQueueFamily *qf, FFVkExecPool *pool, int nb_contexts, int nb_queries, VkQueryType query_type, int query_64bit, const void *query_create_pnext)
Allocates/frees an execution pool.
Definition vulkan.c:399
static const FFVulkanShaderData * get_shd_data(FFVkExecContext *e, const FFVulkanShader *shd)
Definition vulkan.c:2650
void ff_vk_image_free(FFVulkanContext *s, VkImage *img, VkDeviceMemory *mem)
Free an image created by ff_vk_image_create(); all GPU use must have completed.
Definition vulkan.c:1194
void ff_vk_exec_wait(FFVulkanContext *s, FFVkExecContext *e)
Definition vulkan.c:653
static int init_compute_pipeline(FFVulkanContext *s, FFVulkanShader *shd, VkShaderModule mod, const char *entrypoint)
Definition vulkan.c:2369
int ff_vk_alloc_mem(FFVulkanContext *s, VkMemoryRequirements *req, VkMemoryPropertyFlagBits req_flags, void *alloc_extension, VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
Definition vulkan.c:1066
int ff_vk_image_create(FFVulkanContext *s, VkImage *img, VkDeviceMemory *mem, int width, int height, VkFormat format, int nb_layers, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, void *create_pnext)
Memory/buffer/image allocation helpers.
Definition vulkan.c:1117
int ff_vk_shader_add_push_const(FFVulkanShader *shd, int offset, int size, VkShaderStageFlagBits stage)
Add/update push constants for execution.
Definition vulkan.c:1635
int ff_vk_shader_update_img(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, int set, int bind, int offs, VkImageView view, VkImageLayout layout, VkSampler sampler)
Sets an image descriptor for specified shader and binding.
Definition vulkan.c:2686
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition vulkan.c:2800
int ff_vk_load_props(FFVulkanContext *s)
Loads props/mprops/driver_props.
Definition vulkan.c:151
int ff_vk_map_buffers(FFVulkanContext *s, FFVkBuffer **buf, uint8_t *mem[], int nb_buffers, int invalidate)
Buffer management code.
Definition vulkan.c:1300
VkFormat ff_vk_map_fmt_to_rep(VkFormat fmt, enum FFVkShaderRepFormat rep_fmt)
Returns the view format for the given representation of fmt, or VK_FORMAT_UNDEFINED if there is none.
Definition vulkan.c:2003
const char * ff_vk_ret2str(VkResult res)
Converts Vulkan return values to strings.
Definition vulkan.c:42
static void host_map_free(AVRefStructOpaque opaque, void *obj)
Definition vulkan.c:1539
int ff_vk_init(FFVulkanContext *s, void *log_parent, AVBufferRef *device_ref, AVBufferRef *frames_ref)
Initializes the AVClass, in case this context is not used as the main user's context.
Definition vulkan.c:2816
int ff_vk_exec_add_dep_sw_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f)
Definition vulkan.c:819
void ff_vk_exec_add_dep_obj(FFVulkanContext *s, FFVkExecContext *e, VkObjectType type, uint64_t obj)
Definition vulkan.c:812
static void pooled_buf_free(AVRefStructOpaque opaque, void *obj)
Definition vulkan.c:1443
void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
Definition vulkan.c:1422
const VkComponentMapping ff_comp_identity_map
Definition vulkan.c:34
void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e, AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar, VkPipelineStageFlags2 src_stage, VkPipelineStageFlags2 dst_stage, VkAccessFlagBits2 new_access, VkImageLayout new_layout, uint32_t new_qf)
Definition vulkan.c:2237
int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
Start/submit/wait an execution.
Definition vulkan.c:668
int ff_vk_create_imageviews(FFVulkanContext *s, FFVkExecContext *e, VkImageView views[AV_NUM_DATA_POINTERS], AVFrame *f, enum FFVkShaderRepFormat rep_fmt)
Create an imageview and add it as a dependency to an execution.
Definition vulkan.c:2215
static int create_shader_module(FFVulkanContext *s, FFVulkanShader *shd, VkShaderModule *mod, const uint8_t *spirv, size_t spirv_len)
Definition vulkan.c:2343
static int create_mapped_buffer(FFVulkanContext *s, FFVkBuffer *vkb, VkBufferUsageFlags usage, size_t size, VkExternalMemoryBufferCreateInfo *create_desc, VkImportMemoryHostPointerInfoEXT *import_desc, VkMemoryHostPointerPropertiesEXT props)
Definition vulkan.c:1493
static AVOnce exec_pool_phase_seeded
Definition vulkan.c:390
void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
Free a shader.
Definition vulkan.c:2778
FFVkImageViews * ff_vk_imageviews_alloc(FFVulkanContext *s, int nb_views)
Allocate a reference-counted set of image views, zero-initialized for the caller to create.
Definition vulkan.c:1984
VkResult ff_vk_exec_get_query(FFVulkanContext *s, FFVkExecContext *e, void **data, VkQueryResultFlagBits flags)
Performs nb_queries queries and returns their results and statuses.
Definition vulkan.c:602
int ff_vk_shader_register_exec(FFVulkanContext *s, FFVkExecPool *pool, FFVulkanShader *shd)
Register a shader with an exec pool.
Definition vulkan.c:2576
int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler, int unnorm_coords, VkFilter filt)
Create a sampler.
Definition vulkan.c:1646
void ff_vk_exec_update_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f, VkImageMemoryBarrier2 *bar, uint32_t *nb_img_bar)
Definition vulkan.c:947
FFVkExecContext * ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool)
Retrieve an execution pool.
Definition vulkan.c:630
int ff_vk_mt_is_np_rgb(enum AVPixelFormat pix_fmt)
Returns 1 if pixfmt is a usable RGB format.
Definition vulkan.c:1696
static void reset_imageviews(AVRefStructOpaque unused, void *obj)
Definition vulkan.c:1972
static int init_descriptors(FFVulkanContext *s, FFVulkanShader *shd)
Definition vulkan.c:2404
static void update_set_pool_write(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, int set, VkWriteDescriptorSet *write_info)
Definition vulkan.c:2659
int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
Definition vulkan.c:991
void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e, const FFVulkanShader *shd)
Bind a shader.
Definition vulkan.c:2760
void ff_vk_exec_move_dep_refstruct(FFVulkanContext *s, FFVkExecContext *e, void *obj)
Definition vulkan.c:794
int ff_vk_shader_update_desc_buffer(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, int set, int bind, int elem, FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize len, VkFormat fmt)
Update a descriptor in a buffer with a buffer.
Definition vulkan.c:2724
#define FN_MAP_TO(dst_t, dst_name, src_t, src_name)
Definition vulkan.c:95
AVVulkanDeviceQueueFamily * ff_vk_qf_find(FFVulkanContext *s, VkQueueFlagBits dev_family, VkVideoCodecOperationFlagBitsKHR vid_ops)
Chooses an appropriate QF.
Definition vulkan.c:320
int ff_vk_host_map_buffer(FFVulkanContext *s, FFVkBuffer **dst, uint8_t *src_data, VkDeviceSize size, const AVBufferRef *src_buf, VkBufferUsageFlags usage)
Maps a system RAM buffer into a Vulkan buffer.
Definition vulkan.c:1544
void ff_vk_exec_add_dep_refstruct(FFVulkanContext *s, FFVkExecContext *e, void *obj)
Execution dependency management.
Definition vulkan.c:787
int ff_vk_create_imageview(FFVulkanContext *s, VkImageView *img_view, VkImageAspectFlags *aspect, AVFrame *f, int plane, enum FFVkShaderRepFormat rep_fmt)
Create a single imageview for a given plane.
Definition vulkan.c:2102
int ff_vk_get_pooled_buffer(FFVulkanContext *ctx, AVRefStructPool **buf_pool, FFVkBuffer **buf, VkBufferUsageFlags usage, void *create_pNext, size_t size, VkMemoryPropertyFlagBits mem_props)
Initialize a pool and create AVBufferRefs containing FFVkBuffer.
Definition vulkan.c:1448
static void load_enabled_qfs(FFVulkanContext *s)
Definition vulkan.c:130
int ff_vk_flush_buffer(FFVulkanContext *s, FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize mem_size, int flush)
Flush or invalidate a single buffer, with a given size and offset.
Definition vulkan.c:1349
static atomic_uint exec_pool_phase[FF_ARRAY_ELEMS(((AVVulkanDeviceContext *) NULL) ->qf)]
Definition vulkan.c:389
int ff_vk_exec_mirror_sem_value(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore *dst, uint64_t *dst_val, AVFrame *f)
Definition vulkan.c:966
static void exec_discard_deps(FFVulkanContext *s, FFVkExecContext *e)
Definition vulkan.c:720
void ff_vk_exec_add_dep_signal_sem(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore sem, uint64_t val, VkPipelineStageFlagBits2 stage)
Definition vulkan.c:847
void ff_vk_exec_discard(FFVulkanContext *s, FFVkExecContext *e)
Definition vulkan.c:771
int ff_vk_create_imageviews_fmt(FFVulkanContext *s, FFVkExecContext *e, VkImageView views[AV_NUM_DATA_POINTERS], AVFrame *f, const VkFormat fmts[AV_NUM_DATA_POINTERS])
Same as ff_vk_create_imageviews(), but with an explicit view format for each plane,...
Definition vulkan.c:2153
void ff_vk_exec_add_dep_bool_sem(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore *sem, int nb, VkPipelineStageFlagBits2 stage, int wait)
Definition vulkan.c:861
int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd, const char *spirv, size_t spirv_len, const char *entrypoint)
Link a shader into an executable.
Definition vulkan.c:2446
int ff_vk_exec_add_dep_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f, VkPipelineStageFlagBits2 wait_stage, VkPipelineStageFlagBits2 signal_stage)
Definition vulkan.c:889
void ff_vk_shader_update_push_const(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, VkShaderStageFlagBits stage, int offset, size_t size, void *src)
Update push constant in a shader.
Definition vulkan.c:2750
void ff_vk_exec_add_dep_wait_sem(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore sem, uint64_t val, VkPipelineStageFlagBits2 stage)
Definition vulkan.c:833
const char * desc
Definition libsvtav1.c:83
#define FFMIN(a, b)
Definition macros.h:49
#define FFMAX(a, b)
Definition macros.h:47
#define FFALIGN(x, a)
Definition macros.h:78
uint64_t layout
void * av_calloc(size_t nmemb, size_t size)
Definition mem.c:370
Memory handling functions.
static const char * obj
Definition mscl.c:57
const char data[16]
Definition mxf.c:155
#define av_realloc(p, s)
Definition ops_static.c:54
#define av_malloc(s)
Definition ops_static.c:52
static av_always_inline int pthread_mutex_lock(pthread_mutex_t *mutex)
Definition os2threads.h:119
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition os2threads.h:104
static av_always_inline int pthread_mutex_trylock(pthread_mutex_t *mutex)
Definition os2threads.h:126
static av_always_inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
Definition os2threads.h:132
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition os2threads.h:112
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3524
#define AV_PIX_FMT_GBRAP12
Definition pixfmt.h:572
#define AV_PIX_FMT_YUV420P16
Definition pixfmt.h:559
#define AV_PIX_FMT_GBRPF32
Definition pixfmt.h:587
#define AV_PIX_FMT_P212
Definition pixfmt.h:629
#define AV_PIX_FMT_YUV444P12
Definition pixfmt.h:555
#define AV_PIX_FMT_RGBF32
Definition pixfmt.h:637
#define AV_PIX_FMT_YUV420P10
Definition pixfmt.h:548
#define AV_PIX_FMT_RGBAF32
Definition pixfmt.h:638
#define AV_PIX_FMT_RGBAF16
Definition pixfmt.h:635
#define AV_PIX_FMT_GBRAP16
Definition pixfmt.h:574
#define AV_PIX_FMT_P412
Definition pixfmt.h:630
#define AV_PIX_FMT_P210
Definition pixfmt.h:627
#define AV_PIX_FMT_YUVA444P10
Definition pixfmt.h:601
#define AV_PIX_FMT_P012
Definition pixfmt.h:614
#define AV_PIX_FMT_YUVA420P16
Definition pixfmt.h:604
#define AV_PIX_FMT_P216
Definition pixfmt.h:631
#define AV_PIX_FMT_GBRAP32
Definition pixfmt.h:575
#define AV_PIX_FMT_YUV420P12
Definition pixfmt.h:552
#define AV_PIX_FMT_YUVA420P10
Definition pixfmt.h:599
#define AV_PIX_FMT_YUV422P12
Definition pixfmt.h:553
#define AV_PIX_FMT_Y210
Definition pixfmt.h:617
#define AV_PIX_FMT_GBRAP14
Definition pixfmt.h:573
#define AV_PIX_FMT_P010
Definition pixfmt.h:613
#define AV_PIX_FMT_P016
Definition pixfmt.h:615
#define AV_PIX_FMT_GBRP10
Definition pixfmt.h:567
#define AV_PIX_FMT_GRAY32
Definition pixfmt.h:532
#define AV_PIX_FMT_RGBA128
Definition pixfmt.h:641
#define AV_PIX_FMT_YUV422P10
Definition pixfmt.h:549
#define AV_PIX_FMT_GRAY12
Definition pixfmt.h:529
#define AV_PIX_FMT_GBRAPF16
Definition pixfmt.h:586
#define AV_PIX_FMT_RGBA64
Definition pixfmt.h:538
#define AV_PIX_FMT_XV30
Definition pixfmt.h:620
#define AV_PIX_FMT_GBRP12
Definition pixfmt.h:568
#define AV_PIX_FMT_RGB48
Definition pixfmt.h:534
#define AV_PIX_FMT_BAYER_RGGB16
Definition pixfmt.h:581
#define AV_PIX_FMT_YUVA422P10
Definition pixfmt.h:600
#define AV_PIX_FMT_X2RGB10
Definition pixfmt.h:624
#define AV_PIX_FMT_GRAYF32
Definition pixfmt.h:591
#define AV_PIX_FMT_XV48
Definition pixfmt.h:622
#define AV_PIX_FMT_P410
Definition pixfmt.h:628
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
@ AV_PIX_FMT_UYVA
packed UYVA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), UYVAUYVA...
Definition pixfmt.h:444
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition pixfmt.h:96
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition pixfmt.h:75
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition pixfmt.h:73
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition pixfmt.h:265
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition pixfmt.h:77
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition pixfmt.h:102
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition pixfmt.h:81
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition pixfmt.h:88
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition pixfmt.h:101
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition pixfmt.h:108
@ AV_PIX_FMT_NV24
planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition pixfmt.h:371
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition pixfmt.h:264
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition pixfmt.h:198
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition pixfmt.h:100
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition pixfmt.h:78
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition pixfmt.h:174
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition pixfmt.h:212
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition pixfmt.h:263
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition pixfmt.h:173
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition pixfmt.h:74
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition pixfmt.h:76
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition pixfmt.h:165
#define AV_PIX_FMT_YUVA422P12
Definition pixfmt.h:602
#define AV_PIX_FMT_RGB96
Definition pixfmt.h:640
#define AV_PIX_FMT_P416
Definition pixfmt.h:632
#define AV_PIX_FMT_X2BGR10
Definition pixfmt.h:625
#define AV_PIX_FMT_BGR565
Definition pixfmt.h:540
#define AV_PIX_FMT_Y216
Definition pixfmt.h:619
#define AV_PIX_FMT_GRAY10
Definition pixfmt.h:528
#define AV_PIX_FMT_RGB565
Definition pixfmt.h:535
#define AV_PIX_FMT_GRAY14
Definition pixfmt.h:530
#define AV_PIX_FMT_GBRPF16
Definition pixfmt.h:585
#define AV_PIX_FMT_YUV422P16
Definition pixfmt.h:560
#define AV_PIX_FMT_GRAY16
Definition pixfmt.h:531
#define AV_PIX_FMT_GBRAP10
Definition pixfmt.h:571
#define AV_PIX_FMT_Y212
Definition pixfmt.h:618
#define AV_PIX_FMT_XYZP12
Definition pixfmt.h:609
#define AV_PIX_FMT_YUVA444P16
Definition pixfmt.h:606
#define AV_PIX_FMT_YUVA422P16
Definition pixfmt.h:605
#define AV_PIX_FMT_GBRP16
Definition pixfmt.h:570
#define AV_PIX_FMT_XV36
Definition pixfmt.h:621
#define AV_PIX_FMT_GBRP14
Definition pixfmt.h:569
#define AV_PIX_FMT_YUVA444P12
Definition pixfmt.h:603
#define AV_PIX_FMT_GBRAPF32
Definition pixfmt.h:588
#define AV_PIX_FMT_YUV444P16
Definition pixfmt.h:561
#define AV_PIX_FMT_YUV444P10
Definition pixfmt.h:551
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition refstruct.c:121
void * av_refstruct_pool_get(AVRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition refstruct.c:315
void * av_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition refstruct.c:141
static void av_refstruct_pool_uninit(AVRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition refstruct.h:292
static void * av_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(AVRefStructOpaque opaque, void *obj))
A wrapper around av_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition refstruct.h:94
static AVRefStructPool * av_refstruct_pool_alloc_ext(size_t size, unsigned flags, void *opaque, int(*init_cb)(AVRefStructOpaque opaque, void *obj), void(*reset_cb)(AVRefStructOpaque opaque, void *obj), void(*free_entry_cb)(AVRefStructOpaque opaque, void *obj), void(*free_cb)(AVRefStructOpaque opaque))
A wrapper around av_refstruct_pool_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition refstruct.h:258
#define FF_ARRAY_ELEMS(a)
@ memory_order_relaxed
Definition stdatomic.h:29
unsigned int atomic_uint
Definition stdatomic.h:64
#define atomic_store_explicit(object, desired, order)
Definition stdatomic.h:253
#define atomic_fetch_add(object, operand)
Definition stdatomic.h:312
#define atomic_init(obj, value)
Definition stdatomic.h:119
A reference to a data buffer.
Definition buffer.h:82
uint8_t * data
The data buffer.
Definition buffer.h:90
size_t size
Size of data in bytes.
Definition buffer.h:94
Describe the class of an AVClass context structure.
Definition log.h:76
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition frame.h:500
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition hwcontext.h:63
This struct describes a set or pool of "hardware" frames (i.e.
Definition hwcontext.h:118
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition hwcontext.h:153
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition hwcontext.h:213
AVRefStructPool is an API for a thread-safe pool of objects managed via the RefStruct API.
Definition refstruct.c:184
VkImageLayout layout[AV_NUM_DATA_POINTERS]
VkSemaphore sem[AV_NUM_DATA_POINTERS]
Synchronization timeline semaphores, one for each VkImage.
uint32_t queue_family[AV_NUM_DATA_POINTERS]
Queue family of the images.
VkAccessFlagBits2 access[AV_NUM_DATA_POINTERS]
Updated after every barrier.
uint64_t sem_value[AV_NUM_DATA_POINTERS]
Up to date semaphore value at which each image becomes accessible.
VkImage img[AV_NUM_DATA_POINTERS]
Vulkan images to which the memory is bound to.
Main Vulkan context, allocated as AVHWDeviceContext.hwctx.
Allocated as AVHWFramesContext.hwctx, used to set pool-specific options.
VkImageUsageFlagBits usage
Defines extra usage of output frames.
void(* lock_frame)(struct AVHWFramesContext *fc, AVVkFrame *vkf)
Locks a frame, preventing other threads from changing frame properties.
void(* unlock_frame)(struct AVHWFramesContext *fc, AVVkFrame *vkf)
Similar to lock_frame(), unlocks a frame.
VkBuffer buf
Definition vulkan.h:95
VkDeviceAddress address
Definition vulkan.h:99
size_t size
Definition vulkan.h:98
VkMemoryPropertyFlagBits flags
Definition vulkan.h:97
AVBufferRef * host_ref
Definition vulkan.h:111
size_t virtual_offset
Definition vulkan.h:108
VkDeviceMemory mem
Definition vulkan.h:96
uint8_t * mapped_mem
Definition vulkan.h:103
VkAccessFlagBits access_dst[FF_VK_EXEC_MAX_FRAME_DEPS]
Definition vulkan.h:189
AVBufferRef * buf_deps[FF_VK_EXEC_MAX_BUF_DEPS]
Definition vulkan.h:160
uint32_t idx
Definition vulkan.h:129
uint8_t frame_update[FF_VK_EXEC_MAX_FRAME_DEPS]
Definition vulkan.h:192
void * query_data
Definition vulkan.h:156
uint64_t sem_value
Definition vulkan.h:147
VkSemaphoreSubmitInfo sem_wait[FF_VK_EXEC_MAX_SEM_OPS]
Definition vulkan.h:179
FFVkExecObjDep obj_deps[FF_VK_EXEC_MAX_BUF_DEPS]
Definition vulkan.h:168
VkQueue queue
Definition vulkan.h:137
AVFrame * sw_frame_deps[FF_VK_EXEC_MAX_SW_FRAME_DEPS]
Definition vulkan.h:176
pthread_mutex_t lock
Definition vulkan.h:151
uint32_t queue_family_dst[FF_VK_EXEC_MAX_FRAME_DEPS]
Definition vulkan.h:191
uint64_t * sem_sig_val_dst[FF_VK_EXEC_MAX_SEM_OPS]
Definition vulkan.h:185
VkSemaphoreSubmitInfo sem_sig[FF_VK_EXEC_MAX_SEM_OPS]
Definition vulkan.h:182
const struct FFVkExecPool * parent
Definition vulkan.h:130
int had_submission
Definition vulkan.h:134
int sem_sig_val_dst_cnt
Definition vulkan.h:186
int nb_sw_frame_deps
Definition vulkan.h:177
VkSemaphore sem
Definition vulkan.h:146
uint8_t frame_locked[FF_VK_EXEC_MAX_FRAME_DEPS]
Definition vulkan.h:188
void * refstruct_deps[FF_VK_EXEC_MAX_BUF_DEPS]
Definition vulkan.h:164
VkImageLayout layout_dst[FF_VK_EXEC_MAX_FRAME_DEPS]
Definition vulkan.h:190
AVFrame * frame_deps[FF_VK_EXEC_MAX_FRAME_DEPS]
Definition vulkan.h:172
int nb_frame_deps
Definition vulkan.h:173
int nb_refstruct_deps
Definition vulkan.h:165
VkCommandBuffer buf
Definition vulkan.h:142
VkObjectType type
Definition vulkan.h:125
uint64_t obj
Definition vulkan.h:124
FFVulkanShaderData reg_shd[FF_VK_MAX_SHADERS]
Definition vulkan.h:288
int query_results
Definition vulkan.h:280
atomic_uint_least64_t idx
Definition vulkan.h:272
VkQueryPool query_pool
Definition vulkan.h:278
FFVkExecContext * contexts
Definition vulkan.h:271
VkCommandBuffer * cmd_bufs
Definition vulkan.h:275
int pool_size
Definition vulkan.h:276
int nb_queries
Definition vulkan.h:284
VkCommandPool * cmd_buf_pools
Definition vulkan.h:274
int nb_reg_shd
Definition vulkan.h:289
void * query_data
Definition vulkan.h:279
size_t qd_size
Definition vulkan.h:285
int query_status_stride
Definition vulkan.h:283
int query_statuses
Definition vulkan.h:281
int query_64bit
Definition vulkan.h:282
PFN_vkDestroyImageView destroy_image_view
Definition vulkan.h:567
const VkAllocationCallbacks * alloc
Definition vulkan.h:566
VkImageView views[AV_NUM_DATA_POINTERS]
Definition vulkan.h:569
VkDevice dev
Definition vulkan.h:565
VkDescriptorSetLayoutBinding binding[FF_VK_MAX_DESCRIPTOR_BINDINGS]
Definition vulkan.h:201
VkDescriptorSet * desc_sets
Definition vulkan.h:266
FFVulkanShader * shd
Definition vulkan.h:258
VkDescriptorPool desc_pool
Definition vulkan.h:267
VkPipelineLayout pipeline_layout
Definition vulkan.h:231
FFVulkanDescriptorSet desc_set[FF_VK_MAX_DESCRIPTOR_SETS]
Definition vulkan.h:238
VkPipeline pipeline
Definition vulkan.h:228
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo subgroup_info
Definition vulkan.h:226
VkPipelineStageFlags stage
Definition vulkan.h:222
int push_consts_num
Definition vulkan.h:235
VkSpecializationInfo * specialization_info
Definition vulkan.h:216
int nb_descriptor_sets
Definition vulkan.h:239
int precompiled
Definition vulkan.h:215
VkPushConstantRange push_consts[FF_VK_MAX_PUSH_CONSTS]
Definition vulkan.h:234
uint32_t lg_size[3]
Definition vulkan.h:219
const char * name
Definition vulkan.h:212
VkDescriptorSetLayout desc_layout[FF_VK_MAX_DESCRIPTOR_SETS]
Definition vulkan.h:242
VkPipelineBindPoint bind_point
Definition vulkan.h:223
VkDescriptorPoolSize desc_pool_size[FF_VK_MAX_DESCRIPTOR_TYPES]
Definition vulkan.h:246
int nb_desc_pool_size
Definition vulkan.h:247
#define av_free(p)
#define av_malloc_array(a, b)
#define av_freep(p)
#define av_log(a,...)
#define src
Definition vp8dsp.c:248
static int ref[MAX_W *MAX_W]
#define height
Definition dsp.h:99
#define width
Definition dsp.h:99
static void set(uint8_t *a[], int ch, int index, int ch_count, enum AVSampleFormat f, double v)
Definition swresample.c:56
int size
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition refstruct.h:58
#define img
static int mod(int a, int b)
Modulo operation with only positive remainders.
Definition vf_v360.c:755
static unsigned int seed
Definition videogen.c:78
int len
FFVkShaderRepFormat
Returns the format to use for images in shaders.
Definition vulkan.h:438
@ FF_VK_REP_UINT
Definition vulkan.h:446
@ FF_VK_REP_INT
Definition vulkan.h:444
@ FF_VK_REP_NATIVE
Definition vulkan.h:440
@ FF_VK_REP_FLOAT
Definition vulkan.h:442
#define FF_VK_STRUCT_EXT(CTX, BASE, STRUCT_P, EXT_FLAG, TYPE)
Definition vulkan.h:388
#define FF_VK_EXEC_MAX_SEM_OPS
Definition vulkan.h:118
static const void * ff_vk_find_struct(const void *chain, VkStructureType stype)
Definition vulkan.h:366
#define FF_VK_MAX_SHADERS
Definition vulkan.h:79
static int ff_vk_unmap_buffer(FFVulkanContext *s, FFVkBuffer *buf, int flush)
Definition vulkan.h:668
#define FF_VK_EXEC_MAX_FRAME_DEPS
Definition vulkan.h:115
static int ff_vk_count_images(AVVkFrame *f)
Definition vulkan.h:357
#define FF_VK_MAX_PUSH_CONSTS
Definition vulkan.h:78
#define FF_VK_MAX_DESCRIPTOR_BINDINGS
Definition vulkan.h:76
#define FF_VK_EXEC_MAX_BUF_DEPS
Definition vulkan.h:116
#define FF_VK_EXEC_MAX_SW_FRAME_DEPS
Definition vulkan.h:117
#define FF_VK_MAX_DESCRIPTOR_SETS
Definition vulkan.h:75
static int ff_vk_map_buffer(FFVulkanContext *s, FFVkBuffer *buf, uint8_t **mem, int invalidate)
Definition vulkan.h:661
#define FF_VK_MAX_DESCRIPTOR_TYPES
Definition vulkan.h:77
#define FF_VK_EXT_VIDEO_QUEUE
#define FF_VK_EXT_UNIFIED_IMAGE_LAYOUTS
#define FF_VK_EXT_COOP_MATRIX
#define FF_VK_EXT_INTERNAL_QUEUE_SYNC
#define FF_VK_EXT_NO_FLAG
#define FF_VK_EXT_OPTICAL_FLOW
#define FF_VK_EXT_MAINTENANCE_11
#define FF_VK_EXT_PUSH_DESCRIPTOR
#define FF_VK_EXT_LONG_VECTOR
#define FF_VK_EXT_MAINTENANCE_9
#define FF_VK_EXT_HOST_IMAGE_COPY
#define FF_VK_EXT_ATOMIC_FLOAT
#define FF_VK_EXT_EXTERNAL_HOST_MEMORY
static uint64_t ff_vk_extensions_to_mask(const char *const *extensions, int nb_extensions)
static int ff_vk_load_functions(AVHWDeviceContext *ctx, FFVulkanFunctions *vk, uint64_t extensions_mask, int has_inst, int has_dev)
Function loader.
static int ff_zlib_expand(void *ctx, uint8_t **out, size_t *out_len, const uint8_t *src, int src_len)
Definition zlib_utils.h:30