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 quieries 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  buffer_size = offs + src_buf->size;
1412  buffer_size = FFALIGN(buffer_size, s->props.properties.limits.minMemoryMapAlignment);
1413  buffer_size = FFALIGN(buffer_size, s->hprops.minImportedHostPointerAlignment);
1414 
1415  /* Create a buffer struct */
1416  vkb = av_mallocz(sizeof(*vkb));
1417  if (!vkb) {
1418  av_buffer_unref(&ref);
1419  return AVERROR(ENOMEM);
1420  }
1421 
1422  err = create_mapped_buffer(s, vkb, usage,
1423  buffer_size, &create_desc, &import_desc,
1424  props);
1425  if (err < 0) {
1426  av_buffer_unref(&ref);
1427  av_free(vkb);
1428  return err;
1429  }
1430 
1431  if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
1432  VkBufferDeviceAddressInfo address_info = {
1433  .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
1434  .buffer = vkb->buf,
1435  };
1436  vkb->address = vk->GetBufferDeviceAddress(s->hwctx->act_dev, &address_info);
1437  }
1438 
1439  vkb->host_ref = ref;
1440  vkb->virtual_offset = offs;
1441  vkb->address += offs;
1442  vkb->mapped_mem = src_data;
1443  vkb->size = buffer_size - offs;
1444  vkb->flags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
1445 
1446  /* Create a ref */
1447  *dst = av_buffer_create((uint8_t *)vkb, sizeof(*vkb),
1448  destroy_avvkbuf, s, 0);
1449  if (!(*dst)) {
1450  destroy_avvkbuf(s, (uint8_t *)vkb);
1451  *dst = NULL;
1452  return AVERROR(ENOMEM);
1453  }
1454 
1455  return 0;
1456 }
1457 
1458 int ff_vk_shader_add_push_const(FFVulkanShader *shd, int offset, int size,
1459  VkShaderStageFlagBits stage)
1460 {
1461  VkPushConstantRange *pc;
1462 
1463  shd->push_consts = av_realloc_array(shd->push_consts,
1464  sizeof(*shd->push_consts),
1465  shd->push_consts_num + 1);
1466  if (!shd->push_consts)
1467  return AVERROR(ENOMEM);
1468 
1469  pc = &shd->push_consts[shd->push_consts_num++];
1470  memset(pc, 0, sizeof(*pc));
1471 
1472  pc->stageFlags = stage;
1473  pc->offset = offset;
1474  pc->size = size;
1475 
1476  return 0;
1477 }
1478 
1479 int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler,
1480  int unnorm_coords, VkFilter filt)
1481 {
1482  VkResult ret;
1483  FFVulkanFunctions *vk = &s->vkfn;
1484 
1485  VkSamplerCreateInfo sampler_info = {
1486  .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
1487  .magFilter = filt,
1488  .minFilter = sampler_info.magFilter,
1489  .mipmapMode = unnorm_coords ? VK_SAMPLER_MIPMAP_MODE_NEAREST :
1490  VK_SAMPLER_MIPMAP_MODE_LINEAR,
1491  .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1492  .addressModeV = sampler_info.addressModeU,
1493  .addressModeW = sampler_info.addressModeU,
1494  .anisotropyEnable = VK_FALSE,
1495  .compareOp = VK_COMPARE_OP_NEVER,
1496  .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
1497  .unnormalizedCoordinates = unnorm_coords,
1498  };
1499 
1500  ret = vk->CreateSampler(s->hwctx->act_dev, &sampler_info,
1501  s->hwctx->alloc, sampler);
1502  if (ret != VK_SUCCESS) {
1503  av_log(s, AV_LOG_ERROR, "Unable to init sampler: %s\n",
1504  ff_vk_ret2str(ret));
1505  return AVERROR_EXTERNAL;
1506  }
1507 
1508  return 0;
1509 }
1510 
1511 VkImageAspectFlags ff_vk_aspect_flag(AVFrame *f, int p)
1512 {
1513  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
1514  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
1515  int nb_images = ff_vk_count_images(vkf);
1516  int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
1517 
1518  static const VkImageAspectFlags plane_aspect[] = { VK_IMAGE_ASPECT_PLANE_0_BIT,
1519  VK_IMAGE_ASPECT_PLANE_1_BIT,
1520  VK_IMAGE_ASPECT_PLANE_2_BIT, };
1521 
1522  if (ff_vk_mt_is_np_rgb(hwfc->sw_format) || (nb_planes == nb_images))
1523  return VK_IMAGE_ASPECT_COLOR_BIT;
1524 
1525  return plane_aspect[p];
1526 }
1527 
1528 int ff_vk_mt_is_np_rgb(enum AVPixelFormat pix_fmt)
1529 {
1530  if (pix_fmt == AV_PIX_FMT_ABGR || pix_fmt == AV_PIX_FMT_BGRA ||
1531  pix_fmt == AV_PIX_FMT_RGBA || pix_fmt == AV_PIX_FMT_RGB24 ||
1532  pix_fmt == AV_PIX_FMT_BGR24 || pix_fmt == AV_PIX_FMT_RGB48 ||
1533  pix_fmt == AV_PIX_FMT_RGBA64 || pix_fmt == AV_PIX_FMT_RGB565 ||
1534  pix_fmt == AV_PIX_FMT_BGR565 || pix_fmt == AV_PIX_FMT_BGR0 ||
1535  pix_fmt == AV_PIX_FMT_0BGR || pix_fmt == AV_PIX_FMT_RGB0 ||
1536  pix_fmt == AV_PIX_FMT_GBRP10 || pix_fmt == AV_PIX_FMT_GBRP12 ||
1537  pix_fmt == AV_PIX_FMT_GBRP14 || pix_fmt == AV_PIX_FMT_GBRP16 ||
1538  pix_fmt == AV_PIX_FMT_GBRAP || pix_fmt == AV_PIX_FMT_GBRAP10 ||
1539  pix_fmt == AV_PIX_FMT_GBRAP12 || pix_fmt == AV_PIX_FMT_GBRAP14 ||
1540  pix_fmt == AV_PIX_FMT_GBRAP16 || pix_fmt == AV_PIX_FMT_GBRAP32 ||
1541  pix_fmt == AV_PIX_FMT_GBRPF32 || pix_fmt == AV_PIX_FMT_GBRAPF32 ||
1542  pix_fmt == AV_PIX_FMT_X2RGB10 || pix_fmt == AV_PIX_FMT_X2BGR10 ||
1543  pix_fmt == AV_PIX_FMT_RGBAF32 || pix_fmt == AV_PIX_FMT_RGBF32 ||
1544  pix_fmt == AV_PIX_FMT_RGBA128 || pix_fmt == AV_PIX_FMT_RGB96 ||
1545  pix_fmt == AV_PIX_FMT_GBRP)
1546  return 1;
1547  return 0;
1548 }
1549 
1550 void ff_vk_set_perm(enum AVPixelFormat pix_fmt, int lut[4], int inv)
1551 {
1552  switch (pix_fmt) {
1553  case AV_PIX_FMT_GBRP:
1554  case AV_PIX_FMT_GBRAP:
1555  case AV_PIX_FMT_GBRAP10:
1556  case AV_PIX_FMT_GBRAP12:
1557  case AV_PIX_FMT_GBRAP14:
1558  case AV_PIX_FMT_GBRAP16:
1559  case AV_PIX_FMT_GBRP10:
1560  case AV_PIX_FMT_GBRP12:
1561  case AV_PIX_FMT_GBRP14:
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_GRAY10:
1675  case AV_PIX_FMT_GRAY12:
1676  case AV_PIX_FMT_GRAY14:
1677  case AV_PIX_FMT_GRAY16:
1678  case AV_PIX_FMT_GBRAP10:
1679  case AV_PIX_FMT_GBRAP12:
1680  case AV_PIX_FMT_GBRAP14:
1681  case AV_PIX_FMT_GBRAP16:
1682  case AV_PIX_FMT_GBRP10:
1683  case AV_PIX_FMT_GBRP12:
1684  case AV_PIX_FMT_GBRP14:
1685  case AV_PIX_FMT_GBRP16:
1686  case AV_PIX_FMT_YUV420P10:
1687  case AV_PIX_FMT_YUV420P12:
1688  case AV_PIX_FMT_YUV420P16:
1689  case AV_PIX_FMT_YUV422P10:
1690  case AV_PIX_FMT_YUV422P12:
1691  case AV_PIX_FMT_YUV422P16:
1692  case AV_PIX_FMT_YUV444P10:
1693  case AV_PIX_FMT_YUV444P12:
1694  case AV_PIX_FMT_YUV444P16:
1695  case AV_PIX_FMT_YUVA420P10:
1696  case AV_PIX_FMT_YUVA420P16:
1697  case AV_PIX_FMT_YUVA422P10:
1698  case AV_PIX_FMT_YUVA422P12:
1699  case AV_PIX_FMT_YUVA422P16:
1700  case AV_PIX_FMT_YUVA444P10:
1701  case AV_PIX_FMT_YUVA444P12:
1702  case AV_PIX_FMT_YUVA444P16: {
1703  const char *rep_tab[] = {
1704  [FF_VK_REP_NATIVE] = "r16ui",
1705  [FF_VK_REP_FLOAT] = "r16f",
1706  [FF_VK_REP_INT] = "r16i",
1707  [FF_VK_REP_UINT] = "r16ui",
1708  };
1709  return rep_tab[rep_fmt];
1710  };
1711  case AV_PIX_FMT_GRAY32:
1712  case AV_PIX_FMT_GRAYF32:
1713  case AV_PIX_FMT_GBRPF32:
1714  case AV_PIX_FMT_GBRAPF32: {
1715  const char *rep_tab[] = {
1716  [FF_VK_REP_NATIVE] = "r32f",
1717  [FF_VK_REP_FLOAT] = "r32f",
1718  [FF_VK_REP_INT] = "r32i",
1719  [FF_VK_REP_UINT] = "r32ui",
1720  };
1721  return rep_tab[rep_fmt];
1722  };
1723  case AV_PIX_FMT_GBRAP32: {
1724  const char *rep_tab[] = {
1725  [FF_VK_REP_NATIVE] = "r32ui",
1726  [FF_VK_REP_FLOAT] = NULL,
1727  [FF_VK_REP_INT] = "r32i",
1728  [FF_VK_REP_UINT] = "r32ui",
1729  };
1730  return rep_tab[rep_fmt];
1731  };
1732  case AV_PIX_FMT_NV12:
1733  case AV_PIX_FMT_NV16:
1734  case AV_PIX_FMT_NV24: {
1735  const char *rep_tab[] = {
1736  [FF_VK_REP_NATIVE] = "rg8ui",
1737  [FF_VK_REP_FLOAT] = "rg8",
1738  [FF_VK_REP_INT] = "rg8i",
1739  [FF_VK_REP_UINT] = "rg8ui",
1740  };
1741  return rep_tab[rep_fmt];
1742  };
1743  case AV_PIX_FMT_P010:
1744  case AV_PIX_FMT_P210:
1745  case AV_PIX_FMT_P410: {
1746  const char *rep_tab[] = {
1747  [FF_VK_REP_NATIVE] = "rgb10_a2ui",
1748  [FF_VK_REP_FLOAT] = "rgb10_a2",
1749  [FF_VK_REP_INT] = NULL,
1750  [FF_VK_REP_UINT] = "rgb10_a2ui",
1751  };
1752  return rep_tab[rep_fmt];
1753  };
1754  case AV_PIX_FMT_P012:
1755  case AV_PIX_FMT_P016:
1756  case AV_PIX_FMT_P212:
1757  case AV_PIX_FMT_P216:
1758  case AV_PIX_FMT_P412:
1759  case AV_PIX_FMT_P416: {
1760  const char *rep_tab[] = {
1761  [FF_VK_REP_NATIVE] = "rg16ui",
1762  [FF_VK_REP_FLOAT] = "rg16",
1763  [FF_VK_REP_INT] = "rg16i",
1764  [FF_VK_REP_UINT] = "rg16ui",
1765  };
1766  return rep_tab[rep_fmt];
1767  };
1768  default:
1769  return "rgba32f";
1770  }
1771 }
1772 
1773 typedef struct ImageViewCtx {
1774  int nb_views;
1775  VkImageView views[];
1776 } ImageViewCtx;
1777 
1778 static void destroy_imageviews(void *opaque, uint8_t *data)
1779 {
1780  FFVulkanContext *s = opaque;
1781  FFVulkanFunctions *vk = &s->vkfn;
1782  ImageViewCtx *iv = (ImageViewCtx *)data;
1783 
1784  for (int i = 0; i < iv->nb_views; i++)
1785  vk->DestroyImageView(s->hwctx->act_dev, iv->views[i], s->hwctx->alloc);
1786 
1787  av_free(iv);
1788 }
1789 
1790 static VkFormat map_fmt_to_rep(VkFormat fmt, enum FFVkShaderRepFormat rep_fmt)
1791 {
1792 #define REPS_FMT(fmt) \
1793  [FF_VK_REP_NATIVE] = fmt ## _UINT, \
1794  [FF_VK_REP_FLOAT] = fmt ## _UNORM, \
1795  [FF_VK_REP_INT] = fmt ## _SINT, \
1796  [FF_VK_REP_UINT] = fmt ## _UINT,
1797 
1798 #define REPS_FMT_PACK(fmt, num) \
1799  [FF_VK_REP_NATIVE] = fmt ## _UINT_PACK ## num, \
1800  [FF_VK_REP_FLOAT] = fmt ## _UNORM_PACK ## num, \
1801  [FF_VK_REP_INT] = fmt ## _SINT_PACK ## num, \
1802  [FF_VK_REP_UINT] = fmt ## _UINT_PACK ## num,
1803 
1804  const VkFormat fmts_map[][4] = {
1805  { REPS_FMT_PACK(VK_FORMAT_A2B10G10R10, 32) },
1806  { REPS_FMT_PACK(VK_FORMAT_A2R10G10B10, 32) },
1807  {
1808  VK_FORMAT_B5G6R5_UNORM_PACK16,
1809  VK_FORMAT_B5G6R5_UNORM_PACK16,
1810  VK_FORMAT_UNDEFINED,
1811  VK_FORMAT_UNDEFINED,
1812  },
1813  {
1814  VK_FORMAT_R5G6B5_UNORM_PACK16,
1815  VK_FORMAT_R5G6B5_UNORM_PACK16,
1816  VK_FORMAT_UNDEFINED,
1817  VK_FORMAT_UNDEFINED,
1818  },
1819  { REPS_FMT(VK_FORMAT_B8G8R8) },
1820  { REPS_FMT(VK_FORMAT_B8G8R8A8) },
1821  { REPS_FMT(VK_FORMAT_R8) },
1822  { REPS_FMT(VK_FORMAT_R8G8) },
1823  { REPS_FMT(VK_FORMAT_R8G8B8) },
1824  { REPS_FMT(VK_FORMAT_R8G8B8A8) },
1825  { REPS_FMT(VK_FORMAT_R16) },
1826  { REPS_FMT(VK_FORMAT_R16G16) },
1827  { REPS_FMT(VK_FORMAT_R16G16B16) },
1828  { REPS_FMT(VK_FORMAT_R16G16B16A16) },
1829  {
1830  VK_FORMAT_R32_UINT,
1831  VK_FORMAT_R32_SFLOAT,
1832  VK_FORMAT_R32_SINT,
1833  VK_FORMAT_R32_UINT,
1834  },
1835  {
1836  VK_FORMAT_R32G32B32_SFLOAT,
1837  VK_FORMAT_R32G32B32_SFLOAT,
1838  VK_FORMAT_UNDEFINED,
1839  VK_FORMAT_UNDEFINED,
1840  },
1841  {
1842  VK_FORMAT_R32G32B32A32_SFLOAT,
1843  VK_FORMAT_R32G32B32A32_SFLOAT,
1844  VK_FORMAT_UNDEFINED,
1845  VK_FORMAT_UNDEFINED,
1846  },
1847  {
1848  VK_FORMAT_R32G32B32_UINT,
1849  VK_FORMAT_UNDEFINED,
1850  VK_FORMAT_R32G32B32_SINT,
1851  VK_FORMAT_R32G32B32_UINT,
1852  },
1853  {
1854  VK_FORMAT_R32G32B32A32_UINT,
1855  VK_FORMAT_UNDEFINED,
1856  VK_FORMAT_R32G32B32A32_SINT,
1857  VK_FORMAT_R32G32B32A32_UINT,
1858  },
1859  };
1860 #undef REPS_FMT_PACK
1861 #undef REPS_FMT
1862 
1863  if (fmt == VK_FORMAT_UNDEFINED)
1864  return VK_FORMAT_UNDEFINED;
1865 
1866  for (int i = 0; i < FF_ARRAY_ELEMS(fmts_map); i++) {
1867  if (fmts_map[i][FF_VK_REP_NATIVE] == fmt ||
1868  fmts_map[i][FF_VK_REP_FLOAT] == fmt ||
1869  fmts_map[i][FF_VK_REP_INT] == fmt ||
1870  fmts_map[i][FF_VK_REP_UINT] == fmt)
1871  return fmts_map[i][rep_fmt];
1872  }
1873 
1874  return VK_FORMAT_UNDEFINED;
1875 }
1876 
1877 int ff_vk_create_imageview(FFVulkanContext *s,
1878  VkImageView *img_view, VkImageAspectFlags *aspect,
1879  AVFrame *f, int plane, enum FFVkShaderRepFormat rep_fmt)
1880 {
1881  VkResult ret;
1882  FFVulkanFunctions *vk = &s->vkfn;
1883  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
1884  AVVulkanFramesContext *vkfc = hwfc->hwctx;
1885  const VkFormat *rep_fmts = av_vkfmt_from_pixfmt(hwfc->sw_format);
1886  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
1887  const int nb_images = ff_vk_count_images(vkf);
1888 
1889  VkImageViewUsageCreateInfo view_usage_info = {
1890  .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
1891  .usage = vkfc->usage &
1892  (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
1893  VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
1894  };
1895  VkImageViewCreateInfo view_create_info = {
1896  .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1897  .pNext = &view_usage_info,
1898  .image = vkf->img[FFMIN(plane, nb_images - 1)],
1899  .viewType = VK_IMAGE_VIEW_TYPE_2D,
1900  .format = map_fmt_to_rep(rep_fmts[plane], rep_fmt),
1901  .components = ff_comp_identity_map,
1902  .subresourceRange = {
1903  .aspectMask = ff_vk_aspect_flag(f, plane),
1904  .levelCount = 1,
1905  .layerCount = 1,
1906  },
1907  };
1908  if (view_create_info.format == VK_FORMAT_UNDEFINED) {
1909  av_log(s, AV_LOG_ERROR, "Unable to find a compatible representation "
1910  "of format %i and mode %i\n",
1911  rep_fmts[plane], rep_fmt);
1912  return AVERROR(EINVAL);
1913  }
1914 
1915  ret = vk->CreateImageView(s->hwctx->act_dev, &view_create_info,
1916  s->hwctx->alloc, img_view);
1917  if (ret != VK_SUCCESS) {
1918  av_log(s, AV_LOG_ERROR, "Failed to create imageview: %s\n",
1919  ff_vk_ret2str(ret));
1920  return AVERROR_EXTERNAL;
1921  }
1922 
1923  *aspect = view_create_info.subresourceRange.aspectMask;
1924 
1925  return 0;
1926 }
1927 
1928 int ff_vk_create_imageviews(FFVulkanContext *s, FFVkExecContext *e,
1929  VkImageView views[AV_NUM_DATA_POINTERS],
1930  AVFrame *f, enum FFVkShaderRepFormat rep_fmt)
1931 {
1932  int err;
1933  VkResult ret;
1934  AVBufferRef *buf;
1935  FFVulkanFunctions *vk = &s->vkfn;
1936  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
1937  AVVulkanFramesContext *vkfc = hwfc->hwctx;
1938  const VkFormat *rep_fmts = av_vkfmt_from_pixfmt(hwfc->sw_format);
1939  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
1940  const int nb_images = ff_vk_count_images(vkf);
1941  const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
1942 
1943  ImageViewCtx *iv;
1944  const size_t buf_size = sizeof(*iv) + nb_planes*sizeof(VkImageView);
1945  iv = av_mallocz(buf_size);
1946  if (!iv)
1947  return AVERROR(ENOMEM);
1948 
1949  for (int i = 0; i < nb_planes; i++) {
1950  VkImageViewUsageCreateInfo view_usage_info = {
1951  .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
1952  .usage = vkfc->usage &
1953  (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
1954  VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
1955  };
1956  VkImageViewCreateInfo view_create_info = {
1957  .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1958  .pNext = &view_usage_info,
1959  .image = vkf->img[FFMIN(i, nb_images - 1)],
1960  .viewType = VK_IMAGE_VIEW_TYPE_2D,
1961  .format = map_fmt_to_rep(rep_fmts[i], rep_fmt),
1962  .components = ff_comp_identity_map,
1963  .subresourceRange = {
1964  .aspectMask = ff_vk_aspect_flag(f, i),
1965  .levelCount = 1,
1966  .layerCount = 1,
1967  },
1968  };
1969  if (view_create_info.format == VK_FORMAT_UNDEFINED) {
1970  av_log(s, AV_LOG_ERROR, "Unable to find a compatible representation "
1971  "of format %i and mode %i\n",
1972  rep_fmts[i], rep_fmt);
1973  err = AVERROR(EINVAL);
1974  goto fail;
1975  }
1976 
1977  ret = vk->CreateImageView(s->hwctx->act_dev, &view_create_info,
1978  s->hwctx->alloc, &iv->views[i]);
1979  if (ret != VK_SUCCESS) {
1980  av_log(s, AV_LOG_ERROR, "Failed to create imageview: %s\n",
1981  ff_vk_ret2str(ret));
1982  err = AVERROR_EXTERNAL;
1983  goto fail;
1984  }
1985 
1986  iv->nb_views++;
1987  }
1988 
1989  buf = av_buffer_create((uint8_t *)iv, buf_size, destroy_imageviews, s, 0);
1990  if (!buf) {
1991  err = AVERROR(ENOMEM);
1992  goto fail;
1993  }
1994 
1995  /* Add to queue dependencies */
1996  err = ff_vk_exec_add_dep_buf(s, e, &buf, 1, 0);
1997  if (err < 0)
1998  av_buffer_unref(&buf);
1999 
2000  memcpy(views, iv->views, nb_planes*sizeof(*views));
2001 
2002  return err;
2003 
2004 fail:
2005  for (int i = 0; i < iv->nb_views; i++)
2006  vk->DestroyImageView(s->hwctx->act_dev, iv->views[i], s->hwctx->alloc);
2007  av_free(iv);
2008  return err;
2009 }
2010 
2011 void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e,
2012  AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar,
2013  VkPipelineStageFlags src_stage,
2014  VkPipelineStageFlags dst_stage,
2015  VkAccessFlagBits new_access,
2016  VkImageLayout new_layout,
2017  uint32_t new_qf)
2018 {
2019  int found = -1;
2020  AVVkFrame *vkf = (AVVkFrame *)pic->data[0];
2021  const int nb_images = ff_vk_count_images(vkf);
2022  for (int i = 0; i < e->nb_frame_deps; i++)
2023  if (e->frame_deps[i]->data[0] == pic->data[0]) {
2024  if (e->frame_update[i])
2025  found = i;
2026  break;
2027  }
2028 
2029  for (int i = 0; i < nb_images; i++) {
2030  bar[*nb_bar] = (VkImageMemoryBarrier2) {
2031  .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
2032  .pNext = NULL,
2033  .srcStageMask = src_stage,
2034  .dstStageMask = dst_stage,
2035  .srcAccessMask = found >= 0 ? e->access_dst[found] : vkf->access[i],
2036  .dstAccessMask = new_access,
2037  .oldLayout = found >= 0 ? e->layout_dst[found] : vkf->layout[0],
2038  .newLayout = new_layout,
2039  .srcQueueFamilyIndex = found >= 0 ? e->queue_family_dst[found] : vkf->queue_family[0],
2040  .dstQueueFamilyIndex = new_qf,
2041  .image = vkf->img[i],
2042  .subresourceRange = (VkImageSubresourceRange) {
2043  .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
2044  .layerCount = 1,
2045  .levelCount = 1,
2046  },
2047  };
2048  *nb_bar += 1;
2049  }
2050 
2051  ff_vk_exec_update_frame(s, e, pic, &bar[*nb_bar - nb_images], NULL);
2052 }
2053 
2054 int ff_vk_shader_init(FFVulkanContext *s, FFVulkanShader *shd, const char *name,
2055  VkPipelineStageFlags stage,
2056  const char *extensions[], int nb_extensions,
2057  int lg_x, int lg_y, int lg_z,
2058  uint32_t required_subgroup_size)
2059 {
2060  av_bprint_init(&shd->src, 0, AV_BPRINT_SIZE_UNLIMITED);
2061 
2062  shd->name = name;
2063  shd->stage = stage;
2064  shd->lg_size[0] = lg_x;
2065  shd->lg_size[1] = lg_y;
2066  shd->lg_size[2] = lg_z;
2067 
2068  switch (shd->stage) {
2069  case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
2070  case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
2071  case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
2072  case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
2073  case VK_SHADER_STAGE_MISS_BIT_KHR:
2074  case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
2075  shd->bind_point = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
2076  break;
2077  case VK_SHADER_STAGE_COMPUTE_BIT:
2078  shd->bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
2079  break;
2080  default:
2081  shd->bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS;
2082  break;
2083  };
2084 
2085  if (required_subgroup_size) {
2086  shd->subgroup_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
2087  shd->subgroup_info.requiredSubgroupSize = required_subgroup_size;
2088  }
2089 
2090  av_bprintf(&shd->src, "/* %s shader: %s */\n",
2091  (stage == VK_SHADER_STAGE_TASK_BIT_EXT ||
2092  stage == VK_SHADER_STAGE_MESH_BIT_EXT) ?
2093  "Mesh" :
2094  (shd->bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR) ?
2095  "Raytrace" :
2096  (shd->bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) ?
2097  "Compute" : "Graphics",
2098  name);
2099  GLSLF(0, #version %i ,460);
2100  GLSLC(0, );
2101 
2102  /* Common utilities */
2103  GLSLC(0, #define IS_WITHIN(v1, v2) ((v1.x < v2.x) && (v1.y < v2.y)) );
2104  GLSLC(0, );
2105  GLSLC(0, #extension GL_EXT_scalar_block_layout : require );
2106  GLSLC(0, #extension GL_EXT_shader_explicit_arithmetic_types : require );
2107  GLSLC(0, #extension GL_EXT_control_flow_attributes : require );
2108  GLSLC(0, #extension GL_EXT_shader_image_load_formatted : require );
2109  if (s->extensions & FF_VK_EXT_EXPECT_ASSUME) {
2110  GLSLC(0, #extension GL_EXT_expect_assume : require );
2111  } else {
2112  GLSLC(0, #define assumeEXT(x) (x) );
2113  GLSLC(0, #define expectEXT(x, c) (x) );
2114  }
2115  if ((s->extensions & FF_VK_EXT_DEBUG_UTILS) &&
2116  (s->extensions & FF_VK_EXT_RELAXED_EXTENDED_INSTR)) {
2117  GLSLC(0, #extension GL_EXT_debug_printf : require );
2118  GLSLC(0, #define DEBUG );
2119  }
2120 
2121  if (stage == VK_SHADER_STAGE_TASK_BIT_EXT ||
2122  stage == VK_SHADER_STAGE_MESH_BIT_EXT)
2123  GLSLC(0, #extension GL_EXT_mesh_shader : require );
2124 
2125  for (int i = 0; i < nb_extensions; i++)
2126  GLSLF(0, #extension %s : %s ,extensions[i], "require");
2127  GLSLC(0, );
2128 
2129  GLSLF(0, layout (local_size_x = %i, local_size_y = %i, local_size_z = %i) in;
2130  , shd->lg_size[0], shd->lg_size[1], shd->lg_size[2]);
2131  GLSLC(0, );
2132 
2133  return 0;
2134 }
2135 
2136 void ff_vk_shader_print(void *ctx, FFVulkanShader *shd, int prio)
2137 {
2138  int line = 0;
2139  const char *p = shd->src.str;
2140  const char *start = p;
2141  const size_t len = strlen(p);
2142 
2143  AVBPrint buf;
2144  av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
2145 
2146  for (int i = 0; i < len; i++) {
2147  if (p[i] == '\n') {
2148  av_bprintf(&buf, "%i\t", ++line);
2149  av_bprint_append_data(&buf, start, &p[i] - start + 1);
2150  start = &p[i + 1];
2151  }
2152  }
2153 
2154  av_log(ctx, prio, "Shader %s: \n%s", shd->name, buf.str);
2155  av_bprint_finalize(&buf, NULL);
2156 }
2157 
2158 static int init_pipeline_layout(FFVulkanContext *s, FFVulkanShader *shd)
2159 {
2160  VkResult ret;
2161  FFVulkanFunctions *vk = &s->vkfn;
2162  VkPipelineLayoutCreateInfo pipeline_layout_info;
2163 
2164  /* Finally create the pipeline layout */
2165  pipeline_layout_info = (VkPipelineLayoutCreateInfo) {
2166  .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
2167  .pSetLayouts = shd->desc_layout,
2168  .setLayoutCount = shd->nb_descriptor_sets,
2169  .pushConstantRangeCount = shd->push_consts_num,
2170  .pPushConstantRanges = shd->push_consts,
2171  };
2172 
2173  ret = vk->CreatePipelineLayout(s->hwctx->act_dev, &pipeline_layout_info,
2174  s->hwctx->alloc, &shd->pipeline_layout);
2175  if (ret != VK_SUCCESS) {
2176  av_log(s, AV_LOG_ERROR, "Unable to init pipeline layout: %s\n",
2177  ff_vk_ret2str(ret));
2178  return AVERROR_EXTERNAL;
2179  }
2180 
2181  return 0;
2182 }
2183 
2184 static int create_shader_module(FFVulkanContext *s, FFVulkanShader *shd,
2185  VkShaderModule *mod,
2186  uint8_t *spirv, size_t spirv_len)
2187 {
2188  VkResult ret;
2189  FFVulkanFunctions *vk = &s->vkfn;
2190 
2191  VkShaderModuleCreateInfo shader_module_info = {
2192  .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
2193  .pNext = NULL,
2194  .flags = 0x0,
2195  .pCode = (void *)spirv,
2196  .codeSize = spirv_len,
2197  };
2198 
2199  ret = vk->CreateShaderModule(s->hwctx->act_dev, &shader_module_info,
2200  s->hwctx->alloc, mod);
2201  if (ret != VK_SUCCESS) {
2202  av_log(s, AV_LOG_ERROR, "Error creating shader module: %s\n",
2203  ff_vk_ret2str(ret));
2204  return AVERROR_EXTERNAL;
2205  }
2206 
2207  return 0;
2208 }
2209 
2210 static int init_compute_pipeline(FFVulkanContext *s, FFVulkanShader *shd,
2211  VkShaderModule mod, const char *entrypoint)
2212 {
2213  VkResult ret;
2214  FFVulkanFunctions *vk = &s->vkfn;
2215 
2216  VkComputePipelineCreateInfo pipeline_create_info = {
2217  .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
2218  .flags = (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) ?
2219  VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT : 0x0,
2220  .layout = shd->pipeline_layout,
2221  .stage = (VkPipelineShaderStageCreateInfo) {
2222  .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2223  .pNext = shd->subgroup_info.requiredSubgroupSize ?
2224  &shd->subgroup_info : NULL,
2225  .pName = entrypoint,
2226  .flags = shd->subgroup_info.requiredSubgroupSize ?
2227  VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT : 0x0,
2228  .stage = shd->stage,
2229  .module = mod,
2230  },
2231  };
2232 
2233  ret = vk->CreateComputePipelines(s->hwctx->act_dev, VK_NULL_HANDLE, 1,
2234  &pipeline_create_info,
2235  s->hwctx->alloc, &shd->pipeline);
2236  if (ret != VK_SUCCESS) {
2237  av_log(s, AV_LOG_ERROR, "Unable to init compute pipeline: %s\n",
2238  ff_vk_ret2str(ret));
2239  return AVERROR_EXTERNAL;
2240  }
2241 
2242  return 0;
2243 }
2244 
2245 static int create_shader_object(FFVulkanContext *s, FFVulkanShader *shd,
2246  uint8_t *spirv, size_t spirv_len,
2247  const char *entrypoint)
2248 {
2249  VkResult ret;
2250  FFVulkanFunctions *vk = &s->vkfn;
2251  size_t shader_size = 0;
2252 
2253  VkShaderCreateInfoEXT shader_obj_create = {
2254  .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
2255  .flags = shd->subgroup_info.requiredSubgroupSize ?
2256  VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT : 0x0,
2257  .stage = shd->stage,
2258  .nextStage = 0,
2259  .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
2260  .pCode = spirv,
2261  .codeSize = spirv_len,
2262  .pName = entrypoint,
2263  .pSetLayouts = shd->desc_layout,
2264  .setLayoutCount = shd->nb_descriptor_sets,
2265  .pushConstantRangeCount = shd->push_consts_num,
2266  .pPushConstantRanges = shd->push_consts,
2267  .pSpecializationInfo = NULL,
2268  };
2269 
2270  ret = vk->CreateShadersEXT(s->hwctx->act_dev, 1, &shader_obj_create,
2271  s->hwctx->alloc, &shd->object);
2272  if (ret != VK_SUCCESS) {
2273  av_log(s, AV_LOG_ERROR, "Unable to create shader object: %s\n",
2274  ff_vk_ret2str(ret));
2275  return AVERROR_EXTERNAL;
2276  }
2277 
2278  if (vk->GetShaderBinaryDataEXT(s->hwctx->act_dev, shd->object,
2279  &shader_size, NULL) == VK_SUCCESS)
2280  av_log(s, AV_LOG_VERBOSE, "Shader %s size: %zu binary (%zu SPIR-V)\n",
2281  shd->name, shader_size, spirv_len);
2282 
2283  return 0;
2284 }
2285 
2286 static int init_descriptors(FFVulkanContext *s, FFVulkanShader *shd)
2287 {
2288  VkResult ret;
2289  FFVulkanFunctions *vk = &s->vkfn;
2290 
2291  shd->desc_layout = av_malloc_array(shd->nb_descriptor_sets,
2292  sizeof(*shd->desc_layout));
2293  if (!shd->desc_layout)
2294  return AVERROR(ENOMEM);
2295 
2296  if (!(s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER)) {
2297  int has_singular = 0;
2298  int max_descriptors = 0;
2299  for (int i = 0; i < shd->nb_descriptor_sets; i++) {
2300  max_descriptors = FFMAX(max_descriptors, shd->desc_set[i].nb_bindings);
2301  if (shd->desc_set[i].singular)
2302  has_singular = 1;
2303  }
2304  shd->use_push = (s->extensions & FF_VK_EXT_PUSH_DESCRIPTOR) &&
2305  (max_descriptors <= s->push_desc_props.maxPushDescriptors) &&
2306  (shd->nb_descriptor_sets == 1) &&
2307  (has_singular == 0);
2308  }
2309 
2310  for (int i = 0; i < shd->nb_descriptor_sets; i++) {
2311  FFVulkanDescriptorSet *set = &shd->desc_set[i];
2312  VkDescriptorSetLayoutCreateInfo desc_layout_create = {
2313  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
2314  .bindingCount = set->nb_bindings,
2315  .pBindings = set->binding,
2316  .flags = (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) ?
2317  VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT :
2318  (shd->use_push) ?
2319  VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR :
2320  0x0,
2321  };
2322 
2323  ret = vk->CreateDescriptorSetLayout(s->hwctx->act_dev,
2324  &desc_layout_create,
2325  s->hwctx->alloc,
2326  &shd->desc_layout[i]);
2327  if (ret != VK_SUCCESS) {
2328  av_log(s, AV_LOG_ERROR, "Unable to create descriptor set layout: %s",
2329  ff_vk_ret2str(ret));
2330  return AVERROR_EXTERNAL;
2331  }
2332 
2333  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2334  vk->GetDescriptorSetLayoutSizeEXT(s->hwctx->act_dev, shd->desc_layout[i],
2335  &set->layout_size);
2336 
2337  set->aligned_size = FFALIGN(set->layout_size,
2338  s->desc_buf_props.descriptorBufferOffsetAlignment);
2339 
2340  for (int j = 0; j < set->nb_bindings; j++)
2341  vk->GetDescriptorSetLayoutBindingOffsetEXT(s->hwctx->act_dev,
2342  shd->desc_layout[i],
2343  j,
2344  &set->binding_offset[j]);
2345  }
2346  }
2347 
2348  return 0;
2349 }
2350 
2351 int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd,
2352  uint8_t *spirv, size_t spirv_len,
2353  const char *entrypoint)
2354 {
2355  int err;
2356  FFVulkanFunctions *vk = &s->vkfn;
2357 
2358  err = init_descriptors(s, shd);
2359  if (err < 0)
2360  return err;
2361 
2362  err = init_pipeline_layout(s, shd);
2363  if (err < 0)
2364  return err;
2365 
2366  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2367  shd->bound_buffer_indices = av_calloc(shd->nb_descriptor_sets,
2368  sizeof(*shd->bound_buffer_indices));
2369  if (!shd->bound_buffer_indices)
2370  return AVERROR(ENOMEM);
2371 
2372  for (int i = 0; i < shd->nb_descriptor_sets; i++)
2373  shd->bound_buffer_indices[i] = i;
2374  }
2375 
2376  if (s->extensions & FF_VK_EXT_SHADER_OBJECT) {
2377  err = create_shader_object(s, shd, spirv, spirv_len, entrypoint);
2378  if (err < 0)
2379  return err;
2380  } else {
2381  VkShaderModule mod;
2382  err = create_shader_module(s, shd, &mod, spirv, spirv_len);
2383  if (err < 0)
2384  return err;
2385 
2386  switch (shd->bind_point) {
2387  case VK_PIPELINE_BIND_POINT_COMPUTE:
2388  err = init_compute_pipeline(s, shd, mod, entrypoint);
2389  break;
2390  default:
2391  av_log(s, AV_LOG_ERROR, "Unsupported shader type: %i\n",
2392  shd->bind_point);
2393  err = AVERROR(EINVAL);
2394  break;
2395  };
2396 
2397  vk->DestroyShaderModule(s->hwctx->act_dev, mod, s->hwctx->alloc);
2398  if (err < 0)
2399  return err;
2400  }
2401 
2402  return 0;
2403 }
2404 
2405 static const struct descriptor_props {
2406  size_t struct_size; /* Size of the opaque which updates the descriptor */
2407  const char *type;
2408  int is_uniform;
2409  int mem_quali; /* Can use a memory qualifier */
2410  int dim_needed; /* Must indicate dimension */
2411  int buf_content; /* Must indicate buffer contents */
2412 } descriptor_props[] = {
2413  [VK_DESCRIPTOR_TYPE_SAMPLER] = { sizeof(VkDescriptorImageInfo), "sampler", 1, 0, 0, 0, },
2414  [VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE] = { sizeof(VkDescriptorImageInfo), "texture", 1, 0, 1, 0, },
2415  [VK_DESCRIPTOR_TYPE_STORAGE_IMAGE] = { sizeof(VkDescriptorImageInfo), "image", 1, 1, 1, 0, },
2416  [VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT] = { sizeof(VkDescriptorImageInfo), "subpassInput", 1, 0, 0, 0, },
2417  [VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER] = { sizeof(VkDescriptorImageInfo), "sampler", 1, 0, 1, 0, },
2418  [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER] = { sizeof(VkDescriptorBufferInfo), NULL, 1, 0, 0, 1, },
2419  [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] = { sizeof(VkDescriptorBufferInfo), "buffer", 0, 1, 0, 1, },
2420  [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC] = { sizeof(VkDescriptorBufferInfo), NULL, 1, 0, 0, 1, },
2421  [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC] = { sizeof(VkDescriptorBufferInfo), "buffer", 0, 1, 0, 1, },
2422  [VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER] = { sizeof(VkBufferView), "samplerBuffer", 1, 0, 0, 0, },
2423  [VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER] = { sizeof(VkBufferView), "imageBuffer", 1, 0, 0, 0, },
2424 };
2425 
2426 int ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd,
2427  FFVulkanDescriptorSetBinding *desc, int nb,
2428  int singular, int print_to_shader_only)
2429 {
2430  int has_sampler = 0;
2431  FFVulkanDescriptorSet *set;
2432 
2433  if (print_to_shader_only)
2434  goto print;
2435 
2436  /* Actual layout allocated for the pipeline */
2437  set = av_realloc_array(shd->desc_set,
2438  sizeof(*shd->desc_set),
2439  shd->nb_descriptor_sets + 1);
2440  if (!set)
2441  return AVERROR(ENOMEM);
2442  shd->desc_set = set;
2443 
2444  set = &set[shd->nb_descriptor_sets];
2445  memset(set, 0, sizeof(*set));
2446 
2447  set->binding = av_calloc(nb, sizeof(*set->binding));
2448  if (!set->binding)
2449  return AVERROR(ENOMEM);
2450 
2451  set->binding_offset = av_calloc(nb, sizeof(*set->binding_offset));
2452  if (!set->binding_offset) {
2453  av_freep(&set->binding);
2454  return AVERROR(ENOMEM);
2455  }
2456 
2457  for (int i = 0; i < nb; i++) {
2458  set->binding[i].binding = i;
2459  set->binding[i].descriptorType = desc[i].type;
2460  set->binding[i].descriptorCount = FFMAX(desc[i].elems, 1);
2461  set->binding[i].stageFlags = desc[i].stages;
2462  set->binding[i].pImmutableSamplers = desc[i].samplers;
2463 
2464  if (desc[i].type == VK_DESCRIPTOR_TYPE_SAMPLER ||
2465  desc[i].type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
2466  has_sampler |= 1;
2467  }
2468 
2469  set->usage = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT |
2470  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
2471  if (has_sampler)
2472  set->usage |= VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT;
2473 
2474  if (!(s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER)) {
2475  for (int i = 0; i < nb; i++) {
2476  int j;
2477  VkDescriptorPoolSize *desc_pool_size;
2478  for (j = 0; j < shd->nb_desc_pool_size; j++)
2479  if (shd->desc_pool_size[j].type == desc[i].type)
2480  break;
2481  if (j >= shd->nb_desc_pool_size) {
2482  desc_pool_size = av_realloc_array(shd->desc_pool_size,
2483  sizeof(*desc_pool_size),
2484  shd->nb_desc_pool_size + 1);
2485  if (!desc_pool_size)
2486  return AVERROR(ENOMEM);
2487 
2488  shd->desc_pool_size = desc_pool_size;
2489  shd->nb_desc_pool_size++;
2490  memset(&desc_pool_size[j], 0, sizeof(VkDescriptorPoolSize));
2491  }
2492  shd->desc_pool_size[j].type = desc[i].type;
2493  shd->desc_pool_size[j].descriptorCount += FFMAX(desc[i].elems, 1);
2494  }
2495  }
2496 
2497  set->singular = singular;
2498  set->nb_bindings = nb;
2499  shd->nb_descriptor_sets++;
2500 
2501 print:
2502  /* Write shader info */
2503  for (int i = 0; i < nb; i++) {
2504  const struct descriptor_props *prop = &descriptor_props[desc[i].type];
2505  GLSLA("layout (set = %i, binding = %i", FFMAX(shd->nb_descriptor_sets - 1, 0), i);
2506 
2507  if (desc[i].mem_layout &&
2508  (desc[i].type != VK_DESCRIPTOR_TYPE_STORAGE_IMAGE))
2509  GLSLA(", %s", desc[i].mem_layout);
2510 
2511  GLSLA(")");
2512 
2513  if (prop->is_uniform)
2514  GLSLA(" uniform");
2515 
2516  if (prop->mem_quali && desc[i].mem_quali)
2517  GLSLA(" %s", desc[i].mem_quali);
2518 
2519  if (prop->type) {
2520  GLSLA(" ");
2521  if (desc[i].type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
2522  if (desc[i].mem_layout) {
2523  int len = strlen(desc[i].mem_layout);
2524  if (desc[i].mem_layout[len - 1] == 'i' &&
2525  desc[i].mem_layout[len - 2] == 'u') {
2526  GLSLA("u");
2527  } else if (desc[i].mem_layout[len - 1] == 'i') {
2528  GLSLA("i");
2529  }
2530  }
2531  }
2532  GLSLA("%s", prop->type);
2533  }
2534 
2535  if (prop->dim_needed)
2536  GLSLA("%iD", desc[i].dimensions);
2537 
2538  GLSLA(" %s", desc[i].name);
2539 
2540  if (prop->buf_content) {
2541  GLSLA(" {\n ");
2542  if (desc[i].buf_elems) {
2543  GLSLA("%s", desc[i].buf_content);
2544  GLSLA("[%i];", desc[i].buf_elems);
2545  } else {
2546  GLSLA("%s", desc[i].buf_content);
2547  }
2548  GLSLA("\n}");
2549  } else if (desc[i].elems > 0) {
2550  GLSLA("[%i]", desc[i].elems);
2551  }
2552 
2553  GLSLA(";");
2554  GLSLA("\n");
2555  }
2556  GLSLA("\n");
2557 
2558  return 0;
2559 }
2560 
2561 int ff_vk_shader_register_exec(FFVulkanContext *s, FFVkExecPool *pool,
2562  FFVulkanShader *shd)
2563 {
2564  int err;
2565  FFVulkanShaderData *sd;
2566 
2567  if (!shd->nb_descriptor_sets)
2568  return 0;
2569 
2570  sd = av_realloc_array(pool->reg_shd,
2571  sizeof(*pool->reg_shd),
2572  pool->nb_reg_shd + 1);
2573  if (!sd)
2574  return AVERROR(ENOMEM);
2575 
2576  pool->reg_shd = sd;
2577  sd = &sd[pool->nb_reg_shd++];
2578  memset(sd, 0, sizeof(*sd));
2579 
2580  sd->shd = shd;
2581  sd->nb_descriptor_sets = shd->nb_descriptor_sets;
2582 
2583  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2584  sd->desc_bind = av_malloc_array(sd->nb_descriptor_sets, sizeof(*sd->desc_bind));
2585  if (!sd->desc_bind)
2586  return AVERROR(ENOMEM);
2587 
2588  sd->desc_set_buf = av_calloc(sd->nb_descriptor_sets, sizeof(*sd->desc_set_buf));
2589  if (!sd->desc_set_buf)
2590  return AVERROR(ENOMEM);
2591 
2592  for (int i = 0; i < sd->nb_descriptor_sets; i++) {
2593  FFVulkanDescriptorSet *set = &shd->desc_set[i];
2594  FFVulkanDescriptorSetData *sdb = &sd->desc_set_buf[i];
2595  int nb = set->singular ? 1 : pool->pool_size;
2596 
2597  err = ff_vk_create_buf(s, &sdb->buf,
2598  set->aligned_size*nb,
2599  NULL, NULL, set->usage,
2600  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
2601  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
2602  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
2603  if (err < 0)
2604  return err;
2605 
2606  err = ff_vk_map_buffer(s, &sdb->buf, &sdb->desc_mem, 0);
2607  if (err < 0)
2608  return err;
2609 
2610  sd->desc_bind[i] = (VkDescriptorBufferBindingInfoEXT) {
2611  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT,
2612  .usage = set->usage,
2613  .address = sdb->buf.address,
2614  };
2615  }
2616  } else if (!shd->use_push) {
2617  VkResult ret;
2618  FFVulkanFunctions *vk = &s->vkfn;
2619  VkDescriptorSetLayout *tmp_layouts;
2620  VkDescriptorSetAllocateInfo set_alloc_info;
2621  VkDescriptorPoolCreateInfo pool_create_info;
2622 
2623  for (int i = 0; i < shd->nb_desc_pool_size; i++)
2624  shd->desc_pool_size[i].descriptorCount *= pool->pool_size;
2625 
2626  pool_create_info = (VkDescriptorPoolCreateInfo) {
2627  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2628  .flags = 0,
2629  .pPoolSizes = shd->desc_pool_size,
2630  .poolSizeCount = shd->nb_desc_pool_size,
2631  .maxSets = sd->nb_descriptor_sets*pool->pool_size,
2632  };
2633 
2634  ret = vk->CreateDescriptorPool(s->hwctx->act_dev, &pool_create_info,
2635  s->hwctx->alloc, &sd->desc_pool);
2636  if (ret != VK_SUCCESS) {
2637  av_log(s, AV_LOG_ERROR, "Unable to create descriptor pool: %s\n",
2638  ff_vk_ret2str(ret));
2639  return AVERROR_EXTERNAL;
2640  }
2641 
2642  tmp_layouts = av_malloc_array(pool_create_info.maxSets, sizeof(*tmp_layouts));
2643  if (!tmp_layouts)
2644  return AVERROR(ENOMEM);
2645 
2646  /* Colate each execution context's descriptor set layouts */
2647  for (int i = 0; i < pool->pool_size; i++)
2648  for (int j = 0; j < sd->nb_descriptor_sets; j++)
2649  tmp_layouts[i*sd->nb_descriptor_sets + j] = shd->desc_layout[j];
2650 
2651  set_alloc_info = (VkDescriptorSetAllocateInfo) {
2652  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2653  .descriptorPool = sd->desc_pool,
2654  .pSetLayouts = tmp_layouts,
2655  .descriptorSetCount = pool_create_info.maxSets,
2656  };
2657 
2658  sd->desc_sets = av_malloc_array(pool_create_info.maxSets,
2659  sizeof(*tmp_layouts));
2660  if (!sd->desc_sets) {
2661  av_free(tmp_layouts);
2662  return AVERROR(ENOMEM);
2663  }
2664  ret = vk->AllocateDescriptorSets(s->hwctx->act_dev, &set_alloc_info,
2665  sd->desc_sets);
2666  av_free(tmp_layouts);
2667  if (ret != VK_SUCCESS) {
2668  av_log(s, AV_LOG_ERROR, "Unable to allocate descriptor set: %s\n",
2669  ff_vk_ret2str(ret));
2670  av_freep(&sd->desc_sets);
2671  return AVERROR_EXTERNAL;
2672  }
2673  }
2674 
2675  return 0;
2676 }
2677 
2678 static inline FFVulkanShaderData *get_shd_data(FFVkExecContext *e,
2679  FFVulkanShader *shd)
2680 {
2681  for (int i = 0; i < e->parent->nb_reg_shd; i++)
2682  if (e->parent->reg_shd[i].shd == shd)
2683  return &e->parent->reg_shd[i];
2684  return NULL;
2685 }
2686 
2687 static inline void update_set_descriptor(FFVulkanContext *s, FFVkExecContext *e,
2688  FFVulkanShader *shd, int set,
2689  int bind_idx, int array_idx,
2690  VkDescriptorGetInfoEXT *desc_get_info,
2691  size_t desc_size)
2692 {
2693  FFVulkanFunctions *vk = &s->vkfn;
2694  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2695  FFVulkanShaderData *sd = get_shd_data(e, shd);
2696  const size_t exec_offset = desc_set->singular ? 0 : desc_set->aligned_size*e->idx;
2697 
2698  void *desc = sd->desc_set_buf[set].desc_mem + /* Base */
2699  exec_offset + /* Execution context */
2700  desc_set->binding_offset[bind_idx] + /* Descriptor binding */
2701  array_idx*desc_size; /* Array position */
2702 
2703  vk->GetDescriptorEXT(s->hwctx->act_dev, desc_get_info, desc_size, desc);
2704 }
2705 
2706 static inline void update_set_pool_write(FFVulkanContext *s, FFVkExecContext *e,
2707  FFVulkanShader *shd, int set,
2708  VkWriteDescriptorSet *write_info)
2709 {
2710  FFVulkanFunctions *vk = &s->vkfn;
2711  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2712  FFVulkanShaderData *sd = get_shd_data(e, shd);
2713 
2714  if (desc_set->singular) {
2715  for (int i = 0; i < e->parent->pool_size; i++) {
2716  write_info->dstSet = sd->desc_sets[i*sd->nb_descriptor_sets + set];
2717  vk->UpdateDescriptorSets(s->hwctx->act_dev, 1, write_info, 0, NULL);
2718  }
2719  } else {
2720  if (shd->use_push) {
2721  vk->CmdPushDescriptorSetKHR(e->buf,
2722  shd->bind_point,
2723  shd->pipeline_layout,
2724  set, 1,
2725  write_info);
2726  } else {
2727  write_info->dstSet = sd->desc_sets[e->idx*sd->nb_descriptor_sets + set];
2728  vk->UpdateDescriptorSets(s->hwctx->act_dev, 1, write_info, 0, NULL);
2729  }
2730  }
2731 }
2732 
2733 int ff_vk_shader_update_img(FFVulkanContext *s, FFVkExecContext *e,
2734  FFVulkanShader *shd, int set, int bind, int offs,
2735  VkImageView view, VkImageLayout layout,
2736  VkSampler sampler)
2737 {
2738  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2739 
2740  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2741  VkDescriptorGetInfoEXT desc_get_info = {
2742  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
2743  .type = desc_set->binding[bind].descriptorType,
2744  };
2745  VkDescriptorImageInfo desc_img_info = {
2746  .imageView = view,
2747  .sampler = sampler,
2748  .imageLayout = layout,
2749  };
2750  size_t desc_size;
2751 
2752  switch (desc_get_info.type) {
2753  case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
2754  desc_get_info.data.pSampledImage = &desc_img_info;
2755  desc_size = s->desc_buf_props.sampledImageDescriptorSize;
2756  break;
2757  case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
2758  desc_get_info.data.pStorageImage = &desc_img_info;
2759  desc_size = s->desc_buf_props.storageImageDescriptorSize;
2760  break;
2761  case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
2762  desc_get_info.data.pInputAttachmentImage = &desc_img_info;
2763  desc_size = s->desc_buf_props.inputAttachmentDescriptorSize;
2764  break;
2765  case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
2766  desc_get_info.data.pCombinedImageSampler = &desc_img_info;
2767  desc_size = s->desc_buf_props.combinedImageSamplerDescriptorSize;
2768  break;
2769  default:
2770  av_log(s, AV_LOG_ERROR, "Invalid descriptor type at set %i binding %i: %i!\n",
2771  set, bind, desc_get_info.type);
2772  return AVERROR(EINVAL);
2773  break;
2774  };
2775 
2776  update_set_descriptor(s, e, shd, set, bind, offs,
2777  &desc_get_info, desc_size);
2778  } else {
2779  VkDescriptorImageInfo desc_pool_write_info_img = {
2780  .sampler = sampler,
2781  .imageView = view,
2782  .imageLayout = layout,
2783  };
2784  VkWriteDescriptorSet desc_pool_write_info = {
2785  .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2786  .dstBinding = bind,
2787  .descriptorCount = 1,
2788  .dstArrayElement = offs,
2789  .descriptorType = desc_set->binding[bind].descriptorType,
2790  .pImageInfo = &desc_pool_write_info_img,
2791  };
2792  update_set_pool_write(s, e, shd, set, &desc_pool_write_info);
2793  }
2794 
2795  return 0;
2796 }
2797 
2798 void ff_vk_shader_update_img_array(FFVulkanContext *s, FFVkExecContext *e,
2799  FFVulkanShader *shd, AVFrame *f,
2800  VkImageView *views, int set, int binding,
2801  VkImageLayout layout, VkSampler sampler)
2802 {
2803  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
2804  const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
2805 
2806  for (int i = 0; i < nb_planes; i++)
2807  ff_vk_shader_update_img(s, e, shd, set, binding, i,
2808  views[i], layout, sampler);
2809 }
2810 
2811 int ff_vk_shader_update_desc_buffer(FFVulkanContext *s, FFVkExecContext *e,
2812  FFVulkanShader *shd,
2813  int set, int bind, int elem,
2814  FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize len,
2815  VkFormat fmt)
2816 {
2817  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
2818 
2819  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2820  VkDescriptorGetInfoEXT desc_get_info = {
2821  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
2822  .type = desc_set->binding[bind].descriptorType,
2823  };
2824  VkDescriptorAddressInfoEXT desc_buf_info = {
2825  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT,
2826  .address = buf->address + offset,
2827  .range = len,
2828  .format = fmt,
2829  };
2830  size_t desc_size;
2831 
2832  switch (desc_get_info.type) {
2833  case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
2834  desc_get_info.data.pUniformBuffer = &desc_buf_info;
2835  desc_size = s->desc_buf_props.uniformBufferDescriptorSize;
2836  break;
2837  case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
2838  desc_get_info.data.pStorageBuffer = &desc_buf_info;
2839  desc_size = s->desc_buf_props.storageBufferDescriptorSize;
2840  break;
2841  case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
2842  desc_get_info.data.pUniformTexelBuffer = &desc_buf_info;
2843  desc_size = s->desc_buf_props.uniformTexelBufferDescriptorSize;
2844  break;
2845  case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
2846  desc_get_info.data.pStorageTexelBuffer = &desc_buf_info;
2847  desc_size = s->desc_buf_props.storageTexelBufferDescriptorSize;
2848  break;
2849  default:
2850  av_log(s, AV_LOG_ERROR, "Invalid descriptor type at set %i binding %i: %i!\n",
2851  set, bind, desc_get_info.type);
2852  return AVERROR(EINVAL);
2853  break;
2854  };
2855 
2856  update_set_descriptor(s, e, shd, set, bind, elem, &desc_get_info, desc_size);
2857  } else {
2858  VkDescriptorBufferInfo desc_pool_write_info_buf = {
2859  .buffer = buf->buf,
2860  .offset = buf->virtual_offset + offset,
2861  .range = len,
2862  };
2863  VkWriteDescriptorSet desc_pool_write_info = {
2864  .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2865  .dstBinding = bind,
2866  .descriptorCount = 1,
2867  .dstArrayElement = elem,
2868  .descriptorType = desc_set->binding[bind].descriptorType,
2869  .pBufferInfo = &desc_pool_write_info_buf,
2870  };
2871  update_set_pool_write(s, e, shd, set, &desc_pool_write_info);
2872  }
2873 
2874  return 0;
2875 }
2876 
2877 void ff_vk_shader_update_push_const(FFVulkanContext *s, FFVkExecContext *e,
2878  FFVulkanShader *shd,
2879  VkShaderStageFlagBits stage,
2880  int offset, size_t size, void *src)
2881 {
2882  FFVulkanFunctions *vk = &s->vkfn;
2883  vk->CmdPushConstants(e->buf, shd->pipeline_layout,
2884  stage, offset, size, src);
2885 }
2886 
2887 void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e,
2888  FFVulkanShader *shd)
2889 {
2890  FFVulkanFunctions *vk = &s->vkfn;
2891  VkDeviceSize offsets[1024];
2892  FFVulkanShaderData *sd = get_shd_data(e, shd);
2893 
2894  if (s->extensions & FF_VK_EXT_SHADER_OBJECT) {
2895  VkShaderStageFlagBits stages = shd->stage;
2896  vk->CmdBindShadersEXT(e->buf, 1, &stages, &shd->object);
2897  } else {
2898  vk->CmdBindPipeline(e->buf, shd->bind_point, shd->pipeline);
2899  }
2900 
2901  if (sd && sd->nb_descriptor_sets) {
2902  if (s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) {
2903  for (int i = 0; i < sd->nb_descriptor_sets; i++)
2904  offsets[i] = shd->desc_set[i].singular ? 0 : shd->desc_set[i].aligned_size*e->idx;
2905 
2906  /* Bind descriptor buffers */
2907  vk->CmdBindDescriptorBuffersEXT(e->buf, sd->nb_descriptor_sets, sd->desc_bind);
2908  /* Binding offsets */
2909  vk->CmdSetDescriptorBufferOffsetsEXT(e->buf, shd->bind_point, shd->pipeline_layout,
2910  0, sd->nb_descriptor_sets,
2911  shd->bound_buffer_indices, offsets);
2912  } else if (!shd->use_push) {
2913  vk->CmdBindDescriptorSets(e->buf, shd->bind_point, shd->pipeline_layout,
2914  0, sd->nb_descriptor_sets,
2915  &sd->desc_sets[e->idx*sd->nb_descriptor_sets],
2916  0, NULL);
2917  }
2918  }
2919 }
2920 
2921 void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
2922 {
2923  FFVulkanFunctions *vk = &s->vkfn;
2924 
2925  av_bprint_finalize(&shd->src, NULL);
2926 
2927 #if 0
2928  if (shd->shader.module)
2929  vk->DestroyShaderModule(s->hwctx->act_dev, shd->shader.module,
2930  s->hwctx->alloc);
2931 #endif
2932 
2933  if (shd->object)
2934  vk->DestroyShaderEXT(s->hwctx->act_dev, shd->object, s->hwctx->alloc);
2935  if (shd->pipeline)
2936  vk->DestroyPipeline(s->hwctx->act_dev, shd->pipeline, s->hwctx->alloc);
2937  if (shd->pipeline_layout)
2938  vk->DestroyPipelineLayout(s->hwctx->act_dev, shd->pipeline_layout,
2939  s->hwctx->alloc);
2940 
2941  for (int i = 0; i < shd->nb_descriptor_sets; i++) {
2942  FFVulkanDescriptorSet *set = &shd->desc_set[i];
2943  av_free(set->binding);
2944  av_free(set->binding_offset);
2945  }
2946 
2947  if (shd->desc_layout) {
2948  for (int i = 0; i < shd->nb_descriptor_sets; i++)
2949  if (shd->desc_layout[i])
2950  vk->DestroyDescriptorSetLayout(s->hwctx->act_dev, shd->desc_layout[i],
2951  s->hwctx->alloc);
2952  }
2953 
2954  av_freep(&shd->desc_pool_size);
2955  av_freep(&shd->desc_layout);
2956  av_freep(&shd->desc_set);
2957  av_freep(&shd->bound_buffer_indices);
2958  av_freep(&shd->push_consts);
2959  shd->push_consts_num = 0;
2960 }
2961 
2962 void ff_vk_uninit(FFVulkanContext *s)
2963 {
2964  av_freep(&s->query_props);
2965  av_freep(&s->qf_props);
2966  av_freep(&s->video_props);
2967  av_freep(&s->coop_mat_props);
2968  av_freep(&s->host_image_copy_layouts);
2969 
2970  av_buffer_unref(&s->device_ref);
2971  av_buffer_unref(&s->frames_ref);
2972 }
2973 
2974 int ff_vk_init(FFVulkanContext *s, void *log_parent,
2975  AVBufferRef *device_ref, AVBufferRef *frames_ref)
2976 {
2977  int err;
2978 
2979  static const AVClass vulkan_context_class = {
2980  .class_name = "vk",
2981  .version = LIBAVUTIL_VERSION_INT,
2982  .parent_log_context_offset = offsetof(FFVulkanContext, log_parent),
2983  };
2984 
2985  memset(s, 0, sizeof(*s));
2986  s->log_parent = log_parent;
2987  s->class = &vulkan_context_class;
2988 
2989  if (frames_ref) {
2990  s->frames_ref = av_buffer_ref(frames_ref);
2991  if (!s->frames_ref)
2992  return AVERROR(ENOMEM);
2993 
2994  s->frames = (AVHWFramesContext *)s->frames_ref->data;
2995  s->hwfc = s->frames->hwctx;
2996 
2997  device_ref = s->frames->device_ref;
2998  }
2999 
3000  s->device_ref = av_buffer_ref(device_ref);
3001  if (!s->device_ref) {
3002  ff_vk_uninit(s);
3003  return AVERROR(ENOMEM);
3004  }
3005 
3006  s->device = (AVHWDeviceContext *)s->device_ref->data;
3007  s->hwctx = s->device->hwctx;
3008 
3009  s->extensions = ff_vk_extensions_to_mask(s->hwctx->enabled_dev_extensions,
3010  s->hwctx->nb_enabled_dev_extensions);
3011  s->extensions |= ff_vk_extensions_to_mask(s->hwctx->enabled_inst_extensions,
3012  s->hwctx->nb_enabled_inst_extensions);
3013 
3014  err = ff_vk_load_functions(s->device, &s->vkfn, s->extensions, 1, 1);
3015  if (err < 0) {
3016  ff_vk_uninit(s);
3017  return err;
3018  }
3019 
3020  err = ff_vk_load_props(s);
3021  if (err < 0) {
3022  ff_vk_uninit(s);
3023  return err;
3024  }
3025 
3026  return 0;
3027 }
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:579
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:551
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:1774
AV_PIX_FMT_GRAY32
#define AV_PIX_FMT_GRAY32
Definition: pixfmt.h:512
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:2921
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:2054
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:55
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
descriptor_props::is_uniform
int is_uniform
Definition: vulkan.c:2408
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:63
FFVkBuffer::host_ref
AVBufferRef * host_ref
Definition: vulkan.h:108
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:578
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:591
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:573
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:613
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:528
AV_PIX_FMT_XV30
#define AV_PIX_FMT_XV30
Definition: pixfmt.h:592
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:2974
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:2962
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:2733
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
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:574
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:2407
AV_PIX_FMT_P212
#define AV_PIX_FMT_P212
Definition: pixfmt.h:601
FFVkShaderRepFormat
FFVkShaderRepFormat
Returns the format to use for images in shaders.
Definition: vulkan.h:404
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:431
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:1773
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:3381
FFVulkanShader::desc_layout
VkDescriptorSetLayout * desc_layout
Definition: vulkan.h:223
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:546
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:302
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:196
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_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:544
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:580
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:2798
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:2561
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AV_PIX_FMT_XV48
#define AV_PIX_FMT_XV48
Definition: pixfmt.h:594
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:2426
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:511
create_shader_module
static int create_shader_module(FFVulkanContext *s, FFVulkanShader *shd, VkShaderModule *mod, uint8_t *spirv, size_t spirv_len)
Definition: vulkan.c:2184
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:1511
FFVkExecPool::query_statuses
int query_statuses
Definition: vulkan.h:263
descriptor_props::struct_size
size_t struct_size
Definition: vulkan.c:2406
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:531
FFVulkanDescriptorSet::binding
VkDescriptorSetLayoutBinding * binding
Definition: vulkan.h:182
init_descriptors
static int init_descriptors(FFVulkanContext *s, FFVulkanShader *shd)
Definition: vulkan.c:2286
init_pipeline_layout
static int init_pipeline_layout(FFVulkanContext *s, FFVulkanShader *shd)
Definition: vulkan.c:2158
AV_PIX_FMT_Y210
#define AV_PIX_FMT_Y210
Definition: pixfmt.h:589
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:540
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:548
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:550
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:549
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:612
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:541
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
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:113
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:2687
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:1550
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:552
FF_VK_REP_FLOAT
@ FF_VK_REP_FLOAT
Definition: vulkan.h:408
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:577
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:539
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:510
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:481
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:609
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:1775
map_fmt_to_rep
static VkFormat map_fmt_to_rep(VkFormat fmt, enum FFVkShaderRepFormat rep_fmt)
Definition: vulkan.c:1790
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:565
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
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:508
if
if(ret)
Definition: filter_design.txt:179
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:547
FFVulkanShaderData::desc_set_buf
FFVulkanDescriptorSetData * desc_set_buf
Definition: vulkan.h:244
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:518
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:2409
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:211
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:600
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:2410
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
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:529
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
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:2210
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:60
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:1877
AV_PIX_FMT_X2BGR10
#define AV_PIX_FMT_X2BGR10
Definition: pixfmt.h:597
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:1778
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:326
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:2877
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:240
sem_wait
#define sem_wait(psem)
Definition: semaphore.h:27
AV_PIX_FMT_P012
#define AV_PIX_FMT_P012
Definition: pixfmt.h:586
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:297
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:69
print
static void print(AVTreeNode *t, int depth)
Definition: tree.c:45
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:561
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:533
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:514
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:411
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
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:535
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:2706
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:590
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:361
AVVulkanDeviceQueueFamily::idx
int idx
Definition: hwcontext_vulkan.h:35
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:575
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:2811
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:603
version
version
Definition: libkvazaar.c:315
AV_PIX_FMT_P210
#define AV_PIX_FMT_P210
Definition: pixfmt.h:599
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:1528
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:2405
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_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:545
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:2011
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:2351
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:596
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:520
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:2887
FFVulkanDescriptorSet::binding_offset
VkDeviceSize * binding_offset
Definition: vulkan.h:183
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:587
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:515
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:335
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:116
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:1928
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:151
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:2411
FFVkExecContext::sem_sig
VkSemaphoreSubmitInfo * sem_sig
Definition: vulkan.h:152
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
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:1458
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
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:532
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_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:576
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:562
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
AV_PIX_FMT_RGBAF32
#define AV_PIX_FMT_RGBAF32
Definition: pixfmt.h:610
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:585
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:343
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:327
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)
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:2136
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:604
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:1479
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:593
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:602
FFVulkanDescriptorSet
Definition: vulkan.h:176
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:509
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:2245
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:163
get_shd_data
static FFVulkanShaderData * get_shd_data(FFVkExecContext *e, FFVulkanShader *shd)
Definition: vulkan.c:2678
CASE
#define CASE(VAL)
FFVulkanFunctions
Definition: vulkan_functions.h:274
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:375
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
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 Mon Jun 30 2025 19:23:02 for FFmpeg by   doxygen 1.8.17