| @@ -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, ¶ms[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(¶ms); |
| | 141 | return ff_filter_frame(outlink, oframe); |
| | 142 | |
| | 143 | fail: |
| | 144 | av_freep(&irect); |
| | 145 | av_freep(¶ms); |
| | 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 |