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_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) * (((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) * (((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_GRAY16:
468 s->premultiply[0] = limited ? unpremultiply16offset : unpremultiply16;
472 switch (outlink->format) {
473 case AV_PIX_FMT_YUV444P:
474 case AV_PIX_FMT_YUVA444P:
475 s->premultiply[0] = full ? premultiply8 : premultiply8offset;
476 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
478 case AV_PIX_FMT_YUVJ444P:
479 s->premultiply[0] = premultiply8;
480 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
482 case AV_PIX_FMT_GBRP:
483 case AV_PIX_FMT_GBRAP:
484 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply8offset : premultiply8;
486 case AV_PIX_FMT_YUV444P9:
487 case AV_PIX_FMT_YUVA444P9:
488 case AV_PIX_FMT_YUV444P10:
489 case AV_PIX_FMT_YUVA444P10:
490 case AV_PIX_FMT_YUV444P12:
491 case AV_PIX_FMT_YUV444P14:
492 case AV_PIX_FMT_YUV444P16:
493 case AV_PIX_FMT_YUVA444P16:
494 s->premultiply[0] = full ? premultiply16 : premultiply16offset;
495 s->premultiply[1] = s->premultiply[2] = premultiply16yuv;
497 case AV_PIX_FMT_GBRP9:
498 case AV_PIX_FMT_GBRP10:
499 case AV_PIX_FMT_GBRAP10:
500 case AV_PIX_FMT_GBRP12:
501 case AV_PIX_FMT_GBRAP12:
502 case AV_PIX_FMT_GBRP14:
503 case AV_PIX_FMT_GBRP16:
504 case AV_PIX_FMT_GBRAP16:
505 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply16offset : premultiply16;
507 case AV_PIX_FMT_GRAY8:
508 s->premultiply[0] = limited ? premultiply8offset : premultiply8;
510 case AV_PIX_FMT_GRAY9:
511 case AV_PIX_FMT_GRAY10:
512 case AV_PIX_FMT_GRAY12:
513 case AV_PIX_FMT_GRAY16:
514 s->premultiply[0] = limited ? premultiply16offset : premultiply16;
522 ctx->internal->execute(ctx, premultiply_slice, &td, NULL, FFMIN(s->height[0],
523 ff_filter_get_nb_threads(ctx)));
529 static int process_frame(FFFrameSync *fs)
531 AVFilterContext *ctx = fs->parent;
532 PreMultiplyContext *s = fs->opaque;
533 AVFilterLink *outlink = ctx->outputs[0];
534 AVFrame *out = NULL, *base, *alpha;
537 if ((ret = ff_framesync_get_frame(&s->fs, 0, &base, 0)) < 0 ||
538 (ret = ff_framesync_get_frame(&s->fs, 1, &alpha, 0)) < 0)
541 if ((ret = filter_frame(ctx, &out, base, alpha)) < 0)
544 out->pts = av_rescale_q(base->pts, s->fs.time_base, outlink->time_base);
546 return ff_filter_frame(outlink, out);
549 static int config_input(AVFilterLink *inlink)
551 AVFilterContext *ctx = inlink->dst;
552 PreMultiplyContext *s = ctx->priv;
553 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
556 s->nb_planes = av_pix_fmt_count_planes(inlink->format);
558 if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
561 hsub = desc->log2_chroma_w;
562 vsub = desc->log2_chroma_h;
563 s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
564 s->height[0] = s->height[3] = inlink->h;
565 s->width[1] = s->width[2] = AV_CEIL_RSHIFT(inlink->w, hsub);
566 s->width[0] = s->width[3] = inlink->w;
568 s->depth = desc->comp[0].depth;
569 s->max = (1 << s->depth) - 1;
570 s->half = (1 << s->depth) / 2;
571 s->offset = 16 << (s->depth - 8);
576 static int config_output(AVFilterLink *outlink)
578 AVFilterContext *ctx = outlink->src;
579 PreMultiplyContext *s = ctx->priv;
580 AVFilterLink *base = ctx->inputs[0];
586 alpha = ctx->inputs[1];
588 if (base->format != alpha->format) {
589 av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
590 return AVERROR(EINVAL);
592 if (base->w != alpha->w ||
593 base->h != alpha->h) {
594 av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
595 "(size %dx%d) do not match the corresponding "
596 "second input link %s parameters (%dx%d) ",
597 ctx->input_pads[0].name, base->w, base->h,
598 ctx->input_pads[1].name, alpha->w, alpha->h);
599 return AVERROR(EINVAL);
603 outlink->w = base->w;
604 outlink->h = base->h;
605 outlink->time_base = base->time_base;
606 outlink->sample_aspect_ratio = base->sample_aspect_ratio;
607 outlink->frame_rate = base->frame_rate;
612 if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
616 in[0].time_base = base->time_base;
617 in[1].time_base = alpha->time_base;
619 in[0].before = EXT_STOP;
620 in[0].after = EXT_INFINITY;
622 in[1].before = EXT_STOP;
623 in[1].after = EXT_INFINITY;
625 s->fs.on_event = process_frame;
627 return ff_framesync_configure(&s->fs);
630 static int activate(AVFilterContext *ctx)
632 PreMultiplyContext *s = ctx->priv;
635 AVFrame *frame = NULL;
640 if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &frame)) > 0) {
641 ret = filter_frame(ctx, &out, frame, frame);
642 av_frame_free(&frame);
645 ret = ff_filter_frame(ctx->outputs[0], out);
649 } else if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
650 ff_outlink_set_status(ctx->outputs[0], status, pts);
653 if (ff_outlink_frame_wanted(ctx->outputs[0]))
654 ff_inlink_request_frame(ctx->inputs[0]);
658 return ff_framesync_activate(&s->fs);
662 static av_cold int init(AVFilterContext *ctx)
664 PreMultiplyContext *s = ctx->priv;
665 AVFilterPad pad = { 0 };
668 if (!strcmp(ctx->filter->name, "unpremultiply"))
671 pad.type = AVMEDIA_TYPE_VIDEO;
672 pad.name = av_strdup("main");
673 pad.config_props = config_input;
675 return AVERROR(ENOMEM);
677 if ((ret = ff_insert_inpad(ctx, 0, &pad)) < 0) {
683 pad.type = AVMEDIA_TYPE_VIDEO;
684 pad.name = av_strdup("alpha");
685 pad.config_props = NULL;
687 return AVERROR(ENOMEM);
689 if ((ret = ff_insert_inpad(ctx, 1, &pad)) < 0) {
698 static av_cold void uninit(AVFilterContext *ctx)
700 PreMultiplyContext *s = ctx->priv;
703 ff_framesync_uninit(&s->fs);
706 static const AVFilterPad premultiply_outputs[] = {
709 .type = AVMEDIA_TYPE_VIDEO,
710 .config_props = config_output,
715 #if CONFIG_PREMULTIPLY_FILTER
717 AVFilter ff_vf_premultiply = {
718 .name = "premultiply",
719 .description = NULL_IF_CONFIG_SMALL("PreMultiply first stream with first plane of second stream."),
720 .priv_size = sizeof(PreMultiplyContext),
723 .query_formats = query_formats,
724 .activate = activate,
726 .outputs = premultiply_outputs,
727 .priv_class = &premultiply_class,
728 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
729 AVFILTER_FLAG_DYNAMIC_INPUTS |
730 AVFILTER_FLAG_SLICE_THREADS,
733 #endif /* CONFIG_PREMULTIPLY_FILTER */
735 #if CONFIG_UNPREMULTIPLY_FILTER
737 #define unpremultiply_options options
738 AVFILTER_DEFINE_CLASS(unpremultiply);
740 AVFilter ff_vf_unpremultiply = {
741 .name = "unpremultiply",
742 .description = NULL_IF_CONFIG_SMALL("UnPreMultiply first stream with first plane of second stream."),
743 .priv_size = sizeof(PreMultiplyContext),
746 .query_formats = query_formats,
747 .activate = activate,
749 .outputs = premultiply_outputs,
750 .priv_class = &unpremultiply_class,
751 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
752 AVFILTER_FLAG_DYNAMIC_INPUTS |
753 AVFILTER_FLAG_SLICE_THREADS,
756 #endif /* CONFIG_UNPREMULTIPLY_FILTER */