diff --git a/Changelog b/Changelog index cbeb248655..cae5254e2b 100644 --- a/Changelog +++ b/Changelog @@ -42,6 +42,7 @@ version : - FITS muxer and encoder - add --disable-autodetect build switch - drop deprecated qtkit input device (use avfoundation instead) +- despill video filter version 3.3: - CrystalHD decoder moved to new decode API diff --git a/doc/filters.texi b/doc/filters.texi index ce3f75dbd6..862290550d 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -6811,6 +6811,41 @@ FFmpeg was configured with @code{--enable-opencl}. Default value is 0. @end table +@section despill + +Remove unwanted contamination of foreground colors, caused by reflected color of +greenscreen or bluescreen. + +This filter accepts the following options: + +@table @option +@item type +Set what type of despill to use. + +@item mix +Set how spillmap will be generated. + +@item expand +Set how much to get rid of still remaining spill. + +@item red +Controls ammount of red in spill area. + +@item green +Controls ammount of green in spill area. +Should be -1 for greenscreen. + +@item blue +Controls ammount of blue in spill area. +Should be -1 for bluescreen. + +@item brightness +Controls brightness of spill area, preserving colors. + +@item alpha +Modify alpha from generated spillmap. +@end table + @section detelecine Apply an exact inverse of the telecine operation. It requires a predefined diff --git a/libavfilter/Makefile b/libavfilter/Makefile index ee840b02e5..1e460ab988 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -166,6 +166,7 @@ OBJS-$(CONFIG_DEINTERLACE_VAAPI_FILTER) += vf_deinterlace_vaapi.o OBJS-$(CONFIG_DEJUDDER_FILTER) += vf_dejudder.o OBJS-$(CONFIG_DELOGO_FILTER) += vf_delogo.o OBJS-$(CONFIG_DESHAKE_FILTER) += vf_deshake.o +OBJS-$(CONFIG_DESPILL_FILTER) += vf_despill.o OBJS-$(CONFIG_DETELECINE_FILTER) += vf_detelecine.o OBJS-$(CONFIG_DILATION_FILTER) += vf_neighbor.o OBJS-$(CONFIG_DISPLACE_FILTER) += vf_displace.o framesync2.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index 8b9b9a4d10..9a2cfea148 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -178,6 +178,7 @@ static void register_all(void) REGISTER_FILTER(DEJUDDER, dejudder, vf); REGISTER_FILTER(DELOGO, delogo, vf); REGISTER_FILTER(DESHAKE, deshake, vf); + REGISTER_FILTER(DESPILL, despill, vf); REGISTER_FILTER(DETELECINE, detelecine, vf); REGISTER_FILTER(DILATION, dilation, vf); REGISTER_FILTER(DISPLACE, displace, vf); diff --git a/libavfilter/version.h b/libavfilter/version.h index 60f18f7c51..4b16de1f8a 100644 --- a/libavfilter/version.h +++ b/libavfilter/version.h @@ -30,7 +30,7 @@ #include "libavutil/version.h" #define LIBAVFILTER_VERSION_MAJOR 6 -#define LIBAVFILTER_VERSION_MINOR 101 +#define LIBAVFILTER_VERSION_MINOR 102 #define LIBAVFILTER_VERSION_MICRO 100 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ diff --git a/libavfilter/vf_despill.c b/libavfilter/vf_despill.c new file mode 100644 index 0000000000..eff9877a1c --- /dev/null +++ b/libavfilter/vf_despill.c @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2017 Paul B Mahol + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "libavutil/opt.h" +#include "libavutil/imgutils.h" +#include "avfilter.h" +#include "formats.h" +#include "internal.h" +#include "video.h" + +typedef struct DespillContext { + const AVClass *class; + + int co[4]; /* color offsets rgba */ + + int alpha; + int type; + float spillmix; + float spillexpand; + float redscale; + float greenscale; + float bluescale; + float brightness; +} DespillContext; + +static int do_despill_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) +{ + DespillContext *s = ctx->priv; + AVFrame *frame = arg; + const int ro = s->co[0], go = s->co[1], bo = s->co[2], ao = s->co[3]; + const int slice_start = (frame->height * jobnr) / nb_jobs; + const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs; + const float brightness = s->brightness; + const float redscale = s->redscale; + const float greenscale = s->greenscale; + const float bluescale = s->bluescale; + const float spillmix = s->spillmix; + const float factor = (1.f - spillmix) * (1.f - s->spillexpand); + float red, green, blue; + int x, y; + + for (y = slice_start; y < slice_end; y++) { + uint8_t *dst = frame->data[0] + y * frame->linesize[0]; + + for (x = 0; x < frame->width; x++) { + float spillmap; + + red = dst[x * 4 + ro] / 255.f; + green = dst[x * 4 + go] / 255.f; + blue = dst[x * 4 + bo] / 255.f; + + if (s->type) { + spillmap = FFMAX(blue - (red * spillmix + green * factor), 0.f); + } else { + spillmap = FFMAX(green - (red * spillmix + blue * factor), 0.f); + } + + red = FFMAX(red + spillmap * redscale + brightness * spillmap, 0.f); + green = FFMAX(green + spillmap * greenscale + brightness * spillmap, 0.f); + blue = FFMAX(blue + spillmap * bluescale + brightness * spillmap, 0.f); + + dst[x * 4 + ro] = av_clip_uint8(red * 255); + dst[x * 4 + go] = av_clip_uint8(green * 255); + dst[x * 4 + bo] = av_clip_uint8(blue * 255); + if (s->alpha) { + spillmap = 1.f - spillmap; + dst[x * 4 + ao] = av_clip_uint8(spillmap * 255); + } + } + } + + return 0; +} + +static int filter_frame(AVFilterLink *link, AVFrame *frame) +{ + AVFilterContext *ctx = link->dst; + int ret; + + if (ret = av_frame_make_writable(frame)) + return ret; + + if (ret = ctx->internal->execute(ctx, do_despill_slice, frame, NULL, FFMIN(frame->height, ff_filter_get_nb_threads(ctx)))) + return ret; + + return ff_filter_frame(ctx->outputs[0], frame); +} + +static av_cold int config_output(AVFilterLink *outlink) +{ + AVFilterContext *ctx = outlink->src; + DespillContext *s = ctx->priv; + const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format); + int i; + + for (i = 0; i < 4; ++i) + s->co[i] = desc->comp[i].offset; + + return 0; +} + +static av_cold int query_formats(AVFilterContext *ctx) +{ + static const enum AVPixelFormat pixel_fmts[] = { + AV_PIX_FMT_ARGB, + AV_PIX_FMT_RGBA, + AV_PIX_FMT_ABGR, + AV_PIX_FMT_BGRA, + AV_PIX_FMT_NONE + }; + AVFilterFormats *formats = NULL; + + formats = ff_make_format_list(pixel_fmts); + if (!formats) + return AVERROR(ENOMEM); + + return ff_set_common_formats(ctx, formats); +} + +static const AVFilterPad despill_inputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .filter_frame = filter_frame, + }, + { NULL } +}; + +static const AVFilterPad despill_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .config_props = config_output, + }, + { NULL } +}; + +#define OFFSET(x) offsetof(DespillContext, x) +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM + +static const AVOption despill_options[] = { + { "type", "set the screen type", OFFSET(type), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "type" }, + { "green", "greenscreen", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "type" }, + { "blue", "bluescreen", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "type" }, + { "mix", "set the spillmap mix", OFFSET(spillmix), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGS }, + { "expand", "set the spillmap expand", OFFSET(spillexpand), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, FLAGS }, + { "red", "set red scale", OFFSET(bluescale), AV_OPT_TYPE_FLOAT, {.dbl=0}, -100, 100, FLAGS }, + { "green", "set green scale", OFFSET(greenscale), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -100, 100, FLAGS }, + { "blue", "set blue scale", OFFSET(bluescale), AV_OPT_TYPE_FLOAT, {.dbl=0}, -100, 100, FLAGS }, + { "brightness", "set brightness", OFFSET(brightness), AV_OPT_TYPE_FLOAT, {.dbl=0}, -10, 10, FLAGS }, + { "alpha", "change alpha component", OFFSET(alpha), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS }, + { NULL } +}; + +AVFILTER_DEFINE_CLASS(despill); + +AVFilter ff_vf_despill = { + .name = "despill", + .description = NULL_IF_CONFIG_SMALL("Despill video."), + .priv_size = sizeof(DespillContext), + .priv_class = &despill_class, + .query_formats = query_formats, + .inputs = despill_inputs, + .outputs = despill_outputs, + .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS, +};