/* * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef AVUTIL_VULKAN_H #define AVUTIL_VULKAN_H #define VK_NO_PROTOTYPES #include #include "pixdesc.h" #include "bprint.h" #include "hwcontext.h" #include "vulkan_functions.h" #include "hwcontext_vulkan.h" #include "avassert.h" #include "intreadwrite.h" /* GLSL management macros */ #define INDENT(N) INDENT_##N #define INDENT_0 #define INDENT_1 INDENT_0 " " #define INDENT_2 INDENT_1 INDENT_1 #define INDENT_3 INDENT_2 INDENT_1 #define INDENT_4 INDENT_3 INDENT_1 #define INDENT_5 INDENT_4 INDENT_1 #define INDENT_6 INDENT_5 INDENT_1 #define C(N, S) INDENT(N) #S "\n" #define GLSLC(N, S) \ do { \ av_bprintf(&shd->src, C(N, S)); \ } while (0) #define GLSLA(...) \ do { \ av_bprintf(&shd->src, __VA_ARGS__); \ } while (0) #define GLSLF(N, S, ...) \ do { \ av_bprintf(&shd->src, C(N, S), __VA_ARGS__); \ } while (0) #define GLSLD(D) \ do { \ av_bprintf(&shd->src, "\n"); \ av_bprint_append_data(&shd->src, D, strlen(D)); \ av_bprintf(&shd->src, "\n"); \ } while (0) /* Helper, pretty much every Vulkan return value needs to be checked */ #define RET(x) \ do { \ if ((err = (x)) < 0) \ goto fail; \ } while (0) /* Convenience macros for specialization lists */ #define SPEC_LIST_MAX 256 #define SPEC_LIST_CREATE(name, max_length, max_size) \ av_assert1((max_length) < (SPEC_LIST_MAX - 3)); \ uint8_t name##_data[(max_size) + 3*sizeof(uint32_t)]; \ VkSpecializationMapEntry name##_entries[(max_length) + 3]; \ VkSpecializationInfo name##_info = { \ .pMapEntries = name##_entries, \ .pData = name##_data, \ }; \ VkSpecializationInfo *name = &name##_info; #define SPEC_LIST_ADD(name, idx, val_bits, val) \ do { \ unsigned int name##_cnt = name->mapEntryCount; \ size_t name##_off = name->dataSize; \ uint8_t *name##_dp = (uint8_t *)name->pData; \ void *name##_ep = (void *)&name->pMapEntries[name##_cnt]; \ AV_WN(val_bits, name##_dp + name##_off, (val)); \ VkSpecializationMapEntry name##_new_entry = { \ .constantID = (idx), \ .offset = name##_off, \ .size = val_bits >> 3, \ }; \ memcpy(name##_ep, &name##_new_entry, \ sizeof(VkSpecializationMapEntry)); \ name->dataSize = name##_off + (val_bits >> 3); \ name->mapEntryCount = name##_cnt + 1; \ } while (0) #define DUP_SAMPLER(x) { x, x, x, x } #define FF_VK_MAX_DESCRIPTOR_SETS 4 #define FF_VK_MAX_DESCRIPTOR_BINDINGS 16 #define FF_VK_MAX_DESCRIPTOR_TYPES 16 #define FF_VK_MAX_PUSH_CONSTS 4 #define FF_VK_MAX_SHADERS 16 typedef struct FFVulkanDescriptorSetBinding { const char *name; VkDescriptorType type; const char *mem_layout; /* Storage images (rgba8, etc.) and buffers (std430, etc.) */ const char *mem_quali; /* readonly, writeonly, etc. */ const char *buf_content; /* For buffers */ uint32_t dimensions; /* Needed for e.g. sampler%iD */ uint32_t elems; /* 0 - scalar, 1 or more - vector */ VkShaderStageFlags stages; uint32_t buf_elems; /* Appends [buf_elems] to the contents. Avoids manually printing to a string. */ VkSampler samplers[4]; /* Sampler to use for all elems */ } FFVulkanDescriptorSetBinding; typedef struct FFVkBuffer { VkBuffer buf; VkDeviceMemory mem; VkMemoryPropertyFlagBits flags; size_t size; VkDeviceAddress address; /* Only valid when allocated via ff_vk_get_pooled_buffer with HOST_VISIBLE or * via ff_vk_host_map_buffer */ uint8_t *mapped_mem; /* Set by ff_vk_host_map_buffer. This is the offset at which the buffer data * actually begins at. * The address and mapped_mem fields will be offset by this amount. */ size_t virtual_offset; /* If host mapping, reference to the backing host memory buffer */ AVBufferRef *host_ref; } FFVkBuffer; typedef struct FFVkExecContext { uint32_t idx; const struct FFVkExecPool *parent; int had_submission; /* Queue for the execution context */ VkQueue queue; int qf; int qi; /* Command buffer for the context */ VkCommandBuffer buf; /* Fence for the command buffer */ VkFence fence; /* Opaque data, untouched, free to use by users */ void *opaque; void *query_data; int query_idx; /* Buffer dependencies */ AVBufferRef **buf_deps; int nb_buf_deps; unsigned int buf_deps_alloc_size; /* Frame dependencies */ AVFrame **frame_deps; unsigned int frame_deps_alloc_size; int nb_frame_deps; /* Software frame dependencies */ AVFrame **sw_frame_deps; unsigned int sw_frame_deps_alloc_size; int nb_sw_frame_deps; VkSemaphoreSubmitInfo *sem_wait; unsigned int sem_wait_alloc; int sem_wait_cnt; VkSemaphoreSubmitInfo *sem_sig; unsigned int sem_sig_alloc; int sem_sig_cnt; uint64_t **sem_sig_val_dst; unsigned int sem_sig_val_dst_alloc; int sem_sig_val_dst_cnt; uint8_t *frame_locked; unsigned int frame_locked_alloc_size; VkAccessFlagBits *access_dst; unsigned int access_dst_alloc; VkImageLayout *layout_dst; unsigned int layout_dst_alloc; uint32_t *queue_family_dst; unsigned int queue_family_dst_alloc; uint8_t *frame_update; unsigned int frame_update_alloc_size; } FFVkExecContext; typedef struct FFVulkanDescriptorSet { /* Descriptor buffer */ VkDeviceSize layout_size; VkDeviceSize aligned_size; /* descriptorBufferOffsetAlignment */ VkBufferUsageFlags usage; VkDescriptorSetLayoutBinding binding[FF_VK_MAX_DESCRIPTOR_BINDINGS]; VkDeviceSize binding_offset[FF_VK_MAX_DESCRIPTOR_BINDINGS]; int nb_bindings; /* Descriptor set is shared between all submissions */ int singular; } FFVulkanDescriptorSet; typedef struct FFVulkanShader { /* Name for id/debugging purposes */ const char *name; /* Whether shader is precompiled or not */ int precompiled; VkSpecializationInfo *specialization_info; /* Shader text */ AVBPrint src; /* Compute shader local group sizes */ uint32_t lg_size[3]; /* Shader bind point/type */ VkPipelineStageFlags stage; VkPipelineBindPoint bind_point; /* Creation info */ VkPipelineShaderStageRequiredSubgroupSizeCreateInfo subgroup_info; /* Base shader object */ VkShaderEXT object; VkPipeline pipeline; /* Pipeline layout */ VkPipelineLayout pipeline_layout; /* Push consts */ VkPushConstantRange push_consts[FF_VK_MAX_PUSH_CONSTS]; int push_consts_num; /* Descriptor sets */ FFVulkanDescriptorSet desc_set[FF_VK_MAX_DESCRIPTOR_SETS]; int nb_descriptor_sets; /* Descriptors */ VkDescriptorSetLayout desc_layout[FF_VK_MAX_DESCRIPTOR_SETS]; /* Descriptor pool */ int use_push; VkDescriptorPoolSize desc_pool_size[FF_VK_MAX_DESCRIPTOR_TYPES]; int nb_desc_pool_size; } FFVulkanShader; typedef struct FFVulkanDescriptorSetData { /* Descriptor buffer */ FFVkBuffer buf; uint8_t *desc_mem; } FFVulkanDescriptorSetData; typedef struct FFVulkanShaderData { /* Shader to which this data belongs to */ FFVulkanShader *shd; int nb_descriptor_sets; /* Descriptor buffer */ FFVulkanDescriptorSetData desc_set_buf[FF_VK_MAX_DESCRIPTOR_SETS]; VkDescriptorBufferBindingInfoEXT desc_bind[FF_VK_MAX_DESCRIPTOR_SETS]; /* Descriptor pools */ VkDescriptorSet *desc_sets; VkDescriptorPool desc_pool; } FFVulkanShaderData; typedef struct FFVkExecPool { FFVkExecContext *contexts; atomic_uint_least64_t idx; VkCommandPool *cmd_buf_pools; VkCommandBuffer *cmd_bufs; int pool_size; VkQueryPool query_pool; void *query_data; int query_results; int query_statuses; int query_64bit; int query_status_stride; int nb_queries; size_t qd_size; /* Registered shaders' data */ FFVulkanShaderData reg_shd[FF_VK_MAX_SHADERS]; int nb_reg_shd; } FFVkExecPool; typedef struct FFVulkanContext { const AVClass *class; void *log_parent; FFVulkanFunctions vkfn; FFVulkanExtensions extensions; VkPhysicalDeviceProperties2 props; VkPhysicalDeviceVulkan11Properties props_11; VkPhysicalDeviceDriverProperties driver_props; VkPhysicalDeviceMemoryProperties mprops; VkPhysicalDeviceExternalMemoryHostPropertiesEXT hprops; VkPhysicalDeviceDescriptorBufferPropertiesEXT desc_buf_props; VkPhysicalDeviceSubgroupSizeControlProperties subgroup_props; VkPhysicalDeviceCooperativeMatrixPropertiesKHR coop_matrix_props; VkPhysicalDevicePushDescriptorPropertiesKHR push_desc_props; VkPhysicalDeviceOpticalFlowPropertiesNV optical_flow_props; #ifdef VK_EXT_shader_long_vector VkPhysicalDeviceShaderLongVectorPropertiesEXT long_vector_props; #endif VkQueueFamilyQueryResultStatusPropertiesKHR *query_props; VkQueueFamilyVideoPropertiesKHR *video_props; VkQueueFamilyProperties2 *qf_props; int tot_nb_qfs; VkPhysicalDeviceHostImageCopyPropertiesEXT host_image_props; VkImageLayout *host_image_copy_layouts; VkCooperativeMatrixPropertiesKHR *coop_mat_props; uint32_t coop_mat_props_nb; VkPhysicalDeviceShaderAtomicFloatFeaturesEXT atomic_float_feats; VkPhysicalDeviceVulkan12Features feats_12; VkPhysicalDeviceFeatures2 feats; VkMemoryPropertyFlagBits host_cached_flag; AVBufferRef *device_ref; AVHWDeviceContext *device; AVVulkanDeviceContext *hwctx; AVBufferRef *input_frames_ref; AVBufferRef *frames_ref; AVHWFramesContext *frames; AVVulkanFramesContext *hwfc; uint32_t qfs[64]; int nb_qfs; /* Properties */ int output_width; int output_height; enum AVPixelFormat output_format; enum AVPixelFormat input_format; } FFVulkanContext; static inline int ff_vk_count_images(AVVkFrame *f) { int cnt = 0; while (cnt < FF_ARRAY_ELEMS(f->img) && f->img[cnt]) cnt++; return cnt; } static inline const void *ff_vk_find_struct(const void *chain, VkStructureType stype) { const VkBaseInStructure *in = chain; while (in) { if (in->sType == stype) return in; in = in->pNext; } return NULL; } static inline void ff_vk_link_struct(void *chain, const void *in) { VkBaseOutStructure *out = chain; while (out->pNext) out = out->pNext; out->pNext = (void *)in; } #define FF_VK_STRUCT_EXT(CTX, BASE, STRUCT_P, EXT_FLAG, TYPE) \ do { \ if ((EXT_FLAG == FF_VK_EXT_NO_FLAG) || \ ((CTX)->extensions & EXT_FLAG)) { \ (STRUCT_P)->sType = TYPE; \ ff_vk_link_struct(BASE, STRUCT_P); \ } \ } while (0) /* Identity mapping - r = r, b = b, g = g, a = a */ extern const VkComponentMapping ff_comp_identity_map; /** * Initializes the AVClass, in case this context is not used * as the main user's context. * May use either a frames context reference, or a device context reference. */ int ff_vk_init(FFVulkanContext *s, void *log_parent, AVBufferRef *device_ref, AVBufferRef *frames_ref); /** * Converts Vulkan return values to strings */ const char *ff_vk_ret2str(VkResult res); /** * Map between usage and features. */ VkImageUsageFlags ff_vk_map_feats_to_usage(VkFormatFeatureFlagBits2 feats); VkFormatFeatureFlagBits2 ff_vk_map_usage_to_feats(VkImageUsageFlags usage); /** * Returns 1 if pixfmt is a usable RGB format. */ int ff_vk_mt_is_np_rgb(enum AVPixelFormat pix_fmt); /** * Since storage images may not be swizzled, we have to do this in the * shader itself. This fills in a lookup table to do it. */ void ff_vk_set_perm(enum AVPixelFormat pix_fmt, int lut[4], int inv); /** * Get the aspect flag for a plane from an image. */ VkImageAspectFlags ff_vk_aspect_flag(AVFrame *f, int p); /** * Returns the format to use for images in shaders. */ enum FFVkShaderRepFormat { /* Native format with no conversion. May require casting. */ FF_VK_REP_NATIVE = 0, /* Float conversion of the native format. */ FF_VK_REP_FLOAT, /* Signed integer version of the native format */ FF_VK_REP_INT, /* Unsigned integer version of the native format */ FF_VK_REP_UINT, }; const char *ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt, enum FFVkShaderRepFormat rep_fmt); /** * Loads props/mprops/driver_props */ int ff_vk_load_props(FFVulkanContext *s); /** * Chooses an appropriate QF. */ AVVulkanDeviceQueueFamily *ff_vk_qf_find(FFVulkanContext *s, VkQueueFlagBits dev_family, VkVideoCodecOperationFlagBitsKHR vid_ops); /** * Allocates/frees an execution pool. * If used in a multi-threaded context, there must be at least as many contexts * as there are threads. * ff_vk_exec_pool_init_desc() MUST be called if ff_vk_exec_descriptor_set_add() * has been called. */ 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); void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool); /** * Retrieve an execution pool. Threadsafe. */ FFVkExecContext *ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool); /** * Performs nb_queries queries and returns their results and statuses. * 64_BIT and WITH_STATUS flags are ignored as 64_BIT must be specified via * query_64bit in ff_vk_exec_pool_init() and WITH_STATUS is always enabled. */ VkResult ff_vk_exec_get_query(FFVulkanContext *s, FFVkExecContext *e, void **data, VkQueryResultFlagBits flags); /** * Start/submit/wait an execution. * ff_vk_exec_start() always waits on a submission, so using ff_vk_exec_wait() * is not necessary (unless using it is just better). */ int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e); int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e); void ff_vk_exec_wait(FFVulkanContext *s, FFVkExecContext *e); /** * Execution dependency management. * Can attach buffers to executions that will only be unref'd once the * buffer has finished executing. * Adding a frame dep will *lock the frame*, until either the dependencies * are discarded, the execution is submitted, or a failure happens. * update_frame will update the frame's properties before it is unlocked, * only if submission was successful. */ int ff_vk_exec_add_dep_buf(FFVulkanContext *s, FFVkExecContext *e, AVBufferRef **deps, int nb_deps, int ref); int ff_vk_exec_add_dep_wait_sem(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore sem, uint64_t val, VkPipelineStageFlagBits2 stage); int ff_vk_exec_add_dep_bool_sem(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore *sem, int nb, VkPipelineStageFlagBits2 stage, int wait); /* Ownership transferred if !wait */ int ff_vk_exec_add_dep_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f, VkPipelineStageFlagBits2 wait_stage, VkPipelineStageFlagBits2 signal_stage); int ff_vk_exec_add_dep_sw_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f); void ff_vk_exec_update_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f, VkImageMemoryBarrier2 *bar, uint32_t *nb_img_bar); int ff_vk_exec_mirror_sem_value(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore *dst, uint64_t *dst_val, AVFrame *f); void ff_vk_exec_discard_deps(FFVulkanContext *s, FFVkExecContext *e); /** * Create a single imageview for a given plane. */ int ff_vk_create_imageview(FFVulkanContext *s, VkImageView *img_view, VkImageAspectFlags *aspect, AVFrame *f, int plane, enum FFVkShaderRepFormat rep_fmt); /** * Create an imageview and add it as a dependency to an execution. */ int ff_vk_create_imageviews(FFVulkanContext *s, FFVkExecContext *e, VkImageView views[AV_NUM_DATA_POINTERS], AVFrame *f, enum FFVkShaderRepFormat rep_fmt); #define ff_vk_buf_barrier(dst, vkb, s_stage, s_access, s_access2, \ d_stage, d_access, d_access2, offs, bsz) \ do { \ dst = (VkBufferMemoryBarrier2) { \ .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, \ .srcStageMask = VK_PIPELINE_STAGE_2_ ##s_stage, \ .srcAccessMask = VK_ACCESS_2_ ##s_access | \ VK_ACCESS_2_ ##s_access2, \ .dstStageMask = VK_PIPELINE_STAGE_2_ ##d_stage, \ .dstAccessMask = VK_ACCESS_2_ ##d_access | \ VK_ACCESS_2_ ##d_access2, \ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, \ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, \ .buffer = vkb->buf, \ .offset = offs, \ .size = bsz \ }; \ } while(0) void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e, AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar, VkPipelineStageFlags2 src_stage, VkPipelineStageFlags2 dst_stage, VkAccessFlagBits2 new_access, VkImageLayout new_layout, uint32_t new_qf); /** * Memory/buffer/image allocation helpers. */ int ff_vk_alloc_mem(FFVulkanContext *s, VkMemoryRequirements *req, VkMemoryPropertyFlagBits req_flags, void *alloc_extension, VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem); int ff_vk_create_buf(FFVulkanContext *s, FFVkBuffer *buf, size_t size, void *pNext, void *alloc_pNext, VkBufferUsageFlags usage, VkMemoryPropertyFlagBits flags); /** * Flush or invalidate a single buffer, with a given size and offset. */ int ff_vk_flush_buffer(FFVulkanContext *s, FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize mem_size, int flush); /** * Buffer management code. */ int ff_vk_map_buffers(FFVulkanContext *s, FFVkBuffer **buf, uint8_t *mem[], int nb_buffers, int invalidate); int ff_vk_unmap_buffers(FFVulkanContext *s, FFVkBuffer **buf, int nb_buffers, int flush); static inline int ff_vk_map_buffer(FFVulkanContext *s, FFVkBuffer *buf, uint8_t **mem, int invalidate) { return ff_vk_map_buffers(s, (FFVkBuffer *[]){ buf }, mem, 1, invalidate); } static inline int ff_vk_unmap_buffer(FFVulkanContext *s, FFVkBuffer *buf, int flush) { return ff_vk_unmap_buffers(s, (FFVkBuffer *[]){ buf }, 1, flush); } void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf); /** Initialize a pool and create AVBufferRefs containing FFVkBuffer. * Threadsafe to use. Buffers are automatically mapped on creation if * VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT is set in mem_props. Users should * synchronize access themselvesd. Mainly meant for device-local buffers. */ int ff_vk_get_pooled_buffer(FFVulkanContext *ctx, AVBufferPool **buf_pool, AVBufferRef **buf, VkBufferUsageFlags usage, void *create_pNext, size_t size, VkMemoryPropertyFlagBits mem_props); /** Maps a system RAM buffer into a Vulkan buffer. * References the source buffer. */ int ff_vk_host_map_buffer(FFVulkanContext *s, AVBufferRef **dst, uint8_t *src_data, const AVBufferRef *src_buf, VkBufferUsageFlags usage); /** * Create a sampler. */ int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler, int unnorm_coords, VkFilter filt); /** * Initialize a shader object, with a specific set of extensions, type+bind, * local group size, and subgroup requirements. */ 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. * If spec is non-null, it must have been created with SPEC_LIST_CREATE(). * The IDs for the workgroup size must be 253, 254, 255. */ int ff_vk_shader_load(FFVulkanShader *shd, VkPipelineStageFlags stage, VkSpecializationInfo *spec, uint32_t wg_size[3], uint32_t required_subgroup_size); /** * Output the shader code as logging data, with a specific * priority. */ void ff_vk_shader_print(void *ctx, FFVulkanShader *shd, int prio); /** * Link a shader into an executable. */ int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd, const char *spirv, size_t spirv_len, const char *entrypoint); /** * Add/update push constants for execution. */ int ff_vk_shader_add_push_const(FFVulkanShader *shd, int offset, int size, VkShaderStageFlagBits stage); /** * Add descriptor to a shader. Must be called before shader init. */ int ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd, const FFVulkanDescriptorSetBinding *desc, int nb, int singular, int print_to_shader_only); /** * Register a shader with an exec pool. * Pool may be NULL if all descriptor sets are read-only. */ int ff_vk_shader_register_exec(FFVulkanContext *s, FFVkExecPool *pool, FFVulkanShader *shd); /** * Bind a shader. */ void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e, const FFVulkanShader *shd); /** * Update push constant in a shader. * Must be called before binding the shader. */ void ff_vk_shader_update_push_const(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, VkShaderStageFlagBits stage, int offset, size_t size, void *src); /** * Update a descriptor in a buffer with a buffer. * Must be called before binding the shader. */ 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); /** * Sets an image descriptor for specified shader and binding. */ int ff_vk_shader_update_img(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, int set, int bind, int offs, VkImageView view, VkImageLayout layout, VkSampler sampler); /** * Update a descriptor in a buffer with an image array.. * Must be called before binding the shader. */ 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); /** * Free a shader. */ void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd); /** * Frees main context. */ void ff_vk_uninit(FFVulkanContext *s); #endif /* AVUTIL_VULKAN_H */