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