diff options
| -rw-r--r-- | Changelog | 1 | ||||
| -rw-r--r-- | doc/filters.texi | 94 | ||||
| -rw-r--r-- | libavfilter/Makefile | 2 | ||||
| -rw-r--r-- | libavfilter/allfilters.c | 2 | ||||
| -rw-r--r-- | libavfilter/f_metadata.c | 341 | ||||
| -rw-r--r-- | libavfilter/version.h | 2 |
6 files changed, 441 insertions, 1 deletions
@@ -66,6 +66,7 @@ version <next>: - nnedi deinterlacer - streamselect video and astreamselect audio filter - swaprect filter +- metadata video and ametadata audio filter version 2.8: diff --git a/doc/filters.texi b/doc/filters.texi index 8ae402af58..56de876dca 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -8445,6 +8445,100 @@ format=rgb24,mergeplanes=0x000102:yuv444p @end example @end itemize +@section metadata, ametadata + +Manipulate frame metadata. + +This filter accepts the following options: + +@table @option +@item mode +Set mode of operation of the filter. + +Can be one of the following: + +@table @samp +@item select +If both @code{value} and @code{key} is set, select frames +which have such metadata. If only @code{key} is set, select +every frame that has such key in metadata. + +@item add +Add new metadata @code{key} and @code{value}. If key is already available +do nothing. + +@item modify +Modify value of already present key. + +@item delete +If @code{value} is set, delete only keys that have such value. +Otherwise, delete key. + +@item print +Print key and its value if metadata was found. If @code{key} is not set print all +metadata values available in frame. +@end table + +@item key +Set key used with all modes. Must be set for all modes except @code{print}. + +@item value +Set metadata value which will be used. This option is mandatory for +@code{modify} and @code{add} mode. + +@item length +Set length of how many characters of two metadata values need to match to be +considered same. Default is all available characters. + +@item function +Which function to use when comparing metadata value and @code{value}. + +Can be one of following: + +@table @samp +@item string +Values are interpreted as strings, returns true if @code{value} is same as metadata value up +to N chars as set in @code{length} option. + +@item less +Values are interpreted as floats, returns true if @code{value} is less than metadata value. + +@item equal +Values are interpreted as floats, returns true if @code{value} is equal with metadata value. + +@item greater +Values are interpreted as floats, returns true if @code{value} is greater than metadata value. + +@item expr +Values are interpreted as floats, returns true if expression from option @code{expr} +evaluates to true. +@end table + +@item expr +Set expression which is used when @code{function} is set to @code{expr}. +The expression is evaluated through the eval API and can contain the following +constants: + +@table @option +@item VALUE1 +Float representation of @code{value} from metadata key. + +@item VALUE2 +Float representation of @code{value} as supplied by user in @code{value} option. +@end table +@end table + +@subsection Examples + +@itemize +@item +Print all metadata values for frames with key @code{lavfi.singnalstats.YDIF} with values +between 0 and 1. +@example +@end example +signalstats,metadata=print:key=lavfi.signalstats.YDIF:function=expr:expr='between(VALUE1,0,1)' +@end itemize + @section mpdecimate Drop frames that do not differ greatly from the previous frame in diff --git a/libavfilter/Makefile b/libavfilter/Makefile index a1268e237f..8916588169 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 489da258f8..fa7d304907 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 0000000000..1969cb5e30 --- /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 d75d588198..1fe7757bf0 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, \ |