FFmpeg
vulkan_filter.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 "vulkan_filter.h"
22 
24  AVBufferRef *frames_ref,
25  int width, int height, enum AVPixelFormat sw_format)
26 {
27  int err;
28  AVHWFramesContext *frames_ctx;
29  AVHWDeviceContext *device_ctx;
30  AVVulkanFramesContext *vk_frames;
31  AVVulkanDeviceContext *vk_dev;
32  AVBufferRef *device_ref = avctx->hw_device_ctx;
33 
34  /* Check if context is reusable as-is */
35  if (frames_ref) {
36  int no_storage = 0;
38  const VkFormat *sub = av_vkfmt_from_pixfmt(sw_format);
39 
40  frames_ctx = (AVHWFramesContext *)frames_ref->data;
41  device_ctx = (AVHWDeviceContext *)frames_ctx->device_ref->data;
42  vk_frames = frames_ctx->hwctx;
43  vk_dev = device_ctx->hwctx;
44 
45  /* Basic format validation */
46  if (width != frames_ctx->width ||
47  height != frames_ctx->height ||
48  sw_format != frames_ctx->sw_format ||
49  (vk_frames->tiling != VK_IMAGE_TILING_LINEAR &&
50  vk_frames->tiling != VK_IMAGE_TILING_OPTIMAL) ||
51  !(vk_frames->usage & VK_IMAGE_USAGE_SAMPLED_BIT)) {
52  goto skip;
53  }
54 
55  if (vk_frames->usage & VK_IMAGE_USAGE_STORAGE_BIT)
56  goto accept;
57 
60  err = ff_vk_load_functions(device_ctx, &s->vkfn, s->extensions, 1, 1);
61  if (err < 0)
62  return err;
63  vk = &s->vkfn;
64 
65  /* Check if the subformats can do storage */
66  for (int i = 0; sub[i] != VK_FORMAT_UNDEFINED; i++) {
67  VkFormatProperties2 prop = {
68  .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
69  };
70  vk->GetPhysicalDeviceFormatProperties2(vk_dev->phys_dev, sub[i],
71  &prop);
72 
73  if (vk_frames->tiling == VK_IMAGE_TILING_LINEAR) {
74  no_storage |= !(prop.formatProperties.linearTilingFeatures &
75  VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT);
76  } else {
77  no_storage |= !(prop.formatProperties.optimalTilingFeatures &
78  VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT);
79  }
80  }
81 
82  /* Check if it's usable */
83  if (no_storage) {
84 skip:
85  device_ref = frames_ctx->device_ref;
86  frames_ref = NULL;
87  } else {
88 accept:
89  frames_ref = av_buffer_ref(frames_ref);
90  if (!frames_ref)
91  return AVERROR(ENOMEM);
92  }
93  }
94 
95  if (!frames_ref) {
96  if (!device_ref) {
97  av_log(avctx, AV_LOG_ERROR,
98  "Vulkan filtering requires a device context!\n");
99  return AVERROR(EINVAL);
100  }
101 
102  frames_ref = av_hwframe_ctx_alloc(device_ref);
103 
104  frames_ctx = (AVHWFramesContext *)frames_ref->data;
105  frames_ctx->format = AV_PIX_FMT_VULKAN;
106  frames_ctx->sw_format = sw_format;
107  frames_ctx->width = width;
108  frames_ctx->height = height;
109 
110  vk_frames = frames_ctx->hwctx;
111  vk_frames->tiling = VK_IMAGE_TILING_OPTIMAL;
112  vk_frames->usage = VK_IMAGE_USAGE_SAMPLED_BIT |
113  VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
114  VK_IMAGE_USAGE_TRANSFER_DST_BIT;
115 
116  err = av_hwframe_ctx_init(frames_ref);
117  if (err < 0) {
118  av_buffer_unref(&frames_ref);
119  return err;
120  }
121 
122  device_ctx = (AVHWDeviceContext *)frames_ctx->device_ref->data;
123  vk_dev = device_ctx->hwctx;
124  }
125 
126  s->extensions = ff_vk_extensions_to_mask(vk_dev->enabled_dev_extensions,
127  vk_dev->nb_enabled_dev_extensions);
128 
129  /**
130  * libplacebo does not use descriptor buffers.
131  */
132  if (!(s->extensions & FF_VK_EXT_DESCRIPTOR_BUFFER) &&
133  strcmp(avctx->filter->name, "libplacebo")) {
134  av_log(avctx, AV_LOG_ERROR, "Vulkan filtering requires that "
135  "the %s extension is supported!\n",
136  VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME);
137  av_buffer_unref(&frames_ref);
138  return AVERROR(EINVAL);
139  }
140 
141  err = ff_vk_load_functions(device_ctx, &s->vkfn, s->extensions, 1, 1);
142  if (err < 0) {
143  av_buffer_unref(&frames_ref);
144  return err;
145  }
146 
147  s->frames_ref = frames_ref;
148  s->frames = frames_ctx;
149  s->hwfc = vk_frames;
150  s->device = device_ctx;
151  s->hwctx = device_ctx->hwctx;
152 
153  err = ff_vk_load_props(s);
154  if (err < 0)
155  av_buffer_unref(&s->frames_ref);
156 
157  return err;
158 }
159 
161 {
162  AVHWFramesContext *input_frames;
163  AVFilterContext *avctx = inlink->dst;
164  FFVulkanContext *s = inlink->dst->priv;
165 
166  if (!inlink->hw_frames_ctx) {
167  av_log(inlink->dst, AV_LOG_ERROR, "Vulkan filtering requires a "
168  "hardware frames context on the input.\n");
169  return AVERROR(EINVAL);
170  }
171 
172  input_frames = (AVHWFramesContext *)inlink->hw_frames_ctx->data;
173  if (input_frames->format != AV_PIX_FMT_VULKAN)
174  return AVERROR(EINVAL);
175 
176  /* Extract the device and default output format from the first input. */
177  if (avctx->inputs[0] != inlink)
178  return 0;
179 
180  /* Save the ref, without reffing it */
181  s->input_frames_ref = inlink->hw_frames_ctx;
182 
183  /* Defaults */
184  s->output_format = input_frames->sw_format;
185  s->output_width = inlink->w;
186  s->output_height = inlink->h;
187 
188  return 0;
189 }
190 
192 {
193  int err;
194  FFVulkanContext *s = outlink->src->priv;
195 
196  av_buffer_unref(&outlink->hw_frames_ctx);
197 
198  err = ff_vk_filter_init_context(outlink->src, s, s->input_frames_ref,
199  s->output_width, s->output_height,
200  s->output_format);
201  if (err < 0)
202  return err;
203 
204  outlink->hw_frames_ctx = av_buffer_ref(s->frames_ref);
205  if (!outlink->hw_frames_ctx)
206  return AVERROR(ENOMEM);
207 
208  outlink->w = s->output_width;
209  outlink->h = s->output_height;
210 
211  return err;
212 }
213 
215 {
216  FFVulkanContext *s = avctx->priv;
217 
218  s->output_format = AV_PIX_FMT_NONE;
219 
220  return 0;
221 }
222 
224  FFVulkanPipeline *pl, AVFrame *out_f, AVFrame *in_f,
225  VkSampler sampler, void *push_src, size_t push_size)
226 {
227  int err = 0;
228  FFVulkanFunctions *vk = &vkctx->vkfn;
229  VkImageView in_views[AV_NUM_DATA_POINTERS];
230  VkImageView out_views[AV_NUM_DATA_POINTERS];
231  VkImageMemoryBarrier2 img_bar[37];
232  int nb_img_bar = 0;
233 
234  /* Update descriptors and init the exec context */
235  FFVkExecContext *exec = ff_vk_exec_get(e);
236  ff_vk_exec_start(vkctx, exec);
237 
238  ff_vk_exec_bind_pipeline(vkctx, exec, pl);
239 
240  if (push_src)
241  ff_vk_update_push_exec(vkctx, exec, pl, VK_SHADER_STAGE_COMPUTE_BIT,
242  0, push_size, push_src);
243 
244  if (in_f) {
245  RET(ff_vk_exec_add_dep_frame(vkctx, exec, in_f,
246  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
247  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
248  RET(ff_vk_create_imageviews(vkctx, exec, in_views, in_f));
249  ff_vk_update_descriptor_img_array(vkctx, pl, exec, in_f, in_views, 0, 0,
250  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
251  sampler);
252  ff_vk_frame_barrier(vkctx, exec, in_f, img_bar, &nb_img_bar,
253  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
254  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
255  VK_ACCESS_SHADER_READ_BIT,
256  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
257  VK_QUEUE_FAMILY_IGNORED);
258  }
259 
260  RET(ff_vk_exec_add_dep_frame(vkctx, exec, out_f,
261  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
262  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
263  RET(ff_vk_create_imageviews(vkctx, exec, out_views, out_f));
264  ff_vk_update_descriptor_img_array(vkctx, pl, exec, out_f, out_views, 0, !!in_f,
265  VK_IMAGE_LAYOUT_GENERAL,
266  VK_NULL_HANDLE);
267  ff_vk_frame_barrier(vkctx, exec, out_f, img_bar, &nb_img_bar,
268  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
269  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
270  VK_ACCESS_SHADER_WRITE_BIT,
271  VK_IMAGE_LAYOUT_GENERAL,
272  VK_QUEUE_FAMILY_IGNORED);
273 
274  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
275  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
276  .pImageMemoryBarriers = img_bar,
277  .imageMemoryBarrierCount = nb_img_bar,
278  });
279 
280  vk->CmdDispatch(exec->buf,
281  FFALIGN(vkctx->output_width, pl->wg_size[0])/pl->wg_size[0],
282  FFALIGN(vkctx->output_height, pl->wg_size[1])/pl->wg_size[1],
283  pl->wg_size[2]);
284 
285  return ff_vk_exec_submit(vkctx, exec);
286 fail:
287  ff_vk_exec_discard_deps(vkctx, exec);
288  return err;
289 }
290 
292  FFVulkanPipeline *pls[2],
293  AVFrame *out, AVFrame *tmp, AVFrame *in,
294  VkSampler sampler, void *push_src, size_t push_size)
295 {
296  int err = 0;
297  FFVulkanFunctions *vk = &vkctx->vkfn;
298  VkImageView in_views[AV_NUM_DATA_POINTERS];
299  VkImageView tmp_views[AV_NUM_DATA_POINTERS];
300  VkImageView out_views[AV_NUM_DATA_POINTERS];
301  VkImageMemoryBarrier2 img_bar[37];
302  int nb_img_bar = 0;
303 
304  /* Update descriptors and init the exec context */
305  FFVkExecContext *exec = ff_vk_exec_get(e);
306  ff_vk_exec_start(vkctx, exec);
307 
308  RET(ff_vk_exec_add_dep_frame(vkctx, exec, in,
309  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
310  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
311  RET(ff_vk_exec_add_dep_frame(vkctx, exec, tmp,
312  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
313  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
314  RET(ff_vk_exec_add_dep_frame(vkctx, exec, out,
315  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
316  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
317 
318  RET(ff_vk_create_imageviews(vkctx, exec, in_views, in));
319  RET(ff_vk_create_imageviews(vkctx, exec, tmp_views, tmp));
320  RET(ff_vk_create_imageviews(vkctx, exec, out_views, out));
321 
322  ff_vk_frame_barrier(vkctx, exec, in, img_bar, &nb_img_bar,
323  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
324  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
325  VK_ACCESS_SHADER_READ_BIT,
326  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
327  VK_QUEUE_FAMILY_IGNORED);
328  ff_vk_frame_barrier(vkctx, exec, tmp, img_bar, &nb_img_bar,
329  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
330  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
331  VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
332  VK_IMAGE_LAYOUT_GENERAL,
333  VK_QUEUE_FAMILY_IGNORED);
334  ff_vk_frame_barrier(vkctx, exec, out, img_bar, &nb_img_bar,
335  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
336  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
337  VK_ACCESS_SHADER_WRITE_BIT,
338  VK_IMAGE_LAYOUT_GENERAL,
339  VK_QUEUE_FAMILY_IGNORED);
340 
341  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
342  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
343  .pImageMemoryBarriers = img_bar,
344  .imageMemoryBarrierCount = nb_img_bar,
345  });
346 
347  for (int i = 0; i < 2; i++) {
348  FFVulkanPipeline *pl = pls[i];
349  AVFrame *src_f = !i ? in : tmp;
350  AVFrame *dst_f = !i ? tmp : out;
351  VkImageView *src_views = !i ? in_views : tmp_views;
352  VkImageView *dst_views = !i ? tmp_views : out_views;
353 
354  ff_vk_exec_bind_pipeline(vkctx, exec, pl);
355 
356  if (push_src)
357  ff_vk_update_push_exec(vkctx, exec, pl, VK_SHADER_STAGE_COMPUTE_BIT,
358  0, push_size, push_src);
359 
360  ff_vk_update_descriptor_img_array(vkctx, pl, exec, src_f, src_views, 0, 0,
361  !i ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL :
362  VK_IMAGE_LAYOUT_GENERAL,
363  sampler);
364  ff_vk_update_descriptor_img_array(vkctx, pl, exec, dst_f, dst_views, 0, 1,
365  VK_IMAGE_LAYOUT_GENERAL,
366  VK_NULL_HANDLE);
367 
368  vk->CmdDispatch(exec->buf,
369  FFALIGN(vkctx->output_width, pl->wg_size[0])/pl->wg_size[0],
370  FFALIGN(vkctx->output_height, pl->wg_size[1])/pl->wg_size[1],
371  pl->wg_size[2]);
372  }
373 
374  return ff_vk_exec_submit(vkctx, exec);
375 fail:
376  ff_vk_exec_discard_deps(vkctx, exec);
377  return err;
378 }
379 
381  FFVulkanPipeline *pl,
382  AVFrame *out, AVFrame *in[], int nb_in,
383  VkSampler sampler, void *push_src, size_t push_size)
384 {
385  int err = 0;
386  FFVulkanFunctions *vk = &vkctx->vkfn;
387  VkImageView in_views[16][AV_NUM_DATA_POINTERS];
388  VkImageView out_views[AV_NUM_DATA_POINTERS];
389  VkImageMemoryBarrier2 img_bar[128];
390  int nb_img_bar = 0;
391 
392  /* Update descriptors and init the exec context */
393  FFVkExecContext *exec = ff_vk_exec_get(e);
394  ff_vk_exec_start(vkctx, exec);
395 
396  /* Inputs */
397  for (int i = 0; i < nb_in; i++) {
398  RET(ff_vk_exec_add_dep_frame(vkctx, exec, in[i],
399  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
400  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
401  RET(ff_vk_create_imageviews(vkctx, exec, in_views[i], in[i]));
402 
403  ff_vk_frame_barrier(vkctx, exec, in[i], img_bar, &nb_img_bar,
404  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
405  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
406  VK_ACCESS_SHADER_READ_BIT,
407  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
408  VK_QUEUE_FAMILY_IGNORED);
409  }
410 
411  /* Output */
412  RET(ff_vk_exec_add_dep_frame(vkctx, exec, out,
413  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
414  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
415  RET(ff_vk_create_imageviews(vkctx, exec, out_views, out));
416  ff_vk_frame_barrier(vkctx, exec, out, img_bar, &nb_img_bar,
417  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
418  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
419  VK_ACCESS_SHADER_WRITE_BIT,
420  VK_IMAGE_LAYOUT_GENERAL,
421  VK_QUEUE_FAMILY_IGNORED);
422 
423  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
424  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
425  .pImageMemoryBarriers = img_bar,
426  .imageMemoryBarrierCount = nb_img_bar,
427  });
428 
429  ff_vk_exec_bind_pipeline(vkctx, exec, pl);
430 
431  if (push_src)
432  ff_vk_update_push_exec(vkctx, exec, pl, VK_SHADER_STAGE_COMPUTE_BIT,
433  0, push_size, push_src);
434 
435  for (int i = 0; i < nb_in; i++)
436  ff_vk_update_descriptor_img_array(vkctx, pl, exec, in[i], in_views[i], 0, i,
437  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
438  sampler);
439 
440  ff_vk_update_descriptor_img_array(vkctx, pl, exec, out, out_views, 0, nb_in,
441  VK_IMAGE_LAYOUT_GENERAL,
442  VK_NULL_HANDLE);
443 
444  vk->CmdDispatch(exec->buf,
445  FFALIGN(vkctx->output_width, pl->wg_size[0])/pl->wg_size[0],
446  FFALIGN(vkctx->output_height, pl->wg_size[1])/pl->wg_size[1],
447  pl->wg_size[2]);
448 
449  return ff_vk_exec_submit(vkctx, exec);
450 fail:
451  ff_vk_exec_discard_deps(vkctx, exec);
452  return err;
453 }
AVHWDeviceContext::hwctx
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:92
ff_vk_load_props
int ff_vk_load_props(FFVulkanContext *s)
Loads props/mprops/driver_props.
Definition: vulkan.c:86
AVVulkanDeviceContext::phys_dev
VkPhysicalDevice phys_dev
Physical device.
Definition: hwcontext_vulkan.h:65
ff_vk_exec_get
FFVkExecContext * ff_vk_exec_get(FFVkExecPool *pool)
Retrieve an execution pool.
Definition: vulkan.c:494
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
ff_vk_update_descriptor_img_array
void ff_vk_update_descriptor_img_array(FFVulkanContext *s, FFVulkanPipeline *pl, FFVkExecContext *e, AVFrame *f, VkImageView *views, int set, int binding, VkImageLayout layout, VkSampler sampler)
Definition: vulkan.c:1746
FFVulkanContext::output_height
int output_height
Definition: vulkan.h:265
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
out
FILE * out
Definition: movenc.c:54
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:209
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:334
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
ff_vk_filter_init
int ff_vk_filter_init(AVFilterContext *avctx)
General lavfi IO functions.
Definition: vulkan_filter.c:214
av_hwframe_ctx_alloc
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:248
ff_vk_filter_process_Nin
int ff_vk_filter_process_Nin(FFVulkanContext *vkctx, FFVkExecPool *e, FFVulkanPipeline *pl, AVFrame *out, AVFrame *in[], int nb_in, VkSampler sampler, void *push_src, size_t push_size)
Up to 16 inputs, one output.
Definition: vulkan_filter.c:380
FF_VK_EXT_DESCRIPTOR_BUFFER
@ FF_VK_EXT_DESCRIPTOR_BUFFER
Definition: vulkan_functions.h:40
AVFilterContext::hw_device_ctx
AVBufferRef * hw_device_ctx
For filters which will create hardware frames, sets the device the filter should create them in.
Definition: avfilter.h:457
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:229
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:376
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:596
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:412
fail
#define fail()
Definition: checkasm.h:138
FFVulkanPipeline::wg_size
int wg_size[3]
Definition: vulkan.h:144
vulkan_filter.h
ff_vk_filter_init_context
int ff_vk_filter_init_context(AVFilterContext *avctx, FFVulkanContext *s, AVBufferRef *frames_ref, int width, int height, enum AVPixelFormat sw_format)
Can be called manually, if not using ff_vk_filter_config_output.
Definition: vulkan_filter.c:23
AVVulkanFramesContext
Allocated as AVHWFramesContext.hwctx, used to set pool-specific options.
Definition: hwcontext_vulkan.h:176
ff_vk_filter_process_2pass
int ff_vk_filter_process_2pass(FFVulkanContext *vkctx, FFVkExecPool *e, FFVulkanPipeline *pls[2], AVFrame *out, AVFrame *tmp, AVFrame *in, VkSampler sampler, void *push_src, size_t push_size)
Submit a compute shader with a single in and single out with 2 stages.
Definition: vulkan_filter.c:291
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVHWFramesContext::height
int height
Definition: hwcontext.h:229
FFVulkanContext::output_width
int output_width
Definition: vulkan.h:264
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:89
ff_vk_exec_bind_pipeline
void ff_vk_exec_bind_pipeline(FFVulkanContext *s, FFVkExecContext *e, FFVulkanPipeline *pl)
Definition: vulkan.c:1841
if
if(ret)
Definition: filter_design.txt:179
AVVulkanDeviceContext
Main Vulkan context, allocated as AVHWDeviceContext.hwctx.
Definition: hwcontext_vulkan.h:44
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:222
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
AVVulkanDeviceContext::nb_enabled_dev_extensions
int nb_enabled_dev_extensions
Definition: hwcontext_vulkan.h:99
AVHWFramesContext::device_ref
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:141
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:405
ff_vk_filter_config_output
int ff_vk_filter_config_output(AVFilterLink *outlink)
Definition: vulkan_filter.c:191
AVVulkanFramesContext::usage
VkImageUsageFlagBits usage
Defines extra usage of output frames.
Definition: hwcontext_vulkan.h:195
FFVulkanContext
Definition: vulkan.h:228
FFVulkanPipeline
Definition: vulkan.h:132
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:341
height
#define height
FFVkExecContext
Definition: vulkan.h:153
ff_vk_update_push_exec
void ff_vk_update_push_exec(FFVulkanContext *s, FFVkExecContext *e, FFVulkanPipeline *pl, VkShaderStageFlagBits stage, int offset, size_t size, void *src)
Definition: vulkan.c:1759
ff_vk_filter_process_simple
int ff_vk_filter_process_simple(FFVulkanContext *vkctx, FFVkExecPool *e, FFVulkanPipeline *pl, AVFrame *out_f, AVFrame *in_f, VkSampler sampler, void *push_src, size_t push_size)
Submit a compute shader with a zero/one input and single out for execution.
Definition: vulkan_filter.c:223
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
ff_vk_exec_start
int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
Start/submit/wait an execution.
Definition: vulkan.c:510
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:244
VkFormat
enum VkFormat VkFormat
Definition: hwcontext_stub.c:25
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:1299
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
FFVulkanContext::vkfn
FFVulkanFunctions vkfn
Definition: vulkan.h:231
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:162
FFVkExecPool
Definition: vulkan.h:210
FFVkExecContext::buf
VkCommandBuffer buf
Definition: vulkan.h:164
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AVVulkanFramesContext::tiling
VkImageTiling tiling
Controls the tiling of allocated frames.
Definition: hwcontext_vulkan.h:185
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
AVVulkanDeviceContext::enabled_dev_extensions
const char *const * enabled_dev_extensions
Enabled device extensions.
Definition: hwcontext_vulkan.h:98
ff_vk_filter_config_input
int ff_vk_filter_config_input(AVFilterLink *inlink)
Definition: vulkan_filter.c:160
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
ff_vk_exec_discard_deps
void ff_vk_exec_discard_deps(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:546
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
ff_vk_exec_submit
int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:721
ff_vk_extensions_to_mask
static uint64_t ff_vk_extensions_to_mask(const char *const *extensions, int nb_extensions)
Definition: vulkan_loader.h:34
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_vk_create_imageviews
int ff_vk_create_imageviews(FFVulkanContext *s, FFVkExecContext *e, VkImageView views[AV_NUM_DATA_POINTERS], AVFrame *f)
Create an imageview and add it as a dependency to an execution.
Definition: vulkan.c:1226
AVFilterContext::filter
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:400
RET
#define RET(x)
Definition: vulkan.h:68
FFVulkanFunctions
Definition: vulkan_functions.h:226
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375