2 * This file is part of FFmpeg.
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 /* Generic macro for creating contexts which need to keep their addresses
24 * if another context is created. */
25 #define FN_CREATING(ctx, type, shortname, array, num) \
26 static av_always_inline type *create_ ##shortname(ctx *dctx) \
28 type **array, *sctx = av_mallocz(sizeof(*sctx)); \
32 array = av_realloc_array(dctx->array, sizeof(*dctx->array), dctx->num + 1);\
38 dctx->array = array; \
39 dctx->array[dctx->num++] = sctx; \
44 const VkComponentMapping ff_comp_identity_map = {
45 .r = VK_COMPONENT_SWIZZLE_IDENTITY,
46 .g = VK_COMPONENT_SWIZZLE_IDENTITY,
47 .b = VK_COMPONENT_SWIZZLE_IDENTITY,
48 .a = VK_COMPONENT_SWIZZLE_IDENTITY,
51 /* Converts return values to strings */
52 const char *ff_vk_ret2str(VkResult res)
54 #define CASE(VAL) case VAL: return #VAL
62 CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
63 CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
64 CASE(VK_ERROR_INITIALIZATION_FAILED);
65 CASE(VK_ERROR_DEVICE_LOST);
66 CASE(VK_ERROR_MEMORY_MAP_FAILED);
67 CASE(VK_ERROR_LAYER_NOT_PRESENT);
68 CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
69 CASE(VK_ERROR_FEATURE_NOT_PRESENT);
70 CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
71 CASE(VK_ERROR_TOO_MANY_OBJECTS);
72 CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
73 CASE(VK_ERROR_FRAGMENTED_POOL);
74 CASE(VK_ERROR_SURFACE_LOST_KHR);
75 CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
76 CASE(VK_SUBOPTIMAL_KHR);
77 CASE(VK_ERROR_OUT_OF_DATE_KHR);
78 CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
79 CASE(VK_ERROR_VALIDATION_FAILED_EXT);
80 CASE(VK_ERROR_INVALID_SHADER_NV);
81 CASE(VK_ERROR_OUT_OF_POOL_MEMORY);
82 CASE(VK_ERROR_INVALID_EXTERNAL_HANDLE);
83 CASE(VK_ERROR_NOT_PERMITTED_EXT);
84 default: return "Unknown error";
89 static int vk_alloc_mem(AVFilterContext *avctx, VkMemoryRequirements *req,
90 VkMemoryPropertyFlagBits req_flags, void *alloc_extension,
91 VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
95 VkPhysicalDeviceProperties props;
96 VkPhysicalDeviceMemoryProperties mprops;
97 VulkanFilterContext *s = avctx->priv;
99 VkMemoryAllocateInfo alloc_info = {
100 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
101 .pNext = alloc_extension,
104 vkGetPhysicalDeviceProperties(s->hwctx->phys_dev, &props);
105 vkGetPhysicalDeviceMemoryProperties(s->hwctx->phys_dev, &mprops);
107 /* Align if we need to */
108 if (req_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
109 req->size = FFALIGN(req->size, props.limits.minMemoryMapAlignment);
111 alloc_info.allocationSize = req->size;
113 /* The vulkan spec requires memory types to be sorted in the "optimal"
114 * order, so the first matching type we find will be the best/fastest one */
115 for (int i = 0; i < mprops.memoryTypeCount; i++) {
116 /* The memory type must be supported by the requirements (bitfield) */
117 if (!(req->memoryTypeBits & (1 << i)))
120 /* The memory type flags must include our properties */
121 if ((mprops.memoryTypes[i].propertyFlags & req_flags) != req_flags)
124 /* Found a suitable memory type */
130 av_log(avctx, AV_LOG_ERROR, "No memory type found for flags 0x%x\n",
132 return AVERROR(EINVAL);
135 alloc_info.memoryTypeIndex = index;
137 ret = vkAllocateMemory(s->hwctx->act_dev, &alloc_info,
138 s->hwctx->alloc, mem);
139 if (ret != VK_SUCCESS) {
140 av_log(avctx, AV_LOG_ERROR, "Failed to allocate memory: %s\n",
142 return AVERROR(ENOMEM);
145 *mem_flags |= mprops.memoryTypes[index].propertyFlags;
150 int ff_vk_create_buf(AVFilterContext *avctx, FFVkBuffer *buf, size_t size,
151 VkBufferUsageFlags usage, VkMemoryPropertyFlagBits flags)
155 VkMemoryRequirements req;
156 VulkanFilterContext *s = avctx->priv;
158 VkBufferCreateInfo buf_spawn = {
159 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
162 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
163 .size = size, /* Gets FFALIGNED during alloc if host visible
167 ret = vkCreateBuffer(s->hwctx->act_dev, &buf_spawn, NULL, &buf->buf);
168 if (ret != VK_SUCCESS) {
169 av_log(avctx, AV_LOG_ERROR, "Failed to create buffer: %s\n",
171 return AVERROR_EXTERNAL;
174 vkGetBufferMemoryRequirements(s->hwctx->act_dev, buf->buf, &req);
176 err = vk_alloc_mem(avctx, &req, flags, NULL, &buf->flags, &buf->mem);
180 ret = vkBindBufferMemory(s->hwctx->act_dev, buf->buf, buf->mem, 0);
181 if (ret != VK_SUCCESS) {
182 av_log(avctx, AV_LOG_ERROR, "Failed to bind memory to buffer: %s\n",
184 return AVERROR_EXTERNAL;
190 int ff_vk_map_buffers(AVFilterContext *avctx, FFVkBuffer *buf, uint8_t *mem[],
191 int nb_buffers, int invalidate)
194 VulkanFilterContext *s = avctx->priv;
195 VkMappedMemoryRange *inval_list = NULL;
198 for (int i = 0; i < nb_buffers; i++) {
199 ret = vkMapMemory(s->hwctx->act_dev, buf[i].mem, 0,
200 VK_WHOLE_SIZE, 0, (void **)&mem[i]);
201 if (ret != VK_SUCCESS) {
202 av_log(avctx, AV_LOG_ERROR, "Failed to map buffer memory: %s\n",
204 return AVERROR_EXTERNAL;
211 for (int i = 0; i < nb_buffers; i++) {
212 const VkMappedMemoryRange ival_buf = {
213 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
214 .memory = buf[i].mem,
215 .size = VK_WHOLE_SIZE,
217 if (buf[i].flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
219 inval_list = av_fast_realloc(s->scratch, &s->scratch_size,
220 (++inval_count)*sizeof(*inval_list));
222 return AVERROR(ENOMEM);
223 inval_list[inval_count - 1] = ival_buf;
227 ret = vkInvalidateMappedMemoryRanges(s->hwctx->act_dev, inval_count,
229 if (ret != VK_SUCCESS) {
230 av_log(avctx, AV_LOG_ERROR, "Failed to invalidate memory: %s\n",
232 return AVERROR_EXTERNAL;
239 int ff_vk_unmap_buffers(AVFilterContext *avctx, FFVkBuffer *buf, int nb_buffers,
244 VulkanFilterContext *s = avctx->priv;
245 VkMappedMemoryRange *flush_list = NULL;
249 for (int i = 0; i < nb_buffers; i++) {
250 const VkMappedMemoryRange flush_buf = {
251 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
252 .memory = buf[i].mem,
253 .size = VK_WHOLE_SIZE,
255 if (buf[i].flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
257 flush_list = av_fast_realloc(s->scratch, &s->scratch_size,
258 (++flush_count)*sizeof(*flush_list));
260 return AVERROR(ENOMEM);
261 flush_list[flush_count - 1] = flush_buf;
266 ret = vkFlushMappedMemoryRanges(s->hwctx->act_dev, flush_count,
268 if (ret != VK_SUCCESS) {
269 av_log(avctx, AV_LOG_ERROR, "Failed to flush memory: %s\n",
271 err = AVERROR_EXTERNAL; /* We still want to try to unmap them */
275 for (int i = 0; i < nb_buffers; i++)
276 vkUnmapMemory(s->hwctx->act_dev, buf[i].mem);
281 void ff_vk_free_buf(AVFilterContext *avctx, FFVkBuffer *buf)
283 VulkanFilterContext *s = avctx->priv;
287 if (buf->buf != VK_NULL_HANDLE)
288 vkDestroyBuffer(s->hwctx->act_dev, buf->buf, s->hwctx->alloc);
289 if (buf->mem != VK_NULL_HANDLE)
290 vkFreeMemory(s->hwctx->act_dev, buf->mem, s->hwctx->alloc);
293 int ff_vk_add_push_constant(AVFilterContext *avctx, VulkanPipeline *pl,
294 int offset, int size, VkShaderStageFlagBits stage)
296 VkPushConstantRange *pc;
298 pl->push_consts = av_realloc_array(pl->push_consts, sizeof(*pl->push_consts),
299 pl->push_consts_num + 1);
300 if (!pl->push_consts)
301 return AVERROR(ENOMEM);
303 pc = &pl->push_consts[pl->push_consts_num++];
304 memset(pc, 0, sizeof(*pc));
306 pc->stageFlags = stage;
313 FN_CREATING(VulkanFilterContext, FFVkExecContext, exec_ctx, exec_ctx, exec_ctx_num)
314 int ff_vk_create_exec_ctx(AVFilterContext *avctx, FFVkExecContext **ctx, int queue)
318 VulkanFilterContext *s = avctx->priv;
320 VkCommandPoolCreateInfo cqueue_create = {
321 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
322 .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
323 .queueFamilyIndex = queue,
325 VkCommandBufferAllocateInfo cbuf_create = {
326 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
327 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
328 .commandBufferCount = 1,
330 VkFenceCreateInfo fence_spawn = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
332 e = create_exec_ctx(s);
334 return AVERROR(ENOMEM);
336 ret = vkCreateCommandPool(s->hwctx->act_dev, &cqueue_create,
337 s->hwctx->alloc, &e->pool);
338 if (ret != VK_SUCCESS) {
339 av_log(avctx, AV_LOG_ERROR, "Command pool creation failure: %s\n",
344 cbuf_create.commandPool = e->pool;
346 ret = vkAllocateCommandBuffers(s->hwctx->act_dev, &cbuf_create, &e->buf);
347 if (ret != VK_SUCCESS) {
348 av_log(avctx, AV_LOG_ERROR, "Command buffer alloc failure: %s\n",
353 ret = vkCreateFence(s->hwctx->act_dev, &fence_spawn,
354 s->hwctx->alloc, &e->fence);
355 if (ret != VK_SUCCESS) {
356 av_log(avctx, AV_LOG_ERROR, "Failed to create frame fence: %s\n",
361 vkGetDeviceQueue(s->hwctx->act_dev, queue, 0, &e->queue);
368 int ff_vk_start_exec_recording(AVFilterContext *avctx, FFVkExecContext *e)
371 VkCommandBufferBeginInfo cmd_start = {
372 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
373 .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
379 ret = vkBeginCommandBuffer(e->buf, &cmd_start);
380 if (ret != VK_SUCCESS) {
381 av_log(avctx, AV_LOG_ERROR, "Failed to start command recoding: %s\n",
383 return AVERROR_EXTERNAL;
389 int ff_vk_add_exec_dep(AVFilterContext *avctx, FFVkExecContext *e,
390 AVFrame *frame, VkPipelineStageFlagBits in_wait_dst_flag)
392 AVVkFrame *f = (AVVkFrame *)frame->data[0];
394 e->sem_wait = av_fast_realloc(e->sem_wait, &e->sem_wait_alloc,
395 (e->sem_wait_cnt + 1)*sizeof(*e->sem_wait));
397 return AVERROR(ENOMEM);
399 e->sem_wait_dst = av_fast_realloc(e->sem_wait_dst, &e->sem_wait_dst_alloc,
400 (e->sem_wait_cnt + 1)*sizeof(*e->sem_wait_dst));
401 if (!e->sem_wait_dst)
402 return AVERROR(ENOMEM);
404 e->sem_sig = av_fast_realloc(e->sem_sig, &e->sem_sig_alloc,
405 (e->sem_sig_cnt + 1)*sizeof(*e->sem_sig));
407 return AVERROR(ENOMEM);
409 e->sem_wait[e->sem_wait_cnt] = f->sem;
410 e->sem_wait_dst[e->sem_wait_cnt] = in_wait_dst_flag;
413 e->sem_sig[e->sem_sig_cnt] = f->sem;
419 int ff_vk_submit_exec_queue(AVFilterContext *avctx, FFVkExecContext *e)
422 VulkanFilterContext *s = avctx->priv;
424 VkSubmitInfo s_info = {
425 .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
426 .commandBufferCount = 1,
427 .pCommandBuffers = &e->buf,
429 .pWaitSemaphores = e->sem_wait,
430 .pWaitDstStageMask = e->sem_wait_dst,
431 .waitSemaphoreCount = e->sem_wait_cnt,
433 .pSignalSemaphores = e->sem_sig,
434 .signalSemaphoreCount = e->sem_sig_cnt,
437 vkEndCommandBuffer(e->buf);
439 ret = vkQueueSubmit(e->queue, 1, &s_info, e->fence);
440 if (ret != VK_SUCCESS) {
441 av_log(avctx, AV_LOG_ERROR, "Unable to submit command buffer: %s\n",
443 return AVERROR_EXTERNAL;
446 vkWaitForFences(s->hwctx->act_dev, 1, &e->fence, VK_TRUE, UINT64_MAX);
447 vkResetFences(s->hwctx->act_dev, 1, &e->fence);
452 int ff_vk_filter_query_formats(AVFilterContext *avctx)
454 static const enum AVPixelFormat pixel_formats[] = {
455 AV_PIX_FMT_VULKAN, AV_PIX_FMT_NONE,
457 AVFilterFormats *pix_fmts = ff_make_format_list(pixel_formats);
459 return AVERROR(ENOMEM);
461 return ff_set_common_formats(avctx, pix_fmts);
464 static int vulkan_filter_set_device(AVFilterContext *avctx,
467 VulkanFilterContext *s = avctx->priv;
469 av_buffer_unref(&s->device_ref);
471 s->device_ref = av_buffer_ref(device);
473 return AVERROR(ENOMEM);
475 s->device = (AVHWDeviceContext*)s->device_ref->data;
476 s->hwctx = s->device->hwctx;
481 static int vulkan_filter_set_frames(AVFilterContext *avctx,
484 VulkanFilterContext *s = avctx->priv;
486 av_buffer_unref(&s->frames_ref);
488 s->frames_ref = av_buffer_ref(frames);
490 return AVERROR(ENOMEM);
495 int ff_vk_filter_config_input(AVFilterLink *inlink)
498 AVFilterContext *avctx = inlink->dst;
499 VulkanFilterContext *s = avctx->priv;
500 AVHWFramesContext *input_frames;
502 if (!inlink->hw_frames_ctx) {
503 av_log(avctx, AV_LOG_ERROR, "Vulkan filtering requires a "
504 "hardware frames context on the input.\n");
505 return AVERROR(EINVAL);
508 /* Extract the device and default output format from the first input. */
509 if (avctx->inputs[0] != inlink)
512 input_frames = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
513 if (input_frames->format != AV_PIX_FMT_VULKAN)
514 return AVERROR(EINVAL);
516 err = vulkan_filter_set_device(avctx, input_frames->device_ref);
519 err = vulkan_filter_set_frames(avctx, inlink->hw_frames_ctx);
523 /* Default output parameters match input parameters. */
524 s->input_format = input_frames->sw_format;
525 if (s->output_format == AV_PIX_FMT_NONE)
526 s->output_format = input_frames->sw_format;
527 if (!s->output_width)
528 s->output_width = inlink->w;
529 if (!s->output_height)
530 s->output_height = inlink->h;
535 int ff_vk_filter_config_output_inplace(AVFilterLink *outlink)
538 AVFilterContext *avctx = outlink->src;
539 VulkanFilterContext *s = avctx->priv;
541 av_buffer_unref(&outlink->hw_frames_ctx);
543 if (!s->device_ref) {
544 if (!avctx->hw_device_ctx) {
545 av_log(avctx, AV_LOG_ERROR, "Vulkan filtering requires a "
547 return AVERROR(EINVAL);
550 err = vulkan_filter_set_device(avctx, avctx->hw_device_ctx);
555 outlink->hw_frames_ctx = av_buffer_ref(s->frames_ref);
556 if (!outlink->hw_frames_ctx)
557 return AVERROR(ENOMEM);
559 outlink->w = s->output_width;
560 outlink->h = s->output_height;
565 int ff_vk_filter_config_output(AVFilterLink *outlink)
568 AVFilterContext *avctx = outlink->src;
569 VulkanFilterContext *s = avctx->priv;
570 AVBufferRef *output_frames_ref;
571 AVHWFramesContext *output_frames;
573 av_buffer_unref(&outlink->hw_frames_ctx);
575 if (!s->device_ref) {
576 if (!avctx->hw_device_ctx) {
577 av_log(avctx, AV_LOG_ERROR, "Vulkan filtering requires a "
579 return AVERROR(EINVAL);
582 err = vulkan_filter_set_device(avctx, avctx->hw_device_ctx);
587 output_frames_ref = av_hwframe_ctx_alloc(s->device_ref);
588 if (!output_frames_ref) {
589 err = AVERROR(ENOMEM);
592 output_frames = (AVHWFramesContext*)output_frames_ref->data;
594 output_frames->format = AV_PIX_FMT_VULKAN;
595 output_frames->sw_format = s->output_format;
596 output_frames->width = s->output_width;
597 output_frames->height = s->output_height;
599 err = av_hwframe_ctx_init(output_frames_ref);
601 av_log(avctx, AV_LOG_ERROR, "Failed to initialise output "
602 "frames: %d.\n", err);
606 outlink->hw_frames_ctx = output_frames_ref;
607 outlink->w = s->output_width;
608 outlink->h = s->output_height;
612 av_buffer_unref(&output_frames_ref);
616 int ff_vk_filter_init(AVFilterContext *avctx)
618 VulkanFilterContext *s = avctx->priv;
620 s->output_format = AV_PIX_FMT_NONE;
623 return AVERROR_EXTERNAL;
628 FN_CREATING(VulkanFilterContext, VkSampler, sampler, samplers, samplers_num)
629 VkSampler *ff_vk_init_sampler(AVFilterContext *avctx, int unnorm_coords,
633 VulkanFilterContext *s = avctx->priv;
635 VkSamplerCreateInfo sampler_info = {
636 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
638 .minFilter = sampler_info.magFilter,
639 .mipmapMode = unnorm_coords ? VK_SAMPLER_MIPMAP_MODE_NEAREST :
640 VK_SAMPLER_MIPMAP_MODE_LINEAR,
641 .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
642 .addressModeV = sampler_info.addressModeU,
643 .addressModeW = sampler_info.addressModeU,
644 .anisotropyEnable = VK_FALSE,
645 .compareOp = VK_COMPARE_OP_NEVER,
646 .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
647 .unnormalizedCoordinates = unnorm_coords,
650 VkSampler *sampler = create_sampler(s);
654 ret = vkCreateSampler(s->hwctx->act_dev, &sampler_info,
655 s->hwctx->alloc, sampler);
656 if (ret != VK_SUCCESS) {
657 av_log(avctx, AV_LOG_ERROR, "Unable to init sampler: %s\n",
665 int ff_vk_mt_is_np_rgb(enum AVPixelFormat pix_fmt)
667 if (pix_fmt == AV_PIX_FMT_ABGR || pix_fmt == AV_PIX_FMT_BGRA ||
668 pix_fmt == AV_PIX_FMT_RGBA || pix_fmt == AV_PIX_FMT_RGB24 ||
669 pix_fmt == AV_PIX_FMT_BGR24 || pix_fmt == AV_PIX_FMT_RGB48 ||
670 pix_fmt == AV_PIX_FMT_RGBA64 || pix_fmt == AV_PIX_FMT_RGB565 ||
671 pix_fmt == AV_PIX_FMT_BGR565 || pix_fmt == AV_PIX_FMT_BGR0 ||
672 pix_fmt == AV_PIX_FMT_0BGR || pix_fmt == AV_PIX_FMT_RGB0)
677 const char *ff_vk_shader_rep_fmt(enum AVPixelFormat pixfmt)
679 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pixfmt);
680 const int high = desc->comp[0].depth > 8;
681 return high ? "rgba16f" : "rgba8";
684 int ff_vk_create_imageview(AVFilterContext *avctx, VkImageView *v, VkImage img,
685 VkFormat fmt, const VkComponentMapping map)
687 VulkanFilterContext *s = avctx->priv;
688 VkImageViewCreateInfo imgview_spawn = {
689 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
692 .viewType = VK_IMAGE_VIEW_TYPE_2D,
695 .subresourceRange = {
696 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
704 VkResult ret = vkCreateImageView(s->hwctx->act_dev, &imgview_spawn,
706 if (ret != VK_SUCCESS) {
707 av_log(s, AV_LOG_ERROR, "Failed to create imageview: %s\n",
709 return AVERROR_EXTERNAL;
715 void ff_vk_destroy_imageview(AVFilterContext *avctx, VkImageView *v)
717 VulkanFilterContext *s = avctx->priv;
719 vkDestroyImageView(s->hwctx->act_dev, *v, s->hwctx->alloc);
724 FN_CREATING(VulkanPipeline, SPIRVShader, shader, shaders, shaders_num)
725 SPIRVShader *ff_vk_init_shader(AVFilterContext *avctx, VulkanPipeline *pl,
726 const char *name, VkShaderStageFlags stage)
728 SPIRVShader *shd = create_shader(pl);
732 av_bprint_init(&shd->src, 0, AV_BPRINT_SIZE_UNLIMITED);
734 shd->shader.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
735 shd->shader.stage = stage;
739 GLSLF(0, #version %i ,460);
740 GLSLC(0, #define IS_WITHIN(v1, v2) ((v1.x < v2.x) && (v1.y < v2.y)) );
746 void ff_vk_set_compute_shader_sizes(AVFilterContext *avctx, SPIRVShader *shd,
749 shd->local_size[0] = local_size[0];
750 shd->local_size[1] = local_size[1];
751 shd->local_size[2] = local_size[2];
753 av_bprintf(&shd->src, "layout (local_size_x = %i, "
754 "local_size_y = %i, local_size_z = %i) in;\n\n",
755 shd->local_size[0], shd->local_size[1], shd->local_size[2]);
758 static void print_shader(AVFilterContext *avctx, SPIRVShader *shd, int prio)
761 const char *p = shd->src.str;
762 const char *start = p;
765 av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
767 for (int i = 0; i < strlen(p); i++) {
769 av_bprintf(&buf, "%i\t", ++line);
770 av_bprint_append_data(&buf, start, &p[i] - start + 1);
775 av_log(avctx, prio, "Shader %s: \n%s", shd->name, buf.str);
776 av_bprint_finalize(&buf, NULL);
779 int ff_vk_compile_shader(AVFilterContext *avctx, SPIRVShader *shd,
780 const char *entrypoint)
783 VulkanFilterContext *s = avctx->priv;
784 VkShaderModuleCreateInfo shader_create;
787 static const enum GLSlangStage emap[] = {
788 [VK_SHADER_STAGE_VERTEX_BIT] = GLSLANG_VERTEX,
789 [VK_SHADER_STAGE_FRAGMENT_BIT] = GLSLANG_FRAGMENT,
790 [VK_SHADER_STAGE_COMPUTE_BIT] = GLSLANG_COMPUTE,
793 shd->shader.pName = entrypoint;
795 res = glslang_compile(shd->src.str, emap[shd->shader.stage]);
797 return AVERROR(ENOMEM);
800 av_log(avctx, AV_LOG_ERROR, "Error compiling shader %s: %s!\n",
801 shd->name, av_err2str(res->rval));
802 print_shader(avctx, shd, AV_LOG_ERROR);
804 av_log(avctx, AV_LOG_ERROR, "%s", res->error_msg);
805 av_free(res->error_msg);
809 print_shader(avctx, shd, AV_LOG_VERBOSE);
811 shader_create.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
812 shader_create.pNext = NULL;
813 shader_create.codeSize = res->size;
814 shader_create.flags = 0;
815 shader_create.pCode = res->data;
817 ret = vkCreateShaderModule(s->hwctx->act_dev, &shader_create, NULL,
818 &shd->shader.module);
820 /* Free the GLSlangResult struct */
823 if (ret != VK_SUCCESS) {
824 av_log(avctx, AV_LOG_ERROR, "Unable to create shader module: %s\n",
826 return AVERROR_EXTERNAL;
829 av_log(avctx, AV_LOG_VERBOSE, "Shader %s linked! Size: %zu bytes\n",
830 shd->name, shader_create.codeSize);
835 static const struct descriptor_props {
836 size_t struct_size; /* Size of the opaque which updates the descriptor */
839 int mem_quali; /* Can use a memory qualifier */
840 int dim_needed; /* Must indicate dimension */
841 int buf_content; /* Must indicate buffer contents */
842 } descriptor_props[] = {
843 [VK_DESCRIPTOR_TYPE_SAMPLER] = { sizeof(VkDescriptorImageInfo), "sampler", 1, 0, 0, 0, },
844 [VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE] = { sizeof(VkDescriptorImageInfo), "texture", 1, 0, 1, 0, },
845 [VK_DESCRIPTOR_TYPE_STORAGE_IMAGE] = { sizeof(VkDescriptorImageInfo), "image", 1, 1, 1, 0, },
846 [VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT] = { sizeof(VkDescriptorImageInfo), "subpassInput", 1, 0, 0, 0, },
847 [VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER] = { sizeof(VkDescriptorImageInfo), "sampler", 1, 0, 1, 0, },
848 [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER] = { sizeof(VkDescriptorBufferInfo), NULL, 1, 0, 0, 1, },
849 [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] = { sizeof(VkDescriptorBufferInfo), "buffer", 0, 1, 0, 1, },
850 [VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC] = { sizeof(VkDescriptorBufferInfo), NULL, 1, 0, 0, 1, },
851 [VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC] = { sizeof(VkDescriptorBufferInfo), "buffer", 0, 1, 0, 1, },
852 [VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER] = { sizeof(VkBufferView), "samplerBuffer", 1, 0, 0, 0, },
853 [VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER] = { sizeof(VkBufferView), "imageBuffer", 1, 0, 0, 0, },
856 int ff_vk_add_descriptor_set(AVFilterContext *avctx, VulkanPipeline *pl,
857 SPIRVShader *shd, VulkanDescriptorSetBinding *desc,
858 int num, int only_print_to_shader)
861 VkDescriptorSetLayout *layout;
862 VulkanFilterContext *s = avctx->priv;
864 if (only_print_to_shader)
867 pl->desc_layout = av_realloc_array(pl->desc_layout, sizeof(*pl->desc_layout),
868 pl->descriptor_sets_num + 1);
869 if (!pl->desc_layout)
870 return AVERROR(ENOMEM);
872 layout = &pl->desc_layout[pl->descriptor_sets_num];
873 memset(layout, 0, sizeof(*layout));
875 { /* Create descriptor set layout descriptions */
876 VkDescriptorSetLayoutCreateInfo desc_create_layout = { 0 };
877 VkDescriptorSetLayoutBinding *desc_binding;
879 desc_binding = av_mallocz(sizeof(*desc_binding)*num);
881 return AVERROR(ENOMEM);
883 for (int i = 0; i < num; i++) {
884 desc_binding[i].binding = i;
885 desc_binding[i].descriptorType = desc[i].type;
886 desc_binding[i].descriptorCount = FFMAX(desc[i].elems, 1);
887 desc_binding[i].stageFlags = desc[i].stages;
888 desc_binding[i].pImmutableSamplers = desc[i].samplers;
891 desc_create_layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
892 desc_create_layout.pBindings = desc_binding;
893 desc_create_layout.bindingCount = num;
895 ret = vkCreateDescriptorSetLayout(s->hwctx->act_dev, &desc_create_layout,
896 s->hwctx->alloc, layout);
897 av_free(desc_binding);
898 if (ret != VK_SUCCESS) {
899 av_log(avctx, AV_LOG_ERROR, "Unable to init descriptor set "
900 "layout: %s\n", ff_vk_ret2str(ret));
901 return AVERROR_EXTERNAL;
905 { /* Pool each descriptor by type and update pool counts */
906 for (int i = 0; i < num; i++) {
908 for (j = 0; j < pl->pool_size_desc_num; j++)
909 if (pl->pool_size_desc[j].type == desc[i].type)
911 if (j >= pl->pool_size_desc_num) {
912 pl->pool_size_desc = av_realloc_array(pl->pool_size_desc,
913 sizeof(*pl->pool_size_desc),
914 ++pl->pool_size_desc_num);
915 if (!pl->pool_size_desc)
916 return AVERROR(ENOMEM);
917 memset(&pl->pool_size_desc[j], 0, sizeof(VkDescriptorPoolSize));
919 pl->pool_size_desc[j].type = desc[i].type;
920 pl->pool_size_desc[j].descriptorCount += FFMAX(desc[i].elems, 1);
924 { /* Create template creation struct */
925 VkDescriptorUpdateTemplateCreateInfo *dt;
926 VkDescriptorUpdateTemplateEntry *des_entries;
928 /* Freed after descriptor set initialization */
929 des_entries = av_mallocz(num*sizeof(VkDescriptorUpdateTemplateEntry));
931 return AVERROR(ENOMEM);
933 for (int i = 0; i < num; i++) {
934 des_entries[i].dstBinding = i;
935 des_entries[i].descriptorType = desc[i].type;
936 des_entries[i].descriptorCount = FFMAX(desc[i].elems, 1);
937 des_entries[i].dstArrayElement = 0;
938 des_entries[i].offset = ((uint8_t *)desc[i].updater) - (uint8_t *)s;
939 des_entries[i].stride = descriptor_props[desc[i].type].struct_size;
942 pl->desc_template_info = av_realloc_array(pl->desc_template_info,
943 sizeof(*pl->desc_template_info),
944 pl->descriptor_sets_num + 1);
945 if (!pl->desc_template_info)
946 return AVERROR(ENOMEM);
948 dt = &pl->desc_template_info[pl->descriptor_sets_num];
949 memset(dt, 0, sizeof(*dt));
951 dt->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
952 dt->templateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET;
953 dt->descriptorSetLayout = *layout;
954 dt->pDescriptorUpdateEntries = des_entries;
955 dt->descriptorUpdateEntryCount = num;
958 pl->descriptor_sets_num++;
961 /* Write shader info */
962 for (int i = 0; i < num; i++) {
963 const struct descriptor_props *prop = &descriptor_props[desc[i].type];
964 GLSLA("layout (set = %i, binding = %i", pl->descriptor_sets_num - 1, i);
966 if (desc[i].mem_layout)
967 GLSLA(", %s", desc[i].mem_layout);
970 if (prop->is_uniform)
973 if (prop->mem_quali && desc[i].mem_quali)
974 GLSLA(" %s", desc[i].mem_quali);
977 GLSLA(" %s", prop->type);
979 if (prop->dim_needed)
980 GLSLA("%iD", desc[i].dimensions);
982 GLSLA(" %s", desc[i].name);
984 if (prop->buf_content)
985 GLSLA(" {\n %s\n}", desc[i].buf_content);
986 else if (desc[i].elems > 0)
987 GLSLA("[%i]", desc[i].elems);
996 void ff_vk_update_descriptor_set(AVFilterContext *avctx, VulkanPipeline *pl,
999 VulkanFilterContext *s = avctx->priv;
1001 vkUpdateDescriptorSetWithTemplate(s->hwctx->act_dev,
1002 pl->desc_set[set_id],
1003 pl->desc_template[set_id], s);
1006 void ff_vk_update_push_exec(AVFilterContext *avctx, FFVkExecContext *e,
1007 VkShaderStageFlagBits stage, int offset,
1008 size_t size, void *src)
1010 vkCmdPushConstants(e->buf, e->bound_pl->pipeline_layout,
1011 stage, offset, size, src);
1014 int ff_vk_init_pipeline_layout(AVFilterContext *avctx, VulkanPipeline *pl)
1017 VulkanFilterContext *s = avctx->priv;
1019 { /* Init descriptor set pool */
1020 VkDescriptorPoolCreateInfo pool_create_info = {
1021 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
1022 .poolSizeCount = pl->pool_size_desc_num,
1023 .pPoolSizes = pl->pool_size_desc,
1024 .maxSets = pl->descriptor_sets_num,
1027 ret = vkCreateDescriptorPool(s->hwctx->act_dev, &pool_create_info,
1028 s->hwctx->alloc, &pl->desc_pool);
1029 av_freep(&pl->pool_size_desc);
1030 if (ret != VK_SUCCESS) {
1031 av_log(avctx, AV_LOG_ERROR, "Unable to init descriptor set "
1032 "pool: %s\n", ff_vk_ret2str(ret));
1033 return AVERROR_EXTERNAL;
1037 { /* Allocate descriptor sets */
1038 VkDescriptorSetAllocateInfo alloc_info = {
1039 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
1040 .descriptorPool = pl->desc_pool,
1041 .descriptorSetCount = pl->descriptor_sets_num,
1042 .pSetLayouts = pl->desc_layout,
1045 pl->desc_set = av_malloc(pl->descriptor_sets_num*sizeof(*pl->desc_set));
1047 return AVERROR(ENOMEM);
1049 ret = vkAllocateDescriptorSets(s->hwctx->act_dev, &alloc_info,
1051 if (ret != VK_SUCCESS) {
1052 av_log(avctx, AV_LOG_ERROR, "Unable to allocate descriptor set: %s\n",
1053 ff_vk_ret2str(ret));
1054 return AVERROR_EXTERNAL;
1058 { /* Finally create the pipeline layout */
1059 VkPipelineLayoutCreateInfo spawn_pipeline_layout = {
1060 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1061 .setLayoutCount = pl->descriptor_sets_num,
1062 .pSetLayouts = pl->desc_layout,
1063 .pushConstantRangeCount = pl->push_consts_num,
1064 .pPushConstantRanges = pl->push_consts,
1067 ret = vkCreatePipelineLayout(s->hwctx->act_dev, &spawn_pipeline_layout,
1068 s->hwctx->alloc, &pl->pipeline_layout);
1069 av_freep(&pl->push_consts);
1070 pl->push_consts_num = 0;
1071 if (ret != VK_SUCCESS) {
1072 av_log(avctx, AV_LOG_ERROR, "Unable to init pipeline layout: %s\n",
1073 ff_vk_ret2str(ret));
1074 return AVERROR_EXTERNAL;
1078 { /* Descriptor template (for tightly packed descriptors) */
1079 VkDescriptorUpdateTemplateCreateInfo *desc_template_info;
1081 pl->desc_template = av_malloc(pl->descriptor_sets_num*sizeof(*pl->desc_template));
1082 if (!pl->desc_template)
1083 return AVERROR(ENOMEM);
1085 /* Create update templates for the descriptor sets */
1086 for (int i = 0; i < pl->descriptor_sets_num; i++) {
1087 desc_template_info = &pl->desc_template_info[i];
1088 desc_template_info->pipelineLayout = pl->pipeline_layout;
1089 ret = vkCreateDescriptorUpdateTemplate(s->hwctx->act_dev,
1092 &pl->desc_template[i]);
1093 av_free((void *)desc_template_info->pDescriptorUpdateEntries);
1094 if (ret != VK_SUCCESS) {
1095 av_log(avctx, AV_LOG_ERROR, "Unable to init descriptor "
1096 "template: %s\n", ff_vk_ret2str(ret));
1097 return AVERROR_EXTERNAL;
1101 av_freep(&pl->desc_template_info);
1107 FN_CREATING(VulkanFilterContext, VulkanPipeline, pipeline, pipelines, pipelines_num)
1108 VulkanPipeline *ff_vk_create_pipeline(AVFilterContext *avctx)
1110 return create_pipeline(avctx->priv);
1113 int ff_vk_init_compute_pipeline(AVFilterContext *avctx, VulkanPipeline *pl)
1117 VulkanFilterContext *s = avctx->priv;
1119 VkComputePipelineCreateInfo pipe = {
1120 .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
1121 .layout = pl->pipeline_layout,
1124 for (i = 0; i < pl->shaders_num; i++) {
1125 if (pl->shaders[i]->shader.stage & VK_SHADER_STAGE_COMPUTE_BIT) {
1126 pipe.stage = pl->shaders[i]->shader;
1130 if (i == pl->shaders_num) {
1131 av_log(avctx, AV_LOG_ERROR, "Can't init compute pipeline, no shader\n");
1132 return AVERROR(EINVAL);
1135 ret = vkCreateComputePipelines(s->hwctx->act_dev, VK_NULL_HANDLE, 1, &pipe,
1136 s->hwctx->alloc, &pl->pipeline);
1137 if (ret != VK_SUCCESS) {
1138 av_log(avctx, AV_LOG_ERROR, "Unable to init compute pipeline: %s\n",
1139 ff_vk_ret2str(ret));
1140 return AVERROR_EXTERNAL;
1143 pl->bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
1148 void ff_vk_bind_pipeline_exec(AVFilterContext *avctx, FFVkExecContext *e,
1151 vkCmdBindPipeline(e->buf, pl->bind_point, pl->pipeline);
1153 vkCmdBindDescriptorSets(e->buf, pl->bind_point, pl->pipeline_layout, 0,
1154 pl->descriptor_sets_num, pl->desc_set, 0, 0);
1159 static void free_exec_ctx(VulkanFilterContext *s, FFVkExecContext *e)
1161 vkDestroyFence(s->hwctx->act_dev, e->fence, s->hwctx->alloc);
1163 if (e->buf != VK_NULL_HANDLE)
1164 vkFreeCommandBuffers(s->hwctx->act_dev, e->pool, 1, &e->buf);
1165 if (e->pool != VK_NULL_HANDLE)
1166 vkDestroyCommandPool(s->hwctx->act_dev, e->pool, s->hwctx->alloc);
1168 av_free(e->sem_wait);
1169 av_free(e->sem_wait_dst);
1170 av_free(e->sem_sig);
1175 static void free_pipeline(VulkanFilterContext *s, VulkanPipeline *pl)
1177 for (int i = 0; i < pl->shaders_num; i++) {
1178 SPIRVShader *shd = pl->shaders[i];
1179 av_bprint_finalize(&shd->src, NULL);
1180 vkDestroyShaderModule(s->hwctx->act_dev, shd->shader.module,
1185 vkDestroyPipeline(s->hwctx->act_dev, pl->pipeline, s->hwctx->alloc);
1186 vkDestroyPipelineLayout(s->hwctx->act_dev, pl->pipeline_layout,
1189 for (int i = 0; i < pl->descriptor_sets_num; i++) {
1190 if (pl->desc_template && pl->desc_template[i])
1191 vkDestroyDescriptorUpdateTemplate(s->hwctx->act_dev, pl->desc_template[i],
1193 if (pl->desc_layout && pl->desc_layout[i])
1194 vkDestroyDescriptorSetLayout(s->hwctx->act_dev, pl->desc_layout[i],
1198 /* Also frees the descriptor sets */
1200 vkDestroyDescriptorPool(s->hwctx->act_dev, pl->desc_pool,
1203 av_freep(&pl->desc_set);
1204 av_freep(&pl->shaders);
1205 av_freep(&pl->desc_layout);
1206 av_freep(&pl->desc_template);
1207 av_freep(&pl->push_consts);
1208 pl->push_consts_num = 0;
1210 /* Only freed in case of failure */
1211 av_freep(&pl->pool_size_desc);
1212 if (pl->desc_template_info) {
1213 for (int i = 0; i < pl->descriptor_sets_num; i++)
1214 av_free((void *)pl->desc_template_info[i].pDescriptorUpdateEntries);
1215 av_freep(&pl->desc_template_info);
1221 void ff_vk_filter_uninit(AVFilterContext *avctx)
1223 VulkanFilterContext *s = avctx->priv;
1227 for (int i = 0; i < s->samplers_num; i++)
1228 vkDestroySampler(s->hwctx->act_dev, *s->samplers[i], s->hwctx->alloc);
1229 av_freep(&s->samplers);
1231 for (int i = 0; i < s->pipelines_num; i++)
1232 free_pipeline(s, s->pipelines[i]);
1233 av_freep(&s->pipelines);
1235 for (int i = 0; i < s->exec_ctx_num; i++)
1236 free_exec_ctx(s, s->exec_ctx[i]);
1237 av_freep(&s->exec_ctx);
1239 av_freep(&s->scratch);
1240 s->scratch_size = 0;
1242 av_buffer_unref(&s->device_ref);
1243 av_buffer_unref(&s->frames_ref);