FFmpeg
vf_bwdif_vulkan.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) Lynne
3  * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
4  * Copyright (C) 2016 Thomas Mundt <loudmax@yahoo.de>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "libavutil/random_seed.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/vulkan_spirv.h"
26 #include "vulkan_filter.h"
27 #include "yadif.h"
28 #include "filters.h"
29 
30 typedef struct BWDIFVulkanContext {
31  YADIFContext yadif;
32  FFVulkanContext vkctx;
33 
34  int initialized;
35  FFVkExecPool e;
36  AVVulkanDeviceQueueFamily *qf;
37  FFVulkanShader shd;
38 } BWDIFVulkanContext;
39 
40 typedef struct BWDIFParameters {
41  int parity;
42  int tff;
43  int current_field;
44 } BWDIFParameters;
45 
46 extern const char *ff_source_bwdif_comp;
47 
48 static av_cold int init_filter(AVFilterContext *ctx)
49 {
50  int err;
51  uint8_t *spv_data;
52  size_t spv_len;
53  void *spv_opaque = NULL;
54  BWDIFVulkanContext *s = ctx->priv;
55  FFVulkanContext *vkctx = &s->vkctx;
56  const int planes = av_pix_fmt_count_planes(s->vkctx.output_format);
57  FFVulkanShader *shd;
58  FFVkSPIRVCompiler *spv;
59  FFVulkanDescriptorSetBinding *desc;
60 
61  spv = ff_vk_spirv_init();
62  if (!spv) {
63  av_log(ctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
64  return AVERROR_EXTERNAL;
65  }
66 
67  s->qf = ff_vk_qf_find(vkctx, VK_QUEUE_COMPUTE_BIT, 0);
68  if (!s->qf) {
69  av_log(ctx, AV_LOG_ERROR, "Device has no compute queues\n");
70  err = AVERROR(ENOTSUP);
71  goto fail;
72  }
73 
74  RET(ff_vk_exec_pool_init(vkctx, s->qf, &s->e, s->qf->num*4, 0, 0, 0, NULL));
75 
76  RET(ff_vk_shader_init(vkctx, &s->shd, "bwdif",
77  VK_SHADER_STAGE_COMPUTE_BIT,
78  NULL, 0,
79  1, 64, 1,
80  0));
81  shd = &s->shd;
82 
83  desc = (FFVulkanDescriptorSetBinding []) {
84  {
85  .name = "prev",
86  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
87  .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.input_format, FF_VK_REP_FLOAT),
88  .mem_quali = "readonly",
89  .dimensions = 2,
90  .elems = planes,
91  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
92  },
93  {
94  .name = "cur",
95  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
96  .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.input_format, FF_VK_REP_FLOAT),
97  .mem_quali = "readonly",
98  .dimensions = 2,
99  .elems = planes,
100  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
101  },
102  {
103  .name = "next",
104  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
105  .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.input_format, FF_VK_REP_FLOAT),
106  .mem_quali = "readonly",
107  .dimensions = 2,
108  .elems = planes,
109  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
110  },
111  {
112  .name = "dst",
113  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
114  .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format, FF_VK_REP_FLOAT),
115  .mem_quali = "writeonly",
116  .dimensions = 2,
117  .elems = planes,
118  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
119  },
120  };
121 
122  RET(ff_vk_shader_add_descriptor_set(vkctx, &s->shd, desc, 4, 0, 0));
123 
124  GLSLC(0, layout(push_constant, std430) uniform pushConstants { );
125  GLSLC(1, int parity; );
126  GLSLC(1, int tff; );
127  GLSLC(1, int current_field; );
128  GLSLC(0, }; );
129 
130  ff_vk_shader_add_push_const(&s->shd, 0, sizeof(BWDIFParameters),
131  VK_SHADER_STAGE_COMPUTE_BIT);
132 
133  GLSLD(ff_source_bwdif_comp );
134  GLSLC(0, void main() );
135  GLSLC(0, { );
136  GLSLC(1, ivec2 size; );
137  GLSLC(1, const ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
138  GLSLC(1, bool filter_field = ((pos.y ^ parity) & 1) == 1; );
139  GLSLF(1, bool is_intra = filter_field && (current_field == %i); ,YADIF_FIELD_END);
140  GLSLC(1, bool field_parity = (parity ^ tff) != 0; );
141  GLSLC(0, );
142  GLSLC(1, size = imageSize(dst[0]); );
143  GLSLC(1, if (!IS_WITHIN(pos, size)) { );
144  GLSLC(2, return; );
145  GLSLC(1, } else if (is_intra) { );
146  for (int i = 0; i < planes; i++) {
147  if (i == 1) {
148  GLSLF(2, size = imageSize(dst[%i]); ,i);
149  GLSLC(2, if (!IS_WITHIN(pos, size)) );
150  GLSLC(3, return; );
151  }
152  GLSLF(2, process_plane_intra(%i, pos); ,i);
153  }
154  GLSLC(1, } else if (filter_field) { );
155  for (int i = 0; i < planes; i++) {
156  if (i == 1) {
157  GLSLF(2, size = imageSize(dst[%i]); ,i);
158  GLSLC(2, if (!IS_WITHIN(pos, size)) );
159  GLSLC(3, return; );
160  }
161  GLSLF(2, process_plane(%i, pos, filter_field, is_intra, field_parity); ,i);
162  }
163  GLSLC(1, } else { );
164  for (int i = 0; i < planes; i++) {
165  if (i == 1) {
166  GLSLF(2, size = imageSize(dst[%i]); ,i);
167  GLSLC(2, if (!IS_WITHIN(pos, size)) );
168  GLSLC(3, return; );
169  }
170  GLSLF(2, imageStore(dst[%i], pos, imageLoad(cur[%i], pos)); ,i, i);
171  }
172  GLSLC(1, } );
173  GLSLC(0, } );
174 
175  RET(spv->compile_shader(vkctx, spv, &s->shd, &spv_data, &spv_len, "main",
176  &spv_opaque));
177  RET(ff_vk_shader_link(vkctx, &s->shd, spv_data, spv_len, "main"));
178 
179  RET(ff_vk_shader_register_exec(vkctx, &s->e, &s->shd));
180 
181  s->initialized = 1;
182 
183 fail:
184  if (spv_opaque)
185  spv->free_shader(spv, &spv_opaque);
186  if (spv)
187  spv->uninit(&spv);
188 
189  return err;
190 }
191 
192 static void bwdif_vulkan_filter_frame(AVFilterContext *ctx, AVFrame *dst,
193  int parity, int tff)
194 {
195  BWDIFVulkanContext *s = ctx->priv;
196  YADIFContext *y = &s->yadif;
197  BWDIFParameters params = {
198  .parity = parity,
199  .tff = tff,
200  .current_field = y->current_field,
201  };
202 
203  ff_vk_filter_process_Nin(&s->vkctx, &s->e, &s->shd, dst,
204  (AVFrame *[]){ y->prev, y->cur, y->next }, 3,
205  VK_NULL_HANDLE, &params, sizeof(params));
206 
207  if (y->current_field == YADIF_FIELD_END)
208  y->current_field = YADIF_FIELD_NORMAL;
209 }
210 
211 static void bwdif_vulkan_uninit(AVFilterContext *avctx)
212 {
213  BWDIFVulkanContext *s = avctx->priv;
214  FFVulkanContext *vkctx = &s->vkctx;
215 
216  ff_vk_exec_pool_free(vkctx, &s->e);
217  ff_vk_shader_free(vkctx, &s->shd);
218 
219  ff_vk_uninit(&s->vkctx);
220 
221  ff_yadif_uninit(avctx);
222 
223  s->initialized = 0;
224 }
225 
226 static int bwdif_vulkan_config_input(AVFilterLink *inlink)
227 {
228  FilterLink *l = ff_filter_link(inlink);
229  AVHWFramesContext *input_frames;
230  AVFilterContext *avctx = inlink->dst;
231  BWDIFVulkanContext *s = avctx->priv;
232  FFVulkanContext *vkctx = &s->vkctx;
233 
234  if (!l->hw_frames_ctx) {
235  av_log(inlink->dst, AV_LOG_ERROR, "Vulkan filtering requires a "
236  "hardware frames context on the input.\n");
237  return AVERROR(EINVAL);
238  }
239 
240  input_frames = (AVHWFramesContext *)l->hw_frames_ctx->data;
241  if (input_frames->format != AV_PIX_FMT_VULKAN)
242  return AVERROR(EINVAL);
243 
244  /* Extract the device and default output format from the first input. */
245  if (avctx->inputs[0] != inlink)
246  return 0;
247 
248  /* Save the ref, without reffing it */
249  vkctx->input_frames_ref = l->hw_frames_ctx;
250 
251  /* Defaults */
252  vkctx->output_format = input_frames->sw_format;
253  vkctx->output_width = inlink->w;
254  vkctx->output_height = inlink->h;
255 
256  return 0;
257 }
258 
259 static int bwdif_vulkan_config_output(AVFilterLink *outlink)
260 {
261  FilterLink *l = ff_filter_link(outlink);
262  int err;
263  AVFilterContext *avctx = outlink->src;
264  BWDIFVulkanContext *s = avctx->priv;
265  YADIFContext *y = &s->yadif;
266  FFVulkanContext *vkctx = &s->vkctx;
267 
268  av_buffer_unref(&l->hw_frames_ctx);
269 
270  err = ff_vk_filter_init_context(avctx, vkctx, vkctx->input_frames_ref,
271  vkctx->output_width, vkctx->output_height,
272  vkctx->output_format);
273  if (err < 0)
274  return err;
275 
276  /* For logging */
277  vkctx->class = y->class;
278 
279  l->hw_frames_ctx = av_buffer_ref(vkctx->frames_ref);
280  if (!l->hw_frames_ctx)
281  return AVERROR(ENOMEM);
282 
283  err = ff_yadif_config_output_common(outlink);
284  if (err < 0)
285  return err;
286 
287  y->csp = av_pix_fmt_desc_get(vkctx->frames->sw_format);
288  y->filter = bwdif_vulkan_filter_frame;
289 
290  if (AV_CEIL_RSHIFT(outlink->w, y->csp->log2_chroma_w) < 4 || AV_CEIL_RSHIFT(outlink->h, y->csp->log2_chroma_h) < 4) {
291  av_log(avctx, AV_LOG_ERROR, "Video with planes less than 4 columns or lines is not supported\n");
292  return AVERROR(EINVAL);
293  }
294 
295  return init_filter(avctx);
296 }
297 
298 static const AVClass bwdif_vulkan_class = {
299  .class_name = "bwdif_vulkan",
300  .item_name = av_default_item_name,
301  .option = ff_yadif_options,
302  .version = LIBAVUTIL_VERSION_INT,
303  .category = AV_CLASS_CATEGORY_FILTER,
304 };
305 
306 static const AVFilterPad bwdif_vulkan_inputs[] = {
307  {
308  .name = "default",
309  .type = AVMEDIA_TYPE_VIDEO,
310  .filter_frame = ff_yadif_filter_frame,
311  .config_props = &bwdif_vulkan_config_input,
312  },
313 };
314 
315 static const AVFilterPad bwdif_vulkan_outputs[] = {
316  {
317  .name = "default",
318  .type = AVMEDIA_TYPE_VIDEO,
319  .request_frame = ff_yadif_request_frame,
320  .config_props = &bwdif_vulkan_config_output,
321  },
322 };
323 
324 const FFFilter ff_vf_bwdif_vulkan = {
325  .p.name = "bwdif_vulkan",
326  .p.description = NULL_IF_CONFIG_SMALL("Deinterlace Vulkan frames via bwdif"),
327  .p.priv_class = &bwdif_vulkan_class,
328  .p.flags = AVFILTER_FLAG_HWDEVICE |
329  AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
330  .priv_size = sizeof(BWDIFVulkanContext),
331  .init = &ff_vk_filter_init,
332  .uninit = &bwdif_vulkan_uninit,
333  FILTER_INPUTS(bwdif_vulkan_inputs),
334  FILTER_OUTPUTS(bwdif_vulkan_outputs),
335  FILTER_SINGLE_PIXFMT(AV_PIX_FMT_VULKAN),
336  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
337 };
YADIFContext::class
const AVClass * class
Definition: yadif.h:52
FFVulkanContext::output_height
int output_height
Definition: vulkan.h:308
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_vk_shader_free
void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
Free a shader.
Definition: vulkan.c:2546
ff_vk_shader_init
int ff_vk_shader_init(FFVulkanContext *s, FFVulkanShader *shd, const char *name, VkPipelineStageFlags stage, const char *extensions[], int nb_extensions, int lg_x, int lg_y, int lg_z, uint32_t required_subgroup_size)
Initialize a shader object, with a specific set of extensions, type+bind, local group size,...
Definition: vulkan.c:1689
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3313
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
RET
#define RET(x)
Definition: vulkan.h:67
ff_vk_exec_pool_init
int ff_vk_exec_pool_init(FFVulkanContext *s, AVVulkanDeviceQueueFamily *qf, FFVkExecPool *pool, int nb_contexts, int nb_queries, VkQueryType query_type, int query_64bit, const void *query_create_pnext)
Allocates/frees an execution pool.
Definition: vulkan.c:296
planes
static const struct @475 planes[]
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:198
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
YADIFContext::csp
const AVPixFmtDescriptor * csp
Definition: yadif.h:76
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:262
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
ff_vk_filter_init
int ff_vk_filter_init(AVFilterContext *avctx)
General lavfi IO functions.
Definition: vulkan_filter.c:233
FFVulkanContext::class
const AVClass * class
Definition: vulkan.h:268
BWDIFParameters::current_field
int current_field
Definition: vf_bwdif_vulkan.c:43
ff_vk_uninit
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition: vulkan.c:2587
FFVkSPIRVCompiler::uninit
void(* uninit)(struct FFVkSPIRVCompiler **ctx)
Definition: vulkan_spirv.h:32
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:203
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
ff_vf_bwdif_vulkan
const FFFilter ff_vf_bwdif_vulkan
Definition: vf_bwdif_vulkan.c:324
ff_source_bwdif_comp
const char * ff_source_bwdif_comp
BWDIFParameters::tff
int tff
Definition: vf_bwdif_vulkan.c:42
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3353
ff_yadif_config_output_common
int ff_yadif_config_output_common(AVFilterLink *outlink)
Definition: yadif_common.c:218
bwdif_vulkan_uninit
static void bwdif_vulkan_uninit(AVFilterContext *avctx)
Definition: vf_bwdif_vulkan.c:211
BWDIFVulkanContext::shd
FFVulkanShader shd
Definition: vf_bwdif_vulkan.c:37
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:272
fail
#define fail()
Definition: checkasm.h:193
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:25
ff_vk_shader_register_exec
int ff_vk_shader_register_exec(FFVulkanContext *s, FFVkExecPool *pool, FFVulkanShader *shd)
Register a shader with an exec pool.
Definition: vulkan.c:2186
ff_vk_shader_add_descriptor_set
int ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd, FFVulkanDescriptorSetBinding *desc, int nb, int singular, int print_to_shader_only)
Add descriptor to a shader.
Definition: vulkan.c:2053
FFVulkanContext::frames_ref
AVBufferRef * frames_ref
Definition: vulkan.h:299
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
GLSLC
#define GLSLC(N, S)
Definition: vulkan.h:44
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
main
int main
Definition: dovi_rpuenc.c:37
bwdif_vulkan_config_input
static int bwdif_vulkan_config_input(AVFilterLink *inlink)
Definition: vf_bwdif_vulkan.c:226
FFFilter
Definition: filters.h:265
FFVulkanContext::output_width
int output_width
Definition: vulkan.h:307
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
filters.h
FF_VK_REP_FLOAT
@ FF_VK_REP_FLOAT
Definition: vulkan.h:377
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
GLSLD
#define GLSLD(D)
Definition: vulkan.h:59
ff_vk_exec_pool_free
void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
Definition: vulkan.c:233
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
if
if(ret)
Definition: filter_design.txt:179
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_vk_shader_rep_fmt
const char * ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt, enum FFVkShaderRepFormat rep_fmt)
Definition: vulkan.c:1295
BWDIFVulkanContext::initialized
int initialized
Definition: vf_bwdif_vulkan.c:34
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
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:211
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
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:265
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:239
FFVulkanContext
Definition: vulkan.h:267
bwdif_vulkan_config_output
static int bwdif_vulkan_config_output(AVFilterLink *outlink)
Definition: vf_bwdif_vulkan.c:259
BWDIFParameters::parity
int parity
Definition: vf_bwdif_vulkan.c:41
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
AV_CLASS_CATEGORY_FILTER
@ AV_CLASS_CATEGORY_FILTER
Definition: log.h:36
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: filters.h:206
ff_yadif_options
const AVOption ff_yadif_options[]
Definition: yadif_common.c:273
ff_vk_filter_process_Nin
int ff_vk_filter_process_Nin(FFVulkanContext *vkctx, FFVkExecPool *e, FFVulkanShader *shd, 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:407
yadif.h
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
FFVulkanDescriptorSetBinding
Definition: vulkan.h:75
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:94
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
BWDIFVulkanContext::vkctx
FFVulkanContext vkctx
Definition: vf_bwdif_vulkan.c:32
AVFILTER_FLAG_HWDEVICE
#define AVFILTER_FLAG_HWDEVICE
The filter can create hardware frames using AVFilterContext.hw_device_ctx.
Definition: avfilter.h:171
size
int size
Definition: twinvq_data.h:10344
YADIFContext::filter
void(* filter)(AVFilterContext *ctx, AVFrame *dstpic, int parity, int tff)
Definition: yadif.h:65
FFVulkanShader
Definition: vulkan.h:183
parity
mcdeint parity
Definition: vf_mcdeint.c:281
BWDIFVulkanContext::yadif
YADIFContext yadif
Definition: vf_bwdif_vulkan.c:31
FFVulkanContext::output_format
enum AVPixelFormat output_format
Definition: vulkan.h:309
FFVkSPIRVCompiler::compile_shader
int(* compile_shader)(FFVulkanContext *s, struct FFVkSPIRVCompiler *ctx, FFVulkanShader *shd, uint8_t **data, size_t *size, const char *entrypoint, void **opaque)
Definition: vulkan_spirv.h:28
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
FFVulkanContext::input_frames_ref
AVBufferRef * input_frames_ref
Definition: vulkan.h:298
FFVkSPIRVCompiler
Definition: vulkan_spirv.h:26
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
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
BWDIFVulkanContext
Definition: vf_bwdif_vulkan.c:30
YADIFContext
Definition: yadif.h:51
ff_vk_shader_link
int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd, uint8_t *spirv, size_t spirv_len, const char *entrypoint)
Link a shader into an executable.
Definition: vulkan.c:1978
vulkan_spirv.h
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
BWDIFVulkanContext::e
FFVkExecPool e
Definition: vf_bwdif_vulkan.c:35
FFVkSPIRVCompiler::free_shader
void(* free_shader)(struct FFVkSPIRVCompiler *ctx, void **opaque)
Definition: vulkan_spirv.h:31
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:116
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
FFVkExecPool
Definition: vulkan.h:245
pos
unsigned int pos
Definition: spdifenc.c:414
ff_vk_shader_add_push_const
int ff_vk_shader_add_push_const(FFVulkanShader *shd, int offset, int size, VkShaderStageFlagBits stage)
Add/update push constants for execution.
Definition: vulkan.c:1204
ff_vk_qf_find
AVVulkanDeviceQueueFamily * ff_vk_qf_find(FFVulkanContext *s, VkQueueFlagBits dev_family, VkVideoCodecOperationFlagBitsKHR vid_ops)
Chooses an appropriate QF.
Definition: vulkan.c:220
BWDIFVulkanContext::qf
AVVulkanDeviceQueueFamily * qf
Definition: vf_bwdif_vulkan.c:36
bwdif_vulkan_class
static const AVClass bwdif_vulkan_class
Definition: vf_bwdif_vulkan.c:298
bwdif_vulkan_outputs
static const AVFilterPad bwdif_vulkan_outputs[]
Definition: vf_bwdif_vulkan.c:315
random_seed.h
YADIF_FIELD_END
@ YADIF_FIELD_END
The first or last field in a sequence.
Definition: yadif.h:47
GLSLF
#define GLSLF(N, S,...)
Definition: vulkan.h:54
ff_yadif_request_frame
int ff_yadif_request_frame(AVFilterLink *link)
Definition: yadif_common.c:184
bwdif_vulkan_inputs
static const AVFilterPad bwdif_vulkan_inputs[]
Definition: vf_bwdif_vulkan.c:306
AVFilterContext
An instance of a filter.
Definition: avfilter.h:257
YADIF_FIELD_NORMAL
@ YADIF_FIELD_NORMAL
A normal field in the middle of a sequence.
Definition: yadif.h:48
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:269
ff_yadif_uninit
void ff_yadif_uninit(AVFilterContext *ctx)
Definition: yadif_common.c:258
YADIFContext::current_field
int current_field
YADIFCurrentField.
Definition: yadif.h:88
bwdif_vulkan_filter_frame
static void bwdif_vulkan_filter_frame(AVFilterContext *ctx, AVFrame *dst, int parity, int tff)
Definition: vf_bwdif_vulkan.c:192
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:188
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
init_filter
static av_cold int init_filter(AVFilterContext *ctx)
Definition: vf_bwdif_vulkan.c:48
AVVulkanDeviceQueueFamily
Definition: hwcontext_vulkan.h:33
BWDIFParameters
Definition: vf_bwdif_vulkan.c:40
FFVulkanContext::frames
AVHWFramesContext * frames
Definition: vulkan.h:300
FILTER_SINGLE_PIXFMT
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
Definition: filters.h:252
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
ff_yadif_filter_frame
int ff_yadif_filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: yadif_common.c:104
Generated on Fri Mar 14 2025 19:22:42 for FFmpeg by   doxygen 1.8.17