videolan
/
ffmpeg
mirror of https://git.videolan.org/git/ffmpeg.git
1
Fork 0
Code Releases Activity

avfilter: add maskedmerge filter 

Signed-off-by: Paul B Mahol <onemda@gmail.com>
This commit is contained in:
Paul B Mahol 2015-09-25 22:46:38 +02:00
parent 235381e674
commit 691a7df3c5
6 changed files with 347 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Changelog
View File

@ -12,6 +12,7 @@ version <next>:
- tremolo filter
- agate filter
- chromakey filter
- maskedmerge filter
version 2.8:

19
doc/filters.texi
View File

@ -7625,6 +7625,25 @@ lutyuv=y='bitand(val, 128+64+32)'
@end example
@end itemize
@section maskedmerge
Merge the first input stream with the second input stream using per pixel
weights in the third input stream.
A value of 0 in the third stream pixel component means that pixel component
from first stream is returned unchanged, while maximum value (eg. 255 for
8-bit videos) means that pixel component from second stream is returned
unchanged. Intermediate values define the amount of merging between both
input stream's pixel components.
This filter accepts the following options:
@table @option
@item planes
Set which planes will be processed as bitmap, unprocessed planes will be
copied from first stream.
By default value 0xf, all planes will be processed.
@end table
@section mergeplanes
Merge color channel components from several video streams.

1
libavfilter/Makefile
View File

@ -169,6 +169,7 @@ OBJS-$(CONFIG_LUT3D_FILTER) += vf_lut3d.o
OBJS-$(CONFIG_LUT_FILTER) += vf_lut.o
OBJS-$(CONFIG_LUTRGB_FILTER) += vf_lut.o
OBJS-$(CONFIG_LUTYUV_FILTER) += vf_lut.o
OBJS-$(CONFIG_MASKEDMERGE_FILTER) += vf_maskedmerge.o framesync.o
OBJS-$(CONFIG_MCDEINT_FILTER) += vf_mcdeint.o
OBJS-$(CONFIG_MERGEPLANES_FILTER) += vf_mergeplanes.o framesync.o
OBJS-$(CONFIG_MPDECIMATE_FILTER) += vf_mpdecimate.o

1
libavfilter/allfilters.c
View File

@ -191,6 +191,7 @@ void avfilter_register_all(void)
REGISTER_FILTER(LUT, lut, vf);
REGISTER_FILTER(LUTRGB, lutrgb, vf);
REGISTER_FILTER(LUTYUV, lutyuv, vf);
REGISTER_FILTER(MASKEDMERGE, maskedmerge, vf);
REGISTER_FILTER(MCDEINT, mcdeint, vf);
REGISTER_FILTER(MERGEPLANES, mergeplanes, vf);
REGISTER_FILTER(MPDECIMATE, mpdecimate, vf);

2
libavfilter/version.h
View File

@ -30,7 +30,7 @@
#include "libavutil/version.h"
#define LIBAVFILTER_VERSION_MAJOR 6
#define LIBAVFILTER_VERSION_MINOR 8
#define LIBAVFILTER_VERSION_MINOR 9
#define LIBAVFILTER_VERSION_MICRO 100
#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \

324
libavfilter/vf_maskedmerge.c Normal file
View File

