History

avfilter: add VA-API variants of the stack filters

Include hstack_vaapi, vstack_vaapi and xstack_vaapi. They may accept input streams with different sizes. libva2 (VA-API 1.0+) is required. Example: $ ffmpeg -hwaccel vaapi -hwaccel_output_format vaapi -i input.h265 -filter_complex "[0:v][0:v]hstack_vaapi" -c:v h264_vaapi out.h264 $ ffmpeg \ -hwaccel vaapi -hwaccel_output_format vaapi -i input.h264 \ -hwaccel vaapi -hwaccel_output_format vaapi -i input.h264 \ -hwaccel vaapi -hwaccel_output_format vaapi -i input.h264 \ -hwaccel vaapi -hwaccel_output_format vaapi -i input.h264 \ -filter_complex "[0:v][1:v][2:v][3:v]xstack_vaapi=inputs=4:fill=0x000000:layout=0_0_1920x1080|w0_0_1920x1080|0_h0_1920x1080|w0_h0_1920x1080" \ -c:v hevc_vaapi out.h265

Haihao Xiang committed 3 years ago

Commit aecfec61 parent 4e3b6277 files · +666 −1Browse files

Showing the changes to libavfilter (4 of 7 files). Show all

Unified · Split

4 files
  1. libavfilter/Makefile +3 −0
  2. libavfilter/allfilters.c +3 −0
  3. libavfilter/version.h +1 −1
  4. libavfilter/vf_stack_vaapi.c +574 −0
