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