FFmpeg
Loading...
Searching...
No Matches
vf_stack.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2015 Paul B. Mahol
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 "config_components.h"
22
23#include "libavutil/avstring.h"
24#include "libavutil/imgutils.h"
25#include "libavutil/mem.h"
26#include "libavutil/opt.h"
28#include "libavutil/pixdesc.h"
29
30#include "avfilter.h"
31#include "drawutils.h"
32#include "filters.h"
33#include "formats.h"
34#include "framesync.h"
35#include "video.h"
36
37typedef struct StackItem {
38 int x[4], y[4];
39 int linesize[4];
40 int height[4];
41} StackItem;
42
65
67 AVFilterFormatsConfig **cfg_in,
68 AVFilterFormatsConfig **cfg_out)
69{
70 const StackContext *s = ctx->priv;
71 int reject_flags = AV_PIX_FMT_FLAG_BITSTREAM |
74
75 if (s->fillcolor_enable) {
76 return ff_set_common_formats2(ctx, cfg_in, cfg_out,
78 }
79
80 return ff_set_common_formats2(ctx, cfg_in, cfg_out,
81 ff_formats_pixdesc_filter(0, reject_flags));
82}
83
85{
86 StackContext *s = ctx->priv;
87 int i, ret;
88
89 if (!strcmp(ctx->filter->name, "vstack"))
90 s->is_vertical = 1;
91
92 if (!strcmp(ctx->filter->name, "hstack"))
93 s->is_horizontal = 1;
94
95 if (!strcmp(ctx->filter->name, "xstack")) {
96 int is_grid;
97 if (strcmp(s->fillcolor_str, "none") &&
98 av_parse_color(s->fillcolor, s->fillcolor_str, -1, ctx) >= 0) {
99 s->fillcolor_enable = 1;
100 } else {
101 s->fillcolor_enable = 0;
102 }
103 is_grid = s->nb_grid_rows && s->nb_grid_columns;
104 if (s->layout && is_grid) {
105 av_log(ctx, AV_LOG_ERROR, "Both layout and grid were specified. Only one is allowed.\n");
106 return AVERROR(EINVAL);
107 }
108 if (!s->layout && !is_grid) {
109 if (s->nb_inputs == 2) {
110 s->nb_grid_rows = 1;
111 s->nb_grid_columns = 2;
112 is_grid = 1;
113 } else {
114 av_log(ctx, AV_LOG_ERROR, "No layout or grid specified.\n");
115 return AVERROR(EINVAL);
116 }
117 }
118
119 if (is_grid) {
120 if (s->nb_grid_rows > INT_MAX / s->nb_grid_columns)
121 return AVERROR(EINVAL);
122 s->nb_inputs = s->nb_grid_rows * s->nb_grid_columns;
123 }
124 }
125
126 s->frames = av_calloc(s->nb_inputs, sizeof(*s->frames));
127 if (!s->frames)
128 return AVERROR(ENOMEM);
129
130 s->items = av_calloc(s->nb_inputs, sizeof(*s->items));
131 if (!s->items)
132 return AVERROR(ENOMEM);
133
134 for (i = 0; i < s->nb_inputs; i++) {
135 AVFilterPad pad = { 0 };
136
138 pad.name = av_asprintf("input%d", i);
139 if (!pad.name)
140 return AVERROR(ENOMEM);
141
142 if ((ret = ff_append_inpad_free_name(ctx, &pad)) < 0)
143 return ret;
144 }
145
146 return 0;
147}
148
149static int process_slice(AVFilterContext *ctx, void *arg, int job, int nb_jobs)
150{
151 StackContext *s = ctx->priv;
152 AVFrame *out = arg;
153 AVFrame **in = s->frames;
154 const int start = ff_slice_pos(s->nb_inputs, job, nb_jobs);
155 const int end = ff_slice_pos(s->nb_inputs, job + 1, nb_jobs);
156
157 for (int i = start; i < end; i++) {
158 StackItem *item = &s->items[i];
159
160 for (int p = 0; p < s->nb_planes; p++) {
161 av_image_copy_plane(out->data[p] + out->linesize[p] * item->y[p] + item->x[p],
162 out->linesize[p],
163 in[i]->data[p],
164 in[i]->linesize[p],
165 item->linesize[p], item->height[p]);
166 }
167 }
168
169 return 0;
170}
171
173{
174 AVFilterContext *ctx = fs->parent;
175 AVFilterLink *outlink = ctx->outputs[0];
176 StackContext *s = fs->opaque;
177 AVFrame **in = s->frames;
178 AVFrame *out;
179 int i, ret;
180
181 for (i = 0; i < s->nb_inputs; i++) {
182 if ((ret = ff_framesync_get_frame(&s->fs, i, &in[i], 0)) < 0)
183 return ret;
184 }
185
186 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
187 if (!out)
188 return AVERROR(ENOMEM);
189 out->pts = av_rescale_q(s->fs.pts, s->fs.time_base, outlink->time_base);
190 out->sample_aspect_ratio = outlink->sample_aspect_ratio;
191
192 if (s->fillcolor_enable)
193 ff_fill_rectangle(&s->draw, &s->color, out->data, out->linesize,
194 0, 0, outlink->w, outlink->h);
195
197 FFMIN(s->nb_inputs, ff_filter_get_nb_threads(ctx)));
198
199 return ff_filter_frame(outlink, out);
200}
201
202static int config_output(AVFilterLink *outlink)
203{
204 AVFilterContext *ctx = outlink->src;
205 StackContext *s = ctx->priv;
206 FilterLink *il = ff_filter_link(ctx->inputs[0]);
207 FilterLink *ol = ff_filter_link(outlink);
208 AVRational frame_rate = il->frame_rate;
209 AVRational sar = ctx->inputs[0]->sample_aspect_ratio;
210 int height = ctx->inputs[0]->h;
211 int width = ctx->inputs[0]->w;
212 FFFrameSyncIn *in;
213 int i, ret;
214
215 s->desc = av_pix_fmt_desc_get(outlink->format);
216 if (!s->desc)
217 return AVERROR_BUG;
218
219 if (s->is_vertical) {
220 for (i = 0; i < s->nb_inputs; i++) {
221 AVFilterLink *inlink = ctx->inputs[i];
222 StackItem *item = &s->items[i];
223
224 if (ctx->inputs[i]->w != width) {
225 av_log(ctx, AV_LOG_ERROR, "Input %d width %d does not match input %d width %d.\n", i, ctx->inputs[i]->w, 0, width);
226 return AVERROR(EINVAL);
227 }
228
229 if ((ret = av_image_fill_linesizes(item->linesize, inlink->format, inlink->w)) < 0) {
230 return ret;
231 }
232
233 item->height[1] = item->height[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
234 item->height[0] = item->height[3] = inlink->h;
235
236 if (i) {
237 item->y[1] = item->y[2] = AV_CEIL_RSHIFT(height, s->desc->log2_chroma_h);
238 item->y[0] = item->y[3] = height;
239
240 if (height > INT_MAX - ctx->inputs[i]->h)
241 return AVERROR(EINVAL);
242 height += ctx->inputs[i]->h;
243 }
244 }
245 } else if (s->is_horizontal) {
246 for (i = 0; i < s->nb_inputs; i++) {
247 AVFilterLink *inlink = ctx->inputs[i];
248 StackItem *item = &s->items[i];
249
250 if (ctx->inputs[i]->h != height) {
251 av_log(ctx, AV_LOG_ERROR, "Input %d height %d does not match input %d height %d.\n", i, ctx->inputs[i]->h, 0, height);
252 return AVERROR(EINVAL);
253 }
254
255 if ((ret = av_image_fill_linesizes(item->linesize, inlink->format, inlink->w)) < 0) {
256 return ret;
257 }
258
259 item->height[1] = item->height[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
260 item->height[0] = item->height[3] = inlink->h;
261
262 if (i) {
263 if ((ret = av_image_fill_linesizes(item->x, inlink->format, width)) < 0) {
264 return ret;
265 }
266
267 if (width > INT_MAX - ctx->inputs[i]->w)
268 return AVERROR(EINVAL);
269 width += ctx->inputs[i]->w;
270 }
271 }
272 } else if (s->nb_grid_rows && s->nb_grid_columns) {
273 int inw = 0, inh = 0;
274 int k = 0;
275 int row_height;
276 height = 0;
277 width = 0;
278 for (i = 0; i < s->nb_grid_rows; i++, inh += row_height) {
279 row_height = ctx->inputs[i * s->nb_grid_columns]->h;
280 inw = 0;
281 for (int j = 0; j < s->nb_grid_columns; j++, k++) {
282 AVFilterLink *inlink = ctx->inputs[k];
283 StackItem *item = &s->items[k];
284
285 if (ctx->inputs[k]->h != row_height) {
286 av_log(ctx, AV_LOG_ERROR, "Input %d height %d does not match current row's height %d.\n",
287 k, ctx->inputs[k]->h, row_height);
288 return AVERROR(EINVAL);
289 }
290
291 if ((ret = av_image_fill_linesizes(item->linesize, inlink->format, inlink->w)) < 0) {
292 return ret;
293 }
294
295 item->height[1] = item->height[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
296 item->height[0] = item->height[3] = inlink->h;
297
298 if ((ret = av_image_fill_linesizes(item->x, inlink->format, inw)) < 0) {
299 return ret;
300 }
301
302 item->y[1] = item->y[2] = AV_CEIL_RSHIFT(inh, s->desc->log2_chroma_h);
303 item->y[0] = item->y[3] = inh;
304
305 if (inw > INT_MAX - ctx->inputs[k]->w)
306 return AVERROR(EINVAL);
307 inw += ctx->inputs[k]->w;
308 }
309 if (height > INT_MAX - row_height)
310 return AVERROR(EINVAL);
311 height += row_height;
312 if (!i)
313 width = inw;
314 if (i && width != inw) {
315 av_log(ctx, AV_LOG_ERROR, "Row %d width %d does not match previous row width %d.\n", i, inw, width);
316 return AVERROR(EINVAL);
317 }
318 }
319 } else {
320 char *arg, *p = s->layout, *saveptr = NULL;
321 char *arg2, *p2, *saveptr2 = NULL;
322 char *arg3, *p3, *saveptr3 = NULL;
323 int inw, inh, size;
324
325 if (s->fillcolor_enable) {
326 const AVFilterLink *inlink = ctx->inputs[0];
327 ret = ff_draw_init_from_link(&s->draw, inlink, 0);
328 if (ret < 0) {
329 av_log(ctx, AV_LOG_ERROR, "Failed to initialize FFDrawContext\n");
330 return ret;
331 }
332 ff_draw_color(&s->draw, &s->color, s->fillcolor);
333 }
334
335 for (i = 0; i < s->nb_inputs; i++) {
336 AVFilterLink *inlink = ctx->inputs[i];
337 StackItem *item = &s->items[i];
338
339 if (!(arg = av_strtok(p, "|", &saveptr)))
340 return AVERROR(EINVAL);
341
342 p = NULL;
343
344 if ((ret = av_image_fill_linesizes(item->linesize, inlink->format, inlink->w)) < 0) {
345 return ret;
346 }
347
348 item->height[1] = item->height[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
349 item->height[0] = item->height[3] = inlink->h;
350
351 p2 = arg;
352 inw = inh = 0;
353
354 for (int j = 0; j < 2; j++) {
355 if (!(arg2 = av_strtok(p2, "_", &saveptr2)))
356 return AVERROR(EINVAL);
357
358 p2 = NULL;
359 p3 = arg2;
360 while ((arg3 = av_strtok(p3, "+", &saveptr3))) {
361 p3 = NULL;
362 if (sscanf(arg3, "w%d", &size) == 1) {
363 if (size == i || size < 0 || size >= s->nb_inputs)
364 return AVERROR(EINVAL);
365
366 if (!j) {
367 if (inw > INT_MAX - ctx->inputs[size]->w)
368 return AVERROR(EINVAL);
369 inw += ctx->inputs[size]->w;
370 } else {
371 if (inh > INT_MAX - ctx->inputs[size]->w)
372 return AVERROR(EINVAL);
373 inh += ctx->inputs[size]->w;
374 }
375 } else if (sscanf(arg3, "h%d", &size) == 1) {
376 if (size == i || size < 0 || size >= s->nb_inputs)
377 return AVERROR(EINVAL);
378
379 if (!j) {
380 if (inw > INT_MAX - ctx->inputs[size]->h)
381 return AVERROR(EINVAL);
382 inw += ctx->inputs[size]->h;
383 } else {
384 if (inh > INT_MAX - ctx->inputs[size]->h)
385 return AVERROR(EINVAL);
386 inh += ctx->inputs[size]->h;
387 }
388 } else if (sscanf(arg3, "%d", &size) == 1) {
389 if (size < 0)
390 return AVERROR(EINVAL);
391
392 if (!j) {
393 if (inw > INT_MAX - size)
394 return AVERROR(EINVAL);
395 inw += size;
396 } else {
397 if (inh > INT_MAX - size)
398 return AVERROR(EINVAL);
399 inh += size;
400 }
401 } else {
402 return AVERROR(EINVAL);
403 }
404 }
405 }
406
407 if ((ret = av_image_fill_linesizes(item->x, inlink->format, inw)) < 0) {
408 return ret;
409 }
410
411 item->y[1] = item->y[2] = AV_CEIL_RSHIFT(inh, s->desc->log2_chroma_h);
412 item->y[0] = item->y[3] = inh;
413
414 if (inlink->w > INT_MAX - inw || inlink->h > INT_MAX - inh)
415 return AVERROR(EINVAL);
416 width = FFMAX(width, inlink->w + inw);
417 height = FFMAX(height, inlink->h + inh);
418 }
419 }
420
421 s->nb_planes = av_pix_fmt_count_planes(outlink->format);
422
423 outlink->w = width;
424 outlink->h = height;
425 ol->frame_rate = frame_rate;
426 outlink->sample_aspect_ratio = sar;
427
428 for (i = 1; i < s->nb_inputs; i++) {
429 il = ff_filter_link(ctx->inputs[i]);
430 if (ol->frame_rate.num != il->frame_rate.num ||
431 ol->frame_rate.den != il->frame_rate.den) {
433 "Video inputs have different frame rates, output will be VFR\n");
434 ol->frame_rate = av_make_q(1, 0);
435 break;
436 }
437 }
438
439 if ((ret = ff_framesync_init(&s->fs, ctx, s->nb_inputs)) < 0)
440 return ret;
441
442 in = s->fs.in;
443 s->fs.opaque = s;
444 s->fs.on_event = process_frame;
445
446 for (i = 0; i < s->nb_inputs; i++) {
447 AVFilterLink *inlink = ctx->inputs[i];
448
449 in[i].time_base = inlink->time_base;
450 in[i].sync = 1;
451 in[i].before = EXT_STOP;
452 in[i].after = s->shortest ? EXT_STOP : EXT_INFINITY;
453 }
454
456 outlink->time_base = s->fs.time_base;
457
458 return ret;
459}
460
462{
463 StackContext *s = ctx->priv;
464
466 av_freep(&s->frames);
467 av_freep(&s->items);
468}
469
471{
472 StackContext *s = ctx->priv;
473 return ff_framesync_activate(&s->fs);
474}
475
476#define OFFSET(x) offsetof(StackContext, x)
477#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
478static const AVOption stack_options[] = {
479 { "inputs", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64=2}, 2, INT_MAX, .flags = FLAGS },
480 { "shortest", "force termination when the shortest input terminates", OFFSET(shortest), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, .flags = FLAGS },
481 { NULL },
482};
483
485
486static const AVFilterPad outputs[] = {
487 {
488 .name = "default",
489 .type = AVMEDIA_TYPE_VIDEO,
490 .config_props = config_output,
491 },
492};
493
494#if CONFIG_HSTACK_FILTER
495
496const FFFilter ff_vf_hstack = {
497 .p.name = "hstack",
498 .p.description = NULL_IF_CONFIG_SMALL("Stack video inputs horizontally."),
499 .p.priv_class = &stack_class,
501 .priv_size = sizeof(StackContext),
504 .init = init,
505 .uninit = uninit,
506 .activate = activate,
507};
508
509#endif /* CONFIG_HSTACK_FILTER */
510
511#if CONFIG_VSTACK_FILTER
512
513const FFFilter ff_vf_vstack = {
514 .p.name = "vstack",
515 .p.description = NULL_IF_CONFIG_SMALL("Stack video inputs vertically."),
516 .p.priv_class = &stack_class,
518 .priv_size = sizeof(StackContext),
521 .init = init,
522 .uninit = uninit,
523 .activate = activate,
524};
525
526#endif /* CONFIG_VSTACK_FILTER */
527
528#if CONFIG_XSTACK_FILTER
529
530static const AVOption xstack_options[] = {
531 { "inputs", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64=2}, 2, INT_MAX, .flags = FLAGS },
532 { "layout", "set custom layout", OFFSET(layout), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, .flags = FLAGS },
533 { "grid", "set fixed size grid layout", OFFSET(nb_grid_columns), AV_OPT_TYPE_IMAGE_SIZE, {.str=NULL}, 0, 0, .flags = FLAGS },
534 { "shortest", "force termination when the shortest input terminates", OFFSET(shortest), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, .flags = FLAGS },
535 { "fill", "set the color for unused pixels", OFFSET(fillcolor_str), AV_OPT_TYPE_STRING, {.str = "none"}, .flags = FLAGS },
536 { NULL },
537};
538
540
541const FFFilter ff_vf_xstack = {
542 .p.name = "xstack",
543 .p.description = NULL_IF_CONFIG_SMALL("Stack video inputs into custom layout."),
544 .p.priv_class = &xstack_class,
546 .priv_size = sizeof(StackContext),
549 .init = init,
550 .uninit = uninit,
551 .activate = activate,
552};
553
554#endif /* CONFIG_XSTACK_FILTER */
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition aeval.c:246
static const AVFilterPad outputs[]
Definition af_aap.c:310
const FFFilter ff_vf_hstack
const FFFilter ff_vf_vstack
const FFFilter ff_vf_xstack
static FILE * out
static AVFormatContext * ctx
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition avfilter.c:132
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition avfilter.c:1112
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition avfilter.c:1754
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition avfilter.c:890
Main libavfilter public API header.
char * av_asprintf(const char *fmt,...)
Definition avstring.c:115
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define s(width, name)
Definition cbs_vp9.c:198
#define fs(width, name, subs,...)
Definition cbs_vp9.c:200
#define FLAGS
Definition cmdutils.c:596
#define AV_CEIL_RSHIFT(a, b)
Definition common.h:60
#define NULL
Definition coverity.c:32
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition drawutils.c:179
AVFilterFormats * ff_draw_supported_pixel_formats(unsigned flags)
Return the list of pixel formats supported by the draw functions.
Definition drawutils.c:688
void ff_fill_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_x, int dst_y, int w, int h)
Fill a rectangle with an uniform color.
Definition drawutils.c:258
int ff_draw_init_from_link(FFDrawContext *draw, const AVFilterLink *link, unsigned flags)
Init a draw context, taking the format, colorspace and range from the given filter link.
Definition drawutils.c:168
misc drawing utilities
int(* init)(AVBSFContext *ctx)
Definition dts2pts.c:613
int ret
Definition ffplay.c:391
static av_always_inline int process_frame(AVTextFormatContext *tfc, InputFile *ifile, AVFrame *frame, const AVPacket *pkt, int *packet_new)
Definition ffprobe.c:1713
int ff_set_common_formats2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *formats)
Definition formats.c:1200
AVFilterFormats * ff_formats_pixdesc_filter(unsigned want, unsigned rej)
Construct a formats list containing all pixel formats with certain properties.
Definition formats.c:629
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
Definition framesync.c:137
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
Definition framesync.c:352
int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe, unsigned get)
Get the current frame in an input.
Definition framesync.c:269
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
Definition framesync.c:301
int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in)
Initialize a frame sync structure.
Definition framesync.c:86
@ EXT_INFINITY
Extend the frame to infinity.
Definition framesync.h:75
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
Definition opt.h:302
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition opt.h:258
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition opt.h:326
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition opt.h:275
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition avfilter.h:172
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition avfilter.h:161
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition error.h:52
#define AVERROR(e)
Definition error.h:45
#define AV_LOG_VERBOSE
Detailed information.
Definition log.h:226
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition rational.h:71
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition imgutils.c:374
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition imgutils.c:89
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition avstring.c:179
misc image utilities
static av_cold void uninit(AVBitStreamFilterContext *ctx)
static int activate(AVBitStreamFilterContext *ctx)
static int config_output(AVBitStreamFilterLink *outlink)
const char * arg
Definition jacosubdec.c:66
#define FILTER_OUTPUTS(array)
Definition filters.h:280
static int ff_slice_pos(int total, int jobnr, int nb_jobs)
Compute the boundary index for a slice when work of size total is split into nb_jobs slices.
Definition filters.h:813
#define AVFILTER_DEFINE_CLASS_EXT(name, desc, options)
Definition filters.h:485
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition filters.h:199
#define AVFILTER_DEFINE_CLASS(fname)
Definition filters.h:493
#define FILTER_QUERY_FUNC2(func)
Definition filters.h:256
#define av_cold
Definition attributes.h:117
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition internal.h:97
#define FFMIN(a, b)
Definition macros.h:49
#define FFMAX(a, b)
Definition macros.h:47
uint64_t layout
void * av_calloc(size_t nmemb, size_t size)
Definition mem.c:370
Memory handling functions.
AVOptions.
@ EXT_STOP
Completely stop all streams with this one.
Definition packetsync.h:62
int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, void *log_ctx)
Put the RGBA values that correspond to color_string in rgba_color.
Definition parseutils.c:359
misc parsing utilities
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3524
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3484
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition pixdesc.h:124
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition pixdesc.h:128
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition pixdesc.h:120
Describe the class of an AVClass context structure.
Definition log.h:76
An instance of a filter.
Definition avfilter.h:279
Lists of formats / etc.
Definition avfilter.h:120
A filter pad used for either input or output.
Definition filters.h:40
enum AVMediaType type
AVFilterPad type.
Definition filters.h:51
const char * name
Pad name.
Definition filters.h:46
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition frame.h:500
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition frame.h:524
AVOption.
Definition opt.h:428
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition pixdesc.h:69
Rational number (pair of numerator and denominator).
Definition rational.h:58
int num
Numerator.
Definition rational.h:59
int den
Denominator.
Definition rational.h:60
Input stream structure.
Definition framesync.h:102
enum FFFrameSyncExtMode after
Extrapolation mode for timestamps after the last frame.
Definition framesync.h:112
enum FFFrameSyncExtMode before
Extrapolation mode for timestamps before the first frame.
Definition framesync.h:107
AVRational time_base
Time base for the incoming frames.
Definition framesync.h:117
unsigned sync
Synchronization level: frames on input at the highest sync level will generate output frame events.
Definition framesync.h:160
Frame sync structure.
Definition framesync.h:168
uint8_t fillcolor[4]
Definition vf_stack.c:54
const AVPixFmtDescriptor * desc
Definition vf_stack.c:45
char * layout
Definition vf_stack.c:47
FFDrawContext draw
Definition vf_stack.c:58
int nb_grid_rows
Definition vf_stack.c:53
AVFrame ** frames
Definition vf_stack.c:62
FFFrameSync fs
Definition vf_stack.c:63
int is_horizontal
Definition vf_stack.c:50
FFDrawColor color
Definition vf_stack.c:59
int fillcolor_enable
Definition vf_stack.c:56
int nb_grid_columns
Definition vf_stack.c:52
char * fillcolor_str
Definition vf_stack.c:55
int is_vertical
Definition vf_stack.c:49
int nb_inputs
Definition vf_stack.c:46
int nb_planes
Definition vf_stack.c:51
StackItem * items
Definition vf_stack.c:61
int linesize[4]
Definition vf_stack.c:39
int height[4]
Definition vf_stack.c:40
int x[4]
Definition vf_stack.c:38
int y[4]
Definition vf_stack.c:38
#define av_freep(p)
#define av_log(a,...)
#define height
Definition dsp.h:99
#define width
Definition dsp.h:99
int size
static const AVOption stack_options[]
Definition vf_stack.c:478
static int process_slice(AVFilterContext *ctx, void *arg, int job, int nb_jobs)
Definition vf_stack.c:149
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition vf_stack.c:66
static int activate(AVFilterContext *ctx)
Definition vf_stack.c:470
static av_cold void uninit(AVFilterContext *ctx)
Definition vf_stack.c:461
#define OFFSET(x)
Definition vf_stack.c:476
static int config_output(AVFilterLink *outlink)
Definition vf_stack.c:202
static int process_frame(FFFrameSync *fs)
Definition vf_stack.c:172
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition video.c:120