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,
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_YUVA444P16,
85 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
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 unpremultiply8(const uint8_t *msrc, const uint8_t *asrc,
223 ptrdiff_t mlinesize, ptrdiff_t alinesize,
226 int half, int max, int offset)
230 for (y = 0; y < h; y++) {
231 for (x = 0; x < w; x++) {
232 if (asrc[x] > 0 && asrc[x] < 255)
233 dst[x] = FFMIN(msrc[x] * 255 / asrc[x], 255);
244 static void unpremultiply8yuv(const uint8_t *msrc, const uint8_t *asrc,
246 ptrdiff_t mlinesize, ptrdiff_t alinesize,
249 int half, int max, int offset)
253 for (y = 0; y < h; y++) {
254 for (x = 0; x < w; x++) {
255 if (asrc[x] > 0 && asrc[x] < 255)
256 dst[x] = FFMIN((msrc[x] - 128) * 255 / asrc[x] + 128, 255);
267 static void unpremultiply8offset(const uint8_t *msrc, const uint8_t *asrc,
269 ptrdiff_t mlinesize, ptrdiff_t alinesize,
272 int half, int max, int offset)
276 for (y = 0; y < h; y++) {
277 for (x = 0; x < w; x++) {
278 if (asrc[x] > 0 && asrc[x] < 255)
279 dst[x] = FFMIN(FFMAX(msrc[x] - offset, 0) * 255 / asrc[x] + offset, 255);
290 static void unpremultiply16(const uint8_t *mmsrc, const uint8_t *aasrc,
292 ptrdiff_t mlinesize, ptrdiff_t alinesize,
295 int half, int max, int offset)
297 const uint16_t *msrc = (const uint16_t *)mmsrc;
298 const uint16_t *asrc = (const uint16_t *)aasrc;
299 uint16_t *dst = (uint16_t *)ddst;
302 for (y = 0; y < h; y++) {
303 for (x = 0; x < w; x++) {
304 if (asrc[x] > 0 && asrc[x] < max)
305 dst[x] = FFMIN(msrc[x] * (unsigned)max / asrc[x], max);
310 dst += dlinesize / 2;
311 msrc += mlinesize / 2;
312 asrc += alinesize / 2;
316 static void unpremultiply16yuv(const uint8_t *mmsrc, const uint8_t *aasrc,
318 ptrdiff_t mlinesize, ptrdiff_t alinesize,
321 int half, int max, int offset)
323 const uint16_t *msrc = (const uint16_t *)mmsrc;
324 const uint16_t *asrc = (const uint16_t *)aasrc;
325 uint16_t *dst = (uint16_t *)ddst;
328 for (y = 0; y < h; y++) {
329 for (x = 0; x < w; x++) {
330 if (asrc[x] > 0 && asrc[x] < max)
331 dst[x] = FFMAX(FFMIN((msrc[x] - half) * max / asrc[x], half - 1), -half) + half;
336 dst += dlinesize / 2;
337 msrc += mlinesize / 2;
338 asrc += alinesize / 2;
342 static void unpremultiply16offset(const uint8_t *mmsrc, const uint8_t *aasrc,
344 ptrdiff_t mlinesize, ptrdiff_t alinesize,
347 int half, int max, int offset)
349 const uint16_t *msrc = (const uint16_t *)mmsrc;
350 const uint16_t *asrc = (const uint16_t *)aasrc;
351 uint16_t *dst = (uint16_t *)ddst;
354 for (y = 0; y < h; y++) {
355 for (x = 0; x < w; x++) {
356 if (asrc[x] > 0 && asrc[x] < max)
357 dst[x] = FFMAX(FFMIN(FFMAX(msrc[x] - offset, 0) * (unsigned)max / asrc[x] + offset, max), 0);
362 dst += dlinesize / 2;
363 msrc += mlinesize / 2;
364 asrc += alinesize / 2;
368 static int premultiply_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
370 PreMultiplyContext *s = ctx->priv;
371 ThreadData *td = arg;
372 AVFrame *out = td->d;
373 AVFrame *alpha = td->a;
374 AVFrame *base = td->m;
377 for (p = 0; p < s->nb_planes; p++) {
378 const int slice_start = (s->height[p] * jobnr) / nb_jobs;
379 const int slice_end = (s->height[p] * (jobnr+1)) / nb_jobs;
381 if (!((1 << p) & s->planes) || p == 3) {
382 av_image_copy_plane(out->data[p] + slice_start * out->linesize[p],
384 base->data[p] + slice_start * base->linesize[p],
386 s->linesize[p], slice_end - slice_start);
390 s->premultiply[p](base->data[p] + slice_start * base->linesize[p],
391 s->inplace ? alpha->data[3] + slice_start * alpha->linesize[3] :
392 alpha->data[0] + slice_start * alpha->linesize[0],
393 out->data[p] + slice_start * out->linesize[p],
394 base->linesize[p], s->inplace ? alpha->linesize[3] : alpha->linesize[0],
396 s->width[p], slice_end - slice_start,
397 s->half, s->inverse ? s->max : s->depth, s->offset);
403 static int filter_frame(AVFilterContext *ctx,
404 AVFrame **out, AVFrame *base, AVFrame *alpha)
406 PreMultiplyContext *s = ctx->priv;
407 AVFilterLink *outlink = ctx->outputs[0];
409 if (ctx->is_disabled) {
410 *out = av_frame_clone(base);
412 return AVERROR(ENOMEM);
417 *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
419 return AVERROR(ENOMEM);
420 av_frame_copy_props(*out, base);
422 full = base->color_range == AVCOL_RANGE_JPEG;
423 limited = base->color_range == AVCOL_RANGE_MPEG;
426 switch (outlink->format) {
427 case AV_PIX_FMT_YUV444P:
428 case AV_PIX_FMT_YUVA444P:
429 s->premultiply[0] = full ? unpremultiply8 : unpremultiply8offset;
430 s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
432 case AV_PIX_FMT_YUVJ444P:
433 s->premultiply[0] = unpremultiply8;
434 s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
436 case AV_PIX_FMT_GBRP:
437 case AV_PIX_FMT_GBRAP:
438 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply8offset : unpremultiply8;
440 case AV_PIX_FMT_YUV444P9:
441 case AV_PIX_FMT_YUVA444P9:
442 case AV_PIX_FMT_YUV444P10:
443 case AV_PIX_FMT_YUVA444P10:
444 case AV_PIX_FMT_YUV444P12:
445 case AV_PIX_FMT_YUV444P14:
446 case AV_PIX_FMT_YUV444P16:
447 case AV_PIX_FMT_YUVA444P16:
448 s->premultiply[0] = full ? unpremultiply16 : unpremultiply16offset;
449 s->premultiply[1] = s->premultiply[2] = unpremultiply16yuv;
451 case AV_PIX_FMT_GBRP9:
452 case AV_PIX_FMT_GBRP10:
453 case AV_PIX_FMT_GBRAP10:
454 case AV_PIX_FMT_GBRP12:
455 case AV_PIX_FMT_GBRAP12:
456 case AV_PIX_FMT_GBRP14:
457 case AV_PIX_FMT_GBRP16:
458 case AV_PIX_FMT_GBRAP16:
459 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply16offset : unpremultiply16;
461 case AV_PIX_FMT_GRAY8:
462 s->premultiply[0] = limited ? unpremultiply8offset : unpremultiply8;
464 case AV_PIX_FMT_GRAY9:
465 case AV_PIX_FMT_GRAY10:
466 case AV_PIX_FMT_GRAY12:
467 case AV_PIX_FMT_GRAY14:
468 case AV_PIX_FMT_GRAY16:
469 s->premultiply[0] = limited ? unpremultiply16offset : unpremultiply16;
473 switch (outlink->format) {
474 case AV_PIX_FMT_YUV444P:
475 case AV_PIX_FMT_YUVA444P:
476 s->premultiply[0] = full ? premultiply8 : premultiply8offset;
477 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
479 case AV_PIX_FMT_YUVJ444P:
480 s->premultiply[0] = premultiply8;
481 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
483 case AV_PIX_FMT_GBRP:
484 case AV_PIX_FMT_GBRAP:
485 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply8offset : premultiply8;
487 case AV_PIX_FMT_YUV444P9:
488 case AV_PIX_FMT_YUVA444P9:
489 case AV_PIX_FMT_YUV444P10:
490 case AV_PIX_FMT_YUVA444P10:
491 case AV_PIX_FMT_YUV444P12:
492 case AV_PIX_FMT_YUV444P14:
493 case AV_PIX_FMT_YUV444P16:
494 case AV_PIX_FMT_YUVA444P16:
495 s->premultiply[0] = full ? premultiply16 : premultiply16offset;
496 s->premultiply[1] = s->premultiply[2] = premultiply16yuv;
498 case AV_PIX_FMT_GBRP9:
499 case AV_PIX_FMT_GBRP10:
500 case AV_PIX_FMT_GBRAP10:
501 case AV_PIX_FMT_GBRP12:
502 case AV_PIX_FMT_GBRAP12:
503 case AV_PIX_FMT_GBRP14:
504 case AV_PIX_FMT_GBRP16:
505 case AV_PIX_FMT_GBRAP16:
506 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply16offset : premultiply16;
508 case AV_PIX_FMT_GRAY8:
509 s->premultiply[0] = limited ? premultiply8offset : premultiply8;
511 case AV_PIX_FMT_GRAY9:
512 case AV_PIX_FMT_GRAY10:
513 case AV_PIX_FMT_GRAY12:
514 case AV_PIX_FMT_GRAY14:
515 case AV_PIX_FMT_GRAY16:
516 s->premultiply[0] = limited ? premultiply16offset : premultiply16;
524 ctx->internal->execute(ctx, premultiply_slice, &td, NULL, FFMIN(s->height[0],
525 ff_filter_get_nb_threads(ctx)));
531 static int process_frame(FFFrameSync *fs)
533 AVFilterContext *ctx = fs->parent;
534 PreMultiplyContext *s = fs->opaque;
535 AVFilterLink *outlink = ctx->outputs[0];
536 AVFrame *out = NULL, *base, *alpha;
539 if ((ret = ff_framesync_get_frame(&s->fs, 0, &base, 0)) < 0 ||
540 (ret = ff_framesync_get_frame(&s->fs, 1, &alpha, 0)) < 0)
543 if ((ret = filter_frame(ctx, &out, base, alpha)) < 0)
546 out->pts = av_rescale_q(base->pts, s->fs.time_base, outlink->time_base);
548 return ff_filter_frame(outlink, out);
551 static int config_input(AVFilterLink *inlink)
553 AVFilterContext *ctx = inlink->dst;
554 PreMultiplyContext *s = ctx->priv;
555 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
558 s->nb_planes = av_pix_fmt_count_planes(inlink->format);
560 if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
563 hsub = desc->log2_chroma_w;
564 vsub = desc->log2_chroma_h;
565 s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
566 s->height[0] = s->height[3] = inlink->h;
567 s->width[1] = s->width[2] = AV_CEIL_RSHIFT(inlink->w, hsub);
568 s->width[0] = s->width[3] = inlink->w;
570 s->depth = desc->comp[0].depth;
571 s->max = (1 << s->depth) - 1;
572 s->half = (1 << s->depth) / 2;
573 s->offset = 16 << (s->depth - 8);
578 static int config_output(AVFilterLink *outlink)
580 AVFilterContext *ctx = outlink->src;
581 PreMultiplyContext *s = ctx->priv;
582 AVFilterLink *base = ctx->inputs[0];
588 alpha = ctx->inputs[1];
590 if (base->format != alpha->format) {
591 av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
592 return AVERROR(EINVAL);
594 if (base->w != alpha->w ||
595 base->h != alpha->h) {
596 av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
597 "(size %dx%d) do not match the corresponding "
598 "second input link %s parameters (%dx%d) ",
599 ctx->input_pads[0].name, base->w, base->h,
600 ctx->input_pads[1].name, alpha->w, alpha->h);
601 return AVERROR(EINVAL);
605 outlink->w = base->w;
606 outlink->h = base->h;
607 outlink->time_base = base->time_base;
608 outlink->sample_aspect_ratio = base->sample_aspect_ratio;
609 outlink->frame_rate = base->frame_rate;
614 if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
618 in[0].time_base = base->time_base;
619 in[1].time_base = alpha->time_base;
621 in[0].before = EXT_STOP;
622 in[0].after = EXT_INFINITY;
624 in[1].before = EXT_STOP;
625 in[1].after = EXT_INFINITY;
627 s->fs.on_event = process_frame;
629 return ff_framesync_configure(&s->fs);
632 static int activate(AVFilterContext *ctx)
634 PreMultiplyContext *s = ctx->priv;
637 AVFrame *frame = NULL;
642 FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
644 if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &frame)) > 0) {
645 ret = filter_frame(ctx, &out, frame, frame);
646 av_frame_free(&frame);
649 ret = ff_filter_frame(ctx->outputs[0], out);
653 } else if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
654 ff_outlink_set_status(ctx->outputs[0], status, pts);
657 if (ff_outlink_frame_wanted(ctx->outputs[0]))
658 ff_inlink_request_frame(ctx->inputs[0]);
662 return ff_framesync_activate(&s->fs);
666 static av_cold int init(AVFilterContext *ctx)
668 PreMultiplyContext *s = ctx->priv;
669 AVFilterPad pad = { 0 };
672 if (!strcmp(ctx->filter->name, "unpremultiply"))
675 pad.type = AVMEDIA_TYPE_VIDEO;
676 pad.name = av_strdup("main");
677 pad.config_props = config_input;
679 return AVERROR(ENOMEM);
681 if ((ret = ff_insert_inpad(ctx, 0, &pad)) < 0) {
687 pad.type = AVMEDIA_TYPE_VIDEO;
688 pad.name = av_strdup("alpha");
689 pad.config_props = NULL;
691 return AVERROR(ENOMEM);
693 if ((ret = ff_insert_inpad(ctx, 1, &pad)) < 0) {
702 static av_cold void uninit(AVFilterContext *ctx)
704 PreMultiplyContext *s = ctx->priv;
707 ff_framesync_uninit(&s->fs);
710 static const AVFilterPad premultiply_outputs[] = {
713 .type = AVMEDIA_TYPE_VIDEO,
714 .config_props = config_output,
719 #if CONFIG_PREMULTIPLY_FILTER
721 AVFilter ff_vf_premultiply = {
722 .name = "premultiply",
723 .description = NULL_IF_CONFIG_SMALL("PreMultiply first stream with first plane of second stream."),
724 .priv_size = sizeof(PreMultiplyContext),
727 .query_formats = query_formats,
728 .activate = activate,
730 .outputs = premultiply_outputs,
731 .priv_class = &premultiply_class,
732 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
733 AVFILTER_FLAG_DYNAMIC_INPUTS |
734 AVFILTER_FLAG_SLICE_THREADS,
737 #endif /* CONFIG_PREMULTIPLY_FILTER */
739 #if CONFIG_UNPREMULTIPLY_FILTER
741 #define unpremultiply_options options
742 AVFILTER_DEFINE_CLASS(unpremultiply);
744 AVFilter ff_vf_unpremultiply = {
745 .name = "unpremultiply",
746 .description = NULL_IF_CONFIG_SMALL("UnPreMultiply first stream with first plane of second stream."),
747 .priv_size = sizeof(PreMultiplyContext),
750 .query_formats = query_formats,
751 .activate = activate,
753 .outputs = premultiply_outputs,
754 .priv_class = &unpremultiply_class,
755 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
756 AVFILTER_FLAG_DYNAMIC_INPUTS |
757 AVFILTER_FLAG_SLICE_THREADS,
760 #endif /* CONFIG_UNPREMULTIPLY_FILTER */