mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-02 03:06:28 +02:00
790f793844
There are lots of files that don't need it: The number of object files that actually need it went down from 2011 to 884 here. Keep it for external users in order to not cause breakages. Also improve the other headers a bit while just at it. Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
256 lines
8.8 KiB
C
256 lines
8.8 KiB
C
/*
|
|
* 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/mem.h"
|
|
#include "libavutil/opt.h"
|
|
#include "libavutil/pixdesc.h"
|
|
#include "avfilter.h"
|
|
#include "internal.h"
|
|
#include "video.h"
|
|
|
|
typedef struct BackgroundkeyContext {
|
|
const AVClass *class;
|
|
|
|
float threshold;
|
|
float similarity;
|
|
float blend;
|
|
int max;
|
|
|
|
int nb_threads;
|
|
int hsub_log2;
|
|
int vsub_log2;
|
|
|
|
int64_t max_sum;
|
|
int64_t *sums;
|
|
|
|
AVFrame *background;
|
|
|
|
int (*do_slice)(AVFilterContext *avctx, void *arg,
|
|
int jobnr, int nb_jobs);
|
|
} BackgroundkeyContext;
|
|
|
|
static int do_backgroundkey_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
|
|
{
|
|
BackgroundkeyContext *s = avctx->priv;
|
|
AVFrame *frame = arg;
|
|
const int slice_start = (frame->height * jobnr) / nb_jobs;
|
|
const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
|
|
const int min_diff = (255 + 255 + 255) * s->similarity;
|
|
const float blend = s->blend;
|
|
const int hsub = s->hsub_log2;
|
|
const int vsub = s->vsub_log2;
|
|
int64_t sum = 0;
|
|
|
|
for (int y = slice_start; y < slice_end; y++) {
|
|
const uint8_t *srcy = frame->data[0] + frame->linesize[0] * y;
|
|
const uint8_t *srcu = frame->data[1] + frame->linesize[1] * (y >> vsub);
|
|
const uint8_t *srcv = frame->data[2] + frame->linesize[2] * (y >> vsub);
|
|
const uint8_t *bsrcy = s->background->data[0] + s->background->linesize[0] * y;
|
|
const uint8_t *bsrcu = s->background->data[1] + s->background->linesize[1] * (y >> vsub);
|
|
const uint8_t *bsrcv = s->background->data[2] + s->background->linesize[2] * (y >> vsub);
|
|
uint8_t *dst = frame->data[3] + frame->linesize[3] * y;
|
|
for (int x = 0; x < frame->width; x++) {
|
|
const int xx = x >> hsub;
|
|
const int diff = FFABS(srcy[x] - bsrcy[x]) +
|
|
FFABS(srcu[xx] - bsrcu[xx]) +
|
|
FFABS(srcv[xx] - bsrcv[xx]);
|
|
int A;
|
|
|
|
sum += diff;
|
|
if (blend > 0.f) {
|
|
A = 255 - av_clipf((min_diff - diff) / blend, 0.f, 255.f);
|
|
} else {
|
|
A = (diff > min_diff) ? 255 : 0;
|
|
}
|
|
|
|
dst[x] = A;
|
|
}
|
|
}
|
|
|
|
s->sums[jobnr] = sum;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_backgroundkey16_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
|
|
{
|
|
BackgroundkeyContext *s = avctx->priv;
|
|
AVFrame *frame = arg;
|
|
const int slice_start = (frame->height * jobnr) / nb_jobs;
|
|
const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
|
|
const int hsub = s->hsub_log2;
|
|
const int vsub = s->vsub_log2;
|
|
const int max = s->max;
|
|
const int min_diff = s->similarity * (s->max + s->max + s->max);
|
|
const float blend = s->blend;
|
|
int64_t sum = 0;
|
|
|
|
for (int y = slice_start; y < slice_end; y++) {
|
|
const uint16_t *srcy = (const uint16_t *)(frame->data[0] + frame->linesize[0] * y);
|
|
const uint16_t *srcu = (const uint16_t *)(frame->data[1] + frame->linesize[1] * (y >> vsub));
|
|
const uint16_t *srcv = (const uint16_t *)(frame->data[2] + frame->linesize[2] * (y >> vsub));
|
|
const uint16_t *bsrcy = (const uint16_t *)(s->background->data[0] + s->background->linesize[0] * y);
|
|
const uint16_t *bsrcu = (const uint16_t *)(s->background->data[1] + s->background->linesize[1] * (y >> vsub));
|
|
const uint16_t *bsrcv = (const uint16_t *)(s->background->data[2] + s->background->linesize[2] * (y >> vsub));
|
|
uint16_t *dst = (uint16_t *)(frame->data[3] + frame->linesize[3] * y);
|
|
for (int x = 0; x < frame->width; x++) {
|
|
const int xx = x >> hsub;
|
|
const int diff = FFABS(srcy[x] - bsrcy[x] ) +
|
|
FFABS(srcu[xx] - bsrcu[xx]) +
|
|
FFABS(srcv[xx] - bsrcv[xx]);
|
|
int A;
|
|
|
|
sum += diff;
|
|
if (blend > 0.f) {
|
|
A = max - av_clipf((min_diff - diff) / blend, 0.f, max);
|
|
} else {
|
|
A = (diff > min_diff) ? max : 0;
|
|
}
|
|
|
|
dst[x] = A;
|
|
}
|
|
}
|
|
|
|
s->sums[jobnr] = sum;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int filter_frame(AVFilterLink *link, AVFrame *frame)
|
|
{
|
|
AVFilterContext *avctx = link->dst;
|
|
BackgroundkeyContext *s = avctx->priv;
|
|
int64_t sum = 0;
|
|
int ret = 0;
|
|
|
|
if (!s->background) {
|
|
s->background = ff_get_video_buffer(link, frame->width, frame->height);
|
|
if (!s->background) {
|
|
ret = AVERROR(ENOMEM);
|
|
goto fail;
|
|
}
|
|
ret = av_frame_copy(s->background, frame);
|
|
if (ret < 0)
|
|
goto fail;
|
|
}
|
|
|
|
if (ret = ff_filter_execute(avctx, s->do_slice, frame, NULL,
|
|
FFMIN(frame->height, s->nb_threads)))
|
|
goto fail;
|
|
|
|
for (int n = 0; n < s->nb_threads; n++)
|
|
sum += s->sums[n];
|
|
if (s->max_sum * s->threshold < sum) {
|
|
ret = av_frame_copy(s->background, frame);
|
|
if (ret < 0)
|
|
goto fail;
|
|
}
|
|
|
|
return ff_filter_frame(avctx->outputs[0], frame);
|
|
fail:
|
|
av_frame_free(&frame);
|
|
return ret;
|
|
}
|
|
|
|
static av_cold int config_output(AVFilterLink *outlink)
|
|
{
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
|
|
AVFilterContext *avctx = outlink->src;
|
|
AVFilterLink *inlink = avctx->inputs[0];
|
|
BackgroundkeyContext *s = avctx->priv;
|
|
int depth;
|
|
|
|
s->nb_threads = ff_filter_get_nb_threads(avctx);
|
|
depth = desc->comp[0].depth;
|
|
s->do_slice = depth <= 8 ? do_backgroundkey_slice : do_backgroundkey16_slice;
|
|
s->max = (1 << depth) - 1;
|
|
s->hsub_log2 = desc->log2_chroma_w;
|
|
s->vsub_log2 = desc->log2_chroma_h;
|
|
s->max_sum = (int64_t)(inlink->w) * inlink->h * s->max;
|
|
s->max_sum += 2LL * (inlink->w >> s->hsub_log2) * (inlink->h >> s->vsub_log2) * s->max;
|
|
|
|
s->sums = av_calloc(s->nb_threads, sizeof(*s->sums));
|
|
if (!s->sums)
|
|
return AVERROR(ENOMEM);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static av_cold void uninit(AVFilterContext *ctx)
|
|
{
|
|
BackgroundkeyContext *s = ctx->priv;
|
|
|
|
av_frame_free(&s->background);
|
|
av_freep(&s->sums);
|
|
}
|
|
|
|
static const AVFilterPad backgroundkey_inputs[] = {
|
|
{
|
|
.name = "default",
|
|
.type = AVMEDIA_TYPE_VIDEO,
|
|
.flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
|
|
.filter_frame = filter_frame,
|
|
},
|
|
};
|
|
|
|
static const AVFilterPad backgroundkey_outputs[] = {
|
|
{
|
|
.name = "default",
|
|
.type = AVMEDIA_TYPE_VIDEO,
|
|
.config_props = config_output,
|
|
},
|
|
};
|
|
|
|
#define OFFSET(x) offsetof(BackgroundkeyContext, x)
|
|
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
|
|
|
|
static const AVOption backgroundkey_options[] = {
|
|
{ "threshold", "set the scene change threshold", OFFSET(threshold), AV_OPT_TYPE_FLOAT, { .dbl = 0.08}, 0.0, 1.0, FLAGS },
|
|
{ "similarity", "set the similarity", OFFSET(similarity), AV_OPT_TYPE_FLOAT, { .dbl = 0.1 }, 0.0, 1.0, FLAGS },
|
|
{ "blend", "set the blend value", OFFSET(blend), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, 0.0, 1.0, FLAGS },
|
|
{ NULL }
|
|
};
|
|
|
|
static const enum AVPixelFormat backgroundkey_fmts[] = {
|
|
AV_PIX_FMT_YUVA420P,
|
|
AV_PIX_FMT_YUVA422P,
|
|
AV_PIX_FMT_YUVA444P,
|
|
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_YUVA422P12, AV_PIX_FMT_YUVA444P12,
|
|
AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
|
|
AV_PIX_FMT_GBRAP,
|
|
AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
|
|
AV_PIX_FMT_NONE
|
|
};
|
|
|
|
AVFILTER_DEFINE_CLASS(backgroundkey);
|
|
|
|
const AVFilter ff_vf_backgroundkey = {
|
|
.name = "backgroundkey",
|
|
.description = NULL_IF_CONFIG_SMALL("Turns a static background into transparency."),
|
|
.priv_size = sizeof(BackgroundkeyContext),
|
|
.priv_class = &backgroundkey_class,
|
|
.uninit = uninit,
|
|
FILTER_INPUTS(backgroundkey_inputs),
|
|
FILTER_OUTPUTS(backgroundkey_outputs),
|
|
FILTER_PIXFMTS_ARRAY(backgroundkey_fmts),
|
|
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
|
|
.process_command = ff_filter_process_command,
|
|
};
|