From 4ca8879d19893562040670f488a9c47aea77beb4 Mon Sep 17 00:00:00 2001 From: Paul B Mahol Date: Sat, 6 Feb 2016 11:19:45 +0100 Subject: avfilter: add metadata filters Signed-off-by: Paul B Mahol --- libavfilter/Makefile | 2 + libavfilter/allfilters.c | 2 + libavfilter/f_metadata.c | 341 +++++++++++++++++++++++++++++++++++++++++++++++ libavfilter/version.h | 2 +- 4 files changed, 346 insertions(+), 1 deletion(-) create mode 100644 libavfilter/f_metadata.c (limited to 'libavfilter') diff --git a/libavfilter/Makefile b/libavfilter/Makefile index a1268e2..8916588 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -39,6 +39,7 @@ OBJS-$(CONFIG_AINTERLEAVE_FILTER) += f_interleave.o OBJS-$(CONFIG_ALIMITER_FILTER) += af_alimiter.o OBJS-$(CONFIG_ALLPASS_FILTER) += af_biquads.o OBJS-$(CONFIG_AMERGE_FILTER) += af_amerge.o +OBJS-$(CONFIG_AMETADATA_FILTER) += f_metadata.o OBJS-$(CONFIG_AMIX_FILTER) += af_amix.o OBJS-$(CONFIG_ANULL_FILTER) += af_anull.o OBJS-$(CONFIG_APAD_FILTER) += af_apad.o @@ -186,6 +187,7 @@ 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_METADATA_FILTER) += f_metadata.o OBJS-$(CONFIG_MPDECIMATE_FILTER) += vf_mpdecimate.o OBJS-$(CONFIG_NEGATE_FILTER) += vf_lut.o OBJS-$(CONFIG_NNEDI_FILTER) += vf_nnedi.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index 489da25..fa7d304 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -59,6 +59,7 @@ void avfilter_register_all(void) REGISTER_FILTER(ALIMITER, alimiter, af); REGISTER_FILTER(ALLPASS, allpass, af); REGISTER_FILTER(AMERGE, amerge, af); + REGISTER_FILTER(AMETADATA, ametadata, af); REGISTER_FILTER(AMIX, amix, af); REGISTER_FILTER(ANEQUALIZER, anequalizer, af); REGISTER_FILTER(ANULL, anull, af); @@ -207,6 +208,7 @@ void avfilter_register_all(void) REGISTER_FILTER(MASKEDMERGE, maskedmerge, vf); REGISTER_FILTER(MCDEINT, mcdeint, vf); REGISTER_FILTER(MERGEPLANES, mergeplanes, vf); + REGISTER_FILTER(METADATA, metadata, vf); REGISTER_FILTER(MPDECIMATE, mpdecimate, vf); REGISTER_FILTER(NEGATE, negate, vf); REGISTER_FILTER(NNEDI, nnedi, vf); diff --git a/libavfilter/f_metadata.c b/libavfilter/f_metadata.c new file mode 100644 index 0000000..1969cb5 --- /dev/null +++ b/libavfilter/f_metadata.c @@ -0,0 +1,341 @@ +/* + * Copyright (c) 2016 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 + */ + +/** + * @file + * filter for manipulating frame metadata + */ + +#include "libavutil/avassert.h" +#include "libavutil/avstring.h" +#include "libavutil/eval.h" +#include "libavutil/fifo.h" +#include "libavutil/internal.h" +#include "libavutil/opt.h" +#include "libavutil/pixelutils.h" +#include "avfilter.h" +#include "audio.h" +#include "formats.h" +#include "internal.h" +#include "video.h" + +enum MetadataMode { + METADATA_SELECT, + METADATA_ADD, + METADATA_MODIFY, + METADATA_DELETE, + METADATA_PRINT, + METADATA_NB +}; + +enum MetadataFunction { + METADATAF_STRING, + METADATAF_LESS, + METADATAF_EQUAL, + METADATAF_GREATER, + METADATAF_EXPR, + METADATAF_NB +}; + +static const char *const var_names[] = { + "VALUE1", + "VALUE2", + NULL +}; + +enum var_name { + VAR_VALUE1, + VAR_VALUE2, + VAR_VARS_NB +}; + +typedef struct MetadataContext { + const AVClass *class; + + int mode; + char *key; + char *value; + int length; + int function; + + char *expr_str; + AVExpr *expr; + double var_values[VAR_VARS_NB]; + + int (*compare)(struct MetadataContext *s, + const char *value1, const char *value2, size_t length); +} MetadataContext; + +#define OFFSET(x) offsetof(MetadataContext, x) +#define DEFINE_OPTIONS(filt_name, FLAGS) \ +static const AVOption filt_name##_options[] = { \ + { "mode", "set a mode of operation", OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, METADATA_NB-1, FLAGS, "mode" }, \ + { "select", "select frame", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_SELECT }, 0, 0, FLAGS, "mode" }, \ + { "add", "add new metadata", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_ADD }, 0, 0, FLAGS, "mode" }, \ + { "modify", "modify metadata", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_MODIFY }, 0, 0, FLAGS, "mode" }, \ + { "delete", "delete metadata", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_DELETE }, 0, 0, FLAGS, "mode" }, \ + { "print", "print metadata", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_PRINT }, 0, 0, FLAGS, "mode" }, \ + { "key", "set metadata key", OFFSET(key), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \ + { "value", "set metadata value", OFFSET(value), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \ + { "function", "function for comparing values", OFFSET(function), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, METADATAF_NB-1, FLAGS, "function" }, \ + { "string", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_STRING }, 0, 3, FLAGS, "function" }, \ + { "less", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_LESS }, 0, 3, FLAGS, "function" }, \ + { "equal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_EQUAL }, 0, 3, FLAGS, "function" }, \ + { "greater", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_GREATER }, 0, 3, FLAGS, "function" }, \ + { "expr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_EXPR }, 0, 3, FLAGS, "function" }, \ + { "expr", "set expression for expr function", OFFSET(expr_str), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \ + { "length", "compare up to N chars for string function", OFFSET(length), AV_OPT_TYPE_INT, {.i64 = INT_MAX }, 1, INT_MAX, FLAGS }, \ + { NULL } \ +} + +static int string(MetadataContext *s, const char *value1, const char *value2, size_t length) +{ + return !strncmp(value1, value2, length); +} + +static int equal(MetadataContext *s, const char *value1, const char *value2, size_t length) +{ + float f1, f2; + + if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2) + return 0; + + return f1 == f2; +} + +static int less(MetadataContext *s, const char *value1, const char *value2, size_t length) +{ + float f1, f2; + + if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2) + return 0; + + return f1 > f2; +} + +static int greater(MetadataContext *s, const char *value1, const char *value2, size_t length) +{ + float f1, f2; + + if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2) + return 0; + + return f1 < f2; +} + +static int parse_expr(MetadataContext *s, const char *value1, const char *value2, size_t length) +{ + double f1, f2; + + if (sscanf(value1, "%lf", &f1) + sscanf(value2, "%lf", &f2) != 2) + return 0; + + s->var_values[VAR_VALUE1] = f1; + s->var_values[VAR_VALUE1] = f2; + + return av_expr_eval(s->expr, s->var_values, NULL); +} + +static av_cold int init(AVFilterContext *ctx) +{ + MetadataContext *s = ctx->priv; + int ret; + + if (!s->key && s->mode != METADATA_PRINT) { + av_log(ctx, AV_LOG_WARNING, "Metadata key must be set\n"); + return AVERROR(EINVAL); + } + + if ((s->mode == METADATA_MODIFY || + s->mode == METADATA_ADD) && !s->value) { + av_log(ctx, AV_LOG_WARNING, "Missing metadata value\n"); + return AVERROR(EINVAL); + } + + switch (s->function) { + case METADATAF_STRING: + s->compare = string; + break; + case METADATAF_LESS: + s->compare = less; + break; + case METADATAF_EQUAL: + s->compare = equal; + break; + case METADATAF_GREATER: + s->compare = greater; + break; + case METADATAF_EXPR: + s->compare = parse_expr; + break; + default: + av_assert0(0); + }; + + if (s->function == METADATAF_EXPR) { + if (!s->expr_str) { + av_log(ctx, AV_LOG_WARNING, "expr option not set\n"); + return AVERROR(EINVAL); + } + if ((ret = av_expr_parse(&s->expr, s->expr_str, + var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) { + av_log(ctx, AV_LOG_ERROR, "Error while parsing expression '%s'\n", s->expr_str); + return ret; + } + } + + return 0; +} + +static int filter_frame(AVFilterLink *inlink, AVFrame *frame) +{ + AVFilterContext *ctx = inlink->dst; + AVFilterLink *outlink = ctx->outputs[0]; + MetadataContext *s = ctx->priv; + AVDictionary *metadata = av_frame_get_metadata(frame); + AVDictionaryEntry *e; + + if (!metadata) + return ff_filter_frame(outlink, frame); + + e = av_dict_get(metadata, !s->key ? "" : s->key, NULL, + !s->key ? AV_DICT_IGNORE_SUFFIX: 0); + + switch (s->mode) { + case METADATA_SELECT: + if (!s->value && e && e->value) { + return ff_filter_frame(outlink, frame); + } else if (s->value && e && e->value && + s->compare(s, s->value, e->value, s->length)) { + return ff_filter_frame(outlink, frame); + } + break; + case METADATA_ADD: + if (e && e->value) { + ; + } else { + av_dict_set(&metadata, s->key, s->value, 0); + } + return ff_filter_frame(outlink, frame); + break; + case METADATA_MODIFY: + if (e && e->value) { + av_dict_set(&metadata, s->key, s->value, 0); + } + return ff_filter_frame(outlink, frame); + break; + case METADATA_PRINT: + if (!s->key && e) { + av_log(ctx, AV_LOG_INFO, "frame %"PRId64" pts %"PRId64"\n", inlink->frame_count, frame->pts); + av_log(ctx, AV_LOG_INFO, "%s=%s\n", e->key, e->value); + while ((e = av_dict_get(metadata, "", e, AV_DICT_IGNORE_SUFFIX)) != NULL) { + av_log(ctx, AV_LOG_INFO, "%s=%s\n", e->key, e->value); + } + } else if (e && e->value && (!s->value || (e->value && s->compare(s, s->value, e->value, s->length)))) { + av_log(ctx, AV_LOG_INFO, "frame %"PRId64" pts %"PRId64"\n", inlink->frame_count, frame->pts); + av_log(ctx, AV_LOG_INFO, "%s=%s\n", s->key, e->value); + } + return ff_filter_frame(outlink, frame); + break; + case METADATA_DELETE: + if (e && e->value && s->value && s->compare(s, s->value, e->value, s->length)) { + av_dict_set(&metadata, s->key, NULL, 0); + } else if (e && e->value) { + av_dict_set(&metadata, s->key, NULL, 0); + } + return ff_filter_frame(outlink, frame); + break; + default: + av_assert0(0); + }; + + av_frame_free(&frame); + + return 0; +} + +#if CONFIG_AMETADATA_FILTER + +DEFINE_OPTIONS(ametadata, AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM); +AVFILTER_DEFINE_CLASS(ametadata); + +static const AVFilterPad ainputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_AUDIO, + .filter_frame = filter_frame, + }, + { NULL } +}; + +static const AVFilterPad aoutputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_AUDIO, + }, + { NULL } +}; + +AVFilter ff_af_ametadata = { + .name = "ametadata", + .description = NULL_IF_CONFIG_SMALL("Manipulate audio frame metadata."), + .priv_size = sizeof(MetadataContext), + .priv_class = &ametadata_class, + .init = init, + .query_formats = ff_query_formats_all, + .inputs = ainputs, + .outputs = aoutputs, + .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, +}; +#endif /* CONFIG_AMETADATA_FILTER */ + +#if CONFIG_METADATA_FILTER + +DEFINE_OPTIONS(metadata, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM); +AVFILTER_DEFINE_CLASS(metadata); + +static const AVFilterPad inputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .filter_frame = filter_frame, + }, + { NULL } +}; + +static const AVFilterPad outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + }, + { NULL } +}; + +AVFilter ff_vf_metadata = { + .name = "metadata", + .description = NULL_IF_CONFIG_SMALL("Manipulate video frame metadata."), + .priv_size = sizeof(MetadataContext), + .priv_class = &metadata_class, + .init = init, + .inputs = inputs, + .outputs = outputs, + .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, +}; +#endif /* CONFIG_METADATA_FILTER */ diff --git a/libavfilter/version.h b/libavfilter/version.h index d75d588..1fe7757 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 30 +#define LIBAVFILTER_VERSION_MINOR 31 #define LIBAVFILTER_VERSION_MICRO 100 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ -- cgit v1.1