FFmpeg
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 "avassert.h"
22 #include "mem.h"
23 
24 #include "vulkan.h"
25 #include "libavutil/vulkan_loader.h"
26 
27 const VkComponentMapping ff_comp_identity_map = {
28  .r = VK_COMPONENT_SWIZZLE_IDENTITY,
29  .g = VK_COMPONENT_SWIZZLE_IDENTITY,
30  .b = VK_COMPONENT_SWIZZLE_IDENTITY,
31  .a = VK_COMPONENT_SWIZZLE_IDENTITY,
32 };
33 
34 /* Converts return values to strings */
35 const char *ff_vk_ret2str(VkResult res)
36 {
37 #define CASE(VAL) case VAL: return #VAL
38  switch (res) {
39  CASE(VK_SUCCESS);
40  CASE(VK_NOT_READY);
41  CASE(VK_TIMEOUT);
42  CASE(VK_EVENT_SET);
43  CASE(VK_EVENT_RESET);
44  CASE(VK_INCOMPLETE);
45  CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
46  CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
47  CASE(VK_ERROR_INITIALIZATION_FAILED);
48  CASE(VK_ERROR_DEVICE_LOST);
49  CASE(VK_ERROR_MEMORY_MAP_FAILED);
50  CASE(VK_ERROR_LAYER_NOT_PRESENT);
51  CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
52  CASE(VK_ERROR_FEATURE_NOT_PRESENT);
53  CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
54  CASE(VK_ERROR_TOO_MANY_OBJECTS);
55  CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
56  CASE(VK_ERROR_FRAGMENTED_POOL);
57  CASE(VK_ERROR_UNKNOWN);
58  CASE(VK_ERROR_OUT_OF_POOL_MEMORY);
59  CASE(VK_ERROR_INVALID_EXTERNAL_HANDLE);
60  CASE(VK_ERROR_FRAGMENTATION);
61  CASE(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS);
62  CASE(VK_PIPELINE_COMPILE_REQUIRED);
63  CASE(VK_ERROR_SURFACE_LOST_KHR);
64  CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
65  CASE(VK_SUBOPTIMAL_KHR);
66  CASE(VK_ERROR_OUT_OF_DATE_KHR);
67  CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
68  CASE(VK_ERROR_VALIDATION_FAILED_EXT);
69  CASE(VK_ERROR_INVALID_SHADER_NV);
70  CASE(VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR);
71  CASE(VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR);
72  CASE(VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR);
73  CASE(VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR);
74  CASE(VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR);
75  CASE(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
76  CASE(VK_ERROR_NOT_PERMITTED_KHR);
77  CASE(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
78  CASE(VK_THREAD_IDLE_KHR);
79  CASE(VK_THREAD_DONE_KHR);
80  CASE(VK_OPERATION_DEFERRED_KHR);
81  CASE(VK_OPERATION_NOT_DEFERRED_KHR);
82  default: return "Unknown error";
83  }
84 #undef CASE
85 }
86 
87 /* Malitia pura, Khronos */
88 #define FN_MAP_TO(dst_t, dst_name, src_t, src_name) \
89  dst_t ff_vk_map_ ##src_name## _to_ ##dst_name(src_t src) \
90  { \
91  dst_t dst = 0x0; \
92  MAP_TO(VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, \
93  VK_IMAGE_USAGE_SAMPLED_BIT); \
94  MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, \
95  VK_IMAGE_USAGE_TRANSFER_SRC_BIT); \
96  MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, \
97  VK_IMAGE_USAGE_TRANSFER_DST_BIT); \
98  MAP_TO(VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, \
99  VK_IMAGE_USAGE_STORAGE_BIT); \
100  MAP_TO(VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, \
101  VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); \
102  MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR, \
103  VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR); \
104  MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR, \
105  VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR); \
106  MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, \
107  VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR); \
108  MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, \
109  VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR); \
110  MAP_TO(VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT, \
111  VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT); \
112  return dst; \
113  }
114 
115 #define MAP_TO(flag1, flag2) if (src & flag2) dst |= flag1;
116 FN_MAP_TO(VkFormatFeatureFlagBits2, feats, VkImageUsageFlags, usage)
117 #undef MAP_TO
118 #define MAP_TO(flag1, flag2) if (src & flag1) dst |= flag2;
119 FN_MAP_TO(VkImageUsageFlags, usage, VkFormatFeatureFlagBits2, feats)
120 #undef MAP_TO
121 #undef FN_MAP_TO
122 
123 static void load_enabled_qfs(FFVulkanContext *s)
124 {
125  s->nb_qfs = 0;
126  for (int i = 0; i < s->hwctx->nb_qf; i++) {
127  /* Skip duplicates */
128  int skip = 0;
129  for (int j = 0; j < s->nb_qfs; j++) {
130  if (s->qfs[j] == s->hwctx->qf[i].idx) {
131  skip = 1;
132  break;
133  }
134  }
135  if (skip)
136  continue;
137 
138  s->qfs[s->nb_qfs++] = s->hwctx->qf[i].idx;
139  }
140 }
141 
142 int ff_vk_load_props(FFVulkanContext *s)
143 {
144  FFVulkanFunctions *vk = &s->vkfn;
145 
146  s->props = (VkPhysicalDeviceProperties2) {
147  .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
148  };
149 
150  FF_VK_STRUCT_EXT(s, &s->props, &s->props_11, FF_VK_EXT_NO_FLAG,
151  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
152  FF_VK_STRUCT_EXT(s, &s->props, &s->driver_props, FF_VK_EXT_NO_FLAG,
153  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
154  FF_VK_STRUCT_EXT(s, &s->props, &s->subgroup_props, FF_VK_EXT_NO_FLAG,
155  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
156 
157  FF_VK_STRUCT_EXT(s, &s->props, &s->push_desc_props, FF_VK_EXT_PUSH_DESCRIPTOR,
158  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
159  FF_VK_STRUCT_EXT(s, &s->props, &s->hprops, FF_VK_EXT_EXTERNAL_HOST_MEMORY,
160  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
161  FF_VK_STRUCT_EXT(s, &s->props, &s->coop_matrix_props, FF_VK_EXT_COOP_MATRIX,
162  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR);
163  FF_VK_STRUCT_EXT(s, &s->props, &s->desc_buf_props, FF_VK_EXT_DESCRIPTOR_BUFFER,
164  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
165  FF_VK_STRUCT_EXT(s, &s->props, &s->optical_flow_props, FF_VK_EXT_OPTICAL_FLOW,
166  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
167  FF_VK_STRUCT_EXT(s, &s->props, &s->host_image_props, FF_VK_EXT_HOST_IMAGE_COPY,
168  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT);
169 
170  s->feats = (VkPhysicalDeviceFeatures2) {
171  .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
172  };
173 
174  FF_VK_STRUCT_EXT(s, &s->feats, &s->feats_12, FF_VK_EXT_NO_FLAG,
175  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
176  FF_VK_STRUCT_EXT(s, &s->feats, &s->atomic_float_feats, FF_VK_EXT_ATOMIC_FLOAT,
177  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
178 
179  /* Try allocating 1024 layouts */
180  s->host_image_copy_layouts = av_malloc(sizeof(*s->host_image_copy_layouts)*1024);
181  s->host_image_props.pCopySrcLayouts = s->host_image_copy_layouts;
182  s->host_image_props.copySrcLayoutCount = 512;
183  s->host_image_props.pCopyDstLayouts = s->host_image_copy_layouts + 512;
184  s->host_image_props.copyDstLayoutCount = 512;
185 
186  vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);
187 
188  /* Check if we had enough memory for all layouts */
189  if (s->host_image_props.copySrcLayoutCount == 512 ||
190  s->host_image_props.copyDstLayoutCount == 512) {
191  VkImageLayout *new_array;
192  size_t new_size;
193  s->host_image_props.pCopySrcLayouts =
194  s->host_image_props.pCopyDstLayouts = NULL;
195  s->host_image_props.copySrcLayoutCount =
196  s->host_image_props.copyDstLayoutCount = 0;
197  vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);
198 
199  new_size = s->host_image_props.copySrcLayoutCount +
200  s->host_image_props.copyDstLayoutCount;
201  new_size *= sizeof(*s->host_image_copy_layouts);
202  new_array = av_realloc(s->host_image_copy_layouts, new_size);
203  if (!new_array)
204  return AVERROR(ENOMEM);
205 
206  s->host_image_copy_layouts = new_array;
207  s->host_image_props.pCopySrcLayouts = new_array;
208  s->host_image_props.pCopyDstLayouts = new_array + s->host_image_props.copySrcLayoutCount;
209  vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);
210  }
211 
212  vk->GetPhysicalDeviceMemoryProperties(s->hwctx->phys_dev, &s->mprops);
213  vk->GetPhysicalDeviceFeatures2(s->hwctx->phys_dev, &s->feats);
214 
215  load_enabled_qfs(s);
216 
217  if (s->qf_props)
218  return 0;
219 
220  vk->GetPhysicalDeviceQueueFamilyProperties2(s->hwctx->phys_dev, &s->tot_nb_qfs, NULL);
221 
222  s->qf_props = av_calloc(s->tot_nb_qfs, sizeof(*s->qf_props));
223  if (!s->qf_props)
224  return AVERROR(ENOMEM);
225 
226  s->query_props = av_calloc(s->tot_nb_qfs, sizeof(*s->query_props));
227  if (!s->qf_props) {
228  av_freep(&s->qf_props);
229  return AVERROR(ENOMEM);
230  }
231 
232  s->video_props = av_calloc(s->tot_nb_qfs, sizeof(*s->video_props));
233  if (!s->video_props) {
234  av_freep(&s->qf_props);
235  av_freep(&s->query_props);
236  return AVERROR(ENOMEM);
237  }
238 
239  for (uint32_t i = 0; i < s->tot_nb_qfs; i++) {
240  s->qf_props[i] = (VkQueueFamilyProperties2) {
241  .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
242  };
243 
244  FF_VK_STRUCT_EXT(s, &s->qf_props[i], &s->query_props[i], FF_VK_EXT_NO_FLAG,
245  VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR);
246  FF_VK_STRUCT_EXT(s, &s->qf_props[i], &s->video_props[i], FF_VK_EXT_VIDEO_QUEUE,
247  VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR);
248  }
249 
250  vk->GetPhysicalDeviceQueueFamilyProperties2(s->hwctx->phys_dev, &s->tot_nb_qfs, s->qf_props);
251 
252  if (s->extensions & FF_VK_EXT_COOP_MATRIX) {
253  vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(s->hwctx->phys_dev,
254  &s->coop_mat_props_nb, NULL);
255 
256  if (s->coop_mat_props_nb) {
257  s->coop_mat_props = av_malloc_array(s->coop_mat_props_nb,
258  sizeof(VkCooperativeMatrixPropertiesKHR));
259  for (int i = 0; i < s->coop_mat_props_nb; i++) {
260  s->coop_mat_props[i] = (VkCooperativeMatrixPropertiesKHR) {
261  .sType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
262  };
263  }
264 
265  vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(s->hwctx->phys_dev,
266  &s->coop_mat_props_nb,
267  s->coop_mat_props);
268  }
269  }
270 
271  return 0;
272 }
273 
274 AVVulkanDeviceQueueFamily *ff_vk_qf_find(FFVulkanContext *s,
275  VkQueueFlagBits dev_family,
276  VkVideoCodecOperationFlagBitsKHR vid_ops)
277 {
278  for (int i = 0; i < s->hwctx->nb_qf; i++) {
279  if ((s->hwctx->qf[i].flags & dev_family) &&
280  (s->hwctx->qf[i].video_caps & vid_ops) == vid_ops) {
281  return &s->hwctx->qf[i];
282  }
283  }
284  return NULL;
285 }
286 
287 void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
288 {
289  FFVulkanFunctions *vk = &s->vkfn;
290 
291  for (int i = 0; i < pool->pool_size; i++) {
292  FFVkExecContext *e = &pool->contexts[i];
293 
294  if (e->fence) {
295  if (e->had_submission)
296  vk->WaitForFences(s->hwctx->act_dev, 1, &e->fence, VK_TRUE, UINT64_MAX);
297  vk->DestroyFence(s->hwctx->act_dev, e->fence, s->hwctx->alloc);
298  }
299 
300  ff_vk_exec_discard_deps(s, e);
301 
302  av_free(e->frame_deps);
303  av_free(e->sw_frame_deps);
304  av_free(e->buf_deps);
305  av_free(e->queue_family_dst);
306  av_free(e->layout_dst);
307  av_free(e->access_dst);
308  av_free(e->frame_update);
309  av_free(e->frame_locked);
310  av_free(e->sem_sig);
311  av_free(e->sem_sig_val_dst);
312  av_free(e->sem_wait);
313  }
314 
315  /* Free shader-specific data */
316  for (int i = 0; i < pool->nb_reg_shd; i++) {
317  FFVulkanShaderData *sd = &pool->reg_shd[i];
318 
319  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
320  for (int j = 0; j < sd->nb_descriptor_sets; j++) {
321  FFVulkanDescriptorSetData *set_data = &sd->desc_set_buf[j];
322  if (set_data->buf.mem)
323  ff_vk_unmap_buffer(s, &set_data->buf, 0);
324  ff_vk_free_buf(s, &set_data->buf);
325  }
326  }
327 
328  if (sd->desc_pool)
329  vk->DestroyDescriptorPool(s->hwctx->act_dev, sd->desc_pool,
330  s->hwctx->alloc);
331 
332  av_freep(&sd->desc_set_buf);
333  av_freep(&sd->desc_bind);
334  av_freep(&sd->desc_sets);
335  }
336 
337  av_freep(&pool->reg_shd);
338 
339  for (int i = 0; i < pool->pool_size; i++) {
340  if (pool->cmd_buf_pools[i])
341  vk->FreeCommandBuffers(s->hwctx->act_dev, pool->cmd_buf_pools[i],
342  1, &pool->cmd_bufs[i]);
343 
344  if (pool->cmd_buf_pools[i])
345  vk->DestroyCommandPool(s->hwctx->act_dev, pool->cmd_buf_pools[i], s->hwctx->alloc);
346  }
347  if (pool->query_pool)
348  vk->DestroyQueryPool(s->hwctx->act_dev, pool->query_pool, s->hwctx->alloc);
349 
350  av_free(pool->query_data);
351  av_free(pool->cmd_buf_pools);
352  av_free(pool->cmd_bufs);
353  av_free(pool->contexts);
354 }
355 
356 int ff_vk_exec_pool_init(FFVulkanContext *s, AVVulkanDeviceQueueFamily *qf,
357  FFVkExecPool *pool, int nb_contexts,
358  int nb_queries, VkQueryType query_type, int query_64bit,
359  const void *query_create_pnext)
360 {
361  int err;
362  VkResult ret;
363  FFVulkanFunctions *vk = &s->vkfn;
364 
365  VkCommandPoolCreateInfo cqueue_create;
366  VkCommandBufferAllocateInfo cbuf_create;
367 
368  const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *ef = NULL;
369 
370  atomic_init(&pool->idx, 0);
371 
372  if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
373  ef = ff_vk_find_struct(query_create_pnext,
374  VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR);
375  if (!ef)
376  return AVERROR(EINVAL);
377  }
378 
379  /* Allocate space for command buffer pools */
380  pool->cmd_buf_pools = av_malloc(nb_contexts*sizeof(*pool->cmd_buf_pools));
381  if (!pool->cmd_buf_pools) {
382  err = AVERROR(ENOMEM);
383  goto fail;
384  }
385 
386  /* Allocate space for command buffers */
387  pool->cmd_bufs = av_malloc(nb_contexts*sizeof(*pool->cmd_bufs));
388  if (!pool->cmd_bufs) {
389  err = AVERROR(ENOMEM);
390  goto fail;
391  }
392 
393  for (int i = 0; i < nb_contexts; i++) {
394  /* Create command pool */
395  cqueue_create = (VkCommandPoolCreateInfo) {
396  .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
397  .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT |
398  VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
399  .queueFamilyIndex = qf->idx,
400  };
401 
402  ret = vk->CreateCommandPool(s->hwctx->act_dev, &cqueue_create,
403  s->hwctx->alloc, &pool->cmd_buf_pools[i]);
404  if (ret != VK_SUCCESS) {
405  av_log(s, AV_LOG_ERROR, "Command pool creation failure: %s\n",
406  ff_vk_ret2str(ret));
407  err = AVERROR_EXTERNAL;
408  goto fail;
409  }
410 
411  /* Allocate command buffer */
412  cbuf_create = (VkCommandBufferAllocateInfo) {
413  .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
414  .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
415  .commandPool = pool->cmd_buf_pools[i],
416  .commandBufferCount = 1,
417  };
418  ret = vk->AllocateCommandBuffers(s->hwctx->act_dev, &cbuf_create,
419  &pool->cmd_bufs[i]);
420  if (ret != VK_SUCCESS) {
421  av_log(s, AV_LOG_ERROR, "Command buffer alloc failure: %s\n",
422  ff_vk_ret2str(ret));
423  err = AVERROR_EXTERNAL;
424  goto fail;
425  }
426  }
427 
428  /* Query pool */
429  if (nb_queries) {
430  VkQueryPoolCreateInfo query_pool_info = {
431  .sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
432  .pNext = query_create_pnext,
433  .queryType = query_type,
434  .queryCount = nb_queries*nb_contexts,
435  };
436  ret = vk->CreateQueryPool(s->hwctx->act_dev, &query_pool_info,
437  s->hwctx->alloc, &pool->query_pool);
438  if (ret != VK_SUCCESS) {
439  av_log(s, AV_LOG_ERROR, "Query pool alloc failure: %s\n",
440  ff_vk_ret2str(ret));
441  err = AVERROR_EXTERNAL;
442  goto fail;
443  }
444 
445  pool->nb_queries = nb_queries;
446  pool->query_status_stride = 1 + 1; /* One result, one status by default */
447  pool->query_results = nb_queries;
448  pool->query_statuses = nb_queries;
449 
450  /* Video encode queries produce two results per query */
451  if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
452  int nb_results = av_popcount(ef->encodeFeedbackFlags);
453  pool->query_status_stride = nb_results + 1;
454  pool->query_results *= nb_results;
455  } else if (query_type == VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR) {
456  pool->query_status_stride = 1;
457  pool->query_results = 0;
458  }
459 
460  pool->qd_size = (pool->query_results + pool->query_statuses)*(query_64bit ? 8 : 4);
461 
462  /* Allocate space for the query data */
463  pool->query_data = av_calloc(nb_contexts, pool->qd_size);
464  if (!pool->query_data) {
465  err = AVERROR(ENOMEM);
466  goto fail;
467  }
468  }
469 
470  /* Allocate space for the contexts */
471  pool->contexts = av_calloc(nb_contexts, sizeof(*pool->contexts));
472  if (!pool->contexts) {
473  err = AVERROR(ENOMEM);
474  goto fail;
475  }
476 
477  pool->pool_size = nb_contexts;
478 
479  /* Init contexts */
480  for (int i = 0; i < pool->pool_size; i++) {
481  FFVkExecContext *e = &pool->contexts[i];
482  VkFenceCreateInfo fence_create = {
483  .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
484  .flags = VK_FENCE_CREATE_SIGNALED_BIT,
485  };
486 
487  /* Fence */
488  ret = vk->CreateFence(s->hwctx->act_dev, &fence_create, s->hwctx->alloc,
489  &e->fence);
490  if (ret != VK_SUCCESS) {
491  av_log(s, AV_LOG_ERROR, "Failed to create submission fence: %s\n",
492  ff_vk_ret2str(ret));
493  return AVERROR_EXTERNAL;
494  }
495 
496  e->idx = i;
497  e->parent = pool;
498 
499  /* Query data */
500  e->query_data = ((uint8_t *)pool->query_data) + pool->qd_size*i;
501  e->query_idx = nb_queries*i;
502 
503  /* Command buffer */
504  e->buf = pool->cmd_bufs[i];
505 
506  /* Queue index distribution */
507  e->qi = i % qf->num;
508  e->qf = qf->idx;
509  vk->GetDeviceQueue(s->hwctx->act_dev, qf->idx, e->qi, &e->queue);
510  }
511 
512  return 0;
513 
514 fail:
515  ff_vk_exec_pool_free(s, pool);
516  return err;
517 }
518 
519 VkResult ff_vk_exec_get_query(FFVulkanContext *s, FFVkExecContext *e,
520  void **data, VkQueryResultFlagBits flags)
521 {
522  FFVulkanFunctions *vk = &s->vkfn;
523  const FFVkExecPool *pool = e->parent;
524  VkQueryResultFlags qf = flags & ~(VK_QUERY_RESULT_64_BIT |
525  VK_QUERY_RESULT_WITH_STATUS_BIT_KHR);
526 
527  if (!e->query_data) {
528  av_log(s, AV_LOG_ERROR, "Requested a query with a NULL query_data pointer!\n");
529  return VK_INCOMPLETE;
530  }
531 
532  qf |= pool->query_64bit ?
533  VK_QUERY_RESULT_64_BIT : 0x0;
534  qf |= pool->query_statuses ?
535  VK_QUERY_RESULT_WITH_STATUS_BIT_KHR : 0x0;
536 
537  if (data)
538  *data = e->query_data;
539 
540  return vk->GetQueryPoolResults(s->hwctx->act_dev, pool->query_pool,
541  e->query_idx,
542  pool->nb_queries,
543  pool->qd_size, e->query_data,
544  pool->qd_size, qf);
545 }
546 
547 FFVkExecContext *ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool)
548 {
549  return &pool->contexts[atomic_fetch_add(&pool->idx, 1) % pool->pool_size];
550 }
551 
552 void ff_vk_exec_wait(FFVulkanContext *s, FFVkExecContext *e)
553 {
554  FFVulkanFunctions *vk = &s->vkfn;
555  vk->WaitForFences(s->hwctx->act_dev, 1, &e->fence, VK_TRUE, UINT64_MAX);
556  ff_vk_exec_discard_deps(s, e);
557 }
558 
559 int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
560 {
561  VkResult ret;
562  FFVulkanFunctions *vk = &s->vkfn;
563  const FFVkExecPool *pool = e->parent;
564 
565  VkCommandBufferBeginInfo cmd_start = {
566  .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
567  .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
568  };
569 
570  /* Wait for the fence to be signalled */
571  vk->WaitForFences(s->hwctx->act_dev, 1, &e->fence, VK_TRUE, UINT64_MAX);
572  vk->ResetFences(s->hwctx->act_dev, 1, &e->fence);
573 
574  /* Discard queue dependencies */
575  ff_vk_exec_discard_deps(s, e);
576 
577  ret = vk->BeginCommandBuffer(e->buf, &cmd_start);
578  if (ret != VK_SUCCESS) {
579  av_log(s, AV_LOG_ERROR, "Failed to start command recoding: %s\n",
580  ff_vk_ret2str(ret));
581  return AVERROR_EXTERNAL;
582  }
583 
584  if (pool->nb_queries)
585  vk->CmdResetQueryPool(e->buf, pool->query_pool,
586  e->query_idx, pool->nb_queries);
587 
588  return 0;
589 }
590 
591 void ff_vk_exec_discard_deps(FFVulkanContext *s, FFVkExecContext *e)
592 {
593  for (int j = 0; j < e->nb_buf_deps; j++)
594  av_buffer_unref(&e->buf_deps[j]);
595  e->nb_buf_deps = 0;
596 
597  for (int j = 0; j < e->nb_sw_frame_deps; j++)
598  av_frame_free(&e->sw_frame_deps[j]);
599  e->nb_sw_frame_deps = 0;
600 
601  for (int j = 0; j < e->nb_frame_deps; j++) {
602  AVFrame *f = e->frame_deps[j];
603  if (e->frame_locked[j]) {
604  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
605  AVVulkanFramesContext *vkfc = hwfc->hwctx;
606  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
607  vkfc->unlock_frame(hwfc, vkf);
608  e->frame_locked[j] = 0;
609  }
610  e->frame_update[j] = 0;
611  }
612  e->nb_frame_deps = 0;
613 
614  e->sem_wait_cnt = 0;
615  e->sem_sig_cnt = 0;
616  e->sem_sig_val_dst_cnt = 0;
617 }
618 
619 int ff_vk_exec_add_dep_buf(FFVulkanContext *s, FFVkExecContext *e,
620  AVBufferRef **deps, int nb_deps, int ref)
621 {
622  AVBufferRef **dst = av_fast_realloc(e->buf_deps, &e->buf_deps_alloc_size,
623  (e->nb_buf_deps + nb_deps) * sizeof(*dst));
624  if (!dst) {
625  ff_vk_exec_discard_deps(s, e);
626  return AVERROR(ENOMEM);
627  }
628 
629  e->buf_deps = dst;
630 
631  for (int i = 0; i < nb_deps; i++) {
632  if (!deps[i])
633  continue;
634 
635  e->buf_deps[e->nb_buf_deps] = ref ? av_buffer_ref(deps[i]) : deps[i];
636  if (!e->buf_deps[e->nb_buf_deps]) {
637  ff_vk_exec_discard_deps(s, e);
638  return AVERROR(ENOMEM);
639  }
640  e->nb_buf_deps++;
641  }
642 
643  return 0;
644 }
645 
646 int ff_vk_exec_add_dep_sw_frame(FFVulkanContext *s, FFVkExecContext *e,
647  AVFrame *f)
648 {
649  AVFrame **dst = av_fast_realloc(e->sw_frame_deps, &e->sw_frame_deps_alloc_size,
650  (e->nb_sw_frame_deps + 1) * sizeof(*dst));
651  if (!dst) {
652  ff_vk_exec_discard_deps(s, e);
653  return AVERROR(ENOMEM);
654  }
655 
656  e->sw_frame_deps = dst;
657 
658  e->sw_frame_deps[e->nb_sw_frame_deps] = av_frame_clone(f);
659  if (!e->sw_frame_deps[e->nb_sw_frame_deps]) {
660  ff_vk_exec_discard_deps(s, e);
661  return AVERROR(ENOMEM);
662  }
663 
664  e->nb_sw_frame_deps++;
665 
666  return 0;
667 }
668 
669 #define ARR_REALLOC(str, arr, alloc_s, cnt) \
670  do { \
671  arr = av_fast_realloc(str->arr, alloc_s, (cnt + 1)*sizeof(*arr)); \
672  if (!arr) { \
673  ff_vk_exec_discard_deps(s, e); \
674  return AVERROR(ENOMEM); \
675  } \
676  str->arr = arr; \
677  } while (0)
678 
679 typedef struct TempSyncCtx {
680  int nb_sem;
681  VkSemaphore sem[];
682 } TempSyncCtx;
683 
684 static void destroy_tmp_semaphores(void *opaque, uint8_t *data)
685 {
686  FFVulkanContext *s = opaque;
687  FFVulkanFunctions *vk = &s->vkfn;
688  TempSyncCtx *ts = (TempSyncCtx *)data;
689 
690  for (int i = 0; i < ts->nb_sem; i++)
691  vk->DestroySemaphore(s->hwctx->act_dev, ts->sem[i], s->hwctx->alloc);
692 
693  av_free(ts);
694 }
695 
696 int ff_vk_exec_add_dep_wait_sem(FFVulkanContext *s, FFVkExecContext *e,
697  VkSemaphore sem, uint64_t val,
698  VkPipelineStageFlagBits2 stage)
699 {
700  VkSemaphoreSubmitInfo *sem_wait;
701  ARR_REALLOC(e, sem_wait, &e->sem_wait_alloc, e->sem_wait_cnt);
702 
703  e->sem_wait[e->sem_wait_cnt++] = (VkSemaphoreSubmitInfo) {
704  .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
705  .semaphore = sem,
706  .value = val,
707  .stageMask = stage,
708  };
709 
710  return 0;
711 }
712 
713 int ff_vk_exec_add_dep_bool_sem(FFVulkanContext *s, FFVkExecContext *e,
714  VkSemaphore *sem, int nb,
715  VkPipelineStageFlagBits2 stage,
716  int wait)
717 {
718  int err;
719  size_t buf_size;
720  AVBufferRef *buf;
721  TempSyncCtx *ts;
722  FFVulkanFunctions *vk = &s->vkfn;
723 
724  /* Do not transfer ownership if we're signalling a binary semaphore,
725  * since we're probably exporting it. */
726  if (!wait) {
727  for (int i = 0; i < nb; i++) {
728  VkSemaphoreSubmitInfo *sem_sig;
729  ARR_REALLOC(e, sem_sig, &e->sem_sig_alloc, e->sem_sig_cnt);
730 
731  e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
732  .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
733  .semaphore = sem[i],
734  .stageMask = stage,
735  };
736  }
737 
738  return 0;
739  }
740 
741  buf_size = sizeof(*ts) + sizeof(VkSemaphore)*nb;
742  ts = av_mallocz(buf_size);
743  if (!ts) {
744  err = AVERROR(ENOMEM);
745  goto fail;
746  }
747 
748  memcpy(ts->sem, sem, nb*sizeof(*sem));
749  ts->nb_sem = nb;
750 
751  buf = av_buffer_create((uint8_t *)ts, buf_size, destroy_tmp_semaphores, s, 0);
752  if (!buf) {
753  av_free(ts);
754  err = AVERROR(ENOMEM);
755  goto fail;
756  }
757 
758  err = ff_vk_exec_add_dep_buf(s, e, &buf, 1, 0);
759  if (err < 0) {
760  av_buffer_unref(&buf);
761  return err;
762  }
763 
764  for (int i = 0; i < nb; i++) {
765  err = ff_vk_exec_add_dep_wait_sem(s, e, sem[i], 0, stage);
766  if (err < 0)
767  return err;
768  }
769 
770  return 0;
771 
772 fail:
773  for (int i = 0; i < nb; i++)
774  vk->DestroySemaphore(s->hwctx->act_dev, sem[i], s->hwctx->alloc);
775 
776  return err;
777 }
778 
779 int ff_vk_exec_add_dep_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f,
780  VkPipelineStageFlagBits2 wait_stage,
781  VkPipelineStageFlagBits2 signal_stage)
782 {
783  uint8_t *frame_locked;
784  uint8_t *frame_update;
785  AVFrame **frame_deps;
786  AVBufferRef **buf_deps;
787  VkImageLayout *layout_dst;
788  uint32_t *queue_family_dst;
789  VkAccessFlagBits *access_dst;
790 
791  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
792  AVVulkanFramesContext *vkfc = hwfc->hwctx;
793  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
794  int nb_images = ff_vk_count_images(vkf);
795 
796  /* Don't add duplicates */
797  for (int i = 0; i < e->nb_frame_deps; i++)
798  if (e->frame_deps[i]->data[0] == f->data[0])
799  return 1;
800 
801  ARR_REALLOC(e, layout_dst, &e->layout_dst_alloc, e->nb_frame_deps);
802  ARR_REALLOC(e, queue_family_dst, &e->queue_family_dst_alloc, e->nb_frame_deps);
803  ARR_REALLOC(e, access_dst, &e->access_dst_alloc, e->nb_frame_deps);
804 
805  ARR_REALLOC(e, frame_locked, &e->frame_locked_alloc_size, e->nb_frame_deps);
806  ARR_REALLOC(e, frame_update, &e->frame_update_alloc_size, e->nb_frame_deps);
807  ARR_REALLOC(e, frame_deps, &e->frame_deps_alloc_size, e->nb_frame_deps);
808 
809  /* prepare_frame in hwcontext_vulkan.c uses the regular frame management
810  * code but has no frame yet, and it doesn't need to actually store a ref
811  * to the frame. */
812  if (f->buf[0]) {
813  ARR_REALLOC(e, buf_deps, &e->buf_deps_alloc_size, e->nb_buf_deps);
814  e->buf_deps[e->nb_buf_deps] = av_buffer_ref(f->buf[0]);
815  if (!e->buf_deps[e->nb_buf_deps]) {
816  ff_vk_exec_discard_deps(s, e);
817  return AVERROR(ENOMEM);
818  }
819  e->nb_buf_deps++;
820  }
821 
822  e->frame_deps[e->nb_frame_deps] = f;
823 
824  vkfc->lock_frame(hwfc, vkf);
825  e->frame_locked[e->nb_frame_deps] = 1;
826  e->frame_update[e->nb_frame_deps] = 0;
827  e->nb_frame_deps++;
828 
829  for (int i = 0; i < nb_images; i++) {
830  VkSemaphoreSubmitInfo *sem_wait;
831  VkSemaphoreSubmitInfo *sem_sig;
832  uint64_t **sem_sig_val_dst;
833 
834  ARR_REALLOC(e, sem_wait, &e->sem_wait_alloc, e->sem_wait_cnt);
835  ARR_REALLOC(e, sem_sig, &e->sem_sig_alloc, e->sem_sig_cnt);
836  ARR_REALLOC(e, sem_sig_val_dst, &e->sem_sig_val_dst_alloc, e->sem_sig_val_dst_cnt);
837 
838  e->sem_wait[e->sem_wait_cnt++] = (VkSemaphoreSubmitInfo) {
839  .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
840  .semaphore = vkf->sem[i],
841  .value = vkf->sem_value[i],
842  .stageMask = wait_stage,
843  };
844 
845  e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
846  .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
847  .semaphore = vkf->sem[i],
848  .value = vkf->sem_value[i] + 1,
849  .stageMask = signal_stage,
850  };
851 
852  e->sem_sig_val_dst[e->sem_sig_val_dst_cnt] = &vkf->sem_value[i];
853  e->sem_sig_val_dst_cnt++;
854  }
855 
856  return 0;
857 }
858 
859 void ff_vk_exec_update_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f,
860  VkImageMemoryBarrier2 *bar, uint32_t *nb_img_bar)
861 {
862  int i;
863  for (i = 0; i < e->nb_frame_deps; i++)
864  if (e->frame_deps[i]->data[0] == f->data[0])
865  break;
866  av_assert0(i < e->nb_frame_deps);
867 
868  /* Don't update duplicates */
869  if (nb_img_bar && !e->frame_update[i])
870  (*nb_img_bar)++;
871 
872  e->queue_family_dst[i] = bar->dstQueueFamilyIndex;
873  e->access_dst[i] = bar->dstAccessMask;
874  e->layout_dst[i] = bar->newLayout;
875  e->frame_update[i] = 1;
876 }
877 
878 int ff_vk_exec_mirror_sem_value(FFVulkanContext *s, FFVkExecContext *e,
879  VkSemaphore *dst, uint64_t *dst_val,
880  AVFrame *f)
881 {
882  uint64_t **sem_sig_val_dst;
883  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
884 
885  /* Reject unknown frames */
886  int i;
887  for (i = 0; i < e->nb_frame_deps; i++)
888  if (e->frame_deps[i]->data[0] == f->data[0])
889  break;
890  if (i == e->nb_frame_deps)
891  return AVERROR(EINVAL);
892 
893  ARR_REALLOC(e, sem_sig_val_dst, &e->sem_sig_val_dst_alloc, e->sem_sig_val_dst_cnt);
894 
895  *dst = vkf->sem[0];
896  *dst_val = vkf->sem_value[0];
897 
898  e->sem_sig_val_dst[e->sem_sig_val_dst_cnt] = dst_val;
899  e->sem_sig_val_dst_cnt++;
900 
901  return 0;
902 }
903 
904 int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
905 {
906  VkResult ret;
907  FFVulkanFunctions *vk = &s->vkfn;
908  VkCommandBufferSubmitInfo cmd_buf_info = (VkCommandBufferSubmitInfo) {
909  .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
910  .commandBuffer = e->buf,
911  };
912  VkSubmitInfo2 submit_info = (VkSubmitInfo2) {
913  .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
914  .pCommandBufferInfos = &cmd_buf_info,
915  .commandBufferInfoCount = 1,
916  .pWaitSemaphoreInfos = e->sem_wait,
917  .waitSemaphoreInfoCount = e->sem_wait_cnt,
918  .pSignalSemaphoreInfos = e->sem_sig,
919  .signalSemaphoreInfoCount = e->sem_sig_cnt,
920  };
921 
922  ret = vk->EndCommandBuffer(e->buf);
923  if (ret != VK_SUCCESS) {
924  av_log(s, AV_LOG_ERROR, "Unable to finish command buffer: %s\n",
925  ff_vk_ret2str(ret));
926  ff_vk_exec_discard_deps(s, e);
927  return AVERROR_EXTERNAL;
928  }
929 
930  s->hwctx->lock_queue(s->device, e->qf, e->qi);
931  ret = vk->QueueSubmit2(e->queue, 1, &submit_info, e->fence);
932  s->hwctx->unlock_queue(s->device, e->qf, e->qi);
933 
934  if (ret != VK_SUCCESS) {
935  av_log(s, AV_LOG_ERROR, "Unable to submit command buffer: %s\n",
936  ff_vk_ret2str(ret));
937  ff_vk_exec_discard_deps(s, e);
938  return AVERROR_EXTERNAL;
939  }
940 
941  for (int i = 0; i < e->sem_sig_val_dst_cnt; i++)
942  *e->sem_sig_val_dst[i] += 1;
943 
944  /* Unlock all frames */
945  for (int j = 0; j < e->nb_frame_deps; j++) {
946  if (e->frame_locked[j]) {
947  AVFrame *f = e->frame_deps[j];
948  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
949  AVVulkanFramesContext *vkfc = hwfc->hwctx;
950  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
951 
952  if (e->frame_update[j]) {
953  int nb_images = ff_vk_count_images(vkf);
954  for (int i = 0; i < nb_images; i++) {
955  vkf->layout[i] = e->layout_dst[j];
956  vkf->access[i] = e->access_dst[j];
957  vkf->queue_family[i] = e->queue_family_dst[j];
958  }
959  }
960  vkfc->unlock_frame(hwfc, vkf);
961  e->frame_locked[j] = 0;
962  }
963  }
964 
965  e->had_submission = 1;
966 
967  return 0;
968 }
969 
970 int ff_vk_alloc_mem(FFVulkanContext *s, VkMemoryRequirements *req,
971  VkMemoryPropertyFlagBits req_flags, void *alloc_extension,
972  VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
973 {
974  VkResult ret;
975  int index = -1;
976  FFVulkanFunctions *vk = &s->vkfn;
977 
978  VkMemoryAllocateInfo alloc_info = {
979  .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
980  .pNext = alloc_extension,
981  };
982 
983  alloc_info.allocationSize = req->size;
984 
985  /* The vulkan spec requires memory types to be sorted in the "optimal"
986  * order, so the first matching type we find will be the best/fastest one */
987  for (int i = 0; i < s->mprops.memoryTypeCount; i++) {
988  /* The memory type must be supported by the requirements (bitfield) */
989  if (!(req->memoryTypeBits & (1 << i)))
990  continue;
991 
992  /* The memory type flags must include our properties */
993  if ((req_flags != UINT32_MAX) &&
994  ((s->mprops.memoryTypes[i].propertyFlags & req_flags) != req_flags))
995  continue;
996 
997  /* Found a suitable memory type */
998  index = i;
999  break;
1000  }
1001 
1002  if (index < 0) {
1003  av_log(s, AV_LOG_ERROR, "No memory type found for flags 0x%x\n",
1004  req_flags);
1005  return AVERROR(EINVAL);
1006  }
1007 
1008  alloc_info.memoryTypeIndex = index;
1009 
1010  ret = vk->AllocateMemory(s->hwctx->act_dev, &alloc_info,
1011  s->hwctx->alloc, mem);
1012  if (ret != VK_SUCCESS)
1013  return AVERROR(ENOMEM);
1014 
1015  if (mem_flags)
1016  *mem_flags |= s->mprops.memoryTypes[index].propertyFlags;
1017 
1018  return 0;
1019 }
1020 
1021 int ff_vk_create_buf(FFVulkanContext *s, FFVkBuffer *buf, size_t size,
1022  void *pNext, void *alloc_pNext,
1023  VkBufferUsageFlags usage, VkMemoryPropertyFlagBits flags)
1024 {
1025  int err;
1026  VkResult ret;
1027  int use_ded_mem;
1028  FFVulkanFunctions *vk = &s->vkfn;
1029 
1030  /* Buffer usage flags corresponding to buffer descriptor types */
1031  const VkBufferUsageFlags desc_usage =
1032  VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
1033  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
1034  VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
1035  VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
1036 
1037  if ((s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) && (usage & desc_usage))
1038  usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
1039 
1040  VkBufferCreateInfo buf_spawn = {
1041  .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1042  .pNext = pNext,
1043  .usage = usage,
1044  .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
1045  .size = flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ?
1046  FFALIGN(size, s->props.properties.limits.minMemoryMapAlignment) :
1047  size,
1048  };
1049 
1050  VkMemoryAllocateFlagsInfo alloc_flags = {
1051  .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
1052  .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
1053  };
1054  VkBufferMemoryRequirementsInfo2 req_desc = {
1055  .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
1056  };
1057  VkMemoryDedicatedAllocateInfo ded_alloc = {
1058  .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
1059  .pNext = alloc_pNext,
1060  };
1061  VkMemoryDedicatedRequirements ded_req = {
1062  .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
1063  };
1064  VkMemoryRequirements2 req = {
1065  .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
1066  .pNext = &ded_req,
1067  };
1068 
1069  av_log(s, AV_LOG_DEBUG, "Creating a buffer of %"SIZE_SPECIFIER" bytes, "
1070  "usage: 0x%x, flags: 0x%x\n",
1071  size, usage, flags);
1072 
1073  ret = vk->CreateBuffer(s->hwctx->act_dev, &buf_spawn, s->hwctx->alloc, &buf->buf);
1074  if (ret != VK_SUCCESS) {
1075  av_log(s, AV_LOG_ERROR, "Failed to create buffer: %s\n",
1076  ff_vk_ret2str(ret));
1077  return AVERROR_EXTERNAL;
1078  }
1079 
1080  req_desc.buffer = buf->buf;
1081 
1082  vk->GetBufferMemoryRequirements2(s->hwctx->act_dev, &req_desc, &req);
1083 
1084  /* In case the implementation prefers/requires dedicated allocation */
1085  use_ded_mem = ded_req.prefersDedicatedAllocation |
1086  ded_req.requiresDedicatedAllocation;
1087  if (use_ded_mem) {
1088  ded_alloc.buffer = buf->buf;
1089  ded_alloc.pNext = alloc_pNext;
1090  alloc_pNext = &ded_alloc;
1091  }
1092 
1093  if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1094  alloc_flags.pNext = alloc_pNext;
1095  alloc_pNext = &alloc_flags;
1096  }
1097 
1098  err = ff_vk_alloc_mem(s, &req.memoryRequirements, flags, alloc_pNext,
1099  &buf->flags, &buf->mem);
1100  if (err)
1101  return err;
1102 
1103  ret = vk->BindBufferMemory(s->hwctx->act_dev, buf->buf, buf->mem, 0);
1104  if (ret != VK_SUCCESS) {
1105  av_log(s, AV_LOG_ERROR, "Failed to bind memory to buffer: %s\n",
1106  ff_vk_ret2str(ret));
1107  return AVERROR_EXTERNAL;
1108  }
1109 
1110  if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1111  VkBufferDeviceAddressInfo address_info = {
1112  .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
1113  .buffer = buf->buf,
1114  };
1115  buf->address = vk->GetBufferDeviceAddress(s->hwctx->act_dev, &address_info);
1116  }
1117 
1118  buf->size = size;
1119 
1120  return 0;
1121 }
1122 
1123 int ff_vk_map_buffers(FFVulkanContext *s, FFVkBuffer **buf, uint8_t *mem[],
1124  int nb_buffers, int invalidate)
1125 {
1126  VkResult ret;
1127  FFVulkanFunctions *vk = &s->vkfn;
1128  VkMappedMemoryRange inval_list[64];
1129  int inval_count = 0;
1130 
1131  for (int i = 0; i < nb_buffers; i++) {
1132  void *dst;
1133  ret = vk->MapMemory(s->hwctx->act_dev, buf[i]->mem, 0,
1134  VK_WHOLE_SIZE, 0, &dst);
1135  if (ret != VK_SUCCESS) {
1136  av_log(s, AV_LOG_ERROR, "Failed to map buffer memory: %s\n",
1137  ff_vk_ret2str(ret));
1138  return AVERROR_EXTERNAL;
1139  }
1140  mem[i] = buf[i]->mapped_mem = dst;
1141  }
1142 
1143  if (!invalidate)
1144  return 0;
1145 
1146  for (int i = 0; i < nb_buffers; i++) {
1147  const VkMappedMemoryRange ival_buf = {
1148  .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1149  .memory = buf[i]->mem,
1150  .size = VK_WHOLE_SIZE,
1151  };
1152  if (buf[i]->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
1153  continue;
1154  inval_list[inval_count++] = ival_buf;
1155  }
1156 
1157  if (inval_count) {
1158  ret = vk->InvalidateMappedMemoryRanges(s->hwctx->act_dev, inval_count,
1159  inval_list);
1160  if (ret != VK_SUCCESS) {
1161  av_log(s, AV_LOG_ERROR, "Failed to invalidate memory: %s\n",
1162  ff_vk_ret2str(ret));
1163  return AVERROR_EXTERNAL;
1164  }
1165  }
1166 
1167  return 0;
1168 }
1169 
1170 int ff_vk_unmap_buffers(FFVulkanContext *s, FFVkBuffer **buf, int nb_buffers,
1171  int flush)
1172 {
1173  int err = 0;
1174  VkResult ret;
1175  FFVulkanFunctions *vk = &s->vkfn;
1176  VkMappedMemoryRange flush_list[64];
1177  int flush_count = 0;
1178 
1179  if (flush) {
1180  for (int i = 0; i < nb_buffers; i++) {
1181  const VkMappedMemoryRange flush_buf = {
1182  .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1183  .memory = buf[i]->mem,
1184  .size = VK_WHOLE_SIZE,
1185  };
1186 
1187  av_assert0(!buf[i]->host_ref);
1188  if (buf[i]->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
1189  continue;
1190  flush_list[flush_count++] = flush_buf;
1191  }
1192  }
1193 
1194  if (flush_count) {
1195  ret = vk->FlushMappedMemoryRanges(s->hwctx->act_dev, flush_count,
1196  flush_list);
1197  if (ret != VK_SUCCESS) {
1198  av_log(s, AV_LOG_ERROR, "Failed to flush memory: %s\n",
1199  ff_vk_ret2str(ret));
1200  err = AVERROR_EXTERNAL; /* We still want to try to unmap them */
1201  }
1202  }
1203 
1204  for (int i = 0; i < nb_buffers; i++) {
1205  vk->UnmapMemory(s->hwctx->act_dev, buf[i]->mem);
1206  buf[i]->mapped_mem = NULL;
1207  }
1208 
1209  return err;
1210 }
1211 
1212 void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
1213 {
1214  FFVulkanFunctions *vk = &s->vkfn;
1215 
1216  if (!buf || !s->hwctx)
1217  return;
1218 
1219  if (buf->mapped_mem && !buf->host_ref)
1220  ff_vk_unmap_buffer(s, buf, 0);
1221  if (buf->buf != VK_NULL_HANDLE)
1222  vk->DestroyBuffer(s->hwctx->act_dev, buf->buf, s->hwctx->alloc);
1223  if (buf->mem != VK_NULL_HANDLE)
1224  vk->FreeMemory(s->hwctx->act_dev, buf->mem, s->hwctx->alloc);
1225  if (buf->host_ref)
1226  av_buffer_unref(&buf->host_ref);
1227 
1228  buf->buf = VK_NULL_HANDLE;
1229  buf->mem = VK_NULL_HANDLE;
1230  buf->mapped_mem = NULL;
1231 }
1232 
1233 static void free_data_buf(void *opaque, uint8_t *data)
1234 {
1235  FFVulkanContext *ctx = opaque;
1236  FFVkBuffer *buf = (FFVkBuffer *)data;
1237  ff_vk_free_buf(ctx, buf);
1238  av_free(data);
1239 }
1240 
1241 static AVBufferRef *alloc_data_buf(void *opaque, size_t size)
1242 {
1243  AVBufferRef *ref;
1244  uint8_t *buf = av_mallocz(size);
1245  if (!buf)
1246  return NULL;
1247 
1248  ref = av_buffer_create(buf, size, free_data_buf, opaque, 0);
1249  if (!ref)
1250  av_free(buf);
1251  return ref;
1252 }
1253 
1254 int ff_vk_get_pooled_buffer(FFVulkanContext *ctx, AVBufferPool **buf_pool,
1255  AVBufferRef **buf, VkBufferUsageFlags usage,
1256  void *create_pNext, size_t size,
1257  VkMemoryPropertyFlagBits mem_props)
1258 {
1259  int err;
1260  AVBufferRef *ref;
1261  FFVkBuffer *data;
1262 
1263  *buf = NULL;
1264 
1265  if (!(*buf_pool)) {
1266  *buf_pool = av_buffer_pool_init2(sizeof(FFVkBuffer), ctx,
1267  alloc_data_buf, NULL);
1268  if (!(*buf_pool))
1269  return AVERROR(ENOMEM);
1270  }
1271 
1272  *buf = ref = av_buffer_pool_get(*buf_pool);
1273  if (!ref)
1274  return AVERROR(ENOMEM);
1275 
1276  data = (FFVkBuffer *)ref->data;
1277  data->stage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
1278  data->access = VK_ACCESS_2_NONE;
1279 
1280  if (data->size >= size)
1281  return 0;
1282 
1283  ff_vk_free_buf(ctx, data);
1284  memset(data, 0, sizeof(*data));
1285 
1286  err = ff_vk_create_buf(ctx, data, size,
1287  create_pNext, NULL, usage,
1288  mem_props);
1289  if (err < 0) {
1290  av_buffer_unref(&ref);
1291  *buf = NULL;
1292  return err;
1293  }
1294 
1295  if (mem_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
1296  err = ff_vk_map_buffer(ctx, data, &data->mapped_mem, 0);
1297  if (err < 0) {
1298  av_buffer_unref(&ref);
1299  *buf = NULL;
1300  return err;
1301  }
1302  }
1303 
1304  return 0;
1305 }
1306 
1307 static int create_mapped_buffer(FFVulkanContext *s,
1308  FFVkBuffer *vkb, VkBufferUsageFlags usage,
1309  size_t size,
1310  VkExternalMemoryBufferCreateInfo *create_desc,
1311  VkImportMemoryHostPointerInfoEXT *import_desc,
1312  VkMemoryHostPointerPropertiesEXT props)
1313 {
1314  int err;
1315  VkResult ret;
1316  FFVulkanFunctions *vk = &s->vkfn;
1317 
1318  VkBufferCreateInfo buf_spawn = {
1319  .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1320  .pNext = create_desc,
1321  .usage = usage,
1322  .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
1323  .size = size,
1324  };
1325  VkMemoryRequirements req = {
1326  .size = size,
1327  .alignment = s->hprops.minImportedHostPointerAlignment,
1328  .memoryTypeBits = props.memoryTypeBits,
1329  };
1330 
1331  err = ff_vk_alloc_mem(s, &req,
1332  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
1333  import_desc, &vkb->flags, &vkb->mem);
1334  if (err < 0)
1335  return err;
1336 
1337  ret = vk->CreateBuffer(s->hwctx->act_dev, &buf_spawn, s->hwctx->alloc, &vkb->buf);
1338  if (ret != VK_SUCCESS) {
1339  vk->FreeMemory(s->hwctx->act_dev, vkb->mem, s->hwctx->alloc);
1340  return AVERROR_EXTERNAL;
1341  }
1342 
1343  ret = vk->BindBufferMemory(s->hwctx->act_dev, vkb->buf, vkb->mem, 0);
1344  if (ret != VK_SUCCESS) {
1345  vk->FreeMemory(s->hwctx->act_dev, vkb->mem, s->hwctx->alloc);
1346  vk->DestroyBuffer(s->hwctx->act_dev, vkb->buf, s->hwctx->alloc);
1347  return AVERROR_EXTERNAL;
1348  }
1349 
1350  return 0;
1351 }
1352 
1353 static void destroy_avvkbuf(void *opaque, uint8_t *data)
1354 {
1355  FFVulkanContext *s = opaque;
1356  FFVkBuffer *buf = (FFVkBuffer *)data;
1357  ff_vk_free_buf(s, buf);
1358  av_free(buf);
1359 }
1360 
1361 int ff_vk_host_map_buffer(FFVulkanContext *s, AVBufferRef **dst,
1362  uint8_t *src_data, const AVBufferRef *src_buf,
1363  VkBufferUsageFlags usage)
1364 {
1365  int err;
1366  VkResult ret;
1367  FFVulkanFunctions *vk = &s->vkfn;
1368 
1369  VkExternalMemoryBufferCreateInfo create_desc = {
1370  .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
1371  .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
1372  };
1373  VkMemoryAllocateFlagsInfo alloc_flags = {
1374  .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
1375  .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
1376  };
1377  VkImportMemoryHostPointerInfoEXT import_desc = {
1378  .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
1379  .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
1380  .pNext = usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT ? &alloc_flags : NULL,
1381  };
1382  VkMemoryHostPointerPropertiesEXT props;
1383 
1384  AVBufferRef *ref;
1385  FFVkBuffer *vkb;
1386  size_t offs;
1387  size_t buffer_size;
1388 
1389  *dst = NULL;
1390 
1391  /* Get the previous point at which mapping was possible and use it */
1392  offs = (uintptr_t)src_data % s->hprops.minImportedHostPointerAlignment;
1393  import_desc.pHostPointer = src_data - offs;
1394 
1395  props = (VkMemoryHostPointerPropertiesEXT) {
1396  VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
1397  };
1398  ret = vk->GetMemoryHostPointerPropertiesEXT(s->hwctx->act_dev,
1399  import_desc.handleType,
1400  import_desc.pHostPointer,
1401  &props);
1402  if (!(ret == VK_SUCCESS && props.memoryTypeBits))
1403  return AVERROR(EINVAL);
1404 
1405  /* Ref the source buffer */
1406  ref = av_buffer_ref(src_buf);
1407  if (!ref)
1408  return AVERROR(ENOMEM);
1409 
1410  /* Add the offset at the start, which gets ignored */
1411  const ptrdiff_t src_offset = src_data - src_buf->data;
1412  buffer_size = offs + (src_buf->size - src_offset);
1413  buffer_size = FFALIGN(buffer_size, s->props.properties.limits.minMemoryMapAlignment);
1414  buffer_size = FFALIGN(buffer_size, s->hprops.minImportedHostPointerAlignment);
1415 
1416  /* Create a buffer struct */
1417  vkb = av_mallocz(sizeof(*vkb));
1418  if (!vkb) {
1419  av_buffer_unref(&ref);
1420  return AVERROR(ENOMEM);
1421  }
1422 
1423  err = create_mapped_buffer(s, vkb, usage,
1424  buffer_size, &create_desc, &import_desc,
1425  props);
1426  if (err < 0) {
1427  av_buffer_unref(&ref);
1428  av_free(vkb);
1429  return err;
1430  }
1431 
1432  if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1433  VkBufferDeviceAddressInfo address_info = {
1434  .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
1435  .buffer = vkb->buf,
1436  };
1437  vkb->address = vk->GetBufferDeviceAddress(s->hwctx->act_dev, &address_info);
1438  }
1439 
1440  vkb->host_ref = ref;
1441  vkb->virtual_offset = offs;
1442  vkb->address += offs;
1443  vkb->mapped_mem = src_data;
1444  vkb->size = buffer_size - offs;
1445  vkb->flags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
1446 
1447  /* Create a ref */
1448  *dst = av_buffer_create((uint8_t *)vkb, sizeof(*vkb),
1449  destroy_avvkbuf, s, 0);
1450  if (!(*dst)) {
1451  destroy_avvkbuf(s, (uint8_t *)vkb);
1452  *dst = NULL;
1453  return AVERROR(ENOMEM);
1454  }
1455 
1456  return 0;
1457 }
1458 
1459 int ff_vk_shader_add_push_const(FFVulkanShader *shd, int offset, int size,
1460  VkShaderStageFlagBits stage)
1461 {
1462  VkPushConstantRange *pc;
1463 
1464  shd->push_consts = av_realloc_array(shd->push_consts,
1465  sizeof(*shd->push_consts),
1466  shd->push_consts_num + 1);
1467  if (!shd->push_consts)
1468  return AVERROR(ENOMEM);
1469 
1470  pc = &shd->push_consts[shd->push_consts_num++];
1471  memset(pc, 0, sizeof(*pc));
1472 
1473  pc->stageFlags = stage;
1474  pc->offset = offset;
1475  pc->size = size;
1476 
1477  return 0;
1478 }
1479 
1480 int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler,
1481  int unnorm_coords, VkFilter filt)
1482 {
1483  VkResult ret;
1484  FFVulkanFunctions *vk = &s->vkfn;
1485 
1486  VkSamplerCreateInfo sampler_info = {
1487  .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
1488  .magFilter = filt,
1489  .minFilter = sampler_info.magFilter,
1490  .mipmapMode = unnorm_coords ? VK_SAMPLER_MIPMAP_MODE_NEAREST :
1491  VK_SAMPLER_MIPMAP_MODE_LINEAR,
1492  .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1493  .addressModeV = sampler_info.addressModeU,
1494  .addressModeW = sampler_info.addressModeU,
1495  .anisotropyEnable = VK_FALSE,
1496  .compareOp = VK_COMPARE_OP_NEVER,
1497  .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
1498  .unnormalizedCoordinates = unnorm_coords,
1499  };
1500 
1501  ret = vk->CreateSampler(s->hwctx->act_dev, &sampler_info,
1502  s->hwctx->alloc, sampler);
1503  if (ret != VK_SUCCESS) {
1504  av_log(s, AV_LOG_ERROR, "Unable to init sampler: %s\n",
1505  ff_vk_ret2str(ret));
1506  return AVERROR_EXTERNAL;
1507  }
1508 
1509  return 0;
1510 }
1511 
1512 VkImageAspectFlags ff_vk_aspect_flag(AVFrame *f, int p)
1513 {
1514  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
1515  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
1516  int nb_images = ff_vk_count_images(vkf);
1517  int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
1518 
1519  static const VkImageAspectFlags plane_aspect[] = { VK_IMAGE_ASPECT_PLANE_0_BIT,
1520  VK_IMAGE_ASPECT_PLANE_1_BIT,
1521  VK_IMAGE_ASPECT_PLANE_2_BIT, };
1522 
1523  if (ff_vk_mt_is_np_rgb(hwfc->sw_format) || (nb_planes == nb_images))
1524  return VK_IMAGE_ASPECT_COLOR_BIT;
1525 
1526  return plane_aspect[p];
1527 }
1528 
1529 int ff_vk_mt_is_np_rgb(enum AVPixelFormat pix_fmt)
1530 {
1531  if (pix_fmt == AV_PIX_FMT_ABGR || pix_fmt == AV_PIX_FMT_BGRA ||
1532  pix_fmt == AV_PIX_FMT_RGBA || pix_fmt == AV_PIX_FMT_RGB24 ||
1533  pix_fmt == AV_PIX_FMT_BGR24 || pix_fmt == AV_PIX_FMT_RGB48 ||
1534  pix_fmt == AV_PIX_FMT_RGBA64 || pix_fmt == AV_PIX_FMT_RGB565 ||
1535  pix_fmt == AV_PIX_FMT_BGR565 || pix_fmt == AV_PIX_FMT_BGR0 ||
1536  pix_fmt == AV_PIX_FMT_0BGR || pix_fmt == AV_PIX_FMT_RGB0 ||
1537  pix_fmt == AV_PIX_FMT_GBRP10MSB || pix_fmt == AV_PIX_FMT_GBRP12MSB ||
1538  pix_fmt == AV_PIX_FMT_GBRP16 ||
1539  pix_fmt == AV_PIX_FMT_GBRAP || pix_fmt == AV_PIX_FMT_GBRAP10 ||
1540  pix_fmt == AV_PIX_FMT_GBRAP12 || pix_fmt == AV_PIX_FMT_GBRAP14 ||
1541  pix_fmt == AV_PIX_FMT_GBRAP16 || pix_fmt == AV_PIX_FMT_GBRAP32 ||
1542  pix_fmt == AV_PIX_FMT_GBRPF32 || pix_fmt == AV_PIX_FMT_GBRAPF32 ||
1543  pix_fmt == AV_PIX_FMT_X2RGB10 || pix_fmt == AV_PIX_FMT_X2BGR10 ||
1544  pix_fmt == AV_PIX_FMT_RGBAF32 || pix_fmt == AV_PIX_FMT_RGBF32 ||
1545  pix_fmt == AV_PIX_FMT_RGBA128 || pix_fmt == AV_PIX_FMT_RGB96 ||
1546  pix_fmt == AV_PIX_FMT_GBRP || pix_fmt == AV_PIX_FMT_BAYER_RGGB16)
1547  return 1;
1548  return 0;
1549 }
1550 
1551 void ff_vk_set_perm(enum AVPixelFormat pix_fmt, int lut[4], int inv)
1552 {
1553  switch (pix_fmt) {
1554  case AV_PIX_FMT_GBRP:
1555  case AV_PIX_FMT_GBRAP:
1556  case AV_PIX_FMT_GBRAP10:
1557  case AV_PIX_FMT_GBRAP12:
1558  case AV_PIX_FMT_GBRAP14:
1559  case AV_PIX_FMT_GBRAP16:
1560  case AV_PIX_FMT_GBRP10MSB:
1561  case AV_PIX_FMT_GBRP12MSB:
1562  case AV_PIX_FMT_GBRP16:
1563  case AV_PIX_FMT_GBRPF32:
1564  case AV_PIX_FMT_GBRAP32:
1565  case AV_PIX_FMT_GBRAPF32:
1566  lut[0] = 1;
1567  lut[1] = 2;
1568  lut[2] = 0;
1569  lut[3] = 3;
1570  break;
1571  default:
1572  lut[0] = 0;
1573  lut[1] = 1;
1574  lut[2] = 2;
1575  lut[3] = 3;
1576  break;
1577  }
1578 
1579  if (inv) {
1580  int lut_tmp[4] = { lut[0], lut[1], lut[2], lut[3] };
1581  for (int i = 0; i < 4; i++)
1582  lut[lut_tmp[i]] = i;
1583  }
1584 
1585  return;
1586 }
1587 
1588 const char *ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt,
1589  enum FFVkShaderRepFormat rep_fmt)
1590 {
1591  switch (pix_fmt) {
1592  case AV_PIX_FMT_RGBA:
1593  case AV_PIX_FMT_BGRA:
1594  case AV_PIX_FMT_RGB24:
1595  case AV_PIX_FMT_BGR24:
1596  case AV_PIX_FMT_BGR0:
1597  case AV_PIX_FMT_RGB0:
1598  case AV_PIX_FMT_RGB565:
1599  case AV_PIX_FMT_BGR565:
1600  case AV_PIX_FMT_UYVA:
1601  case AV_PIX_FMT_YUYV422:
1602  case AV_PIX_FMT_UYVY422: {
1603  const char *rep_tab[] = {
1604  [FF_VK_REP_NATIVE] = "rgba8ui",
1605  [FF_VK_REP_FLOAT] = "rgba8",
1606  [FF_VK_REP_INT] = "rgba8i",
1607  [FF_VK_REP_UINT] = "rgba8ui",
1608  };
1609  return rep_tab[rep_fmt];
1610  }
1611  case AV_PIX_FMT_X2RGB10:
1612  case AV_PIX_FMT_X2BGR10:
1613  case AV_PIX_FMT_Y210:
1614  case AV_PIX_FMT_XV30: {
1615  const char *rep_tab[] = {
1616  [FF_VK_REP_NATIVE] = "rgb10_a2ui",
1617  [FF_VK_REP_FLOAT] = "rgb10_a2",
1618  [FF_VK_REP_INT] = NULL,
1619  [FF_VK_REP_UINT] = "rgb10_a2ui",
1620  };
1621  return rep_tab[rep_fmt];
1622  }
1623  case AV_PIX_FMT_RGB48:
1624  case AV_PIX_FMT_RGBA64:
1625  case AV_PIX_FMT_Y212:
1626  case AV_PIX_FMT_Y216:
1627  case AV_PIX_FMT_XV36:
1628  case AV_PIX_FMT_XV48: {
1629  const char *rep_tab[] = {
1630  [FF_VK_REP_NATIVE] = "rgba16ui",
1631  [FF_VK_REP_FLOAT] = "rgba16",
1632  [FF_VK_REP_INT] = "rgba16i",
1633  [FF_VK_REP_UINT] = "rgba16ui",
1634  };
1635  return rep_tab[rep_fmt];
1636  }
1637  case AV_PIX_FMT_RGBF32:
1638  case AV_PIX_FMT_RGBAF32: {
1639  const char *rep_tab[] = {
1640  [FF_VK_REP_NATIVE] = "rgba32f",
1641  [FF_VK_REP_FLOAT] = "rgba32f",
1642  [FF_VK_REP_INT] = "rgba32i",
1643  [FF_VK_REP_UINT] = "rgba32ui",
1644  };
1645  return rep_tab[rep_fmt];
1646  }
1647  case AV_PIX_FMT_RGB96:
1648  case AV_PIX_FMT_RGBA128: {
1649  const char *rep_tab[] = {
1650  [FF_VK_REP_NATIVE] = "rgba32ui",
1651  [FF_VK_REP_FLOAT] = NULL,
1652  [FF_VK_REP_INT] = "rgba32i",
1653  [FF_VK_REP_UINT] = "rgba32ui",
1654  };
1655  return rep_tab[rep_fmt];
1656  }
1657  case AV_PIX_FMT_GBRP:
1658  case AV_PIX_FMT_GRAY8:
1659  case AV_PIX_FMT_GBRAP:
1660  case AV_PIX_FMT_YUV420P:
1661  case AV_PIX_FMT_YUV422P:
1662  case AV_PIX_FMT_YUV444P:
1663  case AV_PIX_FMT_YUVA420P:
1664  case AV_PIX_FMT_YUVA422P:
1665  case AV_PIX_FMT_YUVA444P: {
1666  const char *rep_tab[] = {
1667  [FF_VK_REP_NATIVE] = "r8ui",
1668  [FF_VK_REP_FLOAT] = "r8",
1669  [FF_VK_REP_INT] = "r8i",
1670  [FF_VK_REP_UINT] = "r8ui",
1671  };
1672  return rep_tab[rep_fmt];
1673  };
1674  case AV_PIX_FMT_GRAY10MSB:
1675  case AV_PIX_FMT_GRAY12MSB:
1676  case AV_PIX_FMT_GRAY16:
1677  case AV_PIX_FMT_GBRAP10:
1678  case AV_PIX_FMT_GBRAP12:
1679  case AV_PIX_FMT_GBRAP14:
1680  case AV_PIX_FMT_GBRAP16:
1681  case AV_PIX_FMT_GBRP10MSB:
1682  case AV_PIX_FMT_GBRP12MSB:
1683  case AV_PIX_FMT_GBRP16:
1684  case AV_PIX_FMT_YUV420P10MSB:
1685  case AV_PIX_FMT_YUV420P12MSB:
1686  case AV_PIX_FMT_YUV420P16:
1687  case AV_PIX_FMT_YUV422P10MSB:
1688  case AV_PIX_FMT_YUV422P12MSB:
1689  case AV_PIX_FMT_YUV422P16:
1690  case AV_PIX_FMT_YUV444P10MSB:
1691  case AV_PIX_FMT_YUV444P12MSB:
1692  case AV_PIX_FMT_YUV444P16:
1693  case AV_PIX_FMT_YUVA420P16:
1694  case AV_PIX_FMT_YUVA422P16:
1695  case AV_PIX_FMT_YUVA444P16:
1696  case AV_PIX_FMT_BAYER_RGGB16: {
1697  const char *rep_tab[] = {
1698  [FF_VK_REP_NATIVE] = "r16ui",
1699  [FF_VK_REP_FLOAT] = "r16f",
1700  [FF_VK_REP_INT] = "r16i",
1701  [FF_VK_REP_UINT] = "r16ui",
1702  };
1703  return rep_tab[rep_fmt];
1704  };
1705  case AV_PIX_FMT_GRAY32:
1706  case AV_PIX_FMT_GRAYF32:
1707  case AV_PIX_FMT_GBRPF32:
1708  case AV_PIX_FMT_GBRAPF32: {
1709  const char *rep_tab[] = {
1710  [FF_VK_REP_NATIVE] = "r32f",
1711  [FF_VK_REP_FLOAT] = "r32f",
1712  [FF_VK_REP_INT] = "r32i",
1713  [FF_VK_REP_UINT] = "r32ui",
1714  };
1715  return rep_tab[rep_fmt];
1716  };
1717  case AV_PIX_FMT_GBRAP32: {
1718  const char *rep_tab[] = {
1719  [FF_VK_REP_NATIVE] = "r32ui",
1720  [FF_VK_REP_FLOAT] = NULL,
1721  [FF_VK_REP_INT] = "r32i",
1722  [FF_VK_REP_UINT] = "r32ui",
1723  };
1724  return rep_tab[rep_fmt];
1725  };
1726  case AV_PIX_FMT_NV12:
1727  case AV_PIX_FMT_NV16:
1728  case AV_PIX_FMT_NV24: {
1729  const char *rep_tab[] = {
1730  [FF_VK_REP_NATIVE] = "rg8ui",
1731  [FF_VK_REP_FLOAT] = "rg8",
1732  [FF_VK_REP_INT] = "rg8i",
1733  [FF_VK_REP_UINT] = "rg8ui",
1734  };
1735  return rep_tab[rep_fmt];
1736  };
1737  case AV_PIX_FMT_P010:
1738  case AV_PIX_FMT_P210:
1739  case AV_PIX_FMT_P410: {
1740  const char *rep_tab[] = {
1741  [FF_VK_REP_NATIVE] = "rgb10_a2ui",
1742  [FF_VK_REP_FLOAT] = "rgb10_a2",
1743  [FF_VK_REP_INT] = NULL,
1744  [FF_VK_REP_UINT] = "rgb10_a2ui",
1745  };
1746  return rep_tab[rep_fmt];
1747  };
1748  case AV_PIX_FMT_P012:
1749  case AV_PIX_FMT_P016:
1750  case AV_PIX_FMT_P212:
1751  case AV_PIX_FMT_P216:
1752  case AV_PIX_FMT_P412:
1753  case AV_PIX_FMT_P416: {
1754  const char *rep_tab[] = {
1755  [FF_VK_REP_NATIVE] = "rg16ui",
1756  [FF_VK_REP_FLOAT] = "rg16",
1757  [FF_VK_REP_INT] = "rg16i",
1758  [FF_VK_REP_UINT] = "rg16ui",
1759  };
1760  return rep_tab[rep_fmt];
1761  };
1762  default:
1763  return "rgba32f";
1764  }
1765 }
1766 
1767 typedef struct ImageViewCtx {
1768  int nb_views;
1769  VkImageView views[];
1770 } ImageViewCtx;
1771 
1772 static void destroy_imageviews(void *opaque, uint8_t *data)
1773 {
1774  FFVulkanContext *s = opaque;
1775  FFVulkanFunctions *vk = &s->vkfn;
1776  ImageViewCtx *iv = (ImageViewCtx *)data;
1777 
1778  for (int i = 0; i < iv->nb_views; i++)
1779  vk->DestroyImageView(s->hwctx->act_dev, iv->views[i], s->hwctx->alloc);
1780 
1781  av_free(iv);
1782 }
1783 
1784 static VkFormat map_fmt_to_rep(VkFormat fmt, enum FFVkShaderRepFormat rep_fmt)
1785 {
1786 #define REPS_FMT(fmt) \
1787  [FF_VK_REP_NATIVE] = fmt ## _UINT, \
1788  [FF_VK_REP_FLOAT] = fmt ## _UNORM, \
1789  [FF_VK_REP_INT] = fmt ## _SINT, \
1790  [FF_VK_REP_UINT] = fmt ## _UINT,
1791 
1792 #define REPS_FMT_PACK(fmt, num) \
1793  [FF_VK_REP_NATIVE] = fmt ## _UINT_PACK ## num, \
1794  [FF_VK_REP_FLOAT] = fmt ## _UNORM_PACK ## num, \
1795  [FF_VK_REP_INT] = fmt ## _SINT_PACK ## num, \
1796  [FF_VK_REP_UINT] = fmt ## _UINT_PACK ## num,
1797 
1798  const VkFormat fmts_map[][4] = {
1799  { REPS_FMT_PACK(VK_FORMAT_A2B10G10R10, 32) },
1800  { REPS_FMT_PACK(VK_FORMAT_A2R10G10B10, 32) },
1801  {
1802  VK_FORMAT_B5G6R5_UNORM_PACK16,
1803  VK_FORMAT_B5G6R5_UNORM_PACK16,
1804  VK_FORMAT_UNDEFINED,
1805  VK_FORMAT_UNDEFINED,
1806  },
1807  {
1808  VK_FORMAT_R5G6B5_UNORM_PACK16,
1809  VK_FORMAT_R5G6B5_UNORM_PACK16,
1810  VK_FORMAT_UNDEFINED,
1811  VK_FORMAT_UNDEFINED,
1812  },
1813  { REPS_FMT(VK_FORMAT_B8G8R8) },
1814  { REPS_FMT(VK_FORMAT_B8G8R8A8) },
1815  { REPS_FMT(VK_FORMAT_R8) },
1816  { REPS_FMT(VK_FORMAT_R8G8) },
1817  { REPS_FMT(VK_FORMAT_R8G8B8) },
1818  { REPS_FMT(VK_FORMAT_R8G8B8A8) },
1819  { REPS_FMT(VK_FORMAT_R16) },
1820  { REPS_FMT(VK_FORMAT_R16G16) },
1821  { REPS_FMT(VK_FORMAT_R16G16B16) },
1822  { REPS_FMT(VK_FORMAT_R16G16B16A16) },
1823  {
1824  VK_FORMAT_R32_UINT,
1825  VK_FORMAT_R32_SFLOAT,
1826  VK_FORMAT_R32_SINT,
1827  VK_FORMAT_R32_UINT,
1828  },
1829  {
1830  VK_FORMAT_R32G32B32_SFLOAT,
1831  VK_FORMAT_R32G32B32_SFLOAT,
1832  VK_FORMAT_UNDEFINED,
1833  VK_FORMAT_UNDEFINED,
1834  },
1835  {
1836  VK_FORMAT_R32G32B32A32_SFLOAT,
1837  VK_FORMAT_R32G32B32A32_SFLOAT,
1838  VK_FORMAT_UNDEFINED,
1839  VK_FORMAT_UNDEFINED,
1840  },
1841  {
1842  VK_FORMAT_R32G32B32_UINT,
1843  VK_FORMAT_UNDEFINED,
1844  VK_FORMAT_R32G32B32_SINT,
1845  VK_FORMAT_R32G32B32_UINT,
1846  },
1847  {
1848  VK_FORMAT_R32G32B32A32_UINT,
1849  VK_FORMAT_UNDEFINED,
1850  VK_FORMAT_R32G32B32A32_SINT,
1851  VK_FORMAT_R32G32B32A32_UINT,
1852  },
1853  };
1854 #undef REPS_FMT_PACK
1855 #undef REPS_FMT
1856 
1857  if (fmt == VK_FORMAT_UNDEFINED)
1858  return VK_FORMAT_UNDEFINED;
1859 
1860  for (int i = 0; i < FF_ARRAY_ELEMS(fmts_map); i++) {
1861  if (fmts_map[i][FF_VK_REP_NATIVE] == fmt ||
1862  fmts_map[i][FF_VK_REP_FLOAT] == fmt ||
1863  fmts_map[i][FF_VK_REP_INT] == fmt ||
1864  fmts_map[i][FF_VK_REP_UINT] == fmt)
1865  return fmts_map[i][rep_fmt];
1866  }
1867 
1868  return VK_FORMAT_UNDEFINED;
1869 }
1870 
1871 int ff_vk_create_imageview(FFVulkanContext *s,
1872  VkImageView *img_view, VkImageAspectFlags *aspect,
1873  AVFrame *f, int plane, enum FFVkShaderRepFormat rep_fmt)
1874 {
1875  VkResult ret;
1876  FFVulkanFunctions *vk = &s->vkfn;
1877  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
1878  AVVulkanFramesContext *vkfc = hwfc->hwctx;
1879  const VkFormat *rep_fmts = av_vkfmt_from_pixfmt(hwfc->sw_format);
1880  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
1881  const int nb_images = ff_vk_count_images(vkf);
1882 
1883  VkImageViewUsageCreateInfo view_usage_info = {
1884  .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
1885  .usage = vkfc->usage &
1886  (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
1887  VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
1888  };
1889  VkImageViewCreateInfo view_create_info = {
1890  .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1891  .pNext = &view_usage_info,
1892  .image = vkf->img[FFMIN(plane, nb_images - 1)],
1893  .viewType = VK_IMAGE_VIEW_TYPE_2D,
1894  .format = map_fmt_to_rep(rep_fmts[plane], rep_fmt),
1895  .components = ff_comp_identity_map,
1896  .subresourceRange = {
1897  .aspectMask = ff_vk_aspect_flag(f, plane),
1898  .levelCount = 1,
1899  .layerCount = 1,
1900  },
1901  };
1902  if (view_create_info.format == VK_FORMAT_UNDEFINED) {
1903  av_log(s, AV_LOG_ERROR, "Unable to find a compatible representation "
1904  "of format %i and mode %i\n",
1905  rep_fmts[plane], rep_fmt);
1906  return AVERROR(EINVAL);
1907  }
1908 
1909  ret = vk->CreateImageView(s->hwctx->act_dev, &view_create_info,
1910  s->hwctx->alloc, img_view);
1911  if (ret != VK_SUCCESS) {
1912  av_log(s, AV_LOG_ERROR, "Failed to create imageview: %s\n",
1913  ff_vk_ret2str(ret));
1914  return AVERROR_EXTERNAL;
1915  }
1916 
1917  *aspect = view_create_info.subresourceRange.aspectMask;
1918 
1919  return 0;
1920 }
1921 
1922 int ff_vk_create_imageviews(FFVulkanContext *s, FFVkExecContext *e,
1923  VkImageView views[AV_NUM_DATA_POINTERS],
1924  AVFrame *f, enum FFVkShaderRepFormat rep_fmt)
1925 {
1926  int err;
1927  VkResult ret;
1928  AVBufferRef *buf;
1929  FFVulkanFunctions *vk = &s->vkfn;
1930  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
1931  AVVulkanFramesContext *vkfc = hwfc->hwctx;
1932  const VkFormat *rep_fmts = av_vkfmt_from_pixfmt(hwfc->sw_format);
1933  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
1934  const int nb_images = ff_vk_count_images(vkf);
1935  const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
1936 
1937  ImageViewCtx *iv;
1938  const size_t buf_size = sizeof(*iv) + nb_planes*sizeof(VkImageView);
1939  iv = av_mallocz(buf_size);
1940  if (!iv)
1941  return AVERROR(ENOMEM);
1942 
1943  for (int i = 0; i < nb_planes; i++) {
1944  VkImageViewUsageCreateInfo view_usage_info = {
1945  .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
1946  .usage = vkfc->usage &
1947  (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
1948  VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
1949  };
1950  VkImageViewCreateInfo view_create_info = {
1951  .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1952  .pNext = &view_usage_info,
1953  .image = vkf->img[FFMIN(i, nb_images - 1)],
1954  .viewType = VK_IMAGE_VIEW_TYPE_2D,
1955  .format = map_fmt_to_rep(rep_fmts[i], rep_fmt),
1956  .components = ff_comp_identity_map,
1957  .subresourceRange = {
1958  .aspectMask = ff_vk_aspect_flag(f, i),
1959  .levelCount = 1,
1960  .layerCount = 1,
1961  },
1962  };
1963  if (view_create_info.format == VK_FORMAT_UNDEFINED) {
1964  av_log(s, AV_LOG_ERROR, "Unable to find a compatible representation "
1965  "of format %i and mode %i\n",
1966  rep_fmts[i], rep_fmt);
1967  err = AVERROR(EINVAL);
1968  goto fail;
1969  }
1970 
1971  ret = vk->CreateImageView(s->hwctx->act_dev, &view_create_info,
1972  s->hwctx->alloc, &iv->views[i]);
1973  if (ret != VK_SUCCESS) {
1974  av_log(s, AV_LOG_ERROR, "Failed to create imageview: %s\n",
1975  ff_vk_ret2str(ret));
1976  err = AVERROR_EXTERNAL;
1977  goto fail;
1978  }
1979 
1980  iv->nb_views++;
1981  }
1982 
1983  buf = av_buffer_create((uint8_t *)iv, buf_size, destroy_imageviews, s, 0);
1984  if (!buf) {
1985  err = AVERROR(ENOMEM);
1986  goto fail;
1987  }
1988 
1989  /* Add to queue dependencies */
1990  err = ff_vk_exec_add_dep_buf(s, e, &buf, 1, 0);
1991  if (err < 0)
1992  av_buffer_unref(&buf);
1993 
1994  memcpy(views, iv->views, nb_planes*sizeof(*views));
1995 
1996  return err;
1997 
1998 fail:
1999  for (int i = 0; i < iv->nb_views; i++)
2000  vk->DestroyImageView(s->hwctx->act_dev, iv->views[i], s->hwctx->alloc);
2001  av_free(iv);
2002  return err;
2003 }
2004 
2005 void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e,
2006  AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar,
2007  VkPipelineStageFlags src_stage,
2008  VkPipelineStageFlags dst_stage,
2009  VkAccessFlagBits new_access,
2010  VkImageLayout new_layout,
2011  uint32_t new_qf)
2012 {
2013  int found = -1;
2014  AVVkFrame *vkf = (AVVkFrame *)pic->data[0];
2015  const int nb_images = ff_vk_count_images(vkf);
2016  for (int i = 0; i < e->nb_frame_deps; i++)
2017  if (e->frame_deps[i]->data[0] == pic->data[0]) {
2018  if (e->frame_update[i])
2019  found = i;
2020  break;
2021  }
2022 
2023  for (int i = 0; i < nb_images; i++) {
2024  bar[*nb_bar] = (VkImageMemoryBarrier2) {
2025  .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
2026  .pNext = NULL,
2027  .srcStageMask = src_stage,
2028  .dstStageMask = dst_stage,
2029  .srcAccessMask = found >= 0 ? e->access_dst[found] : vkf->access[i],
2030  .dstAccessMask = new_access,
2031  .oldLayout = found >= 0 ? e->layout_dst[found] : vkf->layout[0],
2032  .newLayout = new_layout,
2033  .srcQueueFamilyIndex = found >= 0 ? e->queue_family_dst[found] : vkf->queue_family[0],
2034  .dstQueueFamilyIndex = new_qf,
2035  .image = vkf->img[i],
2036  .subresourceRange = (VkImageSubresourceRange) {
2037  .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
2038  .layerCount = 1,
2039  .levelCount = 1,
2040  },
2041  };
2042  *nb_bar += 1;
2043  }
2044 
2045  ff_vk_exec_update_frame(s, e, pic, &bar[*nb_bar - nb_images], NULL);
2046 }
2047 
2048 int ff_vk_shader_init(FFVulkanContext *s, FFVulkanShader *shd, const char *name,
2049  VkPipelineStageFlags stage,
2050  const char *extensions[], int nb_extensions,
2051  int lg_x, int lg_y, int lg_z,
2052  uint32_t required_subgroup_size)
2053 {
2054  av_bprint_init(&shd->src, 0, AV_BPRINT_SIZE_UNLIMITED);
2055 
2056  shd->name = name;
2057  shd->stage = stage;
2058  shd->lg_size[0] = lg_x;
2059  shd->lg_size[1] = lg_y;
2060  shd->lg_size[2] = lg_z;
2061 
2062  switch (shd->stage) {
2063  case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
2064  case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
2065  case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
2066  case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
2067  case VK_SHADER_STAGE_MISS_BIT_KHR:
2068  case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
2069  shd->bind_point = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
2070  break;
2071  case VK_SHADER_STAGE_COMPUTE_BIT:
2072  shd->bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
2073  break;
2074  default:
2075  shd->bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS;
2076  break;
2077  };
2078 
2079  if (required_subgroup_size) {
2080  shd->subgroup_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
2081  shd->subgroup_info.requiredSubgroupSize = required_subgroup_size;
2082  }
2083 
2084  av_bprintf(&shd->src, "/* %s shader: %s */\n",
2085  (stage == VK_SHADER_STAGE_TASK_BIT_EXT ||
2086  stage == VK_SHADER_STAGE_MESH_BIT_EXT) ?
2087  "Mesh" :
2088  (shd->bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR) ?
2089  "Raytrace" :
2090  (shd->bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) ?
2091  "Compute" : "Graphics",
2092  name);
2093  GLSLF(0, #version %i ,460);
2094  GLSLC(0, );
2095 
2096  /* Common utilities */
2097  GLSLC(0, #define IS_WITHIN(v1, v2) ((v1.x < v2.x) && (v1.y < v2.y)) );
2098  GLSLC(0, );
2099  GLSLC(0, #extension GL_EXT_scalar_block_layout : require );
2100  GLSLC(0, #extension GL_EXT_shader_explicit_arithmetic_types : require );
2101  GLSLC(0, #extension GL_EXT_control_flow_attributes : require );
2102  GLSLC(0, #extension GL_EXT_shader_image_load_formatted : require );
2103  if (s->extensions & FF_VK_EXT_EXPECT_ASSUME) {
2104  GLSLC(0, #extension GL_EXT_expect_assume : require );
2105  } else {
2106  GLSLC(0, #define assumeEXT(x) (x) );
2107  GLSLC(0, #define expectEXT(x, c) (x) );
2108  }
2109  if ((s->extensions & FF_VK_EXT_DEBUG_UTILS) &&
2110  (s->extensions & FF_VK_EXT_RELAXED_EXTENDED_INSTR)) {
2111  GLSLC(0, #extension GL_EXT_debug_printf : require );
2112  GLSLC(0, #define DEBUG );
2113  }
2114 
2115  if (stage == VK_SHADER_STAGE_TASK_BIT_EXT ||
2116  stage == VK_SHADER_STAGE_MESH_BIT_EXT)
2117  GLSLC(0, #extension GL_EXT_mesh_shader : require );
2118 
2119  for (int i = 0; i < nb_extensions; i++)
2120  GLSLF(0, #extension %s : %s ,extensions[i], "require");
2121  GLSLC(0, );
2122 
2123  GLSLF(0, layout (local_size_x = %i, local_size_y = %i, local_size_z = %i) in;
2124  , shd->lg_size[0], shd->lg_size[1], shd->lg_size[2]);
2125  GLSLC(0, );
2126 
2127  return 0;
2128 }
2129 
2130 void ff_vk_shader_print(void *ctx, FFVulkanShader *shd, int prio)
2131 {
2132  int line = 0;
2133  const char *p = shd->src.str;
2134  const char *start = p;
2135  const size_t len = strlen(p);
2136 
2137  AVBPrint buf;
2138  av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
2139 
2140  for (int i = 0; i < len; i++) {
2141  if (p[i] == '\n') {
2142  av_bprintf(&buf, "%i\t", ++line);
2143  av_bprint_append_data(&buf, start, &p[i] - start + 1);
2144  start = &p[i + 1];
2145  }
2146  }
2147 
2148  av_log(ctx, prio, "Shader %s: \n%s", shd->name, buf.str);
2149  av_bprint_finalize(&buf, NULL);
2150 }
2151 
2152 static int init_pipeline_layout(FFVulkanContext *s, FFVulkanShader *shd)
2153 {
2154  VkResult ret;
2155  FFVulkanFunctions *vk = &s->vkfn;
2156  VkPipelineLayoutCreateInfo pipeline_layout_info;
2157 
2158  /* Finally create the pipeline layout */
2159  pipeline_layout_info = (VkPipelineLayoutCreateInfo) {
2160  .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
2161  .pSetLayouts = shd->desc_layout,
2162  .setLayoutCount = shd->nb_descriptor_sets,
2163  .pushConstantRangeCount = shd->push_consts_num,
2164  .pPushConstantRanges = shd->push_consts,
2165  };
2166 
2167  ret = vk->CreatePipelineLayout(s->hwctx->act_dev, &pipeline_layout_info,
2168  s->hwctx->alloc, &shd->pipeline_layout);
2169  if (ret != VK_SUCCESS) {
2170  av_log(s, AV_LOG_ERROR, "Unable to init pipeline layout: %s\n",
2171  ff_vk_ret2str(ret));
2172  return AVERROR_EXTERNAL;
2173  }
2174 
2175  return 0;
2176 }
2177 
2178 static int create_shader_module(FFVulkanContext *s, FFVulkanShader *shd,
2179  VkShaderModule *mod,
2180  uint8_t *spirv, size_t spirv_len)
2181 {
2182  VkResult ret;
2183  FFVulkanFunctions *vk = &s->vkfn;
2184 
2185  VkShaderModuleCreateInfo shader_module_info = {
2186  .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
2187  .pNext = NULL,
2188  .flags = 0x0,
2189  .pCode = (void *)spirv,
2190  .codeSize = spirv_len,
2191  };
2192 
2193  ret = vk->CreateShaderModule(s->hwctx->act_dev, &shader_module_info,
2194  s->hwctx->alloc, mod);
2195  if (ret != VK_SUCCESS) {
2196  av_log(s, AV_LOG_ERROR, "Error creating shader module: %s\n",
2197  ff_vk_ret2str(ret));
2198  return AVERROR_EXTERNAL;
2199  }
2200 
2201  return 0;
2202 }
2203 
2204 static int init_compute_pipeline(FFVulkanContext *s, FFVulkanShader *shd,
2205  VkShaderModule mod, const char *entrypoint)
2206 {
2207  VkResult ret;
2208  FFVulkanFunctions *vk = &s->vkfn;
2209 
2210  VkComputePipelineCreateInfo pipeline_create_info = {
2211  .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
2212  .flags = (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) ?
2213  VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT : 0x0,
2214  .layout = shd->pipeline_layout,
2215  .stage = (VkPipelineShaderStageCreateInfo) {
2216  .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2217  .pNext = shd->subgroup_info.requiredSubgroupSize ?
2218  &shd->subgroup_info : NULL,
2219  .pName = entrypoint,
2220  .flags = shd->subgroup_info.requiredSubgroupSize ?
2221  VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT : 0x0,
2222  .stage = shd->stage,
2223  .module = mod,
2224  },
2225  };
2226 
2227  ret = vk->CreateComputePipelines(s->hwctx->act_dev, VK_NULL_HANDLE, 1,
2228  &pipeline_create_info,
2229  s->hwctx->alloc, &shd->pipeline);
2230  if (ret != VK_SUCCESS) {
2231  av_log(s, AV_LOG_ERROR, "Unable to init compute pipeline: %s\n",
2232  ff_vk_ret2str(ret));
2233  return AVERROR_EXTERNAL;
2234  }
2235 
2236  return 0;
2237 }
2238 
2239 static int create_shader_object(FFVulkanContext *s, FFVulkanShader *shd,
2240  uint8_t *spirv, size_t spirv_len,
2241  const char *entrypoint)
2242 {
2243  VkResult ret;
2244  FFVulkanFunctions *vk = &s->vkfn;
2245  size_t shader_size = 0;
2246 
2247  VkShaderCreateInfoEXT shader_obj_create = {
2248  .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
2249  .flags = shd->subgroup_info.requiredSubgroupSize ?
2250  VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT : 0x0,
2251  .stage = shd->stage,
2252  .nextStage = 0,
2253  .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
2254  .pCode = spirv,
2255  .codeSize = spirv_len,
2256  .pName = entrypoint,
2257  .pSetLayouts = shd->desc_layout,
2258  .setLayoutCount = shd->nb_descriptor_sets,
2259  .pushConstantRangeCount = shd->push_consts_num,
2260  .pPushConstantRanges = shd->push_consts,
2261  .pSpecializationInfo = NULL,
2262  };
2263 
2264  ret = vk->CreateShadersEXT(s->hwctx->act_dev, 1, &shader_obj_create,
2265  s->hwctx->alloc, &shd->object);
2266  if (ret != VK_SUCCESS) {
2267  av_log(s, AV_LOG_ERROR, "Unable to create shader object: %s\n",
2268  ff_vk_ret2str(ret));
2269  return AVERROR_EXTERNAL;
2270  }
2271 
2272  if (vk->GetShaderBinaryDataEXT(s->hwctx->act_dev, shd->object,
2273  &shader_size, NULL) == VK_SUCCESS)
2274  av_log(s, AV_LOG_VERBOSE, "Shader %s size: %zu binary (%zu SPIR-V)\n",
2275  shd->name, shader_size, spirv_len);
2276 
2277  return 0;
2278 }
2279 
2280 static int init_descriptors(FFVulkanContext *s, FFVulkanShader *shd)
2281 {
2282  VkResult ret;
2283  FFVulkanFunctions *vk = &s->vkfn;
2284 
2285  shd->desc_layout = av_malloc_array(shd->nb_descriptor_sets,
2286  sizeof(*shd->desc_layout));
2287  if (!shd->desc_layout)
2288  return AVERROR(ENOMEM);
2289 
2290  if (!(s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER)) {
2291  int has_singular = 0;
2292  int max_descriptors = 0;
2293  for (int i = 0; i < shd->nb_descriptor_sets; i++) {
2294  max_descriptors = FFMAX(max_descriptors, shd->desc_set[i].nb_bindings);
2295  if (shd->desc_set[i].singular)
2296  has_singular = 1;
2297  }
2298  shd->use_push = (s->extensions & FF_VK_EXT_PUSH_DESCRIPTOR) &&
2299  (max_descriptors <= s->push_desc_props.maxPushDescriptors) &&
2300  (shd->nb_descriptor_sets == 1) &&
2301  (has_singular == 0);
2302  }
2303 
2304  for (int i = 0; i < shd->nb_descriptor_sets; i++) {
2305  FFVulkanDescriptorSet *set = &shd->desc_set[i];
2306  VkDescriptorSetLayoutCreateInfo desc_layout_create = {
2307  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
2308  .bindingCount = set->nb_bindings,
2309  .pBindings = set->binding,
2310  .flags = (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) ?
2311  VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT :
2312  (shd->use_push) ?
2313  VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR :
2314  0x0,
2315  };
2316 
2317  ret = vk->CreateDescriptorSetLayout(s->hwctx->act_dev,
2318  &desc_layout_create,
2319  s->hwctx->alloc,
2320  &shd->desc_layout[i]);
2321  if (ret != VK_SUCCESS) {
2322  av_log(s, AV_LOG_ERROR, "Unable to create descriptor set layout: %s",
2323  ff_vk_ret2str(ret));
2324  return AVERROR_EXTERNAL;
2325  }
2326 
2327  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2328  vk->GetDescriptorSetLayoutSizeEXT(s->hwctx->act_dev, shd->desc_layout[i],
2329  &set->layout_size);
2330 
2331  set->aligned_size = FFALIGN(set->layout_size,
2332  s->desc_buf_props.descriptorBufferOffsetAlignment);
2333 
2334  for (int j = 0; j < set->nb_bindings; j++)
2335  vk->GetDescriptorSetLayoutBindingOffsetEXT(s->hwctx->act_dev,
2336  shd->desc_layout[i],
2337  j,
2338  &set->binding_offset[j]);
2339  }
2340  }
2341 
2342  return 0;
2343 }
2344 
2345 int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd,
2346  uint8_t *spirv, size_t spirv_len,
2347  const char *entrypoint)
2348 {
2349  int err;
2350  FFVulkanFunctions *vk = &s->vkfn;
2351 
2352  err = init_descriptors(s, shd);
2353  if (err < 0)
2354  return err;
2355 
2356  err = init_pipeline_layout(s, shd);
2357  if (err < 0)
2358  return err;
2359 
2360  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2361  shd->bound_buffer_indices = av_calloc(shd->nb_descriptor_sets,
2362  sizeof(*shd->bound_buffer_indices));
2363  if (!shd->bound_buffer_indices)
2364  return AVERROR(ENOMEM);
2365 
2366  for (int i = 0; i < shd->nb_descriptor_sets; i++)
2367  shd->bound_buffer_indices[i] = i;
2368  }
2369 
2370  if (s->extensions & FF_VK_EXT_SHADER_OBJECT) {
2371  err = create_shader_object(s, shd, spirv, spirv_len, entrypoint);
2372  if (err < 0)
2373  return err;
2374  } else {
2375  VkShaderModule mod;
2376  err = create_shader_module(s, shd, &mod, spirv, spirv_len);
2377  if (err < 0)
2378  return err;
2379 
2380  switch (shd->bind_point) {
2381  case VK_PIPELINE_BIND_POINT_COMPUTE:
2382  err = init_compute_pipeline(s, shd, mod, entrypoint);
2383  break;
2384  default:
2385  av_log(s, AV_LOG_ERROR, "Unsupported shader type: %i\n",
2386  shd->bind_point);
2387  err = AVERROR(EINVAL);
2388  break;
2389  };
2390 
2391  vk->DestroyShaderModule(s->hwctx->act_dev, mod, s->hwctx->alloc);
2392  if (err < 0)
2393  return err;
2394  }
2395 
2396  return 0;
2397 }
2398 
2399 static const struct descriptor_props {
2400  size_t struct_size; /* Size of the opaque which updates the descriptor */
2401  const char *type;
2402  int is_uniform;
2403  int mem_quali; /* Can use a memory qualifier */
2404  int dim_needed; /* Must indicate dimension */
2405  int buf_content; /* Must indicate buffer contents */
2406 } descriptor_props[] = {
2407  [VK_DESCRIPTOR_TYPE_SAMPLER] = { sizeof(VkDescriptorImageInfo), "sampler", 1, 0, 0, 0, },
2408  [VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE] = { sizeof(VkDescriptorImageInfo), "texture", 1, 0, 1, 0, },
2409  [VK_DESCRIPTOR_TYPE_STORAGE_IMAGE] = { sizeof(VkDescriptorImageInfo), "image", 1, 1, 1, 0, },
2410  [VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT] = { sizeof(VkDescriptorImageInfo), "subpassInput", 1, 0, 0, 0, },
2411  [VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER] = { sizeof(VkDescriptorImageInfo), "sampler", 1, 0, 1, 0, },
2412  [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER] = { sizeof(VkDescriptorBufferInfo), NULL, 1, 0, 0, 1, },
2413  [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] = { sizeof(VkDescriptorBufferInfo), "buffer", 0, 1, 0, 1, },
2414  [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC] = { sizeof(VkDescriptorBufferInfo), NULL, 1, 0, 0, 1, },
2415  [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC] = { sizeof(VkDescriptorBufferInfo), "buffer", 0, 1, 0, 1, },
2416  [VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER] = { sizeof(VkBufferView), "samplerBuffer", 1, 0, 0, 0, },
2417  [VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER] = { sizeof(VkBufferView), "imageBuffer", 1, 0, 0, 0, },
2418 };
2419 
2420 int ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd,
2421  FFVulkanDescriptorSetBinding *desc, int nb,
2422  int singular, int print_to_shader_only)
2423 {
2424  int has_sampler = 0;
2425  FFVulkanDescriptorSet *set;
2426 
2427  if (print_to_shader_only)
2428  goto print;
2429 
2430  /* Actual layout allocated for the pipeline */
2431  set = av_realloc_array(shd->desc_set,
2432  sizeof(*shd->desc_set),
2433  shd->nb_descriptor_sets + 1);
2434  if (!set)
2435  return AVERROR(ENOMEM);
2436  shd->desc_set = set;
2437 
2438  set = &set[shd->nb_descriptor_sets];
2439  memset(set, 0, sizeof(*set));
2440 
2441  set->binding = av_calloc(nb, sizeof(*set->binding));
2442  if (!set->binding)
2443  return AVERROR(ENOMEM);
2444 
2445  set->binding_offset = av_calloc(nb, sizeof(*set->binding_offset));
2446  if (!set->binding_offset) {
2447  av_freep(&set->binding);
2448  return AVERROR(ENOMEM);
2449  }
2450 
2451  for (int i = 0; i < nb; i++) {
2452  set->binding[i].binding = i;
2453  set->binding[i].descriptorType = desc[i].type;
2454  set->binding[i].descriptorCount = FFMAX(desc[i].elems, 1);
2455  set->binding[i].stageFlags = desc[i].stages;
2456  set->binding[i].pImmutableSamplers = desc[i].samplers;
2457 
2458  if (desc[i].type == VK_DESCRIPTOR_TYPE_SAMPLER ||
2459  desc[i].type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
2460  has_sampler |= 1;
2461  }
2462 
2463  set->usage = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT |
2464  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
2465  if (has_sampler)
2466  set->usage |= VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT;
2467 
2468  if (!(s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER)) {
2469  for (int i = 0; i < nb; i++) {
2470  int j;
2471  VkDescriptorPoolSize *desc_pool_size;
2472  for (j = 0; j < shd->nb_desc_pool_size; j++)
2473  if (shd->desc_pool_size[j].type == desc[i].type)
2474  break;
2475  if (j >= shd->nb_desc_pool_size) {
2476  desc_pool_size = av_realloc_array(shd->desc_pool_size,
2477  sizeof(*desc_pool_size),
2478  shd->nb_desc_pool_size + 1);
2479  if (!desc_pool_size)
2480  return AVERROR(ENOMEM);
2481 
2482  shd->desc_pool_size = desc_pool_size;
2483  shd->nb_desc_pool_size++;
2484  memset(&desc_pool_size[j], 0, sizeof(VkDescriptorPoolSize));
2485  }
2486  shd->desc_pool_size[j].type = desc[i].type;
2487  shd->desc_pool_size[j].descriptorCount += FFMAX(desc[i].elems, 1);
2488  }
2489  }
2490 
2491  set->singular = singular;
2492  set->nb_bindings = nb;
2493  shd->nb_descriptor_sets++;
2494 
2495 print:
2496  /* Write shader info */
2497  for (int i = 0; i < nb; i++) {
2498  const struct descriptor_props *prop = &descriptor_props[desc[i].type];
2499  GLSLA("layout (set = %i, binding = %i", FFMAX(shd->nb_descriptor_sets - 1, 0), i);
2500 
2501  if (desc[i].mem_layout &&
2502  (desc[i].type != VK_DESCRIPTOR_TYPE_STORAGE_IMAGE))
2503  GLSLA(", %s", desc[i].mem_layout);
2504 
2505  GLSLA(")");
2506 
2507  if (prop->is_uniform)
2508  GLSLA(" uniform");
2509 
2510  if (prop->mem_quali && desc[i].mem_quali)
2511  GLSLA(" %s", desc[i].mem_quali);
2512 
2513  if (prop->type) {
2514  GLSLA(" ");
2515  if (desc[i].type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
2516  if (desc[i].mem_layout) {
2517  int len = strlen(desc[i].mem_layout);
2518  if (desc[i].mem_layout[len - 1] == 'i' &&
2519  desc[i].mem_layout[len - 2] == 'u') {
2520  GLSLA("u");
2521  } else if (desc[i].mem_layout[len - 1] == 'i') {
2522  GLSLA("i");
2523  }
2524  }
2525  }
2526  GLSLA("%s", prop->type);
2527  }
2528 
2529  if (prop->dim_needed)
2530  GLSLA("%iD", desc[i].dimensions);
2531 
2532  GLSLA(" %s", desc[i].name);
2533 
2534  if (prop->buf_content) {
2535  GLSLA(" {\n ");
2536  if (desc[i].buf_elems) {
2537  GLSLA("%s", desc[i].buf_content);
2538  GLSLA("[%i];", desc[i].buf_elems);
2539  } else {
2540  GLSLA("%s", desc[i].buf_content);
2541  }
2542  GLSLA("\n}");
2543  } else if (desc[i].elems > 0) {
2544  GLSLA("[%i]", desc[i].elems);
2545  }
2546 
2547  GLSLA(";");
2548  GLSLA("\n");
2549  }
2550  GLSLA("\n");
2551 
2552  return 0;
2553 }
2554 
2555 int ff_vk_shader_register_exec(FFVulkanContext *s, FFVkExecPool *pool,
2556  FFVulkanShader *shd)
2557 {
2558  int err;
2559  FFVulkanShaderData *sd;
2560 
2561  if (!shd->nb_descriptor_sets)
2562  return 0;
2563 
2564  sd = av_realloc_array(pool->reg_shd,
2565  sizeof(*pool->reg_shd),
2566  pool->nb_reg_shd + 1);
2567  if (!sd)
2568  return AVERROR(ENOMEM);
2569 
2570  pool->reg_shd = sd;
2571  sd = &sd[pool->nb_reg_shd++];
2572  memset(sd, 0, sizeof(*sd));
2573 
2574  sd->shd = shd;
2575  sd->nb_descriptor_sets = shd->nb_descriptor_sets;
2576 
2577  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2578  sd->desc_bind = av_malloc_array(sd->nb_descriptor_sets, sizeof(*sd->desc_bind));
2579  if (!sd->desc_bind)
2580  return AVERROR(ENOMEM);
2581 
2582  sd->desc_set_buf = av_calloc(sd->nb_descriptor_sets, sizeof(*sd->desc_set_buf));
2583  if (!sd->desc_set_buf)
2584  return AVERROR(ENOMEM);
2585 
2586  for (int i = 0; i < sd->nb_descriptor_sets; i++) {
2587  FFVulkanDescriptorSet *set = &shd->desc_set[i];
2588  FFVulkanDescriptorSetData *sdb = &sd->desc_set_buf[i];
2589  int nb = set->singular ? 1 : pool->pool_size;
2590 
2591  err = ff_vk_create_buf(s, &sdb->buf,
2592  set->aligned_size*nb,
2593  NULL, NULL, set->usage,
2594  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
2595  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
2596  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
2597  if (err < 0)
2598  return err;
2599 
2600  err = ff_vk_map_buffer(s, &sdb->buf, &sdb->desc_mem, 0);
2601  if (err < 0)
2602  return err;
2603 
2604  sd->desc_bind[i] = (VkDescriptorBufferBindingInfoEXT) {
2605  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT,
2606  .usage = set->usage,
2607  .address = sdb->buf.address,
2608  };
2609  }
2610  } else if (!shd->use_push) {
2611  VkResult ret;
2612  FFVulkanFunctions *vk = &s->vkfn;
2613  VkDescriptorSetLayout *tmp_layouts;
2614  VkDescriptorSetAllocateInfo set_alloc_info;
2615  VkDescriptorPoolCreateInfo pool_create_info;
2616 
2617  for (int i = 0; i < shd->nb_desc_pool_size; i++)
2618  shd->desc_pool_size[i].descriptorCount *= pool->pool_size;
2619 
2620  pool_create_info = (VkDescriptorPoolCreateInfo) {
2621  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2622  .flags = 0,
2623  .pPoolSizes = shd->desc_pool_size,
2624  .poolSizeCount = shd->nb_desc_pool_size,
2625  .maxSets = sd->nb_descriptor_sets*pool->pool_size,
2626  };
2627 
2628  ret = vk->CreateDescriptorPool(s->hwctx->act_dev, &pool_create_info,
2629  s->hwctx->alloc, &sd->desc_pool);
2630  if (ret != VK_SUCCESS) {
2631  av_log(s, AV_LOG_ERROR, "Unable to create descriptor pool: %s\n",
2632  ff_vk_ret2str(ret));
2633  return AVERROR_EXTERNAL;
2634  }
2635 
2636  tmp_layouts = av_malloc_array(pool_create_info.maxSets, sizeof(*tmp_layouts));
2637  if (!tmp_layouts)
2638  return AVERROR(ENOMEM);
2639 
2640  /* Colate each execution context's descriptor set layouts */
2641  for (int i = 0; i < pool->pool_size; i++)
2642  for (int j = 0; j < sd->nb_descriptor_sets; j++)
2643  tmp_layouts[i*sd->nb_descriptor_sets + j] = shd->desc_layout[j];
2644 
2645  set_alloc_info = (VkDescriptorSetAllocateInfo) {
2646  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2647  .descriptorPool = sd->desc_pool,
2648  .pSetLayouts = tmp_layouts,
2649  .descriptorSetCount = pool_create_info.maxSets,
2650  };
2651 
2652  sd->desc_sets = av_malloc_array(pool_create_info.maxSets,
2653  sizeof(*tmp_layouts));
2654  if (!sd->desc_sets) {
2655  av_free(tmp_layouts);
2656  return AVERROR(ENOMEM);
2657  }
2658  ret = vk->AllocateDescriptorSets(s->hwctx->act_dev, &set_alloc_info,
2659  sd->desc_sets);
2660  av_free(tmp_layouts);
2661  if (ret != VK_SUCCESS) {
2662  av_log(s, AV_LOG_ERROR, "Unable to allocate descriptor set: %s\n",
2663  ff_vk_ret2str(ret));
2664  av_freep(&sd->desc_sets);
2665  return AVERROR_EXTERNAL;
2666  }
2667  }
2668 
2669  return 0;
2670 }
2671 
2672 static inline FFVulkanShaderData *get_shd_data(FFVkExecContext *e,
2673  FFVulkanShader *shd)
2674 {
2675  for (int i = 0; i < e->parent->nb_reg_shd; i++)
2676  if (e->parent->reg_shd[i].shd == shd)
2677  return &e->parent->reg_shd[i];
2678  return NULL;
2679 }
2680 
2681 static inline void update_set_descriptor(FFVulkanContext *s, FFVkExecContext *e,
2682  FFVulkanShader *shd, int set,
2683  int bind_idx, int array_idx,
2684  VkDescriptorGetInfoEXT *desc_get_info,
2685  size_t desc_size)
2686 {
2687  FFVulkanFunctions *vk = &s->vkfn;
2688  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2689  FFVulkanShaderData *sd = get_shd_data(e, shd);
2690  const size_t exec_offset = desc_set->singular ? 0 : desc_set->aligned_size*e->idx;
2691 
2692  void *desc = sd->desc_set_buf[set].desc_mem + /* Base */
2693  exec_offset + /* Execution context */
2694  desc_set->binding_offset[bind_idx] + /* Descriptor binding */
2695  array_idx*desc_size; /* Array position */
2696 
2697  vk->GetDescriptorEXT(s->hwctx->act_dev, desc_get_info, desc_size, desc);
2698 }
2699 
2700 static inline void update_set_pool_write(FFVulkanContext *s, FFVkExecContext *e,
2701  FFVulkanShader *shd, int set,
2702  VkWriteDescriptorSet *write_info)
2703 {
2704  FFVulkanFunctions *vk = &s->vkfn;
2705  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2706  FFVulkanShaderData *sd = get_shd_data(e, shd);
2707 
2708  if (desc_set->singular) {
2709  for (int i = 0; i < e->parent->pool_size; i++) {
2710  write_info->dstSet = sd->desc_sets[i*sd->nb_descriptor_sets + set];
2711  vk->UpdateDescriptorSets(s->hwctx->act_dev, 1, write_info, 0, NULL);
2712  }
2713  } else {
2714  if (shd->use_push) {
2715  vk->CmdPushDescriptorSetKHR(e->buf,
2716  shd->bind_point,
2717  shd->pipeline_layout,
2718  set, 1,
2719  write_info);
2720  } else {
2721  write_info->dstSet = sd->desc_sets[e->idx*sd->nb_descriptor_sets + set];
2722  vk->UpdateDescriptorSets(s->hwctx->act_dev, 1, write_info, 0, NULL);
2723  }
2724  }
2725 }
2726 
2727 int ff_vk_shader_update_img(FFVulkanContext *s, FFVkExecContext *e,
2728  FFVulkanShader *shd, int set, int bind, int offs,
2729  VkImageView view, VkImageLayout layout,
2730  VkSampler sampler)
2731 {
2732  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2733 
2734  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2735  VkDescriptorGetInfoEXT desc_get_info = {
2736  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
2737  .type = desc_set->binding[bind].descriptorType,
2738  };
2739  VkDescriptorImageInfo desc_img_info = {
2740  .imageView = view,
2741  .sampler = sampler,
2742  .imageLayout = layout,
2743  };
2744  size_t desc_size;
2745 
2746  switch (desc_get_info.type) {
2747  case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
2748  desc_get_info.data.pSampledImage = &desc_img_info;
2749  desc_size = s->desc_buf_props.sampledImageDescriptorSize;
2750  break;
2751  case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
2752  desc_get_info.data.pStorageImage = &desc_img_info;
2753  desc_size = s->desc_buf_props.storageImageDescriptorSize;
2754  break;
2755  case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
2756  desc_get_info.data.pInputAttachmentImage = &desc_img_info;
2757  desc_size = s->desc_buf_props.inputAttachmentDescriptorSize;
2758  break;
2759  case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
2760  desc_get_info.data.pCombinedImageSampler = &desc_img_info;
2761  desc_size = s->desc_buf_props.combinedImageSamplerDescriptorSize;
2762  break;
2763  default:
2764  av_log(s, AV_LOG_ERROR, "Invalid descriptor type at set %i binding %i: %i!\n",
2765  set, bind, desc_get_info.type);
2766  return AVERROR(EINVAL);
2767  break;
2768  };
2769 
2770  update_set_descriptor(s, e, shd, set, bind, offs,
2771  &desc_get_info, desc_size);
2772  } else {
2773  VkDescriptorImageInfo desc_pool_write_info_img = {
2774  .sampler = sampler,
2775  .imageView = view,
2776  .imageLayout = layout,
2777  };
2778  VkWriteDescriptorSet desc_pool_write_info = {
2779  .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2780  .dstBinding = bind,
2781  .descriptorCount = 1,
2782  .dstArrayElement = offs,
2783  .descriptorType = desc_set->binding[bind].descriptorType,
2784  .pImageInfo = &desc_pool_write_info_img,
2785  };
2786  update_set_pool_write(s, e, shd, set, &desc_pool_write_info);
2787  }
2788 
2789  return 0;
2790 }
2791 
2792 void ff_vk_shader_update_img_array(FFVulkanContext *s, FFVkExecContext *e,
2793  FFVulkanShader *shd, AVFrame *f,
2794  VkImageView *views, int set, int binding,
2795  VkImageLayout layout, VkSampler sampler)
2796 {
2797  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
2798  const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
2799 
2800  for (int i = 0; i < nb_planes; i++)
2801  ff_vk_shader_update_img(s, e, shd, set, binding, i,
2802  views[i], layout, sampler);
2803 }
2804 
2805 int ff_vk_shader_update_desc_buffer(FFVulkanContext *s, FFVkExecContext *e,
2806  FFVulkanShader *shd,
2807  int set, int bind, int elem,
2808  FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize len,
2809  VkFormat fmt)
2810 {
2811  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2812 
2813  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2814  VkDescriptorGetInfoEXT desc_get_info = {
2815  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
2816  .type = desc_set->binding[bind].descriptorType,
2817  };
2818  VkDescriptorAddressInfoEXT desc_buf_info = {
2819  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT,
2820  .address = buf->address + offset,
2821  .range = len,
2822  .format = fmt,
2823  };
2824  size_t desc_size;
2825 
2826  switch (desc_get_info.type) {
2827  case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
2828  desc_get_info.data.pUniformBuffer = &desc_buf_info;
2829  desc_size = s->desc_buf_props.uniformBufferDescriptorSize;
2830  break;
2831  case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
2832  desc_get_info.data.pStorageBuffer = &desc_buf_info;
2833  desc_size = s->desc_buf_props.storageBufferDescriptorSize;
2834  break;
2835  case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
2836  desc_get_info.data.pUniformTexelBuffer = &desc_buf_info;
2837  desc_size = s->desc_buf_props.uniformTexelBufferDescriptorSize;
2838  break;
2839  case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
2840  desc_get_info.data.pStorageTexelBuffer = &desc_buf_info;
2841  desc_size = s->desc_buf_props.storageTexelBufferDescriptorSize;
2842  break;
2843  default:
2844  av_log(s, AV_LOG_ERROR, "Invalid descriptor type at set %i binding %i: %i!\n",
2845  set, bind, desc_get_info.type);
2846  return AVERROR(EINVAL);
2847  break;
2848  };
2849 
2850  update_set_descriptor(s, e, shd, set, bind, elem, &desc_get_info, desc_size);
2851  } else {
2852  VkDescriptorBufferInfo desc_pool_write_info_buf = {
2853  .buffer = buf->buf,
2854  .offset = buf->virtual_offset + offset,
2855  .range = len,
2856  };
2857  VkWriteDescriptorSet desc_pool_write_info = {
2858  .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2859  .dstBinding = bind,
2860  .descriptorCount = 1,
2861  .dstArrayElement = elem,
2862  .descriptorType = desc_set->binding[bind].descriptorType,
2863  .pBufferInfo = &desc_pool_write_info_buf,
2864  };
2865  update_set_pool_write(s, e, shd, set, &desc_pool_write_info);
2866  }
2867 
2868  return 0;
2869 }
2870 
2871 void ff_vk_shader_update_push_const(FFVulkanContext *s, FFVkExecContext *e,
2872  FFVulkanShader *shd,
2873  VkShaderStageFlagBits stage,
2874  int offset, size_t size, void *src)
2875 {
2876  FFVulkanFunctions *vk = &s->vkfn;
2877  vk->CmdPushConstants(e->buf, shd->pipeline_layout,
2878  stage, offset, size, src);
2879 }
2880 
2881 void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e,
2882  FFVulkanShader *shd)
2883 {
2884  FFVulkanFunctions *vk = &s->vkfn;
2885  VkDeviceSize offsets[1024];
2886  FFVulkanShaderData *sd = get_shd_data(e, shd);
2887 
2888  if (s->extensions & FF_VK_EXT_SHADER_OBJECT) {
2889  VkShaderStageFlagBits stages = shd->stage;
2890  vk->CmdBindShadersEXT(e->buf, 1, &stages, &shd->object);
2891  } else {
2892  vk->CmdBindPipeline(e->buf, shd->bind_point, shd->pipeline);
2893  }
2894 
2895  if (sd && sd->nb_descriptor_sets) {
2896  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2897  for (int i = 0; i < sd->nb_descriptor_sets; i++)
2898  offsets[i] = shd->desc_set[i].singular ? 0 : shd->desc_set[i].aligned_size*e->idx;
2899 
2900  /* Bind descriptor buffers */
2901  vk->CmdBindDescriptorBuffersEXT(e->buf, sd->nb_descriptor_sets, sd->desc_bind);
2902  /* Binding offsets */
2903  vk->CmdSetDescriptorBufferOffsetsEXT(e->buf, shd->bind_point, shd->pipeline_layout,
2904  0, sd->nb_descriptor_sets,
2905  shd->bound_buffer_indices, offsets);
2906  } else if (!shd->use_push) {
2907  vk->CmdBindDescriptorSets(e->buf, shd->bind_point, shd->pipeline_layout,
2908  0, sd->nb_descriptor_sets,
2909  &sd->desc_sets[e->idx*sd->nb_descriptor_sets],
2910  0, NULL);
2911  }
2912  }
2913 }
2914 
2915 void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
2916 {
2917  FFVulkanFunctions *vk = &s->vkfn;
2918 
2919  av_bprint_finalize(&shd->src, NULL);
2920 
2921 #if 0
2922  if (shd->shader.module)
2923  vk->DestroyShaderModule(s->hwctx->act_dev, shd->shader.module,
2924  s->hwctx->alloc);
2925 #endif
2926 
2927  if (shd->object)
2928  vk->DestroyShaderEXT(s->hwctx->act_dev, shd->object, s->hwctx->alloc);
2929  if (shd->pipeline)
2930  vk->DestroyPipeline(s->hwctx->act_dev, shd->pipeline, s->hwctx->alloc);
2931  if (shd->pipeline_layout)
2932  vk->DestroyPipelineLayout(s->hwctx->act_dev, shd->pipeline_layout,
2933  s->hwctx->alloc);
2934 
2935  for (int i = 0; i < shd->nb_descriptor_sets; i++) {
2936  FFVulkanDescriptorSet *set = &shd->desc_set[i];
2937  av_free(set->binding);
2938  av_free(set->binding_offset);
2939  }
2940 
2941  if (shd->desc_layout) {
2942  for (int i = 0; i < shd->nb_descriptor_sets; i++)
2943  if (shd->desc_layout[i])
2944  vk->DestroyDescriptorSetLayout(s->hwctx->act_dev, shd->desc_layout[i],
2945  s->hwctx->alloc);
2946  }
2947 
2948  av_freep(&shd->desc_pool_size);
2949  av_freep(&shd->desc_layout);
2950  av_freep(&shd->desc_set);
2951  av_freep(&shd->bound_buffer_indices);
2952  av_freep(&shd->push_consts);
2953  shd->push_consts_num = 0;
2954 }
2955 
2956 void ff_vk_uninit(FFVulkanContext *s)
2957 {
2958  av_freep(&s->query_props);
2959  av_freep(&s->qf_props);
2960  av_freep(&s->video_props);
2961  av_freep(&s->coop_mat_props);
2962  av_freep(&s->host_image_copy_layouts);
2963 
2964  av_buffer_unref(&s->device_ref);
2965  av_buffer_unref(&s->frames_ref);
2966 }
2967 
2968 int ff_vk_init(FFVulkanContext *s, void *log_parent,
2969  AVBufferRef *device_ref, AVBufferRef *frames_ref)
2970 {
2971  int err;
2972 
2973  static const AVClass vulkan_context_class = {
2974  .class_name = "vk",
2975  .version = LIBAVUTIL_VERSION_INT,
2976  .parent_log_context_offset = offsetof(FFVulkanContext, log_parent),
2977  };
2978 
2979  memset(s, 0, sizeof(*s));
2980  s->log_parent = log_parent;
2981  s->class = &vulkan_context_class;
2982 
2983  if (frames_ref) {
2984  s->frames_ref = av_buffer_ref(frames_ref);
2985  if (!s->frames_ref)
2986  return AVERROR(ENOMEM);
2987 
2988  s->frames = (AVHWFramesContext *)s->frames_ref->data;
2989  s->hwfc = s->frames->hwctx;
2990 
2991  device_ref = s->frames->device_ref;
2992  }
2993 
2994  s->device_ref = av_buffer_ref(device_ref);
2995  if (!s->device_ref) {
2996  ff_vk_uninit(s);
2997  return AVERROR(ENOMEM);
2998  }
2999 
3000  s->device = (AVHWDeviceContext *)s->device_ref->data;
3001  s->hwctx = s->device->hwctx;
3002 
3003  s->extensions = ff_vk_extensions_to_mask(s->hwctx->enabled_dev_extensions,
3004  s->hwctx->nb_enabled_dev_extensions);
3005  s->extensions |= ff_vk_extensions_to_mask(s->hwctx->enabled_inst_extensions,
3006  s->hwctx->nb_enabled_inst_extensions);
3007 
3008  err = ff_vk_load_functions(s->device, &s->vkfn, s->extensions, 1, 1);
3009  if (err < 0) {
3010  ff_vk_uninit(s);
3011  return err;
3012  }
3013 
3014  err = ff_vk_load_props(s);
3015  if (err < 0) {
3016  ff_vk_uninit(s);
3017  return err;
3018  }
3019 
3020  return 0;
3021 }
FFVulkanShader::bind_point
VkPipelineBindPoint bind_point
Definition: vulkan.h:202
flags
const SwsFlags flags[]
Definition: swscale.c:61
vulkan_loader.h
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:615
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:584
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:1021
ff_vk_load_props
int ff_vk_load_props(FFVulkanContext *s)
Loads props/mprops/driver_props.
Definition: vulkan.c:142
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
ImageViewCtx::nb_views
int nb_views
Definition: vulkan.c:1768
AV_PIX_FMT_GRAY32
#define AV_PIX_FMT_GRAY32
Definition: pixfmt.h:536
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_comp_identity_map
const VkComponentMapping ff_comp_identity_map
Definition: vulkan.c:27
FFVkExecContext::frame_deps_alloc_size
unsigned int frame_deps_alloc_size
Definition: vulkan.h:140
ff_vk_shader_free
void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
Free a shader.
Definition: vulkan.c:2915
ff_vk_shader_init
int ff_vk_shader_init(FFVulkanContext *s, FFVulkanShader *shd, const char *name, VkPipelineStageFlags stage, const char *extensions[], int nb_extensions, int lg_x, int lg_y, int lg_z, uint32_t required_subgroup_size)
Initialize a shader object, with a specific set of extensions, type+bind, local group size,...
Definition: vulkan.c:2048
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
atomic_fetch_add
#define atomic_fetch_add(object, operand)
Definition: stdatomic.h:137
FFVkExecPool::contexts
FFVkExecContext * contexts
Definition: vulkan.h:253
FFVkExecPool::idx
atomic_uint_least64_t idx
Definition: vulkan.h:254
FFVulkanDescriptorSetData
Definition: vulkan.h:232
FFVulkanShader::nb_desc_pool_size
int nb_desc_pool_size
Definition: vulkan.h:229
FF_VK_EXT_VIDEO_QUEUE
#define FF_VK_EXT_VIDEO_QUEUE
Definition: vulkan_functions.h:56
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
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:356
FFVulkanShaderData
Definition: vulkan.h:238
DEBUG
#define DEBUG
Definition: vf_framerate.c:29
ARR_REALLOC
#define ARR_REALLOC(str, arr, alloc_s, cnt)
Definition: vulkan.c:669
FFVkExecContext::qf
int qf
Definition: vulkan.h:118
FFVulkanDescriptorSet::aligned_size
VkDeviceSize aligned_size
Definition: vulkan.h:179
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:519
FFVulkanShaderData::shd
FFVulkanShader * shd
Definition: vulkan.h:240
AV_PIX_FMT_YUV444P10MSB
#define AV_PIX_FMT_YUV444P10MSB
Definition: pixfmt.h:573
descriptor_props::is_uniform
int is_uniform
Definition: vulkan.c:2402
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:859
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
FFVkBuffer::host_ref
AVBufferRef * host_ref
Definition: vulkan.h:108
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:614
ff_vk_map_buffer
static int ff_vk_map_buffer(FFVulkanContext *s, FFVkBuffer *buf, uint8_t **mem, int invalidate)
Definition: vulkan.h:534
FFVulkanShader::subgroup_info
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo subgroup_info
Definition: vulkan.h:205
AV_PIX_FMT_Y216
#define AV_PIX_FMT_Y216
Definition: pixfmt.h:627
ff_vk_find_struct
static const void * ff_vk_find_struct(const void *chain, VkStructureType stype)
Definition: vulkan.h:332
FFVulkanShader::pipeline
VkPipeline pipeline
Definition: vulkan.h:209
FFVkExecContext::sem_sig_alloc
unsigned int sem_sig_alloc
Definition: vulkan.h:153
FFVulkanShaderData::desc_bind
VkDescriptorBufferBindingInfoEXT * desc_bind
Definition: vulkan.h:245
FFVulkanShader::src
AVBPrint src
Definition: vulkan.h:195
alloc_data_buf
static AVBufferRef * alloc_data_buf(void *opaque, size_t size)
Definition: vulkan.c:1241
FFVulkanShader::use_push
int use_push
Definition: vulkan.h:227
data
const char data[16]
Definition: mxf.c:149
AV_PIX_FMT_RGBA128
#define AV_PIX_FMT_RGBA128
Definition: pixfmt.h:649
AV_PIX_FMT_XV30
#define AV_PIX_FMT_XV30
Definition: pixfmt.h:628
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
TempSyncCtx::nb_sem
int nb_sem
Definition: vulkan.c:680
FFVkBuffer::address
VkDeviceAddress address
Definition: vulkan.h:92
FFVkExecContext::sem_wait
VkSemaphoreSubmitInfo * sem_wait
Definition: vulkan.h:148
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
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:2968
ff_vk_exec_get
FFVkExecContext * ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool)
Retrieve an execution pool.
Definition: vulkan.c:547
FF_VK_REP_NATIVE
@ FF_VK_REP_NATIVE
Definition: vulkan.h:406
ff_vk_uninit
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition: vulkan.c:2956
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
FF_VK_EXT_COOP_MATRIX
#define FF_VK_EXT_COOP_MATRIX
Definition: vulkan_functions.h:45
av_popcount
#define av_popcount
Definition: common.h:154
FF_VK_REP_INT
@ FF_VK_REP_INT
Definition: vulkan.h:410
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:2727
FFVkExecPool::query_pool
VkQueryPool query_pool
Definition: vulkan.h:260
FFVkExecPool::nb_reg_shd
int nb_reg_shd
Definition: vulkan.h:271
FFVulkanDescriptorSetData::desc_mem
uint8_t * desc_mem
Definition: vulkan.h:235
FFVkExecContext::nb_sw_frame_deps
int nb_sw_frame_deps
Definition: vulkan.h:146
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:779
FFVulkanShaderData::desc_sets
VkDescriptorSet * desc_sets
Definition: vulkan.h:248
descriptor_props::type
const char * type
Definition: vulkan.c:2401
AV_PIX_FMT_P212
#define AV_PIX_FMT_P212
Definition: pixfmt.h:637
FFVkShaderRepFormat
FFVkShaderRepFormat
Returns the format to use for images in shaders.
Definition: vulkan.h:404
AV_PIX_FMT_YUV444P12MSB
#define AV_PIX_FMT_YUV444P12MSB
Definition: pixfmt.h:574
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:448
FFVkBuffer::buf
VkBuffer buf
Definition: vulkan.h:88
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
FF_VK_EXT_HOST_IMAGE_COPY
#define FF_VK_EXT_HOST_IMAGE_COPY
Definition: vulkan_functions.h:52
FF_VK_EXT_EXPECT_ASSUME
#define FF_VK_EXT_EXPECT_ASSUME
Definition: vulkan_functions.h:50
ImageViewCtx
Definition: vulkan.c:1767
FFVkExecContext::frame_update_alloc_size
unsigned int frame_update_alloc_size
Definition: vulkan.h:173
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3634
FFVulkanShader::desc_layout
VkDescriptorSetLayout * desc_layout
Definition: vulkan.h:223
FFVulkanDescriptorSet::nb_bindings
int nb_bindings
Definition: vulkan.h:184
AVVkFrame::img
VkImage img[AV_NUM_DATA_POINTERS]
Vulkan images to which the memory is bound to.
Definition: hwcontext_vulkan.h:303
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
destroy_avvkbuf
static void destroy_avvkbuf(void *opaque, uint8_t *data)
Definition: vulkan.c:1353
fail
#define fail()
Definition: checkasm.h:206
AV_PIX_FMT_GBRP12MSB
#define AV_PIX_FMT_GBRP12MSB
Definition: pixfmt.h:588
ff_vk_exec_add_dep_bool_sem
int ff_vk_exec_add_dep_bool_sem(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore *sem, int nb, VkPipelineStageFlagBits2 stage, int wait)
Definition: vulkan.c:713
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:616
ff_vk_unmap_buffers
int ff_vk_unmap_buffers(FFVulkanContext *s, FFVkBuffer **buf, int nb_buffers, int flush)
Definition: vulkan.c:1170
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:2792
AVVulkanFramesContext
Allocated as AVHWFramesContext.hwctx, used to set pool-specific options.
Definition: hwcontext_vulkan.h:208
av_buffer_pool_init2
AVBufferPool * av_buffer_pool_init2(size_t size, void *opaque, AVBufferRef *(*alloc)(void *opaque, size_t size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
Definition: buffer.c:259
FFVkExecPool::query_64bit
int query_64bit
Definition: vulkan.h:264
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
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AV_PIX_FMT_XV48
#define AV_PIX_FMT_XV48
Definition: pixfmt.h:630
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
cqueue_create
static cqueue * cqueue_create(int size, int max_size)
Definition: af_dynaudnorm.c:179
ff_vk_host_map_buffer
int ff_vk_host_map_buffer(FFVulkanContext *s, AVBufferRef **dst, uint8_t *src_data, const AVBufferRef *src_buf, VkBufferUsageFlags usage)
Maps a system RAM buffer into a Vulkan buffer.
Definition: vulkan.c:1361
ff_vk_ret2str
const char * ff_vk_ret2str(VkResult res)
Converts Vulkan return values to strings.
Definition: vulkan.c:35
ff_vk_shader_add_descriptor_set
int ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd, FFVulkanDescriptorSetBinding *desc, int nb, int singular, int print_to_shader_only)
Add descriptor to a shader.
Definition: vulkan.c:2420
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:535
create_shader_module
static int create_shader_module(FFVulkanContext *s, FFVulkanShader *shd, VkShaderModule *mod, uint8_t *spirv, size_t spirv_len)
Definition: vulkan.c:2178
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:1512
FFVkExecPool::query_statuses
int query_statuses
Definition: vulkan.h:263
descriptor_props::struct_size
size_t struct_size
Definition: vulkan.c:2400
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:63
FFVulkanDescriptorSet::binding
VkDescriptorSetLayoutBinding * binding
Definition: vulkan.h:182
init_descriptors
static int init_descriptors(FFVulkanContext *s, FFVulkanShader *shd)
Definition: vulkan.c:2280
init_pipeline_layout
static int init_pipeline_layout(FFVulkanContext *s, FFVulkanShader *shd)
Definition: vulkan.c:2152
AV_PIX_FMT_Y210
#define AV_PIX_FMT_Y210
Definition: pixfmt.h:625
avassert.h
AVVulkanDeviceQueueFamily::num
int num
Definition: hwcontext_vulkan.h:37
GLSLC
#define GLSLC(N, S)
Definition: vulkan.h:43
FFVulkanDescriptorSetData::buf
FFVkBuffer buf
Definition: vulkan.h:234
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
FFVkExecContext::frame_deps
AVFrame ** frame_deps
Definition: vulkan.h:139
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:564
set
static void set(uint8_t *a[], int ch, int index, int ch_count, enum AVSampleFormat f, double v)
Definition: swresample.c:59
FFVkExecContext::queue_family_dst
uint32_t * queue_family_dst
Definition: vulkan.h:169
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:581
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:390
FFVulkanShader::push_consts
VkPushConstantRange * push_consts
Definition: vulkan.h:215
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:497
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_GBRAP14
#define AV_PIX_FMT_GBRAP14
Definition: pixfmt.h:583
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:582
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_RGB96
#define AV_PIX_FMT_RGB96
Definition: pixfmt.h:648
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:878
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:565
offsets
static const int offsets[]
Definition: hevc_pel.c:34
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AV_PIX_FMT_GRAY10MSB
#define AV_PIX_FMT_GRAY10MSB
Definition: pixfmt.h:567
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:122
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
FFVkExecContext::fence
VkFence fence
Definition: vulkan.h:125
update_set_descriptor
static void update_set_descriptor(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, int set, int bind_idx, int array_idx, VkDescriptorGetInfoEXT *desc_get_info, size_t desc_size)
Definition: vulkan.c:2681
ff_vk_exec_wait
void ff_vk_exec_wait(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:552
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:1551
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
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:1307
AV_PIX_FMT_GBRAP32
#define AV_PIX_FMT_GBRAP32
Definition: pixfmt.h:585
FF_VK_REP_FLOAT
@ FF_VK_REP_FLOAT
Definition: vulkan.h:408
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
FFVkExecContext::nb_buf_deps
int nb_buf_deps
Definition: vulkan.h:135
FFVulkanShader::stage
VkPipelineStageFlags stage
Definition: vulkan.h:201
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:563
ctx
AVFormatContext * ctx
Definition: movenc.c:49
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
ff_vk_exec_add_dep_buf
int ff_vk_exec_add_dep_buf(FFVulkanContext *s, FFVkExecContext *e, AVBufferRef **deps, int nb_deps, int ref)
Execution dependency management.
Definition: vulkan.c:619
AV_PIX_FMT_RGBF32
#define AV_PIX_FMT_RGBF32
Definition: pixfmt.h:645
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
ff_vk_exec_pool_free
void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
Definition: vulkan.c:287
ImageViewCtx::views
VkImageView views[]
Definition: vulkan.c:1769
map_fmt_to_rep
static VkFormat map_fmt_to_rep(VkFormat fmt, enum FFVkShaderRepFormat rep_fmt)
Definition: vulkan.c:1784
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:601
FFVkExecContext::frame_update
uint8_t * frame_update
Definition: vulkan.h:172
FFVkExecContext::query_idx
int query_idx
Definition: vulkan.h:131
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
FFVkExecPool::query_status_stride
int query_status_stride
Definition: vulkan.h:265
FFVkExecContext::parent
const struct FFVkExecPool * parent
Definition: vulkan.h:113
if
if(ret)
Definition: filter_design.txt:179
AV_PIX_FMT_YUV422P10MSB
#define AV_PIX_FMT_YUV422P10MSB
Definition: pixfmt.h:571
ff_vk_exec_add_dep_wait_sem
int ff_vk_exec_add_dep_wait_sem(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore sem, uint64_t val, VkPipelineStageFlagBits2 stage)
Definition: vulkan.c:696
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:580
FFVulkanShaderData::desc_set_buf
FFVulkanDescriptorSetData * desc_set_buf
Definition: vulkan.h:244
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:542
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_vk_shader_rep_fmt
const char * ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt, enum FFVkShaderRepFormat rep_fmt)
Definition: vulkan.c:1588
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
FFVkExecContext::sw_frame_deps_alloc_size
unsigned int sw_frame_deps_alloc_size
Definition: vulkan.h:145
ff_vk_alloc_mem
int ff_vk_alloc_mem(FFVulkanContext *s, VkMemoryRequirements *req, VkMemoryPropertyFlagBits req_flags, void *alloc_extension, VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
Memory/buffer/image allocation helpers.
Definition: vulkan.c:970
FFVkExecContext::sem_sig_val_dst_alloc
unsigned int sem_sig_val_dst_alloc
Definition: vulkan.h:157
descriptor_props::mem_quali
int mem_quali
Definition: vulkan.c:2403
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:213
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:139
FF_VK_EXT_SHADER_OBJECT
#define FF_VK_EXT_SHADER_OBJECT
Definition: vulkan_functions.h:47
FFVkExecContext::access_dst_alloc
unsigned int access_dst_alloc
Definition: vulkan.h:164
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
FFVulkanDescriptorSet::singular
int singular
Definition: vulkan.h:187
FFVkExecContext::sem_sig_cnt
int sem_sig_cnt
Definition: vulkan.h:154
TempSyncCtx::sem
VkSemaphore sem[]
Definition: vulkan.c:681
load_enabled_qfs
static void load_enabled_qfs(FFVulkanContext *s)
Definition: vulkan.c:123
AV_PIX_FMT_P410
#define AV_PIX_FMT_P410
Definition: pixfmt.h:636
TempSyncCtx
Definition: vulkan.c:679
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:370
FFVkExecContext::qi
int qi
Definition: vulkan.h:119
FFVkExecContext::had_submission
int had_submission
Definition: vulkan.h:114
FFVkBuffer::size
size_t size
Definition: vulkan.h:91
descriptor_props::dim_needed
int dim_needed
Definition: vulkan.c:2404
FFVkExecPool::nb_queries
int nb_queries
Definition: vulkan.h:266
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
FFVkBuffer::mapped_mem
uint8_t * mapped_mem
Definition: vulkan.h:100
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
FFVulkanContext
Definition: vulkan.h:274
AV_PIX_FMT_YUV420P10MSB
#define AV_PIX_FMT_YUV420P10MSB
Definition: pixfmt.h:569
FFVulkanShader::nb_descriptor_sets
int nb_descriptor_sets
Definition: vulkan.h:220
FFVulkanShader::bound_buffer_indices
uint32_t * bound_buffer_indices
Definition: vulkan.h:224
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
init_compute_pipeline
static int init_compute_pipeline(FFVulkanContext *s, FFVulkanShader *shd, VkShaderModule mod, const char *entrypoint)
Definition: vulkan.c:2204
GLSLA
#define GLSLA(...)
Definition: vulkan.h:48
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
FFVkExecContext::query_data
void * query_data
Definition: vulkan.h:130
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
usage
const char * usage
Definition: floatimg_cmp.c:62
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:1871
AV_PIX_FMT_X2BGR10
#define AV_PIX_FMT_X2BGR10
Definition: pixfmt.h:633
f
f
Definition: af_crystalizer.c:122
FFVkExecContext::layout_dst
VkImageLayout * layout_dst
Definition: vulkan.h:166
destroy_imageviews
static void destroy_imageviews(void *opaque, uint8_t *data)
Definition: vulkan.c:1772
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
FFVkExecContext::queue_family_dst_alloc
unsigned int queue_family_dst_alloc
Definition: vulkan.h:170
AVVkFrame::access
VkAccessFlagBits access[AV_NUM_DATA_POINTERS]
Updated after every barrier.
Definition: hwcontext_vulkan.h:327
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:2871
FFVulkanDescriptorSetBinding
Definition: vulkan.h:74
FFVulkanShaderData::nb_descriptor_sets
int nb_descriptor_sets
Definition: vulkan.h:241
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
sem_wait
#define sem_wait(psem)
Definition: semaphore.h:27
AV_PIX_FMT_P012
#define AV_PIX_FMT_P012
Definition: pixfmt.h:622
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
AVVkFrame
Definition: hwcontext_vulkan.h:298
vulkan.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
FF_VK_EXT_NO_FLAG
#define FF_VK_EXT_NO_FLAG
Definition: vulkan_functions.h:72
print
static void print(AVTreeNode *t, int depth)
Definition: tree.c:45
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:597
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:538
FFVulkanShader::desc_pool_size
VkDescriptorPoolSize * desc_pool_size
Definition: vulkan.h:228
size
int size
Definition: twinvq_data.h:10344
ff_vk_exec_add_dep_sw_frame
int ff_vk_exec_add_dep_sw_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f)
Definition: vulkan.c:646
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:428
FF_VK_EXT_PUSH_DESCRIPTOR
#define FF_VK_EXT_PUSH_DESCRIPTOR
Definition: vulkan_functions.h:48
FFVkExecContext::nb_frame_deps
int nb_frame_deps
Definition: vulkan.h:141
FFVulkanShader
Definition: vulkan.h:190
FFVulkanShader::pipeline_layout
VkPipelineLayout pipeline_layout
Definition: vulkan.h:212
FFVkExecContext::sem_sig_val_dst_cnt
int sem_sig_val_dst_cnt
Definition: vulkan.h:158
update_set_pool_write
static void update_set_pool_write(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, int set, VkWriteDescriptorSet *write_info)
Definition: vulkan.c:2700
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
FFVkBuffer::flags
VkMemoryPropertyFlagBits flags
Definition: vulkan.h:90
AV_PIX_FMT_Y212
#define AV_PIX_FMT_Y212
Definition: pixfmt.h:626
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
AVVkFrame::queue_family
uint32_t queue_family[AV_NUM_DATA_POINTERS]
Queue family of the images.
Definition: hwcontext_vulkan.h:362
AVVulkanDeviceQueueFamily::idx
int idx
Definition: hwcontext_vulkan.h:35
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
FFVkExecContext
Definition: vulkan.h:111
line
Definition: graph2dot.c:48
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:2805
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_P216
#define AV_PIX_FMT_P216
Definition: pixfmt.h:639
version
version
Definition: libkvazaar.c:315
AV_PIX_FMT_P210
#define AV_PIX_FMT_P210
Definition: pixfmt.h:635
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:1529
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
destroy_tmp_semaphores
static void destroy_tmp_semaphores(void *opaque, uint8_t *data)
Definition: vulkan.c:684
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
FFVkExecContext::sem_wait_cnt
int sem_wait_cnt
Definition: vulkan.h:150
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
FFVkExecContext::queue
VkQueue queue
Definition: vulkan.h:117
FF_VK_EXT_EXTERNAL_HOST_MEMORY
#define FF_VK_EXT_EXTERNAL_HOST_MEMORY
Definition: vulkan_functions.h:36
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
descriptor_props
Definition: vulkan.c:2399
ff_vk_exec_start
int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
Start/submit/wait an execution.
Definition: vulkan.c:559
FF_VK_EXT_RELAXED_EXTENDED_INSTR
#define FF_VK_EXT_RELAXED_EXTENDED_INSTR
Definition: vulkan_functions.h:49
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
FFVkExecPool::cmd_buf_pools
VkCommandPool * cmd_buf_pools
Definition: vulkan.h:256
FF_VK_REP_UINT
@ FF_VK_REP_UINT
Definition: vulkan.h:412
FFVulkanShaderData::desc_pool
VkDescriptorPool desc_pool
Definition: vulkan.h:249
VkFormat
enum VkFormat VkFormat
Definition: hwcontext_stub.c:25
FFVulkanShader::push_consts_num
int push_consts_num
Definition: vulkan.h:216
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
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
ff_vk_frame_barrier
void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e, AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar, VkPipelineStageFlags src_stage, VkPipelineStageFlags dst_stage, VkAccessFlagBits new_access, VkImageLayout new_layout, uint32_t new_qf)
Definition: vulkan.c:2005
FFVkExecContext::layout_dst_alloc
unsigned int layout_dst_alloc
Definition: vulkan.h:167
FFVkExecPool::reg_shd
FFVulkanShaderData * reg_shd
Definition: vulkan.h:270
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_vk_shader_link
int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd, uint8_t *spirv, size_t spirv_len, const char *entrypoint)
Link a shader into an executable.
Definition: vulkan.c:2345
ff_vk_unmap_buffer
static int ff_vk_unmap_buffer(FFVulkanContext *s, FFVkBuffer *buf, int flush)
Definition: vulkan.h:541
FFVkBuffer::mem
VkDeviceMemory mem
Definition: vulkan.h:89
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition: pixfmt.h:632
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
FFVkExecContext::frame_locked_alloc_size
unsigned int frame_locked_alloc_size
Definition: vulkan.h:161
len
int len
Definition: vorbis_enc_data.h:426
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:544
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:40
ff_vk_free_buf
void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
Definition: vulkan.c:1212
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
mod
static int mod(int a, int b)
Modulo operation with only positive remainders.
Definition: vf_v360.c:755
ff_vk_exec_bind_shader
void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd)
Bind a shader.
Definition: vulkan.c:2881
FFVulkanDescriptorSet::binding_offset
VkDeviceSize * binding_offset
Definition: vulkan.h:183
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:623
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:539
FFVkExecContext::sem_wait_alloc
unsigned int sem_wait_alloc
Definition: vulkan.h:149
AVVkFrame::sem
VkSemaphore sem[AV_NUM_DATA_POINTERS]
Synchronization timeline semaphores, one for each VkImage.
Definition: hwcontext_vulkan.h:336
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:118
ret
ret
Definition: filter_design.txt:187
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_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
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
FFVulkanShader::name
const char * name
Definition: vulkan.h:192
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:1922
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:153
FFVkExecPool
Definition: vulkan.h:252
FFVkExecContext::frame_locked
uint8_t * frame_locked
Definition: vulkan.h:160
FFVkExecPool::query_data
void * query_data
Definition: vulkan.h:261
descriptor_props::buf_content
int buf_content
Definition: vulkan.c:2405
FFVkExecContext::sem_sig
VkSemaphoreSubmitInfo * sem_sig
Definition: vulkan.h:152
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:122
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:1459
ff_vk_qf_find
AVVulkanDeviceQueueFamily * ff_vk_qf_find(FFVulkanContext *s, VkQueueFlagBits dev_family, VkVideoCodecOperationFlagBitsKHR vid_ops)
Chooses an appropriate QF.
Definition: vulkan.c:274
FF_VK_EXT_DESCRIPTOR_BUFFER
#define FF_VK_EXT_DESCRIPTOR_BUFFER
Definition: vulkan_functions.h:42
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:88
FFVkExecContext::buf
VkCommandBuffer buf
Definition: vulkan.h:122
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
FFVulkanShader::desc_set
FFVulkanDescriptorSet * desc_set
Definition: vulkan.h:219
free_data_buf
static void free_data_buf(void *opaque, uint8_t *data)
Definition: vulkan.c:1233
GLSLF
#define GLSLF(N, S,...)
Definition: vulkan.h:53
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:598
FF_VK_STRUCT_EXT
#define FF_VK_STRUCT_EXT(CTX, BASE, STRUCT_P, EXT_FLAG, TYPE)
Definition: vulkan.h:354
FFVulkanShader::object
VkShaderEXT object
Definition: vulkan.h:208
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
FF_VK_EXT_ATOMIC_FLOAT
#define FF_VK_EXT_ATOMIC_FLOAT
Definition: vulkan_functions.h:44
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
AV_PIX_FMT_RGBAF32
#define AV_PIX_FMT_RGBAF32
Definition: pixfmt.h:646
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_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:621
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:344
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:79
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
mem.h
AVVkFrame::layout
VkImageLayout layout[AV_NUM_DATA_POINTERS]
Definition: hwcontext_vulkan.h:328
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
FFVkExecPool::cmd_bufs
VkCommandBuffer * cmd_bufs
Definition: vulkan.h:257
FFVkExecContext::sw_frame_deps
AVFrame ** sw_frame_deps
Definition: vulkan.h:144
REPS_FMT_PACK
#define REPS_FMT_PACK(fmt, num)
AV_PIX_FMT_YUV422P12MSB
#define AV_PIX_FMT_YUV422P12MSB
Definition: pixfmt.h:572
ff_vk_shader_print
void ff_vk_shader_print(void *ctx, FFVulkanShader *shd, int prio)
Output the shader code as logging data, with a specific priority.
Definition: vulkan.c:2130
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
ff_vk_count_images
static int ff_vk_count_images(AVVkFrame *f)
Definition: vulkan.h:323
ff_vk_exec_discard_deps
void ff_vk_exec_discard_deps(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:591
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AV_PIX_FMT_P416
#define AV_PIX_FMT_P416
Definition: pixfmt.h:640
FFVkBuffer::virtual_offset
size_t virtual_offset
Definition: vulkan.h:105
ff_vk_init_sampler
int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler, int unnorm_coords, VkFilter filt)
Create a sampler.
Definition: vulkan.c:1480
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
FFVkExecContext::buf_deps_alloc_size
unsigned int buf_deps_alloc_size
Definition: vulkan.h:136
FFVkExecContext::buf_deps
AVBufferRef ** buf_deps
Definition: vulkan.h:134
FFVkBuffer
Definition: vulkan.h:87
ff_vk_exec_submit
int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:904
FF_VK_EXT_OPTICAL_FLOW
#define FF_VK_EXT_OPTICAL_FLOW
Definition: vulkan_functions.h:46
AV_PIX_FMT_XV36
#define AV_PIX_FMT_XV36
Definition: pixfmt.h:629
FF_VK_EXT_DEBUG_UTILS
#define FF_VK_EXT_DEBUG_UTILS
Definition: vulkan_functions.h:37
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
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVVulkanDeviceQueueFamily
Definition: hwcontext_vulkan.h:33
FFVkExecPool::qd_size
size_t qd_size
Definition: vulkan.h:267
AV_PIX_FMT_P412
#define AV_PIX_FMT_P412
Definition: pixfmt.h:638
FFVulkanDescriptorSet
Definition: vulkan.h:176
AV_PIX_FMT_YUV420P12MSB
#define AV_PIX_FMT_YUV420P12MSB
Definition: pixfmt.h:570
AV_PIX_FMT_GBRP10MSB
#define AV_PIX_FMT_GBRP10MSB
Definition: pixfmt.h:587
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
FFVkExecPool::query_results
int query_results
Definition: vulkan.h:262
create_shader_object
static int create_shader_object(FFVulkanContext *s, FFVulkanShader *shd, uint8_t *spirv, size_t spirv_len, const char *entrypoint)
Definition: vulkan.c:2239
AV_PIX_FMT_BAYER_RGGB16
#define AV_PIX_FMT_BAYER_RGGB16
Definition: pixfmt.h:591
FFVkExecContext::sem_sig_val_dst
uint64_t ** sem_sig_val_dst
Definition: vulkan.h:156
av_bprint_append_data
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:148
get_shd_data
static FFVulkanShaderData * get_shd_data(FFVkExecContext *e, FFVulkanShader *shd)
Definition: vulkan.c:2672
CASE
#define CASE(VAL)
FFVulkanFunctions
Definition: vulkan_functions.h:277
FFVkExecPool::pool_size
int pool_size
Definition: vulkan.h:258
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:383
ff_vk_get_pooled_buffer
int ff_vk_get_pooled_buffer(FFVulkanContext *ctx, AVBufferPool **buf_pool, AVBufferRef **buf, VkBufferUsageFlags usage, void *create_pNext, size_t size, VkMemoryPropertyFlagBits mem_props)
Initialize a pool and create AVBufferRefs containing FFVkBuffer.
Definition: vulkan.c:1254
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:1123
FFVkExecContext::idx
uint32_t idx
Definition: vulkan.h:112
src
#define src
Definition: vp8dsp.c:248
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_GRAY12MSB
#define AV_PIX_FMT_GRAY12MSB
Definition: pixfmt.h:568
FN_MAP_TO
#define FN_MAP_TO(dst_t, dst_name, src_t, src_name)
Definition: vulkan.c:88
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
FFVulkanShader::lg_size
int lg_size[3]
Definition: vulkan.h:198
REPS_FMT
#define REPS_FMT(fmt)
FFVkExecContext::access_dst
VkAccessFlagBits * access_dst
Definition: vulkan.h:163
Generated on Sat Nov 1 2025 19:23:01 for FFmpeg by   doxygen 1.8.17