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