| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * Copyright (c) 2021 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 "libavutil/imgutils.h" | ||
| 22 | #include "libavutil/mem.h" | ||
| 23 | #include "libavutil/opt.h" | ||
| 24 | #include "libavutil/pixdesc.h" | ||
| 25 | #include "avfilter.h" | ||
| 26 | #include "filters.h" | ||
| 27 | #include "framesync.h" | ||
| 28 | #include "video.h" | ||
| 29 | |||
| 30 | typedef struct VarBlurContext { | ||
| 31 | const AVClass *class; | ||
| 32 | FFFrameSync fs; | ||
| 33 | |||
| 34 | int min_radius; | ||
| 35 | int max_radius; | ||
| 36 | int planes; | ||
| 37 | |||
| 38 | int depth; | ||
| 39 | int planewidth[4]; | ||
| 40 | int planeheight[4]; | ||
| 41 | |||
| 42 | uint8_t *sat[4]; | ||
| 43 | int sat_linesize[4]; | ||
| 44 | int nb_planes; | ||
| 45 | |||
| 46 | void (*compute_sat)(const uint8_t *ssrc, | ||
| 47 | int linesize, | ||
| 48 | int w, int h, | ||
| 49 | uint8_t *dstp, | ||
| 50 | int dst_linesize); | ||
| 51 | |||
| 52 | int (*blur_plane)(AVFilterContext *ctx, | ||
| 53 | uint8_t *ddst, | ||
| 54 | int ddst_linesize, | ||
| 55 | const uint8_t *rrptr, | ||
| 56 | int rrptr_linesize, | ||
| 57 | int w, int h, | ||
| 58 | const uint8_t *pptr, | ||
| 59 | int pptr_linesize, | ||
| 60 | int slice_start, int slice_end); | ||
| 61 | } VarBlurContext; | ||
| 62 | |||
| 63 | #define OFFSET(x) offsetof(VarBlurContext, x) | ||
| 64 | #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM | ||
| 65 | |||
| 66 | static const AVOption varblur_options[] = { | ||
| 67 | { "min_r", "set min blur radius", OFFSET(min_radius), AV_OPT_TYPE_INT, {.i64=0}, 0, 254, FLAGS }, | ||
| 68 | { "max_r", "set max blur radius", OFFSET(max_radius), AV_OPT_TYPE_INT, {.i64=8}, 1, 255, FLAGS }, | ||
| 69 | { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS }, | ||
| 70 | { NULL } | ||
| 71 | }; | ||
| 72 | |||
| 73 | ✗ | FRAMESYNC_DEFINE_CLASS(varblur, VarBlurContext, fs); | |
| 74 | |||
| 75 | static const enum AVPixelFormat pix_fmts[] = { | ||
| 76 | AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, | ||
| 77 | AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, | ||
| 78 | AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, | ||
| 79 | AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, | ||
| 80 | AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, | ||
| 81 | AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, | ||
| 82 | AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, | ||
| 83 | AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12, | ||
| 84 | AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, | ||
| 85 | AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, | ||
| 86 | AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, | ||
| 87 | AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, | ||
| 88 | AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12, | ||
| 89 | AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16, | ||
| 90 | AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, | ||
| 91 | AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16, | ||
| 92 | AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16, | ||
| 93 | AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16, | ||
| 94 | AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32, | ||
| 95 | AV_PIX_FMT_NONE | ||
| 96 | }; | ||
| 97 | |||
| 98 | #define COMPUTE_SAT(type, stype, depth) \ | ||
| 99 | static void compute_sat##depth(const uint8_t *ssrc, \ | ||
| 100 | int linesize, \ | ||
| 101 | int w, int h, \ | ||
| 102 | uint8_t *dstp, \ | ||
| 103 | int dst_linesize) \ | ||
| 104 | { \ | ||
| 105 | const type *src = (const type *)ssrc; \ | ||
| 106 | stype *dst = (stype *)dstp; \ | ||
| 107 | \ | ||
| 108 | linesize /= (depth / 8); \ | ||
| 109 | dst_linesize /= sizeof(stype); \ | ||
| 110 | dst += dst_linesize; \ | ||
| 111 | \ | ||
| 112 | for (int y = 0; y < h; y++) { \ | ||
| 113 | stype sum = 0; \ | ||
| 114 | \ | ||
| 115 | for (int x = 1; x < w; x++) { \ | ||
| 116 | sum += src[x - 1]; \ | ||
| 117 | dst[x] = sum + dst[x - dst_linesize]; \ | ||
| 118 | } \ | ||
| 119 | \ | ||
| 120 | src += linesize; \ | ||
| 121 | dst += dst_linesize; \ | ||
| 122 | } \ | ||
| 123 | } | ||
| 124 | |||
| 125 | ✗ | COMPUTE_SAT(uint8_t, uint32_t, 8) | |
| 126 | ✗ | COMPUTE_SAT(uint16_t, uint64_t, 16) | |
| 127 | ✗ | COMPUTE_SAT(float, double, 32) | |
| 128 | |||
| 129 | typedef struct ThreadData { | ||
| 130 | AVFrame *in, *out, *radius; | ||
| 131 | } ThreadData; | ||
| 132 | |||
| 133 | ✗ | static float lerpf(float v0, float v1, float f) | |
| 134 | { | ||
| 135 | ✗ | return v0 + (v1 - v0) * f; | |
| 136 | } | ||
| 137 | |||
| 138 | #define BLUR_PLANE(type, stype, bits) \ | ||
| 139 | static int blur_plane##bits(AVFilterContext *ctx, \ | ||
| 140 | uint8_t *ddst, \ | ||
| 141 | int ddst_linesize, \ | ||
| 142 | const uint8_t *rrptr, \ | ||
| 143 | int rrptr_linesize, \ | ||
| 144 | int w, int h, \ | ||
| 145 | const uint8_t *pptr, \ | ||
| 146 | int pptr_linesize, \ | ||
| 147 | int slice_start, int slice_end) \ | ||
| 148 | { \ | ||
| 149 | VarBlurContext *s = ctx->priv; \ | ||
| 150 | const int ddepth = (bits == 32) ? 1 : s->depth; \ | ||
| 151 | const int dst_linesize = ddst_linesize / (bits / 8); \ | ||
| 152 | const int ptr_linesize = pptr_linesize / sizeof(stype); \ | ||
| 153 | const int rptr_linesize = rrptr_linesize / (bits / 8); \ | ||
| 154 | const type *rptr = ((const type *)rrptr) + slice_start * rptr_linesize; \ | ||
| 155 | type *dst = ((type *)ddst) + slice_start * dst_linesize; \ | ||
| 156 | const stype *ptr = (stype *)pptr; \ | ||
| 157 | const float minr = 2.f * s->min_radius + 1.f; \ | ||
| 158 | const float maxr = 2.f * s->max_radius + 1.f; \ | ||
| 159 | const float scaler = (maxr - minr) / ((1 << ddepth) - 1); \ | ||
| 160 | \ | ||
| 161 | for (int y = slice_start; y < slice_end; y++) { \ | ||
| 162 | for (int x = 0; x < w; x++) { \ | ||
| 163 | const float radiusf = minr + (FFMAX(0.f, 2 * rptr[x] + 1 - minr)) * scaler; \ | ||
| 164 | const int radius = floorf(radiusf); \ | ||
| 165 | const float factor = radiusf - radius; \ | ||
| 166 | const int nradius = radius + 1; \ | ||
| 167 | const int l = FFMIN(radius, x); \ | ||
| 168 | const int r = FFMIN(radius, w - x - 1); \ | ||
| 169 | const int t = FFMIN(radius, y); \ | ||
| 170 | const int b = FFMIN(radius, h - y - 1); \ | ||
| 171 | const int nl = FFMIN(nradius, x); \ | ||
| 172 | const int nr = FFMIN(nradius, w - x - 1); \ | ||
| 173 | const int nt = FFMIN(nradius, y); \ | ||
| 174 | const int nb = FFMIN(nradius, h - y - 1); \ | ||
| 175 | stype tl = ptr[(y - t) * ptr_linesize + x - l]; \ | ||
| 176 | stype tr = ptr[(y - t) * ptr_linesize + x + r]; \ | ||
| 177 | stype bl = ptr[(y + b) * ptr_linesize + x - l]; \ | ||
| 178 | stype br = ptr[(y + b) * ptr_linesize + x + r]; \ | ||
| 179 | stype ntl = ptr[(y - nt) * ptr_linesize + x - nl]; \ | ||
| 180 | stype ntr = ptr[(y - nt) * ptr_linesize + x + nr]; \ | ||
| 181 | stype nbl = ptr[(y + nb) * ptr_linesize + x - nl]; \ | ||
| 182 | stype nbr = ptr[(y + nb) * ptr_linesize + x + nr]; \ | ||
| 183 | stype div = (l + r) * (t + b); \ | ||
| 184 | stype ndiv = (nl + nr) * (nt + nb); \ | ||
| 185 | stype p0 = (br + tl - bl - tr) / div; \ | ||
| 186 | stype n0 = (nbr + ntl - nbl - ntr) / ndiv; \ | ||
| 187 | \ | ||
| 188 | if (bits == 32) \ | ||
| 189 | dst[x] = lerpf(p0, n0, factor); \ | ||
| 190 | else \ | ||
| 191 | dst[x] = av_clip_uintp2_c(lrintf( \ | ||
| 192 | lerpf(p0, n0, factor)), \ | ||
| 193 | ddepth); \ | ||
| 194 | } \ | ||
| 195 | \ | ||
| 196 | rptr += rptr_linesize; \ | ||
| 197 | dst += dst_linesize; \ | ||
| 198 | } \ | ||
| 199 | \ | ||
| 200 | return 0; \ | ||
| 201 | } | ||
| 202 | |||
| 203 | ✗ | BLUR_PLANE(uint8_t, uint32_t, 8) | |
| 204 | ✗ | BLUR_PLANE(uint16_t, uint64_t, 16) | |
| 205 | ✗ | BLUR_PLANE(float, double, 32) | |
| 206 | |||
| 207 | ✗ | static int blur_planes(AVFilterContext *ctx, void *arg, | |
| 208 | int jobnr, int nb_jobs) | ||
| 209 | { | ||
| 210 | ✗ | VarBlurContext *s = ctx->priv; | |
| 211 | ✗ | ThreadData *td = arg; | |
| 212 | ✗ | AVFrame *radius = td->radius; | |
| 213 | ✗ | AVFrame *out = td->out; | |
| 214 | ✗ | AVFrame *in = td->in; | |
| 215 | |||
| 216 | ✗ | for (int plane = 0; plane < s->nb_planes; plane++) { | |
| 217 | ✗ | const int height = s->planeheight[plane]; | |
| 218 | ✗ | const int slice_start = (height * jobnr) / nb_jobs; | |
| 219 | ✗ | const int slice_end = (height * (jobnr+1)) / nb_jobs; | |
| 220 | ✗ | const int width = s->planewidth[plane]; | |
| 221 | ✗ | const int linesize = in->linesize[plane]; | |
| 222 | ✗ | const int dst_linesize = out->linesize[plane]; | |
| 223 | ✗ | const uint8_t *rptr = radius->data[plane]; | |
| 224 | ✗ | const int rptr_linesize = radius->linesize[plane]; | |
| 225 | ✗ | uint8_t *ptr = s->sat[plane]; | |
| 226 | ✗ | const int ptr_linesize = s->sat_linesize[plane]; | |
| 227 | ✗ | const uint8_t *src = in->data[plane]; | |
| 228 | ✗ | uint8_t *dst = out->data[plane]; | |
| 229 | |||
| 230 | ✗ | if (!(s->planes & (1 << plane))) { | |
| 231 | ✗ | if (out != in) | |
| 232 | ✗ | av_image_copy_plane(dst + slice_start * dst_linesize, | |
| 233 | dst_linesize, | ||
| 234 | ✗ | src + slice_start * linesize, | |
| 235 | linesize, | ||
| 236 | ✗ | width * ((s->depth + 7) / 8), | |
| 237 | slice_end - slice_start); | ||
| 238 | ✗ | continue; | |
| 239 | } | ||
| 240 | |||
| 241 | ✗ | s->blur_plane(ctx, dst, dst_linesize, | |
| 242 | rptr, rptr_linesize, | ||
| 243 | width, height, | ||
| 244 | ptr, ptr_linesize, | ||
| 245 | slice_start, slice_end); | ||
| 246 | } | ||
| 247 | |||
| 248 | ✗ | return 0; | |
| 249 | } | ||
| 250 | |||
| 251 | ✗ | static int blur_frame(AVFilterContext *ctx, AVFrame *in, AVFrame *radius) | |
| 252 | { | ||
| 253 | ✗ | VarBlurContext *s = ctx->priv; | |
| 254 | ✗ | AVFilterLink *outlink = ctx->outputs[0]; | |
| 255 | ThreadData td; | ||
| 256 | AVFrame *out; | ||
| 257 | |||
| 258 | ✗ | if (av_frame_is_writable(in)) { | |
| 259 | ✗ | out = in; | |
| 260 | } else { | ||
| 261 | ✗ | out = ff_get_video_buffer(outlink, outlink->w, outlink->h); | |
| 262 | ✗ | if (!out) { | |
| 263 | ✗ | av_frame_free(&in); | |
| 264 | ✗ | return AVERROR(ENOMEM); | |
| 265 | } | ||
| 266 | ✗ | av_frame_copy_props(out, in); | |
| 267 | } | ||
| 268 | |||
| 269 | ✗ | for (int plane = 0; plane < s->nb_planes; plane++) { | |
| 270 | ✗ | const int height = s->planeheight[plane]; | |
| 271 | ✗ | const int width = s->planewidth[plane]; | |
| 272 | ✗ | const int linesize = in->linesize[plane]; | |
| 273 | ✗ | uint8_t *ptr = s->sat[plane]; | |
| 274 | ✗ | const int ptr_linesize = s->sat_linesize[plane]; | |
| 275 | ✗ | const uint8_t *src = in->data[plane]; | |
| 276 | |||
| 277 | ✗ | if (!(s->planes & (1 << plane))) | |
| 278 | ✗ | continue; | |
| 279 | |||
| 280 | ✗ | s->compute_sat(src, linesize, width, height, ptr, ptr_linesize); | |
| 281 | } | ||
| 282 | |||
| 283 | ✗ | td.in = in; | |
| 284 | ✗ | td.out = out; | |
| 285 | ✗ | td.radius = radius; | |
| 286 | ✗ | ff_filter_execute(ctx, blur_planes, &td, NULL, | |
| 287 | ✗ | FFMIN(s->planeheight[1], ff_filter_get_nb_threads(ctx))); | |
| 288 | |||
| 289 | ✗ | if (out != in) | |
| 290 | ✗ | av_frame_free(&in); | |
| 291 | ✗ | return ff_filter_frame(outlink, out); | |
| 292 | } | ||
| 293 | |||
| 294 | ✗ | static int activate(AVFilterContext *ctx) | |
| 295 | { | ||
| 296 | ✗ | VarBlurContext *s = ctx->priv; | |
| 297 | ✗ | return ff_framesync_activate(&s->fs); | |
| 298 | } | ||
| 299 | |||
| 300 | ✗ | static int varblur_frame(FFFrameSync *fs) | |
| 301 | { | ||
| 302 | ✗ | AVFilterContext *ctx = fs->parent; | |
| 303 | ✗ | VarBlurContext *s = ctx->priv; | |
| 304 | AVFrame *in, *radius; | ||
| 305 | int ret; | ||
| 306 | |||
| 307 | ✗ | if (s->max_radius <= s->min_radius) | |
| 308 | ✗ | s->max_radius = s->min_radius + 1; | |
| 309 | |||
| 310 | ✗ | ret = ff_framesync_dualinput_get(fs, &in, &radius); | |
| 311 | ✗ | if (ret < 0) | |
| 312 | ✗ | return ret; | |
| 313 | ✗ | if (!radius) | |
| 314 | ✗ | return ff_filter_frame(ctx->outputs[0], in); | |
| 315 | ✗ | return blur_frame(ctx, in, radius); | |
| 316 | } | ||
| 317 | |||
| 318 | ✗ | static int config_output(AVFilterLink *outlink) | |
| 319 | { | ||
| 320 | ✗ | AVFilterContext *ctx = outlink->src; | |
| 321 | ✗ | AVFilterLink *inlink = ctx->inputs[0]; | |
| 322 | ✗ | AVFilterLink *radiuslink = ctx->inputs[1]; | |
| 323 | ✗ | FilterLink *il = ff_filter_link(inlink); | |
| 324 | ✗ | FilterLink *ol = ff_filter_link(outlink); | |
| 325 | ✗ | VarBlurContext *s = ctx->priv; | |
| 326 | ✗ | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format); | |
| 327 | int ret; | ||
| 328 | |||
| 329 | ✗ | if (inlink->w != radiuslink->w || inlink->h != radiuslink->h) { | |
| 330 | ✗ | av_log(ctx, AV_LOG_ERROR, "First input link %s parameters " | |
| 331 | "(size %dx%d) do not match the corresponding " | ||
| 332 | "second input link %s parameters (size %dx%d)\n", | ||
| 333 | ✗ | ctx->input_pads[0].name, inlink->w, inlink->h, | |
| 334 | ✗ | ctx->input_pads[1].name, radiuslink->w, radiuslink->h); | |
| 335 | ✗ | return AVERROR(EINVAL); | |
| 336 | } | ||
| 337 | |||
| 338 | ✗ | outlink->w = inlink->w; | |
| 339 | ✗ | outlink->h = inlink->h; | |
| 340 | ✗ | outlink->time_base = inlink->time_base; | |
| 341 | ✗ | outlink->sample_aspect_ratio = inlink->sample_aspect_ratio; | |
| 342 | ✗ | ol->frame_rate = il->frame_rate; | |
| 343 | |||
| 344 | ✗ | s->depth = desc->comp[0].depth; | |
| 345 | ✗ | s->blur_plane = s->depth <= 8 ? blur_plane8 : s->depth <= 16 ? blur_plane16 : blur_plane32; | |
| 346 | ✗ | s->compute_sat = s->depth <= 8 ? compute_sat8 : s->depth <= 16 ? compute_sat16 : compute_sat32; | |
| 347 | |||
| 348 | ✗ | s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(outlink->w, desc->log2_chroma_w); | |
| 349 | ✗ | s->planewidth[0] = s->planewidth[3] = outlink->w; | |
| 350 | ✗ | s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(outlink->h, desc->log2_chroma_h); | |
| 351 | ✗ | s->planeheight[0] = s->planeheight[3] = outlink->h; | |
| 352 | |||
| 353 | ✗ | s->nb_planes = av_pix_fmt_count_planes(outlink->format); | |
| 354 | |||
| 355 | ✗ | for (int p = 0; p < s->nb_planes; p++) { | |
| 356 | ✗ | s->sat_linesize[p] = (outlink->w + 1) * (4 + 4 * (s->depth > 8)); | |
| 357 | ✗ | s->sat[p] = av_calloc(s->sat_linesize[p], outlink->h + 1); | |
| 358 | ✗ | if (!s->sat[p]) | |
| 359 | ✗ | return AVERROR(ENOMEM); | |
| 360 | } | ||
| 361 | |||
| 362 | ✗ | s->fs.on_event = varblur_frame; | |
| 363 | ✗ | if ((ret = ff_framesync_init_dualinput(&s->fs, ctx)) < 0) | |
| 364 | ✗ | return ret; | |
| 365 | |||
| 366 | ✗ | ret = ff_framesync_configure(&s->fs); | |
| 367 | ✗ | outlink->time_base = s->fs.time_base; | |
| 368 | |||
| 369 | ✗ | return ret; | |
| 370 | } | ||
| 371 | |||
| 372 | ✗ | static av_cold void uninit(AVFilterContext *ctx) | |
| 373 | { | ||
| 374 | ✗ | VarBlurContext *s = ctx->priv; | |
| 375 | |||
| 376 | ✗ | ff_framesync_uninit(&s->fs); | |
| 377 | ✗ | for (int p = 0; p < 4; p++) | |
| 378 | ✗ | av_freep(&s->sat[p]); | |
| 379 | ✗ | } | |
| 380 | |||
| 381 | static const AVFilterPad varblur_inputs[] = { | ||
| 382 | { | ||
| 383 | .name = "default", | ||
| 384 | .type = AVMEDIA_TYPE_VIDEO, | ||
| 385 | }, | ||
| 386 | { | ||
| 387 | .name = "radius", | ||
| 388 | .type = AVMEDIA_TYPE_VIDEO, | ||
| 389 | }, | ||
| 390 | }; | ||
| 391 | |||
| 392 | static const AVFilterPad varblur_outputs[] = { | ||
| 393 | { | ||
| 394 | .name = "default", | ||
| 395 | .type = AVMEDIA_TYPE_VIDEO, | ||
| 396 | .config_props = config_output, | ||
| 397 | }, | ||
| 398 | }; | ||
| 399 | |||
| 400 | const AVFilter ff_vf_varblur = { | ||
| 401 | .name = "varblur", | ||
| 402 | .description = NULL_IF_CONFIG_SMALL("Apply Variable Blur filter."), | ||
| 403 | .priv_size = sizeof(VarBlurContext), | ||
| 404 | .priv_class = &varblur_class, | ||
| 405 | .activate = activate, | ||
| 406 | .preinit = varblur_framesync_preinit, | ||
| 407 | .uninit = uninit, | ||
| 408 | FILTER_INPUTS(varblur_inputs), | ||
| 409 | FILTER_OUTPUTS(varblur_outputs), | ||
| 410 | FILTER_PIXFMTS_ARRAY(pix_fmts), | ||
| 411 | .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | | ||
| 412 | AVFILTER_FLAG_SLICE_THREADS, | ||
| 413 | .process_command = ff_filter_process_command, | ||
| 414 | }; | ||
| 415 |