FFmpeg
vsrc_testsrc_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/csp.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/vulkan_spirv.h"
25 #include "vulkan_filter.h"
26 #include "filters.h"
27 #include "colorspace.h"
28 #include "video.h"
29 
32 };
33 
34 typedef struct TestSrcVulkanPushData {
35  float color_comp[4];
37 
38 typedef struct TestSrcVulkanContext {
40 
45 
46  /* Only used by color_vulkan */
47  uint8_t color_rgba[4];
48 
50 
51  int w, h;
52  int pw, ph;
55  unsigned int nb_frame;
58  int64_t duration; ///< duration expressed in microseconds
59  AVRational sar; ///< sample aspect ratio
60  int draw_once; ///< draw only the first frame, always put out the same picture
61  int draw_once_reset; ///< draw only the first frame or in case of reset
62  AVFrame *picref; ///< cached reference containing the painted picture
64 
66 {
67  int err;
68  uint8_t *spv_data;
69  size_t spv_len;
70  void *spv_opaque = NULL;
71  TestSrcVulkanContext *s = ctx->priv;
72  FFVulkanContext *vkctx = &s->vkctx;
73  const int planes = av_pix_fmt_count_planes(s->vkctx.output_format);
74  FFVulkanShader *shd = &s->shd;
75  FFVkSPIRVCompiler *spv;
77  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->vkctx.output_format);
78 
79  spv = ff_vk_spirv_init();
80  if (!spv) {
81  av_log(ctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
82  return AVERROR_EXTERNAL;
83  }
84 
85  ff_vk_qf_init(vkctx, &s->qf, VK_QUEUE_COMPUTE_BIT);
86  RET(ff_vk_exec_pool_init(vkctx, &s->qf, &s->e, s->qf.nb_queues*4, 0, 0, 0, NULL));
87  RET(ff_vk_shader_init(vkctx, &s->shd, "scale",
88  VK_SHADER_STAGE_COMPUTE_BIT,
89  NULL, 0,
90  32, 32, 1,
91  0));
92 
93  GLSLC(0, layout(push_constant, std430) uniform pushConstants { );
94  GLSLC(1, vec4 color_comp; );
95  GLSLC(0, }; );
96  GLSLC(0, );
97 
98  ff_vk_shader_add_push_const(&s->shd, 0, sizeof(s->opts),
99  VK_SHADER_STAGE_COMPUTE_BIT);
100 
101  desc_set = (FFVulkanDescriptorSetBinding []) {
102  {
103  .name = "output_img",
104  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
105  .mem_layout = ff_vk_shader_rep_fmt(s->vkctx.output_format, FF_VK_REP_FLOAT),
106  .mem_quali = "writeonly",
107  .dimensions = 2,
108  .elems = planes,
109  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
110  },
111  };
112 
113  RET(ff_vk_shader_add_descriptor_set(vkctx, &s->shd, desc_set, 1, 0, 0));
114 
115  GLSLC(0, void main() );
116  GLSLC(0, { );
117  GLSLC(1, ivec2 pos = ivec2(gl_GlobalInvocationID.xy); );
118  if (mode == TESTSRC_COLOR) {
119  double rgb2yuv[3][3];
120  double rgbad[4];
121  double yuvad[4];
122 
123  enum AVColorSpace csp;
124  const AVLumaCoefficients *luma = NULL;
125 
126  s->draw_once = 1;
127 
128  if (desc->flags & AV_PIX_FMT_FLAG_RGB)
129  csp = AVCOL_SPC_RGB;
130  else
131  csp = AVCOL_SPC_SMPTE170M;
132 
133  if (!(desc->flags & AV_PIX_FMT_FLAG_RGB) && !(luma = av_csp_luma_coeffs_from_avcsp(csp)))
134  return AVERROR(EINVAL);
135  else if (!(desc->flags & AV_PIX_FMT_FLAG_RGB))
137 
138  for (int i = 0; i < 4; i++)
139  rgbad[i] = s->color_rgba[i] / 255.0;
140 
141  if (!(desc->flags & AV_PIX_FMT_FLAG_RGB))
142  ff_matrix_mul_3x3_vec(yuvad, rgbad, rgb2yuv);
143  else
144  memcpy(yuvad, rgbad, sizeof(rgbad));
145 
146  yuvad[3] = rgbad[3];
147 
148  if (!(desc->flags & AV_PIX_FMT_FLAG_RGB)) {
149  for (int i = 0; i < 3; i++) {
150  int chroma = (!(desc->flags & AV_PIX_FMT_FLAG_RGB) && i > 0);
151  if (s->out_range == AVCOL_RANGE_MPEG) {
152  yuvad[i] *= (chroma ? 224.0 : 219.0) / 255.0;
153  yuvad[i] += (chroma ? 128.0 : 16.0) / 255.0;
154  } else if (chroma) {
155  yuvad[i] += 0.5;
156  }
157  }
158  }
159 
160  /* Ensure we place the alpha appropriately for gray formats */
161  if (desc->nb_components <= 2)
162  yuvad[1] = yuvad[3];
163 
164  for (int i = 0; i < 4; i++)
165  s->opts.color_comp[i] = yuvad[i];
166 
167  GLSLC(1, vec4 r; );
168  GLSLC(0, );
169  for (int i = 0, c_off = 0; i < planes; i++) {
170  for (int c = 0; c < desc->nb_components; c++) {
171  if (desc->comp[c].plane == i) {
172  int off = desc->comp[c].offset / (FFALIGN(desc->comp[c].depth, 8)/8);
173  GLSLF(1, r[%i] = color_comp[%i]; ,off, c_off++);
174  }
175  }
176  GLSLF(1, imageStore(output_img[%i], pos, r); ,i);
177  GLSLC(0, );
178  }
179  }
180  GLSLC(0, } );
181 
182  RET(spv->compile_shader(vkctx, spv, shd, &spv_data, &spv_len, "main",
183  &spv_opaque));
184  RET(ff_vk_shader_link(vkctx, shd, spv_data, spv_len, "main"));
185 
186  RET(ff_vk_shader_register_exec(vkctx, &s->e, &s->shd));
187 
188  s->initialized = 1;
189 
190 fail:
191  if (spv_opaque)
192  spv->free_shader(spv, &spv_opaque);
193  if (spv)
194  spv->uninit(&spv);
195 
196  return err;
197 }
198 
200 {
201  int err;
202  AVFilterLink *outlink = ctx->outputs[0];
203  TestSrcVulkanContext *s = ctx->priv;
204  AVFrame *frame;
205 
206  if (!s->initialized) {
208  err = init_filter(ctx, mode);
209  if (err < 0)
210  return err;
211  }
212 
213  if (!ff_outlink_frame_wanted(outlink))
214  return FFERROR_NOT_READY;
215  if (s->duration >= 0 &&
216  av_rescale_q(s->pts, s->time_base, AV_TIME_BASE_Q) >= s->duration) {
217  ff_outlink_set_status(outlink, AVERROR_EOF, s->pts);
218  return 0;
219  }
220 
221  if (s->draw_once) {
222  if (s->draw_once_reset) {
223  av_frame_free(&s->picref);
224  s->draw_once_reset = 0;
225  }
226  if (!s->picref) {
227  s->picref = ff_get_video_buffer(outlink, s->w, s->h);
228  if (!s->picref)
229  return AVERROR(ENOMEM);
230 
231  err = ff_vk_filter_process_simple(&s->vkctx, &s->e, &s->shd, s->picref, NULL,
232  VK_NULL_HANDLE, &s->opts, sizeof(s->opts));
233  if (err < 0)
234  return err;
235  }
236  frame = av_frame_clone(s->picref);
237  } else {
238  frame = ff_get_video_buffer(outlink, s->w, s->h);
239  }
240 
241  if (!frame)
242  return AVERROR(ENOMEM);
243 
244  frame->pts = s->pts;
245  frame->duration = 1;
246  frame->flags = AV_FRAME_FLAG_KEY;
247  frame->pict_type = AV_PICTURE_TYPE_I;
248  frame->sample_aspect_ratio = s->sar;
249  if (!s->draw_once) {
250  err = ff_vk_filter_process_simple(&s->vkctx, &s->e, &s->shd, frame, NULL,
251  VK_NULL_HANDLE, &s->opts, sizeof(s->opts));
252  if (err < 0) {
254  return err;
255  }
256  }
257 
258  s->pts++;
259  s->nb_frame++;
260 
261  return ff_filter_frame(outlink, frame);
262 }
263 
265 {
266  int err;
267  FilterLink *l = ff_filter_link(outlink);
268  TestSrcVulkanContext *s = outlink->src->priv;
269  FFVulkanContext *vkctx = &s->vkctx;
270 
271  if (!s->out_format_string) {
273  } else {
274  vkctx->output_format = av_get_pix_fmt(s->out_format_string);
275  if (vkctx->output_format == AV_PIX_FMT_NONE) {
276  av_log(vkctx, AV_LOG_ERROR, "Invalid output format.\n");
277  return AVERROR(EINVAL);
278  }
279  }
280 
281  err = ff_vk_filter_init_context(outlink->src, vkctx, NULL,
282  s->w, s->h, vkctx->output_format);
283  if (err < 0)
284  return err;
285 
287  if (!l->hw_frames_ctx)
288  return AVERROR(ENOMEM);
289 
290  s->time_base = av_inv_q(s->frame_rate);
291  s->nb_frame = 0;
292  s->pts = 0;
293 
294  s->vkctx.output_width = s->w;
295  s->vkctx.output_height = s->h;
296  outlink->w = s->w;
297  outlink->h = s->h;
298  outlink->sample_aspect_ratio = s->sar;
299  l->frame_rate = s->frame_rate;
300  outlink->time_base = s->time_base;
301 
302  return 0;
303 }
304 
306 {
307  TestSrcVulkanContext *s = avctx->priv;
308  FFVulkanContext *vkctx = &s->vkctx;
309 
310  av_frame_free(&s->picref);
311 
312  ff_vk_exec_pool_free(vkctx, &s->e);
313  ff_vk_shader_free(vkctx, &s->shd);
314 
315  ff_vk_uninit(&s->vkctx);
316 
317  s->initialized = 0;
318 }
319 
320 #define OFFSET(x) offsetof(TestSrcVulkanContext, x)
321 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
322 
323 #define COMMON_OPTS \
324  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, { .str = "1920x1080" }, 0, 0, FLAGS }, \
325  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, { .str = "1920x1080" }, 0, 0, FLAGS }, \
326  \
327  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, { .str = "60" }, 0, INT_MAX, FLAGS }, \
328  { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, { .str = "60" }, 0, INT_MAX, FLAGS }, \
329  \
330  { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT64_MAX, FLAGS }, \
331  { "d", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT64_MAX, FLAGS }, \
332  \
333  { "sar", "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, { .dbl = 1 }, 0, INT_MAX, FLAGS }, \
334  \
335  { "format", "Output video format (software format of hardware frames)", OFFSET(out_format_string), AV_OPT_TYPE_STRING, .flags = FLAGS },
336 
337 static const AVOption color_vulkan_options[] = {
338  { "color", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, FLAGS },
339  { "c", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, FLAGS },
341  { "out_range", "Output colour range (from 0 to 2) (default 0)", OFFSET(out_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED}, AVCOL_RANGE_UNSPECIFIED, AVCOL_RANGE_JPEG, .flags = FLAGS, .unit = "range" },
342  { "full", "Full range", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_RANGE_JPEG }, 0, 0, FLAGS, .unit = "range" },
343  { "limited", "Limited range", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_RANGE_MPEG }, 0, 0, FLAGS, .unit = "range" },
344  { "jpeg", "Full range", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_RANGE_JPEG }, 0, 0, FLAGS, .unit = "range" },
345  { "mpeg", "Limited range", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_RANGE_MPEG }, 0, 0, FLAGS, .unit = "range" },
346  { "tv", "Limited range", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_RANGE_MPEG }, 0, 0, FLAGS, .unit = "range" },
347  { "pc", "Full range", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_RANGE_JPEG }, 0, 0, FLAGS, .unit = "range" },
348  { NULL },
349 };
350 
351 AVFILTER_DEFINE_CLASS(color_vulkan);
352 
354  {
355  .name = "default",
356  .type = AVMEDIA_TYPE_VIDEO,
357  .config_props = testsrc_vulkan_config_props,
358  },
359 };
360 
362  .name = "color_vulkan",
363  .description = NULL_IF_CONFIG_SMALL("Generate a constant color (Vulkan)"),
364  .priv_size = sizeof(TestSrcVulkanContext),
367  .inputs = NULL,
372  .priv_class = &color_vulkan_class,
373  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
374 };
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:116
TestSrcVulkanPushData::color_comp
float color_comp[4]
Definition: vsrc_testsrc_vulkan.c:35
r
const char * r
Definition: vf_curves.c:127
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
TestSrcVulkanContext::qf
FFVkQueueFamilyCtx qf
Definition: vsrc_testsrc_vulkan.c:43
ff_vk_shader_free
void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
Free a shader.
Definition: vulkan.c:2413
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:1564
testsrc_vulkan_uninit
static void testsrc_vulkan_uninit(AVFilterContext *avctx)
Definition: vsrc_testsrc_vulkan.c:305
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1062
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3025
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
RET
#define RET(x)
Definition: vulkan.h:67
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
ff_vk_filter_process_simple
int ff_vk_filter_process_simple(FFVulkanContext *vkctx, FFVkExecPool *e, FFVulkanShader *shd, 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:242
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
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:228
int64_t
long long int64_t
Definition: coverity.c:34
TestSrcVulkanContext::duration
int64_t duration
duration expressed in microseconds
Definition: vsrc_testsrc_vulkan.c:58
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
ff_vk_filter_init
int ff_vk_filter_init(AVFilterContext *avctx)
General lavfi IO functions.
Definition: vulkan_filter.c:233
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:696
av_csp_luma_coeffs_from_avcsp
const struct AVLumaCoefficients * av_csp_luma_coeffs_from_avcsp(enum AVColorSpace csp)
Retrieves the Luma coefficients necessary to construct a conversion matrix from an enum constant desc...
Definition: csp.c:58
AVOption
AVOption.
Definition: opt.h:429
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1639
rgb2yuv
static const char rgb2yuv[]
Definition: vf_scale_vulkan.c:69
TestSrcVulkanContext::w
int w
Definition: vsrc_testsrc_vulkan.c:51
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:620
TestSrcVulkanPushData
Definition: vsrc_testsrc_vulkan.c:34
AVLumaCoefficients
Struct containing luma coefficients to be used for RGB to YUV/YCoCg, or similar calculations.
Definition: csp.h:48
ff_vk_uninit
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition: vulkan.c:2452
init_filter
static av_cold int init_filter(AVFilterContext *ctx, enum TestSrcVulkanMode mode)
Definition: vsrc_testsrc_vulkan.c:65
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:205
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(color_vulkan)
video.h
TestSrcVulkanContext::pts
int64_t pts
Definition: vsrc_testsrc_vulkan.c:57
TestSrcVulkanContext::color_rgba
uint8_t color_rgba[4]
Definition: vsrc_testsrc_vulkan.c:47
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3065
COMMON_OPTS
#define COMMON_OPTS
Definition: vsrc_testsrc_vulkan.c:323
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:472
fail
#define fail()
Definition: checkasm.h:188
vulkan_filter.h
OFFSET
#define OFFSET(x)
Definition: vsrc_testsrc_vulkan.c:320
colorspace.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
FLAGS
#define FLAGS
Definition: vsrc_testsrc_vulkan.c:321
TestSrcVulkanContext::initialized
int initialized
Definition: vsrc_testsrc_vulkan.c:41
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:2053
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:1928
TestSrcVulkanContext::draw_once_reset
int draw_once_reset
draw only the first frame or in case of reset
Definition: vsrc_testsrc_vulkan.c:61
FFVulkanContext::frames_ref
AVBufferRef * frames_ref
Definition: vulkan.h:294
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
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:424
s
#define s(width, name)
Definition: cbs_vp9.c:198
TestSrcVulkanContext::out_format_string
char * out_format_string
Definition: vsrc_testsrc_vulkan.c:53
TestSrcVulkanContext::e
FFVkExecPool e
Definition: vsrc_testsrc_vulkan.c:42
TestSrcVulkanContext::out_range
enum AVColorRange out_range
Definition: vsrc_testsrc_vulkan.c:54
AVCOL_SPC_SMPTE170M
@ AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
Definition: pixfmt.h:626
TestSrcVulkanContext::picref
AVFrame * picref
cached reference containing the painted picture
Definition: vsrc_testsrc_vulkan.c:62
filters.h
FF_VK_REP_FLOAT
@ FF_VK_REP_FLOAT
Definition: vulkan.h:367
TestSrcVulkanContext::pw
int pw
Definition: vsrc_testsrc_vulkan.c:52
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:597
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
testsrc_vulkan_activate
static int testsrc_vulkan_activate(AVFilterContext *ctx)
Definition: vsrc_testsrc_vulkan.c:199
ff_matrix_mul_3x3_vec
void ff_matrix_mul_3x3_vec(double dst[3], const double vec[3], const double mat[3][3])
Definition: colorspace.c:66
ff_vk_exec_pool_free
void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
Definition: vulkan.c:238
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
if
if(ret)
Definition: filter_design.txt:179
ff_vsrc_color_vulkan
const AVFilter ff_vsrc_color_vulkan
Definition: vsrc_testsrc_vulkan.c:361
ff_vk_shader_rep_fmt
const char * ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt, enum FFVkShaderRepFormat rep_fmt)
Definition: vulkan.c:1290
TestSrcVulkanContext::opts
TestSrcVulkanPushData opts
Definition: vsrc_testsrc_vulkan.c:49
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
TestSrcVulkanContext::nb_frame
unsigned int nb_frame
Definition: vsrc_testsrc_vulkan.c:55
activate
filter_frame For filters that do not use the activate() callback
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Underlying C type is uint8_t[4].
Definition: opt.h:323
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
testsrc_vulkan_outputs
static const AVFilterPad testsrc_vulkan_outputs[]
Definition: vsrc_testsrc_vulkan.c:353
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:300
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
FFVulkanContext
Definition: vulkan.h:263
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:662
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
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
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
TestSrcVulkanContext::vkctx
FFVulkanContext vkctx
Definition: vsrc_testsrc_vulkan.c:39
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
AVFILTER_FLAG_HWDEVICE
#define AVFILTER_FLAG_HWDEVICE
The filter can create hardware frames using AVFilterContext.hw_device_ctx.
Definition: avfilter.h:173
FFVkQueueFamilyCtx
Definition: vulkan.h:102
FFVulkanShader
Definition: vulkan.h:179
FFVulkanContext::output_format
enum AVPixelFormat output_format
Definition: vulkan.h:304
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
TestSrcVulkanMode
TestSrcVulkanMode
Definition: vsrc_testsrc_vulkan.c:30
csp.h
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
FFVulkanDescriptorSetBinding::name
const char * name
Definition: vulkan.h:76
TestSrcVulkanContext::sar
AVRational sar
sample aspect ratio
Definition: vsrc_testsrc_vulkan.c:59
TestSrcVulkanContext::ph
int ph
Definition: vsrc_testsrc_vulkan.c:52
FFVkSPIRVCompiler
Definition: vulkan_spirv.h:26
TestSrcVulkanContext::frame_rate
AVRational frame_rate
Definition: vsrc_testsrc_vulkan.c:56
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
color_vulkan_options
static const AVOption color_vulkan_options[]
Definition: vsrc_testsrc_vulkan.c:337
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
ff_fill_rgb2yuv_table
void ff_fill_rgb2yuv_table(const AVLumaCoefficients *coeffs, double rgb2yuv[3][3])
Definition: colorspace.c:125
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:619
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:1853
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
vulkan_spirv.h
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:679
FFVkSPIRVCompiler::free_shader
void(* free_shader)(struct FFVkSPIRVCompiler *ctx, void **opaque)
Definition: vulkan_spirv.h:31
AVFilter
Filter definition.
Definition: avfilter.h:201
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
TestSrcVulkanContext::shd
FFVulkanShader shd
Definition: vsrc_testsrc_vulkan.c:44
FFVkExecPool
Definition: vulkan.h:241
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:1223
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2957
random_seed.h
GLSLF
#define GLSLF(N, S,...)
Definition: vulkan.h:54
mode
mode
Definition: ebur128.h:83
TestSrcVulkanContext
Definition: vsrc_testsrc_vulkan.c:38
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
TestSrcVulkanContext::draw_once
int draw_once
draw only the first frame, always put out the same picture
Definition: vsrc_testsrc_vulkan.c:60
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilterContext
An instance of a filter.
Definition: avfilter.h:457
TestSrcVulkanContext::h
int h
Definition: vsrc_testsrc_vulkan.c:51
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
testsrc_vulkan_config_props
static int testsrc_vulkan_config_props(AVFilterLink *outlink)
Definition: vsrc_testsrc_vulkan.c:264
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
TESTSRC_COLOR
@ TESTSRC_COLOR
Definition: vsrc_testsrc_vulkan.c:31
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:661
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
FILTER_SINGLE_PIXFMT
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
Definition: filters.h:252
planes
static const struct @458 planes[]
TestSrcVulkanContext::time_base
AVRational time_base
Definition: vsrc_testsrc_vulkan.c:56