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