libavfilter/Makefile+3−0
@@ -558,6 +558,9 @@ OBJS-$(CONFIG_YAEPBLUR_FILTER) += vf_yaepblur.o · 557 unmodified lines
558558 OBJS-$(CONFIG_ZMQ_FILTER) += f_zmq.o
559559 OBJS-$(CONFIG_ZOOMPAN_FILTER) += vf_zoompan.o
560560 OBJS-$(CONFIG_ZSCALE_FILTER) += vf_zscale.o
561+OBJS-$(CONFIG_HSTACK_VAAPI_FILTER) += vf_stack_vaapi.o framesync.o vaapi_vpp.o
562+OBJS-$(CONFIG_VSTACK_VAAPI_FILTER) += vf_stack_vaapi.o framesync.o vaapi_vpp.o
563+OBJS-$(CONFIG_XSTACK_VAAPI_FILTER) += vf_stack_vaapi.o framesync.o vaapi_vpp.o
561564
562565 OBJS-$(CONFIG_ALLRGB_FILTER) += vsrc_testsrc.o
563566 OBJS-$(CONFIG_ALLYUV_FILTER) += vsrc_testsrc.o
libavfilter/allfilters.c+3−0
@@ -523,6 +523,9 @@ extern const AVFilter ff_vf_yaepblur; · 522 unmodified lines
523523 extern const AVFilter ff_vf_zmq;
524524 extern const AVFilter ff_vf_zoompan;
525525 extern const AVFilter ff_vf_zscale;
526+extern const AVFilter ff_vf_hstack_vaapi;
527+extern const AVFilter ff_vf_vstack_vaapi;
528+extern const AVFilter ff_vf_xstack_vaapi;
526529
527530 extern const AVFilter ff_vsrc_allrgb;
528531 extern const AVFilter ff_vsrc_allyuv;
libavfilter/version.h+1−1
@@ -31,7 +31,7 @@ · 30 unmodified lines
3131
3232 #include "version_major.h"
3333
34−#define LIBAVFILTER_VERSION_MINOR 55
34+#define LIBAVFILTER_VERSION_MINOR 56
3535 #define LIBAVFILTER_VERSION_MICRO 100
3636
3737
libavfilter/vf_stack_vaapi.c+574−0
@@ -0,0 +1,574 @@
1+/*
2+ * This file is part of FFmpeg.
3+ *
4+ * FFmpeg is free software; you can redistribute it and/or
5+ * modify it under the terms of the GNU Lesser General Public
6+ * License as published by the Free Software Foundation; either
7+ * version 2.1 of the License, or (at your option) any later version.
8+ *
9+ * FFmpeg is distributed in the hope that it will be useful,
10+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
11+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12+ * Lesser General Public License for more details.
13+ *
14+ * You should have received a copy of the GNU Lesser General Public
15+ * License along with FFmpeg; if not, write to the Free Software
16+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17+ */
18+
19+/**
20+ * @file
21+ * Hardware accelerated hstack, vstack and xstack filters based on VA-API
22+ */
23+
24+#include "config_components.h"
25+
26+#include "libavutil/opt.h"
27+#include "libavutil/common.h"
28+#include "libavutil/pixdesc.h"
29+#include "libavutil/eval.h"
30+#include "libavutil/hwcontext.h"
31+#include "libavutil/avstring.h"
32+#include "libavutil/avassert.h"
33+#include "libavutil/imgutils.h"
34+#include "libavutil/mathematics.h"
35+#include "libavutil/parseutils.h"
36+#include "libavutil/mem.h"
37+
38+#include "internal.h"
39+#include "filters.h"
40+#include "formats.h"
41+#include "video.h"
42+#include "framesync.h"
43+#include "vaapi_vpp.h"
44+
45+#define OFFSET(x) offsetof(StackVAAPIContext, x)
46+#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
47+
48+enum {
49+ STACK_VAAPI_H = 0,
50+ STACK_VAAPI_V = 1,
51+ STACK_VAAPI_X = 2
52+};
53+
54+typedef struct StackVAAPIContext {
55+ VAAPIVPPContext vppctx; /**< must be the first field */
56+
57+ FFFrameSync fs;
58+ int mode;
59+ VARectangle *rects;
60+ uint8_t fillcolor[4];
61+ int fillcolor_enable;
62+
63+ /* Options */
64+ int nb_inputs;
65+ int shortest;
66+ int tile_width;
67+ int tile_height;
68+ int nb_grid_columns;
69+ int nb_grid_rows;
70+ char *layout;
71+ char *fillcolor_str;
72+} StackVAAPIContext;
73+
74+static int process_frame(FFFrameSync *fs)
75+{
76+ AVFilterContext *avctx = fs->parent;
77+ AVFilterLink *outlink = avctx->outputs[0];
78+ StackVAAPIContext *sctx = fs->opaque;
79+ VAAPIVPPContext *vppctx = fs->opaque;
80+ AVFrame *oframe, *iframe;
81+ VAProcPipelineParameterBuffer *params = NULL;
82+ VARectangle *irect = NULL;
83+ int ret = 0;
84+
85+ if (vppctx->va_context == VA_INVALID_ID)
86+ return AVERROR(EINVAL);
87+
88+ oframe = ff_get_video_buffer(outlink, outlink->w, outlink->h);
89+ if (!oframe)
90+ return AVERROR(ENOMEM);
91+
92+ irect = av_calloc(avctx->nb_inputs, sizeof(*irect));
93+ params = av_calloc(avctx->nb_inputs, sizeof(*params));
94+ if (!irect || !params) {
95+ ret = AVERROR(ENOMEM);
96+ goto fail;
97+ }
98+
99+ for (int i = 0; i < avctx->nb_inputs; i++) {
100+ ret = ff_framesync_get_frame(fs, i, &iframe, 0);
101+ if (ret)
102+ goto fail;
103+
104+ if (i == 0) {
105+ ret = av_frame_copy_props(oframe, iframe);
106+ if (ret < 0)
107+ goto fail;
108+ }
109+
110+ ret = ff_vaapi_vpp_init_params(avctx, &params[i], iframe, oframe);
111+ if (ret)
112+ goto fail;
113+
114+ av_log(avctx, AV_LOG_DEBUG, "stack input %d: %s, %ux%u (%"PRId64").\n",
115+ i, av_get_pix_fmt_name(iframe->format),
116+ iframe->width, iframe->height, iframe->pts);
117+ irect[i].x = 0;
118+ irect[i].y = 0;
119+ irect[i].width = iframe->width;
120+ irect[i].height = iframe->height;
121+ params[i].surface_region = &irect[i];
122+ params[i].surface = (VASurfaceID)(uintptr_t)iframe->data[3];
123+ params[i].output_region = &sctx->rects[i];
124+
125+ if (sctx->fillcolor_enable)
126+ params[i].output_background_color = (sctx->fillcolor[3] << 24 |
127+ sctx->fillcolor[0] << 16 |
128+ sctx->fillcolor[1] << 8 |
129+ sctx->fillcolor[2]);
130+ }
131+
132+ oframe->pts = av_rescale_q(sctx->fs.pts, sctx->fs.time_base, outlink->time_base);
133+ oframe->sample_aspect_ratio = outlink->sample_aspect_ratio;
134+
135+ ret = ff_vaapi_vpp_render_pictures(avctx, params, avctx->nb_inputs, oframe);
136+ if (ret)
137+ goto fail;
138+
139+ av_freep(&irect);
140+ av_freep(&params);
141+ return ff_filter_frame(outlink, oframe);
142+
143+fail:
144+ av_freep(&irect);
145+ av_freep(&params);
146+ av_frame_free(&oframe);
147+ return ret;
148+}
149+
150+static int init_framesync(AVFilterContext *avctx)
151+{
152+ StackVAAPIContext *sctx = avctx->priv;
153+ int ret;
154+
155+ ret = ff_framesync_init(&sctx->fs, avctx, avctx->nb_inputs);
156+ if (ret < 0)
157+ return ret;
158+
159+ sctx->fs.on_event = process_frame;
160+ sctx->fs.opaque = sctx;
161+
162+ for (int i = 0; i < sctx->nb_inputs; i++) {
163+ FFFrameSyncIn *in = &sctx->fs.in[i];
164+
165+ in->before = EXT_STOP;
166+ in->after = sctx->shortest ? EXT_STOP : EXT_INFINITY;
167+ in->sync = 1;
168+ in->time_base = avctx->inputs[i]->time_base;
169+ }
170+
171+ return ff_framesync_configure(&sctx->fs);
172+}
173+
174+#define SET_INPUT_REGION(rect, rx, ry, rw, rh) do { \
175+ rect->x = rx; \
176+ rect->y = ry; \
177+ rect->width = rw; \
178+ rect->height = rh; \
179+ } while (0)
180+
181+static int config_output(AVFilterLink *outlink)
182+{
183+ AVFilterContext *avctx = outlink->src;
184+ StackVAAPIContext *sctx = avctx->priv;
185+ VAAPIVPPContext *vppctx = avctx->priv;
186+ AVFilterLink *inlink0 = avctx->inputs[0];
187+ AVHWFramesContext *hwfc0 = NULL;
188+ int width, height, ret;
189+
190+ if (inlink0->format != AV_PIX_FMT_VAAPI || !inlink0->hw_frames_ctx || !inlink0->hw_frames_ctx->data) {
191+ av_log(avctx, AV_LOG_ERROR, "Software pixel format is not supported.\n");
192+ return AVERROR(EINVAL);
193+ }
194+
195+ hwfc0 = (AVHWFramesContext *)inlink0->hw_frames_ctx->data;
196+
197+ for (int i = 1; i < sctx->nb_inputs; i++) {
198+ AVFilterLink *inlink = avctx->inputs[i];
199+ AVHWFramesContext *hwfc = NULL;
200+
201+ if (inlink->format != AV_PIX_FMT_VAAPI || !inlink->hw_frames_ctx || !inlink->hw_frames_ctx->data) {
202+ av_log(avctx, AV_LOG_ERROR, "Software pixel format is not supported.\n");
203+ return AVERROR(EINVAL);
204+ }
205+
206+ hwfc = (AVHWFramesContext *)inlink->hw_frames_ctx->data;
207+
208+ if (hwfc0->sw_format != hwfc->sw_format) {
209+ av_log(avctx, AV_LOG_ERROR, "All inputs should have the same underlying software pixel format.\n");
210+ return AVERROR(EINVAL);
211+ }
212+
213+ if (hwfc0->device_ctx != hwfc->device_ctx) {
214+ av_log(avctx, AV_LOG_ERROR, "All inputs should have the same underlying vaapi devices.\n");
215+ return AVERROR(EINVAL);
216+ }
217+ }
218+
219+ ff_vaapi_vpp_config_input(inlink0);
220+ vppctx->output_format = hwfc0->sw_format;
221+
222+ if (sctx->mode == STACK_VAAPI_H) {
223+ height = sctx->tile_height;
224+ width = 0;
225+
226+ if (!height)
227+ height = inlink0->h;
228+
229+ for (int i = 0; i < sctx->nb_inputs; i++) {
230+ AVFilterLink *inlink = avctx->inputs[i];
231+ VARectangle *rect = &sctx->rects[i];
232+
233+ SET_INPUT_REGION(rect, width, 0, av_rescale(height, inlink->w, inlink->h), height);
234+ width += av_rescale(height, inlink->w, inlink->h);
235+ }
236+ } else if (sctx->mode == STACK_VAAPI_V) {
237+ height = 0;
238+ width = sctx->tile_width;
239+
240+ if (!width)
241+ width = inlink0->w;
242+
243+ for (int i = 0; i < sctx->nb_inputs; i++) {
244+ AVFilterLink *inlink = avctx->inputs[i];
245+ VARectangle *rect = &sctx->rects[i];
246+
247+ SET_INPUT_REGION(rect, 0, height, width, av_rescale(width, inlink->h, inlink->w));
248+ height += av_rescale(width, inlink->h, inlink->w);
249+ }
250+ } else if (sctx->nb_grid_rows && sctx->nb_grid_columns) {
251+ int xpos = 0, ypos = 0;
252+ int ow, oh, k = 0;
253+
254+ ow = sctx->tile_width;
255+ oh = sctx->tile_height;
256+
257+ if (!ow || !oh) {
258+ ow = avctx->inputs[0]->w;
259+ oh = avctx->inputs[0]->h;
260+ }
261+
262+ for (int i = 0; i < sctx->nb_grid_columns; i++) {
263+ ypos = 0;
264+
265+ for (int j = 0; j < sctx->nb_grid_rows; j++) {
266+ VARectangle *rect = &sctx->rects[k++];
267+
268+ SET_INPUT_REGION(rect, xpos, ypos, ow, oh);
269+ ypos += oh;
270+ }
271+
272+ xpos += ow;
273+ }
274+
275+ width = ow * sctx->nb_grid_columns;
276+ height = oh * sctx->nb_grid_rows;
277+ } else {
278+ char *arg, *p = sctx->layout, *saveptr = NULL;
279+ char *arg2, *p2, *saveptr2 = NULL;
280+ char *arg3, *p3, *saveptr3 = NULL;
281+ int xpos, ypos, size;
282+ int ow, oh;
283+
284+ width = avctx->inputs[0]->w;
285+ height = avctx->inputs[0]->h;
286+
287+ for (int i = 0; i < sctx->nb_inputs; i++) {
288+ AVFilterLink *inlink = avctx->inputs[i];
289+ VARectangle *rect = &sctx->rects[i];
290+
291+ ow = inlink->w;
292+ oh = inlink->h;
293+
294+ if (!(arg = av_strtok(p, "|", &saveptr)))
295+ return AVERROR(EINVAL);
296+
297+ p = NULL;
298+ p2 = arg;
299+ xpos = ypos = 0;
300+
301+ for (int j = 0; j < 3; j++) {
302+ if (!(arg2 = av_strtok(p2, "_", &saveptr2))) {
303+ if (j == 2)
304+ break;
305+ else
306+ return AVERROR(EINVAL);
307+ }
308+
309+ p2 = NULL;
310+ p3 = arg2;
311+
312+ if (j == 2) {
313+ if ((ret = av_parse_video_size(&ow, &oh, p3)) < 0) {
314+ av_log(avctx, AV_LOG_ERROR, "Invalid size '%s'\n", p3);
315+ return ret;
316+ }
317+
318+ break;
319+ }
320+
321+ while ((arg3 = av_strtok(p3, "+", &saveptr3))) {
322+ p3 = NULL;
323+ if (sscanf(arg3, "w%d", &size) == 1) {
324+ if (size == i || size < 0 || size >= sctx->nb_inputs)
325+ return AVERROR(EINVAL);
326+
327+ if (!j)
328+ xpos += sctx->rects[size].width;
329+ else
330+ ypos += sctx->rects[size].width;
331+ } else if (sscanf(arg3, "h%d", &size) == 1) {
332+ if (size == i || size < 0 || size >= sctx->nb_inputs)
333+ return AVERROR(EINVAL);
334+
335+ if (!j)
336+ xpos += sctx->rects[size].height;
337+ else
338+ ypos += sctx->rects[size].height;
339+ } else if (sscanf(arg3, "%d", &size) == 1) {
340+ if (size < 0)
341+ return AVERROR(EINVAL);
342+
343+ if (!j)
344+ xpos += size;
345+ else
346+ ypos += size;
347+ } else {
348+ return AVERROR(EINVAL);
349+ }
350+ }
351+ }
352+
353+ SET_INPUT_REGION(rect, xpos, ypos, ow, oh);
354+ width = FFMAX(width, xpos + ow);
355+ height = FFMAX(height, ypos + oh);
356+ }
357+
358+ }
359+
360+ outlink->w = width;
361+ outlink->h = height;
362+ outlink->frame_rate = inlink0->frame_rate;
363+ outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
364+
365+ for (int i = 1; i < sctx->nb_inputs; i++) {
366+ AVFilterLink *inlink = avctx->inputs[i];
367+ if (outlink->frame_rate.num != inlink->frame_rate.num ||
368+ outlink->frame_rate.den != inlink->frame_rate.den) {
369+ av_log(avctx, AV_LOG_VERBOSE,
370+ "Video inputs have different frame rates, output will be VFR\n");
371+ outlink->frame_rate = av_make_q(1, 0);
372+ break;
373+ }
374+ }
375+
376+ ret = init_framesync(avctx);
377+ if (ret < 0)
378+ return ret;
379+
380+ outlink->time_base = sctx->fs.time_base;
381+
382+ vppctx->output_width = width;
383+ vppctx->output_height = height;
384+
385+ return ff_vaapi_vpp_config_output(outlink);
386+}
387+
388+static int vaapi_stack_init(AVFilterContext *avctx)
389+{
390+ StackVAAPIContext *sctx = avctx->priv;
391+ VAAPIVPPContext *vppctx = avctx->priv;
392+ int ret;
393+
394+ if (!strcmp(avctx->filter->name, "hstack_vaapi"))
395+ sctx->mode = STACK_VAAPI_H;
396+ else if (!strcmp(avctx->filter->name, "vstack_vaapi"))
397+ sctx->mode = STACK_VAAPI_V;
398+ else {
399+ int is_grid;
400+
401+ av_assert0(strcmp(avctx->filter->name, "xstack_vaapi") == 0);
402+ sctx->mode = STACK_VAAPI_X;
403+ is_grid = sctx->nb_grid_rows && sctx->nb_grid_columns;
404+
405+ if (sctx->layout && is_grid) {
406+ av_log(avctx, AV_LOG_ERROR, "Both layout and grid were specified. Only one is allowed.\n");
407+ return AVERROR(EINVAL);
408+ }
409+
410+ if (!sctx->layout && !is_grid) {
411+ if (sctx->nb_inputs == 2) {
412+ sctx->nb_grid_rows = 1;
413+ sctx->nb_grid_columns = 2;
414+ is_grid = 1;
415+ } else {
416+ av_log(avctx, AV_LOG_ERROR, "No layout or grid specified.\n");
417+ return AVERROR(EINVAL);
418+ }
419+ }
420+
421+ if (is_grid)
422+ sctx->nb_inputs = sctx->nb_grid_rows * sctx->nb_grid_columns;
423+
424+ if (strcmp(sctx->fillcolor_str, "none") &&
425+ av_parse_color(sctx->fillcolor, sctx->fillcolor_str, -1, avctx) >= 0) {
426+ sctx->fillcolor_enable = 1;
427+ } else {
428+ sctx->fillcolor_enable = 0;
429+ }
430+ }
431+
432+ for (int i = 0; i < sctx->nb_inputs; i++) {
433+ AVFilterPad pad = { 0 };
434+
435+ pad.type = AVMEDIA_TYPE_VIDEO;
436+ pad.name = av_asprintf("input%d", i);
437+
438+ if (!pad.name)
439+ return AVERROR(ENOMEM);
440+
441+ if ((ret = ff_append_inpad_free_name(avctx, &pad)) < 0)
442+ return ret;
443+ }
444+
445+ /* stack region */
446+ sctx->rects = av_calloc(sctx->nb_inputs, sizeof(*sctx->rects));
447+ if (!sctx->rects)
448+ return AVERROR(ENOMEM);
449+
450+ ff_vaapi_vpp_ctx_init(avctx);
451+ vppctx->output_format = AV_PIX_FMT_NONE;
452+
453+ return 0;
454+}
455+
456+static av_cold void vaapi_stack_uninit(AVFilterContext *avctx)
457+{
458+ StackVAAPIContext *sctx = avctx->priv;
459+
460+ ff_framesync_uninit(&sctx->fs);
461+ av_freep(&sctx->rects);
462+}
463+
464+static int vaapi_stack_activate(AVFilterContext *avctx)
465+{
466+ StackVAAPIContext *sctx = avctx->priv;
467+ return ff_framesync_activate(&sctx->fs);
468+}
469+
470+static int vaapi_stack_query_formats(AVFilterContext *avctx)
471+{
472+ static const enum AVPixelFormat pixel_formats[] = {
473+ AV_PIX_FMT_VAAPI,
474+ AV_PIX_FMT_NONE,
475+ };
476+
477+ return ff_set_common_formats_from_list(avctx, pixel_formats);
478+}
479+
480+static const AVFilterPad vaapi_stack_outputs[] = {
481+ {
482+ .name = "default",
483+ .type = AVMEDIA_TYPE_VIDEO,
484+ .config_props = config_output,
485+ },
486+};
487+
488+#define STACK_COMMON_OPTS \
489+ { "inputs", "Set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, { .i64 = 2 }, 2, UINT16_MAX, .flags = FLAGS }, \
490+ { "shortest", "Force termination when the shortest input terminates", OFFSET(shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
491+
492+#if CONFIG_HSTACK_VAAPI_FILTER
493+
494+static const AVOption hstack_vaapi_options[] = {
495+ STACK_COMMON_OPTS
496+
497+ { "height", "Set output height (0 to use the height of input 0)", OFFSET(tile_height), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, FLAGS },
498+ { NULL }
499+};
500+
501+AVFILTER_DEFINE_CLASS(hstack_vaapi);
502+
503+const AVFilter ff_vf_hstack_vaapi = {
504+ .name = "hstack_vaapi",
505+ .description = NULL_IF_CONFIG_SMALL("VA-API hstack."),
506+ .priv_size = sizeof(StackVAAPIContext),
507+ .priv_class = &hstack_vaapi_class,
508+ .init = vaapi_stack_init,
509+ .uninit = vaapi_stack_uninit,
510+ .activate = vaapi_stack_activate,
511+ FILTER_QUERY_FUNC(vaapi_stack_query_formats),
512+ FILTER_OUTPUTS(vaapi_stack_outputs),
513+ .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
514+ .flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
515+};
516+
517+#endif
518+
519+#if CONFIG_VSTACK_VAAPI_FILTER
520+
521+static const AVOption vstack_vaapi_options[] = {
522+ STACK_COMMON_OPTS
523+
524+ { "width", "Set output width (0 to use the width of input 0)", OFFSET(tile_width), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, FLAGS },
525+ { NULL }
526+};
527+
528+AVFILTER_DEFINE_CLASS(vstack_vaapi);
529+
530+const AVFilter ff_vf_vstack_vaapi = {
531+ .name = "vstack_vaapi",
532+ .description = NULL_IF_CONFIG_SMALL("VA-API vstack."),
533+ .priv_size = sizeof(StackVAAPIContext),
534+ .priv_class = &vstack_vaapi_class,
535+ .init = vaapi_stack_init,
536+ .uninit = vaapi_stack_uninit,
537+ .activate = vaapi_stack_activate,
538+ FILTER_QUERY_FUNC(vaapi_stack_query_formats),
539+ FILTER_OUTPUTS(vaapi_stack_outputs),
540+ .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
541+ .flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
542+};
543+
544+#endif
545+
546+#if CONFIG_XSTACK_VAAPI_FILTER
547+
548+static const AVOption xstack_vaapi_options[] = {
549+ STACK_COMMON_OPTS
550+
551+ { "layout", "Set custom layout", OFFSET(layout), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, .flags = FLAGS },
552+ { "grid", "set fixed size grid layout", OFFSET(nb_grid_columns), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, .flags = FLAGS },
553+ { "grid_tile_size", "set tile size in grid layout", OFFSET(tile_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, .flags = FLAGS },
554+ { "fill", "Set the color for unused pixels", OFFSET(fillcolor_str), AV_OPT_TYPE_STRING, {.str = "none"}, .flags = FLAGS },
555+ { NULL }
556+};
557+
558+AVFILTER_DEFINE_CLASS(xstack_vaapi);
559+
560+const AVFilter ff_vf_xstack_vaapi = {
561+ .name = "xstack_vaapi",
562+ .description = NULL_IF_CONFIG_SMALL("VA-API xstack."),
563+ .priv_size = sizeof(StackVAAPIContext),
564+ .priv_class = &xstack_vaapi_class,
565+ .init = vaapi_stack_init,
566+ .uninit = vaapi_stack_uninit,
567+ .activate = vaapi_stack_activate,
568+ FILTER_OUTPUTS(vaapi_stack_outputs),
569+ FILTER_QUERY_FUNC(vaapi_stack_query_formats),
570+ .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
571+ .flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
572+};
573+
574+#endif

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t