FFmpeg
vf_blend_vulkan.c
Go to the documentation of this file.
1 /*
2  * copyright (c) 2021-2022 Wu Jianhua <jianhua.wu@intel.com>
3  * Copyright (c) Lynne
4  *
5  * The blend modes are based on the blend.c.
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include "libavutil/random_seed.h"
25 #include "libavutil/opt.h"
26 #include "vulkan_filter.h"
27 #include "vulkan_spirv.h"
28 #include "internal.h"
29 #include "framesync.h"
30 #include "blend.h"
31 #include "video.h"
32 
33 #define IN_TOP 0
34 #define IN_BOTTOM 1
35 
36 typedef struct FilterParamsVulkan {
37  const char *blend;
38  const char *blend_func;
39  double opacity;
42 
43 typedef struct BlendVulkanContext {
46 
52  VkSampler sampler;
53 
55  double all_opacity;
58 
59 #define DEFINE_BLEND_MODE(MODE, EXPR) \
60 static const char blend_##MODE[] = "blend_"#MODE; \
61 static const char blend_##MODE##_func[] = { \
62  C(0, vec4 blend_##MODE(vec4 top, vec4 bottom, float opacity) { ) \
63  C(1, vec4 dst = EXPR; ) \
64  C(1, return dst; ) \
65  C(0, } ) \
66 };
67 
68 #define A top
69 #define B bottom
70 
71 #define FN(EXPR) A + ((EXPR) - A) * opacity
72 
73 DEFINE_BLEND_MODE(NORMAL, A * opacity + B * (1.0f - opacity))
74 DEFINE_BLEND_MODE(MULTIPLY, FN(1.0f * A * B / 1.0f))
75 
76 static inline void init_blend_func(FilterParamsVulkan *param)
77 {
78 #define CASE(MODE) case BLEND_##MODE: \
79  param->blend = blend_##MODE;\
80  param->blend_func = blend_##MODE##_func; \
81  break;
82 
83  switch (param->mode) {
84  CASE(NORMAL)
85  CASE(MULTIPLY)
86  default: param->blend = NULL; break;
87  }
88 
89 #undef CASE
90 }
91 
92 static int config_params(AVFilterContext *avctx)
93 {
94  BlendVulkanContext *s = avctx->priv;
95 
96  for (int plane = 0; plane < FF_ARRAY_ELEMS(s->params); plane++) {
97  FilterParamsVulkan *param = &s->params[plane];
98 
99  if (s->all_mode >= 0)
100  param->mode = s->all_mode;
101  if (s->all_opacity < 1)
102  param->opacity = s->all_opacity;
103 
104  init_blend_func(param);
105  if (!param->blend) {
106  av_log(avctx, AV_LOG_ERROR,
107  "Currently the blend mode specified is not supported yet.\n");
108  return AVERROR(EINVAL);
109  }
110  }
111 
112  return 0;
113 }
114 
115 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
116  char *res, int res_len, int flags)
117 {
118  int ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
119  if (ret < 0)
120  return ret;
121 
122  return config_params(ctx);
123 }
124 
126 {
127  int err = 0;
128  uint8_t *spv_data;
129  size_t spv_len;
130  void *spv_opaque = NULL;
131  BlendVulkanContext *s = avctx->priv;
132  FFVulkanContext *vkctx = &s->vkctx;
133  const int planes = av_pix_fmt_count_planes(s->vkctx.output_format);
134  FFVkSPIRVShader *shd = &s->shd;
135  FFVkSPIRVCompiler *spv;
137 
138  spv = ff_vk_spirv_init();
139  if (!spv) {
140  av_log(avctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
141  return AVERROR_EXTERNAL;
142  }
143 
144  ff_vk_qf_init(vkctx, &s->qf, VK_QUEUE_COMPUTE_BIT);
145  RET(ff_vk_exec_pool_init(vkctx, &s->qf, &s->e, s->qf.nb_queues*4, 0, 0, 0, NULL));
146  RET(ff_vk_init_sampler(vkctx, &s->sampler, 1, VK_FILTER_NEAREST));
147  RET(ff_vk_shader_init(&s->pl, &s->shd, "blend_compute",
148  VK_SHADER_STAGE_COMPUTE_BIT, 0));
149 
150  ff_vk_shader_set_compute_sizes(&s->shd, 32, 32, 1);
151 
153  {
154  .name = "top_images",
155  .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
156  .dimensions = 2,
157  .elems = planes,
158  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
159  .samplers = DUP_SAMPLER(s->sampler),
160  },
161  {
162  .name = "bottom_images",
163  .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
164  .dimensions = 2,
165  .elems = planes,
166  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
167  .samplers = DUP_SAMPLER(s->sampler),
168  },
169  {
170  .name = "output_images",
171  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
172  .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format),
173  .mem_quali = "writeonly",
174  .dimensions = 2,
175  .elems = planes,
176  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
177  },
178  };
179 
180  RET(ff_vk_pipeline_descriptor_set_add(vkctx, &s->pl, shd, desc, 3, 0, 0));
181 
182  for (int i = 0, j = 0; i < planes; i++) {
183  for (j = 0; j < i; j++)
184  if (s->params[i].blend_func == s->params[j].blend_func)
185  break;
186  /* note: the bracket is needed, for GLSLD is a macro with multiple statements. */
187  if (j == i) {
188  GLSLD(s->params[i].blend_func);
189  }
190  }
191 
192  GLSLC(0, void main() );
193  GLSLC(0, { );
194  GLSLC(1, ivec2 size; );
195  GLSLC(1, const ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
196  for (int i = 0; i < planes; i++) {
197  GLSLC(0, );
198  GLSLF(1, size = imageSize(output_images[%i]); ,i);
199  GLSLC(1, if (IS_WITHIN(pos, size)) { );
200  GLSLF(2, const vec4 top = texture(top_images[%i], pos); ,i);
201  GLSLF(2, const vec4 bottom = texture(bottom_images[%i], pos); ,i);
202  GLSLF(2, const float opacity = %f; ,s->params[i].opacity);
203  GLSLF(2, vec4 dst = %s(top, bottom, opacity); ,s->params[i].blend);
204  GLSLC(0, );
205  GLSLF(2, imageStore(output_images[%i], pos, dst); ,i);
206  GLSLC(1, } );
207  }
208  GLSLC(0, } );
209 
210  RET(spv->compile_shader(spv, avctx, shd, &spv_data, &spv_len, "main",
211  &spv_opaque));
212  RET(ff_vk_shader_create(vkctx, shd, spv_data, spv_len, "main"));
213 
214  RET(ff_vk_init_compute_pipeline(vkctx, &s->pl, shd));
215  RET(ff_vk_exec_pipeline_register(vkctx, &s->e, &s->pl));
216 
217  s->initialized = 1;
218 
219 fail:
220  if (spv_opaque)
221  spv->free_shader(spv, &spv_opaque);
222  if (spv)
223  spv->uninit(&spv);
224 
225  return err;
226 }
227 
229 {
230  int err;
231  AVFilterContext *avctx = fs->parent;
232  BlendVulkanContext *s = avctx->priv;
233  AVFilterLink *outlink = avctx->outputs[0];
234  AVFrame *top, *bottom, *out;
235 
236  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
237  if (!out) {
238  err = AVERROR(ENOMEM);
239  goto fail;
240  }
241 
242  RET(ff_framesync_get_frame(fs, IN_TOP, &top, 0));
243  RET(ff_framesync_get_frame(fs, IN_BOTTOM, &bottom, 0));
244 
245  RET(av_frame_copy_props(out, top));
246 
247  if (!s->initialized) {
249  AVHWFramesContext *bottom_fc = (AVHWFramesContext*)bottom->hw_frames_ctx->data;
250  if (top_fc->sw_format != bottom_fc->sw_format) {
251  av_log(avctx, AV_LOG_ERROR,
252  "Currently the sw format of the bottom video need to match the top!\n");
253  err = AVERROR(EINVAL);
254  goto fail;
255  }
256  RET(init_filter(avctx));
257  }
258 
259  RET(ff_vk_filter_process_Nin(&s->vkctx, &s->e, &s->pl,
260  out, (AVFrame *[]){ top, bottom }, 2,
261  s->sampler, NULL, 0));
262 
263  return ff_filter_frame(outlink, out);
264 
265 fail:
266  av_frame_free(&out);
267  return err;
268 }
269 
270 static av_cold int init(AVFilterContext *avctx)
271 {
272  BlendVulkanContext *s = avctx->priv;
273 
274  s->fs.on_event = blend_frame;
275 
276  return ff_vk_filter_init(avctx);
277 }
278 
279 static av_cold void uninit(AVFilterContext *avctx)
280 {
281  BlendVulkanContext *s = avctx->priv;
282  FFVulkanContext *vkctx = &s->vkctx;
283  FFVulkanFunctions *vk = &vkctx->vkfn;
284 
285  ff_vk_exec_pool_free(vkctx, &s->e);
286  ff_vk_pipeline_free(vkctx, &s->pl);
287  ff_vk_shader_free(vkctx, &s->shd);
288 
289  if (s->sampler)
290  vk->DestroySampler(vkctx->hwctx->act_dev, s->sampler,
291  vkctx->hwctx->alloc);
292 
293  ff_vk_uninit(&s->vkctx);
294  ff_framesync_uninit(&s->fs);
295 
296  s->initialized = 0;
297 }
298 
299 static int config_props_output(AVFilterLink *outlink)
300 {
301  int err;
302  AVFilterContext *avctx = outlink->src;
303  BlendVulkanContext *s = avctx->priv;
304  AVFilterLink *toplink = avctx->inputs[IN_TOP];
305  AVFilterLink *bottomlink = avctx->inputs[IN_BOTTOM];
306 
307  if (toplink->w != bottomlink->w || toplink->h != bottomlink->h) {
308  av_log(avctx, AV_LOG_ERROR, "First input link %s parameters "
309  "(size %dx%d) do not match the corresponding "
310  "second input link %s parameters (size %dx%d)\n",
311  avctx->input_pads[IN_TOP].name, toplink->w, toplink->h,
312  avctx->input_pads[IN_BOTTOM].name, bottomlink->w, bottomlink->h);
313  return AVERROR(EINVAL);
314  }
315 
316  outlink->sample_aspect_ratio = toplink->sample_aspect_ratio;
317  outlink->frame_rate = toplink->frame_rate;
318 
320 
321  RET(ff_framesync_init_dualinput(&s->fs, avctx));
322 
324  outlink->time_base = s->fs.time_base;
325 
326  RET(config_params(avctx));
327 
328 fail:
329  return err;
330 }
331 
332 static int activate(AVFilterContext *avctx)
333 {
334  BlendVulkanContext *s = avctx->priv;
335  return ff_framesync_activate(&s->fs);
336 }
337 
338 #define OFFSET(x) offsetof(BlendVulkanContext, x)
339 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
340 
341 static const AVOption blend_vulkan_options[] = {
342  { "c0_mode", "set component #0 blend mode", OFFSET(params[0].mode), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, BLEND_NB - 1, FLAGS, .unit = "mode" },
343  { "c1_mode", "set component #1 blend mode", OFFSET(params[1].mode), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, BLEND_NB - 1, FLAGS, .unit = "mode" },
344  { "c2_mode", "set component #2 blend mode", OFFSET(params[2].mode), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, BLEND_NB - 1, FLAGS, .unit = "mode" },
345  { "c3_mode", "set component #3 blend mode", OFFSET(params[3].mode), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, BLEND_NB - 1, FLAGS, .unit = "mode" },
346  { "all_mode", "set blend mode for all components", OFFSET(all_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, BLEND_NB - 1, FLAGS, .unit = "mode" },
347  { "normal", "", 0, AV_OPT_TYPE_CONST, { .i64 = BLEND_NORMAL }, 0, 0, FLAGS, .unit = "mode" },
348  { "multiply", "", 0, AV_OPT_TYPE_CONST, { .i64 = BLEND_MULTIPLY }, 0, 0, FLAGS, .unit = "mode" },
349 
350  { "c0_opacity", "set color component #0 opacity", OFFSET(params[0].opacity), AV_OPT_TYPE_DOUBLE, { .dbl = 1 }, 0, 1, FLAGS },
351  { "c1_opacity", "set color component #1 opacity", OFFSET(params[1].opacity), AV_OPT_TYPE_DOUBLE, { .dbl = 1 }, 0, 1, FLAGS },
352  { "c2_opacity", "set color component #2 opacity", OFFSET(params[2].opacity), AV_OPT_TYPE_DOUBLE, { .dbl = 1 }, 0, 1, FLAGS },
353  { "c3_opacity", "set color component #3 opacity", OFFSET(params[3].opacity), AV_OPT_TYPE_DOUBLE, { .dbl = 1 }, 0, 1, FLAGS },
354  { "all_opacity", "set opacity for all color components", OFFSET(all_opacity), AV_OPT_TYPE_DOUBLE, { .dbl = 1 }, 0, 1, FLAGS },
355 
356  { NULL }
357 };
358 
359 AVFILTER_DEFINE_CLASS(blend_vulkan);
360 
362  {
363  .name = "top",
364  .type = AVMEDIA_TYPE_VIDEO,
365  .config_props = &ff_vk_filter_config_input,
366  },
367  {
368  .name = "bottom",
369  .type = AVMEDIA_TYPE_VIDEO,
370  .config_props = &ff_vk_filter_config_input,
371  },
372 };
373 
374 
376  {
377  .name = "default",
378  .type = AVMEDIA_TYPE_VIDEO,
379  .config_props = &config_props_output,
380  }
381 };
382 
384  .name = "blend_vulkan",
385  .description = NULL_IF_CONFIG_SMALL("Blend two video frames in Vulkan"),
386  .priv_size = sizeof(BlendVulkanContext),
387  .init = &init,
388  .uninit = &uninit,
389  .activate = &activate,
393  .priv_class = &blend_vulkan_class,
394  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
395  .flags = AVFILTER_FLAG_HWDEVICE,
396  .process_command = &process_command,
397 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:112
ff_framesync_configure
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
Definition: framesync.c:134
ff_vf_blend_vulkan
const AVFilter ff_vf_blend_vulkan
Definition: vf_blend_vulkan.c:383
ff_vk_pipeline_free
void ff_vk_pipeline_free(FFVulkanContext *s, FFVulkanPipeline *pl)
Definition: vulkan.c:1868
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
opt.h
ff_framesync_uninit
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
Definition: framesync.c:304
out
FILE * out
Definition: movenc.c:54
FF_FILTER_FLAG_HWFRAME_AWARE
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
Definition: internal.h:343
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
ff_framesync_get_frame
int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe, unsigned get)
Get the current frame in an input.
Definition: framesync.c:267
config_props_output
static int config_props_output(AVFilterLink *outlink)
Definition: vf_blend_vulkan.c:299
ff_vk_qf_init
int ff_vk_qf_init(FFVulkanContext *s, FFVkQueueFamilyCtx *qf, VkQueueFlagBits dev_family)
Chooses a QF and loads it into a context.
Definition: vulkan.c:225
BlendVulkanContext::shd
FFVkSPIRVShader shd
Definition: vf_blend_vulkan.c:51
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
init_blend_func
static void init_blend_func(FilterParamsVulkan *param)
Definition: vf_blend_vulkan.c:76
ff_vk_filter_init
int ff_vk_filter_init(AVFilterContext *avctx)
General lavfi IO functions.
Definition: vulkan_filter.c:219
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:385
ff_vk_shader_create
int ff_vk_shader_create(FFVulkanContext *s, FFVkSPIRVShader *shd, uint8_t *spirv, size_t spirv_size, const char *entrypoint)
Definition: vulkan.c:1413
B
#define B
Definition: vf_blend_vulkan.c:69
AVOption
AVOption.
Definition: opt.h:251
ff_vk_uninit
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition: vulkan.c:1897
FFVkSPIRVCompiler::uninit
void(* uninit)(struct FFVkSPIRVCompiler **ctx)
Definition: vulkan_spirv.h:33
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
BlendVulkanContext::e
FFVkExecPool e
Definition: vf_blend_vulkan.c:49
ff_vk_pipeline_descriptor_set_add
int ff_vk_pipeline_descriptor_set_add(FFVulkanContext *s, FFVulkanPipeline *pl, FFVkSPIRVShader *shd, FFVulkanDescriptorSetBinding *desc, int nb, int read_only, int print_to_shader_only)
Add descriptor to a pipeline.
Definition: vulkan.c:1463
FFFrameSync
Frame sync structure.
Definition: framesync.h:168
ff_vk_shader_set_compute_sizes
void ff_vk_shader_set_compute_sizes(FFVkSPIRVShader *shd, int x, int y, int z)
Definition: vulkan.c:1371
video.h
MULTIPLY
#define MULTIPLY(var, const)
Definition: 4xm.c:164
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:383
BLEND_NB
@ BLEND_NB
Definition: blend.h:69
BlendVulkanContext::all_opacity
double all_opacity
Definition: vf_blend_vulkan.c:55
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3008
BlendVulkanContext::fs
FFFrameSync fs
Definition: vf_blend_vulkan.c:45
AVVulkanDeviceContext::alloc
const VkAllocationCallbacks * alloc
Custom memory allocator, else NULL.
Definition: hwcontext_vulkan.h:48
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:424
fail
#define fail()
Definition: checkasm.h:179
init
static av_cold int init(AVFilterContext *avctx)
Definition: vf_blend_vulkan.c:270
BlendVulkanContext::params
FilterParamsVulkan params[4]
Definition: vf_blend_vulkan.c:54
vulkan_filter.h
blend_vulkan_outputs
static const AVFilterPad blend_vulkan_outputs[]
Definition: vf_blend_vulkan.c:375
BlendVulkanContext::sampler
VkSampler sampler
Definition: vf_blend_vulkan.c:52
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
OFFSET
#define OFFSET(x)
Definition: vf_blend_vulkan.c:338
AVFilterContext::input_pads
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:416
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
blend_vulkan_inputs
static const AVFilterPad blend_vulkan_inputs[]
Definition: vf_blend_vulkan.c:361
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
FilterParamsVulkan
Definition: vf_blend_vulkan.c:36
ctx
AVFormatContext * ctx
Definition: movenc.c:48
activate
static int activate(AVFilterContext *avctx)
Definition: vf_blend_vulkan.c:332
init_filter
static av_cold int init_filter(AVFilterContext *avctx)
Definition: vf_blend_vulkan.c:125
BlendVulkanContext::initialized
int initialized
Definition: vf_blend_vulkan.c:47
FFVkSPIRVCompiler::compile_shader
int(* compile_shader)(struct FFVkSPIRVCompiler *ctx, void *avctx, struct FFVkSPIRVShader *shd, uint8_t **data, size_t *size, const char *entrypoint, void **opaque)
Definition: vulkan_spirv.h:29
ff_vk_exec_pool_free
void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
Definition: vulkan.c:256
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
BlendVulkanContext::qf
FFVkQueueFamilyCtx qf
Definition: vf_blend_vulkan.c:50
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:223
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:736
BLEND_MULTIPLY
@ BLEND_MULTIPLY
Definition: blend.h:42
GLSLD
#define GLSLD(D)
Definition: vulkan.h:60
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:200
BlendMode
BlendMode
Definition: blend.h:27
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:417
ff_vk_filter_config_output
int ff_vk_filter_config_output(AVFilterLink *outlink)
Definition: vulkan_filter.c:196
config_params
static int config_params(AVFilterContext *avctx)
Definition: vf_blend_vulkan.c:92
blend_vulkan_options
static const AVOption blend_vulkan_options[]
Definition: vf_blend_vulkan.c:341
ff_vk_init_compute_pipeline
int ff_vk_init_compute_pipeline(FFVulkanContext *s, FFVulkanPipeline *pl, FFVkSPIRVShader *shd)
Definition: vulkan.c:1809
ff_vk_exec_pool_init
int ff_vk_exec_pool_init(FFVulkanContext *s, FFVkQueueFamilyCtx *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:296
FFVulkanContext
Definition: vulkan.h:229
BlendVulkanContext
Definition: vf_blend_vulkan.c:43
A
#define A
Definition: vf_blend_vulkan.c:68
FFVulkanPipeline
Definition: vulkan.h:132
ff_vk_shader_init
int ff_vk_shader_init(FFVulkanPipeline *pl, FFVkSPIRVShader *shd, const char *name, VkShaderStageFlags stage, uint32_t required_subgroup_size)
Shader management.
Definition: vulkan.c:1345
main
int main(int argc, char **argv)
Definition: avio_http_serve_files.c:99
FLAGS
#define FLAGS
Definition: vf_blend_vulkan.c:339
f
f
Definition: af_crystalizer.c:121
FFVulkanDescriptorSetBinding
Definition: vulkan.h:84
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
ff_framesync_init_dualinput
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
Initialize a frame sync structure for dualinput.
Definition: framesync.c:375
blend_frame
static int blend_frame(FFFrameSync *fs)
Definition: vf_blend_vulkan.c:228
IN_TOP
#define IN_TOP
Definition: vf_blend_vulkan.c:33
AVFILTER_FLAG_HWDEVICE
#define AVFILTER_FLAG_HWDEVICE
The filter can create hardware frames using AVFilterContext.hw_device_ctx.
Definition: avfilter.h:138
size
int size
Definition: twinvq_data.h:10344
FFVkQueueFamilyCtx
Definition: vulkan.h:111
FilterParamsVulkan::opacity
double opacity
Definition: vf_blend_vulkan.c:39
BlendVulkanContext::pl
FFVulkanPipeline pl
Definition: vf_blend_vulkan.c:48
IN_BOTTOM
#define IN_BOTTOM
Definition: vf_blend_vulkan.c:34
FilterParamsVulkan::blend_func
const char * blend_func
Definition: vf_blend_vulkan.c:38
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:879
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
internal.h
FFVkSPIRVCompiler
Definition: vulkan_spirv.h:27
FILTER_SINGLE_PIXFMT
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
Definition: internal.h:172
CASE
#define CASE(MODE)
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
BlendVulkanContext::vkctx
FFVulkanContext vkctx
Definition: vf_blend_vulkan.c:44
blend.h
DUP_SAMPLER
#define DUP_SAMPLER(x)
Definition: vulkan.h:74
ff_vk_shader_rep_fmt
const char * ff_vk_shader_rep_fmt(enum AVPixelFormat pixfmt)
Returns the format to use for images in shaders.
Definition: vulkan.c:1207
BlendVulkanContext::all_mode
enum BlendMode all_mode
Definition: vf_blend_vulkan.c:56
vulkan_spirv.h
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
GLSLF
#define GLSLF(N, S,...)
Definition: vulkan.h:55
FFVkSPIRVCompiler::free_shader
void(* free_shader)(struct FFVkSPIRVCompiler *ctx, void **opaque)
Definition: vulkan_spirv.h:32
AVFilter
Filter definition.
Definition: avfilter.h:166
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:125
ret
ret
Definition: filter_design.txt:187
FFVulkanContext::vkfn
FFVulkanFunctions vkfn
Definition: vulkan.h:232
FFVkExecPool
Definition: vulkan.h:211
pos
unsigned int pos
Definition: spdifenc.c:413
AVFrame::hw_frames_ctx
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
Definition: frame.h:752
random_seed.h
framesync.h
uninit
static av_cold void uninit(AVFilterContext *avctx)
Definition: vf_blend_vulkan.c:279
FFVkSPIRVShader
Definition: vulkan.h:76
mode
mode
Definition: ebur128.h:83
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_blend_vulkan.c:115
DEFINE_BLEND_MODE
#define DEFINE_BLEND_MODE(MODE, EXPR)
Definition: vf_blend_vulkan.c:59
AVFilterContext
An instance of a filter.
Definition: avfilter.h:409
desc
const char * desc
Definition: libsvtav1.c:83
GLSLC
#define GLSLC(N, S)
Definition: vulkan.h:45
ff_vk_filter_config_input
int ff_vk_filter_config_input(AVFilterLink *inlink)
Definition: vulkan_filter.c:165
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFVulkanContext::hwctx
AVVulkanDeviceContext * hwctx
Definition: vulkan.h:254
FilterParamsVulkan::mode
enum BlendMode mode
Definition: vf_blend_vulkan.c:40
AVVulkanDeviceContext::act_dev
VkDevice act_dev
Active device.
Definition: hwcontext_vulkan.h:70
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
FilterParamsVulkan::blend
const char * blend
Definition: vf_blend_vulkan.c:37
ff_vk_init_sampler
int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler, int unnorm_coords, VkFilter filt)
Create a sampler.
Definition: vulkan.c:1163
planes
static const struct @377 planes[]
ff_vk_exec_pipeline_register
int ff_vk_exec_pipeline_register(FFVulkanContext *s, FFVkExecPool *pool, FFVulkanPipeline *pl)
Register a pipeline with an exec pool.
Definition: vulkan.c:1577
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FN
#define FN(EXPR)
Definition: vf_blend_vulkan.c:71
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(blend_vulkan)
ff_framesync_activate
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
Definition: framesync.c:355
ff_vk_shader_free
void ff_vk_shader_free(FFVulkanContext *s, FFVkSPIRVShader *shd)
Definition: vulkan.c:1404
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
RET
#define RET(x)
Definition: vulkan.h:68
FFVulkanFunctions
Definition: vulkan_functions.h:226
BLEND_NORMAL
@ BLEND_NORMAL
Definition: blend.h:29
AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:421