2 * Copyright (c) 2016 Paul B Mahol
4 * This file is part of FFmpeg.
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.
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.
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
21 #include "libavutil/imgutils.h"
22 #include "libavutil/pixdesc.h"
23 #include "libavutil/opt.h"
27 #include "framesync.h"
31 typedef struct ThreadData {
35 typedef struct PreMultiplyContext {
37 int width[4], height[4];
43 int half, depth, offset, max;
46 void (*premultiply[4])(const uint8_t *msrc, const uint8_t *asrc,
48 ptrdiff_t mlinesize, ptrdiff_t alinesize,
51 int half, int shift, int offset);
54 #define OFFSET(x) offsetof(PreMultiplyContext, x)
55 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
57 static const AVOption options[] = {
58 { "planes", "set planes", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
59 { "inplace","enable inplace mode", OFFSET(inplace), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
63 #define premultiply_options options
64 AVFILTER_DEFINE_CLASS(premultiply);
66 static int query_formats(AVFilterContext *ctx)
68 PreMultiplyContext *s = ctx->priv;
70 static const enum AVPixelFormat no_alpha_pix_fmts[] = {
71 AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
72 AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
73 AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
75 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
76 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRPF32,
77 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
81 static const enum AVPixelFormat alpha_pix_fmts[] = {
83 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA444P16,
85 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GBRAPF32,
89 return ff_set_common_formats(ctx, ff_make_format_list(s->inplace ? alpha_pix_fmts : no_alpha_pix_fmts));
92 static void premultiply8(const uint8_t *msrc, const uint8_t *asrc,
94 ptrdiff_t mlinesize, ptrdiff_t alinesize,
97 int half, int shift, int offset)
101 for (y = 0; y < h; y++) {
102 for (x = 0; x < w; x++) {
103 dst[x] = ((msrc[x] * (((asrc[x] >> 1) & 1) + asrc[x])) + 128) >> 8;
112 static void premultiply8yuv(const uint8_t *msrc, const uint8_t *asrc,
114 ptrdiff_t mlinesize, ptrdiff_t alinesize,
117 int half, int shift, int offset)
121 for (y = 0; y < h; y++) {
122 for (x = 0; x < w; x++) {
123 dst[x] = ((((msrc[x] - 128) * (((asrc[x] >> 1) & 1) + asrc[x]))) >> 8) + 128;
132 static void premultiply8offset(const uint8_t *msrc, const uint8_t *asrc,
134 ptrdiff_t mlinesize, ptrdiff_t alinesize,
137 int half, int shift, int offset)
141 for (y = 0; y < h; y++) {
142 for (x = 0; x < w; x++) {
143 dst[x] = ((((msrc[x] - offset) * (((asrc[x] >> 1) & 1) + asrc[x])) + 128) >> 8) + offset;
152 static void premultiply16(const uint8_t *mmsrc, const uint8_t *aasrc,
154 ptrdiff_t mlinesize, ptrdiff_t alinesize,
157 int half, int shift, int offset)
159 const uint16_t *msrc = (const uint16_t *)mmsrc;
160 const uint16_t *asrc = (const uint16_t *)aasrc;
161 uint16_t *dst = (uint16_t *)ddst;
164 for (y = 0; y < h; y++) {
165 for (x = 0; x < w; x++) {
166 dst[x] = ((msrc[x] * (((asrc[x] >> 1) & 1) + asrc[x])) + half) >> shift;
169 dst += dlinesize / 2;
170 msrc += mlinesize / 2;
171 asrc += alinesize / 2;
175 static void premultiply16yuv(const uint8_t *mmsrc, const uint8_t *aasrc,
177 ptrdiff_t mlinesize, ptrdiff_t alinesize,
180 int half, int shift, int offset)
182 const uint16_t *msrc = (const uint16_t *)mmsrc;
183 const uint16_t *asrc = (const uint16_t *)aasrc;
184 uint16_t *dst = (uint16_t *)ddst;
187 for (y = 0; y < h; y++) {
188 for (x = 0; x < w; x++) {
189 dst[x] = ((((msrc[x] - half) * (int64_t)(((asrc[x] >> 1) & 1) + asrc[x]))) >> shift) + half;
192 dst += dlinesize / 2;
193 msrc += mlinesize / 2;
194 asrc += alinesize / 2;
198 static void premultiply16offset(const uint8_t *mmsrc, const uint8_t *aasrc,
200 ptrdiff_t mlinesize, ptrdiff_t alinesize,
203 int half, int shift, int offset)
205 const uint16_t *msrc = (const uint16_t *)mmsrc;
206 const uint16_t *asrc = (const uint16_t *)aasrc;
207 uint16_t *dst = (uint16_t *)ddst;
210 for (y = 0; y < h; y++) {
211 for (x = 0; x < w; x++) {
212 dst[x] = ((((msrc[x] - offset) * (int64_t)(((asrc[x] >> 1) & 1) + asrc[x])) + half) >> shift) + offset;
215 dst += dlinesize / 2;
216 msrc += mlinesize / 2;
217 asrc += alinesize / 2;
221 static void premultiplyf32(const uint8_t *mmsrc, const uint8_t *aasrc,
223 ptrdiff_t mlinesize, ptrdiff_t alinesize,
226 int half, int shift, int offset)
228 const float *msrc = (const float *)mmsrc;
229 const float *asrc = (const float *)aasrc;
230 float *dst = (float *)ddst;
233 for (y = 0; y < h; y++) {
234 for (x = 0; x < w; x++) {
235 dst[x] = msrc[x] * asrc[x];
238 dst += dlinesize / 4;
239 msrc += mlinesize / 4;
240 asrc += alinesize / 4;
244 static void premultiplyf32offset(const uint8_t *mmsrc, const uint8_t *aasrc,
246 ptrdiff_t mlinesize, ptrdiff_t alinesize,
249 int half, int shift, int offset)
251 const float *msrc = (const float *)mmsrc;
252 const float *asrc = (const float *)aasrc;
253 float *dst = (float *)ddst;
256 float offsetf = offset / 65535.0f;
258 for (y = 0; y < h; y++) {
259 for (x = 0; x < w; x++) {
260 dst[x] = ((msrc[x] - offsetf) * asrc[x]) + offsetf;
263 dst += dlinesize / 4;
264 msrc += mlinesize / 4;
265 asrc += alinesize / 4;
269 static void unpremultiply8(const uint8_t *msrc, const uint8_t *asrc,
271 ptrdiff_t mlinesize, ptrdiff_t alinesize,
274 int half, int max, int offset)
278 for (y = 0; y < h; y++) {
279 for (x = 0; x < w; x++) {
280 if (asrc[x] > 0 && asrc[x] < 255)
281 dst[x] = FFMIN(msrc[x] * 255 / asrc[x], 255);
292 static void unpremultiply8yuv(const uint8_t *msrc, const uint8_t *asrc,
294 ptrdiff_t mlinesize, ptrdiff_t alinesize,
297 int half, int max, int offset)
301 for (y = 0; y < h; y++) {
302 for (x = 0; x < w; x++) {
303 if (asrc[x] > 0 && asrc[x] < 255)
304 dst[x] = FFMIN((msrc[x] - 128) * 255 / asrc[x] + 128, 255);
315 static void unpremultiply8offset(const uint8_t *msrc, const uint8_t *asrc,
317 ptrdiff_t mlinesize, ptrdiff_t alinesize,
320 int half, int max, int offset)
324 for (y = 0; y < h; y++) {
325 for (x = 0; x < w; x++) {
326 if (asrc[x] > 0 && asrc[x] < 255)
327 dst[x] = FFMIN(FFMAX(msrc[x] - offset, 0) * 255 / asrc[x] + offset, 255);
338 static void unpremultiply16(const uint8_t *mmsrc, const uint8_t *aasrc,
340 ptrdiff_t mlinesize, ptrdiff_t alinesize,
343 int half, int max, int offset)
345 const uint16_t *msrc = (const uint16_t *)mmsrc;
346 const uint16_t *asrc = (const uint16_t *)aasrc;
347 uint16_t *dst = (uint16_t *)ddst;
350 for (y = 0; y < h; y++) {
351 for (x = 0; x < w; x++) {
352 if (asrc[x] > 0 && asrc[x] < max)
353 dst[x] = FFMIN(msrc[x] * (unsigned)max / asrc[x], max);
358 dst += dlinesize / 2;
359 msrc += mlinesize / 2;
360 asrc += alinesize / 2;
364 static void unpremultiply16yuv(const uint8_t *mmsrc, const uint8_t *aasrc,
366 ptrdiff_t mlinesize, ptrdiff_t alinesize,
369 int half, int max, int offset)
371 const uint16_t *msrc = (const uint16_t *)mmsrc;
372 const uint16_t *asrc = (const uint16_t *)aasrc;
373 uint16_t *dst = (uint16_t *)ddst;
376 for (y = 0; y < h; y++) {
377 for (x = 0; x < w; x++) {
378 if (asrc[x] > 0 && asrc[x] < max)
379 dst[x] = FFMAX(FFMIN((msrc[x] - half) * max / asrc[x], half - 1), -half) + half;
384 dst += dlinesize / 2;
385 msrc += mlinesize / 2;
386 asrc += alinesize / 2;
390 static void unpremultiply16offset(const uint8_t *mmsrc, const uint8_t *aasrc,
392 ptrdiff_t mlinesize, ptrdiff_t alinesize,
395 int half, int max, int offset)
397 const uint16_t *msrc = (const uint16_t *)mmsrc;
398 const uint16_t *asrc = (const uint16_t *)aasrc;
399 uint16_t *dst = (uint16_t *)ddst;
402 for (y = 0; y < h; y++) {
403 for (x = 0; x < w; x++) {
404 if (asrc[x] > 0 && asrc[x] < max)
405 dst[x] = FFMAX(FFMIN(FFMAX(msrc[x] - offset, 0) * (unsigned)max / asrc[x] + offset, max), 0);
410 dst += dlinesize / 2;
411 msrc += mlinesize / 2;
412 asrc += alinesize / 2;
416 static void unpremultiplyf32(const uint8_t *mmsrc, const uint8_t *aasrc,
418 ptrdiff_t mlinesize, ptrdiff_t alinesize,
421 int half, int max, int offset)
423 const float *msrc = (const float *)mmsrc;
424 const float *asrc = (const float *)aasrc;
426 float *dst = (float *)ddst;
429 for (y = 0; y < h; y++) {
430 for (x = 0; x < w; x++) {
432 dst[x] = msrc[x] / asrc[x];
437 dst += dlinesize / 4;
438 msrc += mlinesize / 4;
439 asrc += alinesize / 4;
443 static void unpremultiplyf32offset(const uint8_t *mmsrc, const uint8_t *aasrc,
445 ptrdiff_t mlinesize, ptrdiff_t alinesize,
448 int half, int max, int offset)
450 const float *msrc = (const float *)mmsrc;
451 const float *asrc = (const float *)aasrc;
453 float *dst = (float *)ddst;
456 float offsetf = offset / 65535.0f;
458 for (y = 0; y < h; y++) {
459 for (x = 0; x < w; x++) {
461 dst[x] = (msrc[x] - offsetf) / asrc[x] + offsetf;
466 dst += dlinesize / 4;
467 msrc += mlinesize / 4;
468 asrc += alinesize / 4;
472 static int premultiply_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
474 PreMultiplyContext *s = ctx->priv;
475 ThreadData *td = arg;
476 AVFrame *out = td->d;
477 AVFrame *alpha = td->a;
478 AVFrame *base = td->m;
481 for (p = 0; p < s->nb_planes; p++) {
482 const int slice_start = (s->height[p] * jobnr) / nb_jobs;
483 const int slice_end = (s->height[p] * (jobnr+1)) / nb_jobs;
485 if (!((1 << p) & s->planes) || p == 3) {
486 av_image_copy_plane(out->data[p] + slice_start * out->linesize[p],
488 base->data[p] + slice_start * base->linesize[p],
490 s->linesize[p], slice_end - slice_start);
494 s->premultiply[p](base->data[p] + slice_start * base->linesize[p],
495 s->inplace ? alpha->data[3] + slice_start * alpha->linesize[3] :
496 alpha->data[0] + slice_start * alpha->linesize[0],
497 out->data[p] + slice_start * out->linesize[p],
498 base->linesize[p], s->inplace ? alpha->linesize[3] : alpha->linesize[0],
500 s->width[p], slice_end - slice_start,
501 s->half, s->inverse ? s->max : s->depth, s->offset);
507 static int filter_frame(AVFilterContext *ctx,
508 AVFrame **out, AVFrame *base, AVFrame *alpha)
510 PreMultiplyContext *s = ctx->priv;
511 AVFilterLink *outlink = ctx->outputs[0];
513 if (ctx->is_disabled) {
514 *out = av_frame_clone(base);
516 return AVERROR(ENOMEM);
521 *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
523 return AVERROR(ENOMEM);
524 av_frame_copy_props(*out, base);
526 full = base->color_range == AVCOL_RANGE_JPEG;
527 limited = base->color_range == AVCOL_RANGE_MPEG;
530 switch (outlink->format) {
531 case AV_PIX_FMT_YUV444P:
532 case AV_PIX_FMT_YUVA444P:
533 s->premultiply[0] = full ? unpremultiply8 : unpremultiply8offset;
534 s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
536 case AV_PIX_FMT_YUVJ444P:
537 s->premultiply[0] = unpremultiply8;
538 s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
540 case AV_PIX_FMT_GBRP:
541 case AV_PIX_FMT_GBRAP:
542 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply8offset : unpremultiply8;
544 case AV_PIX_FMT_YUV444P9:
545 case AV_PIX_FMT_YUVA444P9:
546 case AV_PIX_FMT_YUV444P10:
547 case AV_PIX_FMT_YUVA444P10:
548 case AV_PIX_FMT_YUV444P12:
549 case AV_PIX_FMT_YUVA444P12:
550 case AV_PIX_FMT_YUV444P14:
551 case AV_PIX_FMT_YUV444P16:
552 case AV_PIX_FMT_YUVA444P16:
553 s->premultiply[0] = full ? unpremultiply16 : unpremultiply16offset;
554 s->premultiply[1] = s->premultiply[2] = unpremultiply16yuv;
556 case AV_PIX_FMT_GBRP9:
557 case AV_PIX_FMT_GBRP10:
558 case AV_PIX_FMT_GBRAP10:
559 case AV_PIX_FMT_GBRP12:
560 case AV_PIX_FMT_GBRAP12:
561 case AV_PIX_FMT_GBRP14:
562 case AV_PIX_FMT_GBRP16:
563 case AV_PIX_FMT_GBRAP16:
564 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply16offset : unpremultiply16;
566 case AV_PIX_FMT_GBRPF32:
567 case AV_PIX_FMT_GBRAPF32:
568 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiplyf32offset : unpremultiplyf32;
570 case AV_PIX_FMT_GRAY8:
571 s->premultiply[0] = limited ? unpremultiply8offset : unpremultiply8;
573 case AV_PIX_FMT_GRAY9:
574 case AV_PIX_FMT_GRAY10:
575 case AV_PIX_FMT_GRAY12:
576 case AV_PIX_FMT_GRAY14:
577 case AV_PIX_FMT_GRAY16:
578 s->premultiply[0] = limited ? unpremultiply16offset : unpremultiply16;
582 switch (outlink->format) {
583 case AV_PIX_FMT_YUV444P:
584 case AV_PIX_FMT_YUVA444P:
585 s->premultiply[0] = full ? premultiply8 : premultiply8offset;
586 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
588 case AV_PIX_FMT_YUVJ444P:
589 s->premultiply[0] = premultiply8;
590 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
592 case AV_PIX_FMT_GBRP:
593 case AV_PIX_FMT_GBRAP:
594 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply8offset : premultiply8;
596 case AV_PIX_FMT_YUV444P9:
597 case AV_PIX_FMT_YUVA444P9:
598 case AV_PIX_FMT_YUV444P10:
599 case AV_PIX_FMT_YUVA444P10:
600 case AV_PIX_FMT_YUV444P12:
601 case AV_PIX_FMT_YUVA444P12:
602 case AV_PIX_FMT_YUV444P14:
603 case AV_PIX_FMT_YUV444P16:
604 case AV_PIX_FMT_YUVA444P16:
605 s->premultiply[0] = full ? premultiply16 : premultiply16offset;
606 s->premultiply[1] = s->premultiply[2] = premultiply16yuv;
608 case AV_PIX_FMT_GBRP9:
609 case AV_PIX_FMT_GBRP10:
610 case AV_PIX_FMT_GBRAP10:
611 case AV_PIX_FMT_GBRP12:
612 case AV_PIX_FMT_GBRAP12:
613 case AV_PIX_FMT_GBRP14:
614 case AV_PIX_FMT_GBRP16:
615 case AV_PIX_FMT_GBRAP16:
616 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply16offset : premultiply16;
618 case AV_PIX_FMT_GBRPF32:
619 case AV_PIX_FMT_GBRAPF32:
620 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiplyf32offset: premultiplyf32;
622 case AV_PIX_FMT_GRAY8:
623 s->premultiply[0] = limited ? premultiply8offset : premultiply8;
625 case AV_PIX_FMT_GRAY9:
626 case AV_PIX_FMT_GRAY10:
627 case AV_PIX_FMT_GRAY12:
628 case AV_PIX_FMT_GRAY14:
629 case AV_PIX_FMT_GRAY16:
630 s->premultiply[0] = limited ? premultiply16offset : premultiply16;
638 ctx->internal->execute(ctx, premultiply_slice, &td, NULL, FFMIN(s->height[0],
639 ff_filter_get_nb_threads(ctx)));
645 static int process_frame(FFFrameSync *fs)
647 AVFilterContext *ctx = fs->parent;
648 PreMultiplyContext *s = fs->opaque;
649 AVFilterLink *outlink = ctx->outputs[0];
650 AVFrame *out = NULL, *base, *alpha;
653 if ((ret = ff_framesync_get_frame(&s->fs, 0, &base, 0)) < 0 ||
654 (ret = ff_framesync_get_frame(&s->fs, 1, &alpha, 0)) < 0)
657 if ((ret = filter_frame(ctx, &out, base, alpha)) < 0)
660 out->pts = av_rescale_q(base->pts, s->fs.time_base, outlink->time_base);
662 return ff_filter_frame(outlink, out);
665 static int config_input(AVFilterLink *inlink)
667 AVFilterContext *ctx = inlink->dst;
668 PreMultiplyContext *s = ctx->priv;
669 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
672 s->nb_planes = av_pix_fmt_count_planes(inlink->format);
674 if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
677 hsub = desc->log2_chroma_w;
678 vsub = desc->log2_chroma_h;
679 s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
680 s->height[0] = s->height[3] = inlink->h;
681 s->width[1] = s->width[2] = AV_CEIL_RSHIFT(inlink->w, hsub);
682 s->width[0] = s->width[3] = inlink->w;
684 s->depth = desc->flags & AV_PIX_FMT_FLAG_FLOAT ? 16 : desc->comp[0].depth;
685 s->max = (1 << s->depth) - 1;
686 s->half = (1 << s->depth) / 2;
687 s->offset = 16 << (s->depth - 8);
692 static int config_output(AVFilterLink *outlink)
694 AVFilterContext *ctx = outlink->src;
695 PreMultiplyContext *s = ctx->priv;
696 AVFilterLink *base = ctx->inputs[0];
702 alpha = ctx->inputs[1];
704 if (base->format != alpha->format) {
705 av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
706 return AVERROR(EINVAL);
708 if (base->w != alpha->w ||
709 base->h != alpha->h) {
710 av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
711 "(size %dx%d) do not match the corresponding "
712 "second input link %s parameters (%dx%d) ",
713 ctx->input_pads[0].name, base->w, base->h,
714 ctx->input_pads[1].name, alpha->w, alpha->h);
715 return AVERROR(EINVAL);
719 outlink->w = base->w;
720 outlink->h = base->h;
721 outlink->time_base = base->time_base;
722 outlink->sample_aspect_ratio = base->sample_aspect_ratio;
723 outlink->frame_rate = base->frame_rate;
728 if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
732 in[0].time_base = base->time_base;
733 in[1].time_base = alpha->time_base;
735 in[0].before = EXT_STOP;
736 in[0].after = EXT_INFINITY;
738 in[1].before = EXT_STOP;
739 in[1].after = EXT_INFINITY;
741 s->fs.on_event = process_frame;
743 return ff_framesync_configure(&s->fs);
746 static int activate(AVFilterContext *ctx)
748 PreMultiplyContext *s = ctx->priv;
751 AVFrame *frame = NULL;
756 FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
758 if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &frame)) > 0) {
759 ret = filter_frame(ctx, &out, frame, frame);
760 av_frame_free(&frame);
763 ret = ff_filter_frame(ctx->outputs[0], out);
767 } else if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
768 ff_outlink_set_status(ctx->outputs[0], status, pts);
771 if (ff_outlink_frame_wanted(ctx->outputs[0]))
772 ff_inlink_request_frame(ctx->inputs[0]);
776 return ff_framesync_activate(&s->fs);
780 static av_cold int init(AVFilterContext *ctx)
782 PreMultiplyContext *s = ctx->priv;
783 AVFilterPad pad = { 0 };
786 if (!strcmp(ctx->filter->name, "unpremultiply"))
789 pad.type = AVMEDIA_TYPE_VIDEO;
791 pad.config_props = config_input;
793 if ((ret = ff_insert_inpad(ctx, 0, &pad)) < 0)
797 pad.type = AVMEDIA_TYPE_VIDEO;
799 pad.config_props = NULL;
801 if ((ret = ff_insert_inpad(ctx, 1, &pad)) < 0)
808 static av_cold void uninit(AVFilterContext *ctx)
810 PreMultiplyContext *s = ctx->priv;
813 ff_framesync_uninit(&s->fs);
816 static const AVFilterPad premultiply_outputs[] = {
819 .type = AVMEDIA_TYPE_VIDEO,
820 .config_props = config_output,
825 #if CONFIG_PREMULTIPLY_FILTER
827 const AVFilter ff_vf_premultiply = {
828 .name = "premultiply",
829 .description = NULL_IF_CONFIG_SMALL("PreMultiply first stream with first plane of second stream."),
830 .priv_size = sizeof(PreMultiplyContext),
833 .query_formats = query_formats,
834 .activate = activate,
836 .outputs = premultiply_outputs,
837 .priv_class = &premultiply_class,
838 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
839 AVFILTER_FLAG_DYNAMIC_INPUTS |
840 AVFILTER_FLAG_SLICE_THREADS,
843 #endif /* CONFIG_PREMULTIPLY_FILTER */
845 #if CONFIG_UNPREMULTIPLY_FILTER
847 #define unpremultiply_options options
848 AVFILTER_DEFINE_CLASS(unpremultiply);
850 const AVFilter ff_vf_unpremultiply = {
851 .name = "unpremultiply",
852 .description = NULL_IF_CONFIG_SMALL("UnPreMultiply first stream with first plane of second stream."),
853 .priv_size = sizeof(PreMultiplyContext),
856 .query_formats = query_formats,
857 .activate = activate,
859 .outputs = premultiply_outputs,
860 .priv_class = &unpremultiply_class,
861 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
862 AVFILTER_FLAG_DYNAMIC_INPUTS |
863 AVFILTER_FLAG_SLICE_THREADS,
866 #endif /* CONFIG_UNPREMULTIPLY_FILTER */