FFmpeg
vf_chromaber_vulkan.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) Lynne
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/random_seed.h"
22 #include "libavutil/opt.h"
23 #include "vulkan_filter.h"
24 #include "vulkan_spirv.h"
25 #include "internal.h"
26 #include "video.h"
27 
30 
36  VkSampler sampler;
37 
38  /* Push constants / options */
39  struct {
40  float dist[2];
41  } opts;
43 
44 static const char distort_chroma_kernel[] = {
45  C(0, void distort_rgb(ivec2 size, ivec2 pos) )
46  C(0, { )
47  C(1, const vec2 p = ((vec2(pos)/vec2(size)) - 0.5f)*2.0f; )
48  C(1, const vec2 o = p * (dist - 1.0f); )
49  C(0, )
50  C(1, vec4 res; )
51  C(1, res.r = texture(input_img[0], ((p - o)/2.0f) + 0.5f).r; )
52  C(1, res.g = texture(input_img[0], ((p )/2.0f) + 0.5f).g; )
53  C(1, res.b = texture(input_img[0], ((p + o)/2.0f) + 0.5f).b; )
54  C(1, res.a = texture(input_img[0], ((p )/2.0f) + 0.5f).a; )
55  C(1, imageStore(output_img[0], pos, res); )
56  C(0, } )
57  C(0, )
58  C(0, void distort_chroma(int idx, ivec2 size, ivec2 pos) )
59  C(0, { )
60  C(1, vec2 p = ((vec2(pos)/vec2(size)) - 0.5f)*2.0f; )
61  C(1, float d = sqrt(p.x*p.x + p.y*p.y); )
62  C(1, p *= d / (d*dist); )
63  C(1, vec4 res = texture(input_img[idx], (p/2.0f) + 0.5f); )
64  C(1, imageStore(output_img[idx], pos, res); )
65  C(0, } )
66 };
67 
69 {
70  int err;
71  uint8_t *spv_data;
72  size_t spv_len;
73  void *spv_opaque = NULL;
75  FFVulkanContext *vkctx = &s->vkctx;
76  const int planes = av_pix_fmt_count_planes(s->vkctx.output_format);
77  FFVkSPIRVShader *shd = &s->shd;
78  FFVkSPIRVCompiler *spv;
80 
81  /* Normalize options */
82  s->opts.dist[0] = (s->opts.dist[0] / 100.0f) + 1.0f;
83  s->opts.dist[1] = (s->opts.dist[1] / 100.0f) + 1.0f;
84 
85  spv = ff_vk_spirv_init();
86  if (!spv) {
87  av_log(ctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
88  return AVERROR_EXTERNAL;
89  }
90 
91  ff_vk_qf_init(vkctx, &s->qf, VK_QUEUE_COMPUTE_BIT);
92  RET(ff_vk_exec_pool_init(vkctx, &s->qf, &s->e, s->qf.nb_queues*4, 0, 0, 0, NULL));
93  RET(ff_vk_init_sampler(vkctx, &s->sampler, 0, VK_FILTER_LINEAR));
94  RET(ff_vk_shader_init(&s->pl, &s->shd, "chromaber_compute",
95  VK_SHADER_STAGE_COMPUTE_BIT, 0));
96 
97  ff_vk_shader_set_compute_sizes(&s->shd, 32, 32, 1);
98 
99  GLSLC(0, layout(push_constant, std430) uniform pushConstants { );
100  GLSLC(1, vec2 dist; );
101  GLSLC(0, }; );
102  GLSLC(0, );
103 
104  ff_vk_add_push_constant(&s->pl, 0, sizeof(s->opts),
105  VK_SHADER_STAGE_COMPUTE_BIT);
106 
108  {
109  .name = "input_img",
110  .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
111  .dimensions = 2,
112  .elems = planes,
113  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
114  .samplers = DUP_SAMPLER(s->sampler),
115  },
116  {
117  .name = "output_img",
118  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
119  .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format),
120  .mem_quali = "writeonly",
121  .dimensions = 2,
122  .elems = planes,
123  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
124  },
125  };
126 
127  RET(ff_vk_pipeline_descriptor_set_add(vkctx, &s->pl, shd, desc, 2, 0, 0));
128 
130  GLSLC(0, void main() );
131  GLSLC(0, { );
132  GLSLC(1, ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
133  if (planes == 1) {
134  GLSLC(1, distort_rgb(imageSize(output_img[0]), pos); );
135  } else {
136  GLSLC(1, ivec2 size = imageSize(output_img[0]); );
137  GLSLC(1, vec2 npos = vec2(pos)/vec2(size); );
138  GLSLC(1, vec4 res = texture(input_img[0], npos); );
139  GLSLC(1, imageStore(output_img[0], pos, res); );
140  for (int i = 1; i < planes; i++) {
141  GLSLC(0, );
142  GLSLF(1, size = imageSize(output_img[%i]); ,i);
143  GLSLC(1, if (!IS_WITHIN(pos, size)) );
144  GLSLC(2, return; );
145  GLSLF(1, distort_chroma(%i, size, pos); ,i);
146  }
147  }
148  GLSLC(0, } );
149 
150  RET(spv->compile_shader(spv, ctx, shd, &spv_data, &spv_len, "main",
151  &spv_opaque));
152  RET(ff_vk_shader_create(vkctx, shd, spv_data, spv_len, "main"));
153 
154  RET(ff_vk_init_compute_pipeline(vkctx, &s->pl, shd));
155  RET(ff_vk_exec_pipeline_register(vkctx, &s->e, &s->pl));
156 
157  s->initialized = 1;
158 
159 fail:
160  if (spv_opaque)
161  spv->free_shader(spv, &spv_opaque);
162  if (spv)
163  spv->uninit(&spv);
164 
165  return err;
166 }
167 
169 {
170  int err;
171  AVFilterContext *ctx = link->dst;
173  AVFilterLink *outlink = ctx->outputs[0];
174 
175  AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
176  if (!out) {
177  err = AVERROR(ENOMEM);
178  goto fail;
179  }
180 
181  if (!s->initialized)
182  RET(init_filter(ctx, in));
183 
184  RET(ff_vk_filter_process_simple(&s->vkctx, &s->e, &s->pl, out, in,
185  s->sampler, &s->opts, sizeof(s->opts)));
186 
187  err = av_frame_copy_props(out, in);
188  if (err < 0)
189  goto fail;
190 
191  av_frame_free(&in);
192 
193  return ff_filter_frame(outlink, out);
194 
195 fail:
196  av_frame_free(&in);
197  av_frame_free(&out);
198  return err;
199 }
200 
202 {
204  FFVulkanContext *vkctx = &s->vkctx;
205  FFVulkanFunctions *vk = &vkctx->vkfn;
206 
207  ff_vk_exec_pool_free(vkctx, &s->e);
208  ff_vk_pipeline_free(vkctx, &s->pl);
209  ff_vk_shader_free(vkctx, &s->shd);
210 
211  if (s->sampler)
212  vk->DestroySampler(vkctx->hwctx->act_dev, s->sampler,
213  vkctx->hwctx->alloc);
214 
215  ff_vk_uninit(&s->vkctx);
216 
217  s->initialized = 0;
218 }
219 
220 #define OFFSET(x) offsetof(ChromaticAberrationVulkanContext, x)
221 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
223  { "dist_x", "Set horizontal distortion amount", OFFSET(opts.dist[0]), AV_OPT_TYPE_FLOAT, {.dbl = 0.0f}, -10.0f, 10.0f, .flags = FLAGS },
224  { "dist_y", "Set vertical distortion amount", OFFSET(opts.dist[1]), AV_OPT_TYPE_FLOAT, {.dbl = 0.0f}, -10.0f, 10.0f, .flags = FLAGS },
225  { NULL },
226 };
227 
228 AVFILTER_DEFINE_CLASS(chromaber_vulkan);
229 
231  {
232  .name = "default",
233  .type = AVMEDIA_TYPE_VIDEO,
234  .filter_frame = &chromaber_vulkan_filter_frame,
235  .config_props = &ff_vk_filter_config_input,
236  },
237 };
238 
240  {
241  .name = "default",
242  .type = AVMEDIA_TYPE_VIDEO,
243  .config_props = &ff_vk_filter_config_output,
244  },
245 };
246 
248  .name = "chromaber_vulkan",
249  .description = NULL_IF_CONFIG_SMALL("Offset chroma of input video (chromatic aberration)"),
250  .priv_size = sizeof(ChromaticAberrationVulkanContext),
256  .priv_class = &chromaber_vulkan_class,
257  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
258  .flags = AVFILTER_FLAG_HWDEVICE,
259 };
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:108
ff_vk_pipeline_free
void ff_vk_pipeline_free(FFVulkanContext *s, FFVulkanPipeline *pl)
Definition: vulkan.c:1863
r
const char * r
Definition: vf_curves.c:126
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
out
FILE * out
Definition: movenc.c:54
ChromaticAberrationVulkanContext::dist
float dist[2]
Definition: vf_chromaber_vulkan.c:40
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:364
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
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
planes
static const struct @358 planes[]
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
chromaber_vulkan_uninit
static void chromaber_vulkan_uninit(AVFilterContext *avctx)
Definition: vf_chromaber_vulkan.c:201
ff_vk_filter_init
int ff_vk_filter_init(AVFilterContext *avctx)
General lavfi IO functions.
Definition: vulkan_filter.c:214
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:1408
OFFSET
#define OFFSET(x)
Definition: vf_chromaber_vulkan.c:220
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
ff_vk_uninit
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition: vulkan.c:1892
FFVkSPIRVCompiler::uninit
void(* uninit)(struct FFVkSPIRVCompiler **ctx)
Definition: vulkan_spirv.h:33
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
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:1458
ff_vk_shader_set_compute_sizes
void ff_vk_shader_set_compute_sizes(FFVkSPIRVShader *shd, int x, int y, int z)
Definition: vulkan.c:1366
video.h
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:376
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2976
ChromaticAberrationVulkanContext::sampler
VkSampler sampler
Definition: vf_chromaber_vulkan.c:36
AVVulkanDeviceContext::alloc
const VkAllocationCallbacks * alloc
Custom memory allocator, else NULL.
Definition: hwcontext_vulkan.h:48
ff_vk_add_push_constant
int ff_vk_add_push_constant(FFVulkanPipeline *pl, int offset, int size, VkShaderStageFlagBits stage)
Add/update push constants for execution.
Definition: vulkan.c:1138
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:412
fail
#define fail()
Definition: checkasm.h:138
vulkan_filter.h
ChromaticAberrationVulkanContext::e
FFVkExecPool e
Definition: vf_chromaber_vulkan.c:33
ChromaticAberrationVulkanContext
Definition: vf_chromaber_vulkan.c:28
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:47
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
FLAGS
#define FLAGS
Definition: vf_chromaber_vulkan.c:221
ff_vf_chromaber_vulkan
const AVFilter ff_vf_chromaber_vulkan
Definition: vf_chromaber_vulkan.c:247
s
#define s(width, name)
Definition: cbs_vp9.c:254
g
const char * g
Definition: vf_curves.c:127
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
chromaber_vulkan_options
static const AVOption chromaber_vulkan_options[]
Definition: vf_chromaber_vulkan.c:222
ctx
AVFormatContext * ctx
Definition: movenc.c:48
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:192
link
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 link
Definition: filter_design.txt:23
opts
AVDictionary * opts
Definition: movenc.c:50
NULL
#define NULL
Definition: coverity.c:32
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
ChromaticAberrationVulkanContext::opts
struct ChromaticAberrationVulkanContext::@245 opts
GLSLD
#define GLSLD(D)
Definition: vulkan.h:60
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(chromaber_vulkan)
ff_vk_filter_config_output
int ff_vk_filter_config_output(AVFilterLink *outlink)
Definition: vulkan_filter.c:191
ff_vk_init_compute_pipeline
int ff_vk_init_compute_pipeline(FFVulkanContext *s, FFVulkanPipeline *pl, FFVkSPIRVShader *shd)
Definition: vulkan.c:1804
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:228
FFVulkanPipeline
Definition: vulkan.h:132
chromaber_vulkan_outputs
static const AVFilterPad chromaber_vulkan_outputs[]
Definition: vf_chromaber_vulkan.c:239
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:1340
main
int main(int argc, char **argv)
Definition: avio_http_serve_files.c:99
init_filter
static av_cold int init_filter(AVFilterContext *ctx, AVFrame *in)
Definition: vf_chromaber_vulkan.c:68
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
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
chromaber_vulkan_filter_frame
static int chromaber_vulkan_filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_chromaber_vulkan.c:168
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
internal.h
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
FFVkSPIRVCompiler
Definition: vulkan_spirv.h:27
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
FILTER_SINGLE_PIXFMT
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
Definition: internal.h:182
ChromaticAberrationVulkanContext::initialized
int initialized
Definition: vf_chromaber_vulkan.c:31
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:270
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:1202
vulkan_spirv.h
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:53
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
ChromaticAberrationVulkanContext::vkctx
FFVulkanContext vkctx
Definition: vf_chromaber_vulkan.c:29
ChromaticAberrationVulkanContext::pl
FFVulkanPipeline pl
Definition: vf_chromaber_vulkan.c:32
AVFilter
Filter definition.
Definition: avfilter.h:166
FFVulkanContext::vkfn
FFVulkanFunctions vkfn
Definition: vulkan.h:231
FFVkExecPool
Definition: vulkan.h:210
pos
unsigned int pos
Definition: spdifenc.c:413
random_seed.h
FFVkSPIRVShader
Definition: vulkan.h:76
ChromaticAberrationVulkanContext::shd
FFVkSPIRVShader shd
Definition: vf_chromaber_vulkan.c:35
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
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:160
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFVulkanContext::hwctx
AVVulkanDeviceContext * hwctx
Definition: vulkan.h:253
AVVulkanDeviceContext::act_dev
VkDevice act_dev
Active device.
Definition: hwcontext_vulkan.h:70
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:193
ff_vk_init_sampler
int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler, int unnorm_coords, VkFilter filt)
Create a sampler.
Definition: vulkan.c:1158
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:1572
d
d
Definition: ffmpeg_filter.c:331
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
distort_chroma_kernel
static const char distort_chroma_kernel[]
Definition: vf_chromaber_vulkan.c:44
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:285
chromaber_vulkan_inputs
static const AVFilterPad chromaber_vulkan_inputs[]
Definition: vf_chromaber_vulkan.c:230
ff_vk_shader_free
void ff_vk_shader_free(FFVulkanContext *s, FFVkSPIRVShader *shd)
Definition: vulkan.c:1399
RET
#define RET(x)
Definition: vulkan.h:68
FFVulkanFunctions
Definition: vulkan_functions.h:226
ChromaticAberrationVulkanContext::qf
FFVkQueueFamilyCtx qf
Definition: vf_chromaber_vulkan.c:34