@ -0,0 +1,324 @@
/*
* Copyright (c) 2015 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/imgutils.h"
#include "libavutil/pixdesc.h"
#include "libavutil/opt.h"
#include "avfilter.h"
#include "formats.h"
#include "framesync.h"
#include "internal.h"
#include "video.h"
typedef struct MaskedMergeContext {
const AVClass *class;
int width[4], height[4];
int nb_planes;
int planes;
int max, half, depth;
FFFrameSync fs;
void (*maskedmerge)(struct MaskedMergeContext *s, const AVFrame *base,
const AVFrame *overlay, const AVFrame *mask, AVFrame *out);
} MaskedMergeContext;
#define OFFSET(x) offsetof(MaskedMergeContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
static const AVOption maskedmerge_options[] = {
{ "planes", "set planes", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
{ NULL }
};
AVFILTER_DEFINE_CLASS(maskedmerge);
static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP16,
AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
AV_PIX_FMT_NONE
};
ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
return 0;
}
static int process_frame(FFFrameSync *fs)
{
AVFilterContext *ctx = fs->parent;
MaskedMergeContext *s = fs->opaque;
AVFilterLink *outlink = ctx->outputs[0];
AVFrame *out, *base, *overlay, *mask;
int ret;
if ((ret = ff_framesync_get_frame(&s->fs, 0, &base, 0)) < 0 ||
(ret = ff_framesync_get_frame(&s->fs, 1, &overlay, 0)) < 0 ||
(ret = ff_framesync_get_frame(&s->fs, 2, &mask, 0)) < 0)
return ret;
if (ctx->is_disabled) {
out = av_frame_clone(base);
if (!out)
return AVERROR(ENOMEM);
} else {
out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
if (!out)
return AVERROR(ENOMEM);
av_frame_copy_props(out, base);
s->maskedmerge(s, base, overlay, mask, out);
}
out->pts = av_rescale_q(base->pts, s->fs.time_base, outlink->time_base);
return ff_filter_frame(outlink, out);
}
static void maskedmerge8(MaskedMergeContext *s, const AVFrame *base,
const AVFrame *overlay, const AVFrame *mask, AVFrame *out)
{
int p, x, y;
for (p = 0; p < s->nb_planes; p++) {
const uint8_t *bsrc = base->data[p];
const uint8_t *osrc = overlay->data[p];
const uint8_t *msrc = mask->data[p];
uint8_t *dst = out->data[p];
if (!((1 << p) & s->planes)) {
av_image_copy_plane(dst, out->linesize[p], bsrc, base->linesize[p],
s->width[p], s->height[p]);
continue;
}
for (y = 0; y < s->height[p]; y++) {
for (x = 0; x < s->width[p]; x++) {
dst[x] = ((256 - msrc[x]) * bsrc[x] + msrc[x] * osrc[x] + 128) >> 8;
}
dst += out->linesize[p];
bsrc += base->linesize[p];
osrc += overlay->linesize[p];
msrc += mask->linesize[p];
}
}
}
static void maskedmerge16(MaskedMergeContext *s, const AVFrame *base,
const AVFrame *overlay, const AVFrame *mask, AVFrame *out)
{
const int max = s->max;
const int half = s->half;
const int shift = s->depth;
int p, x, y;
for (p = 0; p < s->nb_planes; p++) {
const uint16_t *bsrc = (const uint16_t *)base->data[p];
const uint16_t *osrc = (const uint16_t *)overlay->data[p];
const uint16_t *msrc = (const uint16_t *)mask->data[p];
uint16_t *dst = (uint16_t *)out->data[p];
if (!((1 << p) & s->planes)) {
av_image_copy_plane(out->data[p], out->linesize[p], base->data[p], base->linesize[p],
s->width[p], s->height[p]);
continue;
}
for (y = 0; y < s->height[p]; y++) {
for (x = 0; x < s->width[p]; x++) {
dst[x] = ((max - msrc[x]) * bsrc[x] + msrc[x] * osrc[x] + half) >> shift;
}
dst += out->linesize[p] / 2;
bsrc += base->linesize[p] / 2;
osrc += overlay->linesize[p] / 2;
msrc += mask->linesize[p] / 2;
}
}
}
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
MaskedMergeContext *s = ctx->priv;
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
int vsub, hsub;
s->nb_planes = av_pix_fmt_count_planes(inlink->format);
hsub = desc->log2_chroma_w;
vsub = desc->log2_chroma_h;
s->height[1] = s->height[2] = FF_CEIL_RSHIFT(inlink->h, vsub);
s->height[0] = s->height[3] = inlink->h;
s->width[1] = s->width[2] = FF_CEIL_RSHIFT(inlink->w, hsub);
s->width[0] = s->width[3] = inlink->w;
s->depth = desc->comp[0].depth;
s->max = 1 << s->depth;
s->half = s->max / 2;
if (desc->comp[0].depth == 8)
s->maskedmerge = maskedmerge8;
else
s->maskedmerge = maskedmerge16;
return 0;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
MaskedMergeContext *s = ctx->priv;
AVFilterLink *base = ctx->inputs[0];
AVFilterLink *overlay = ctx->inputs[1];
AVFilterLink *mask = ctx->inputs[2];
FFFrameSyncIn *in;
int ret;
if (base->format != overlay->format ||
base->format != mask->format) {
av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
return AVERROR(EINVAL);
}
if (base->w != overlay->w ||
base->h != overlay->h ||
base->sample_aspect_ratio.num != overlay->sample_aspect_ratio.num ||
base->sample_aspect_ratio.den != overlay->sample_aspect_ratio.den ||
base->w != mask->w ||
base->h != mask->h ||
base->sample_aspect_ratio.num != mask->sample_aspect_ratio.num ||
base->sample_aspect_ratio.den != mask->sample_aspect_ratio.den) {
av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
"(size %dx%d, SAR %d:%d) do not match the corresponding "
"second input link %s parameters (%dx%d, SAR %d:%d) "
"and/or third input link %s parameters (%dx%d, SAR %d:%d)\n",
ctx->input_pads[0].name, base->w, base->h,
base->sample_aspect_ratio.num,
base->sample_aspect_ratio.den,
ctx->input_pads[1].name, overlay->w, overlay->h,
overlay->sample_aspect_ratio.num,
overlay->sample_aspect_ratio.den,
ctx->input_pads[2].name, mask->w, mask->h,
mask->sample_aspect_ratio.num,
mask->sample_aspect_ratio.den);
return AVERROR(EINVAL);
}
outlink->w = base->w;
outlink->h = base->h;
outlink->time_base = base->time_base;
outlink->sample_aspect_ratio = base->sample_aspect_ratio;
outlink->frame_rate = base->frame_rate;
if ((ret = ff_framesync_init(&s->fs, ctx, 3)) < 0)
return ret;
in = s->fs.in;
in[0].time_base = base->time_base;
in[1].time_base = overlay->time_base;
in[2].time_base = mask->time_base;
in[0].sync = 1;
in[0].before = EXT_STOP;
in[0].after = EXT_INFINITY;
in[1].sync = 1;
in[1].before = EXT_STOP;
in[1].after = EXT_INFINITY;
in[2].sync = 1;
in[2].before = EXT_STOP;
in[2].after = EXT_INFINITY;
s->fs.opaque = s;
s->fs.on_event = process_frame;
return ff_framesync_configure(&s->fs);
}
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
{
MaskedMergeContext *s = inlink->dst->priv;
return ff_framesync_filter_frame(&s->fs, inlink, buf);
}
static int request_frame(AVFilterLink *outlink)
{
MaskedMergeContext *s = outlink->src->priv;
return ff_framesync_request_frame(&s->fs, outlink);
}
static av_cold void uninit(AVFilterContext *ctx)
{
MaskedMergeContext *s = ctx->priv;
ff_framesync_uninit(&s->fs);
}
static const AVFilterPad maskedmerge_inputs[] = {
{
.name = "base",
.type = AVMEDIA_TYPE_VIDEO,
.filter_frame = filter_frame,
.config_props = config_input,
},
{
.name = "overlay",
.type = AVMEDIA_TYPE_VIDEO,
.filter_frame = filter_frame,
},
{
.name = "mask",
.type = AVMEDIA_TYPE_VIDEO,
.filter_frame = filter_frame,
},
{ NULL }
};
static const AVFilterPad maskedmerge_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
.config_props = config_output,
.request_frame = request_frame,
},
{ NULL }
};
AVFilter ff_vf_maskedmerge = {
.name = "maskedmerge",
.description = NULL_IF_CONFIG_SMALL("Merge first stream with second stream using third stream as mask."),
.priv_size = sizeof(MaskedMergeContext),
.uninit = uninit,
.query_formats = query_formats,
.inputs = maskedmerge_inputs,
.outputs = maskedmerge_outputs,
.priv_class = &maskedmerge_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
};