avfilter: add metadata filters
[ffmpeg.git] / libavfilter / f_metadata.c
1 /*
2  * Copyright (c) 2016 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * filter for manipulating frame metadata
24  */
25
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/eval.h"
29 #include "libavutil/fifo.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixelutils.h"
33 #include "avfilter.h"
34 #include "audio.h"
35 #include "formats.h"
36 #include "internal.h"
37 #include "video.h"
38
39 enum MetadataMode {
40     METADATA_SELECT,
41     METADATA_ADD,
42     METADATA_MODIFY,
43     METADATA_DELETE,
44     METADATA_PRINT,
45     METADATA_NB
46 };
47
48 enum MetadataFunction {
49     METADATAF_STRING,
50     METADATAF_LESS,
51     METADATAF_EQUAL,
52     METADATAF_GREATER,
53     METADATAF_EXPR,
54     METADATAF_NB
55 };
56
57 static const char *const var_names[] = {
58     "VALUE1",
59     "VALUE2",
60     NULL
61 };
62
63 enum var_name {
64     VAR_VALUE1,
65     VAR_VALUE2,
66     VAR_VARS_NB
67 };
68
69 typedef struct MetadataContext {
70     const AVClass *class;
71
72     int mode;
73     char *key;
74     char *value;
75     int length;
76     int function;
77
78     char *expr_str;
79     AVExpr *expr;
80     double var_values[VAR_VARS_NB];
81
82     int (*compare)(struct MetadataContext *s,
83                    const char *value1, const char *value2, size_t length);
84 } MetadataContext;
85
86 #define OFFSET(x) offsetof(MetadataContext, x)
87 #define DEFINE_OPTIONS(filt_name, FLAGS)                            \
88 static const AVOption filt_name##_options[] = {                     \
89     { "mode", "set a mode of operation", OFFSET(mode),   AV_OPT_TYPE_INT,    {.i64 = 0 }, 0, METADATA_NB-1, FLAGS, "mode" }, \
90     {   "select", "select frame",        0,              AV_OPT_TYPE_CONST,  {.i64 = METADATA_SELECT }, 0, 0, FLAGS, "mode" }, \
91     {   "add",    "add new metadata",    0,              AV_OPT_TYPE_CONST,  {.i64 = METADATA_ADD },    0, 0, FLAGS, "mode" }, \
92     {   "modify", "modify metadata",     0,              AV_OPT_TYPE_CONST,  {.i64 = METADATA_MODIFY }, 0, 0, FLAGS, "mode" }, \
93     {   "delete", "delete metadata",     0,              AV_OPT_TYPE_CONST,  {.i64 = METADATA_DELETE }, 0, 0, FLAGS, "mode" }, \
94     {   "print",  "print metadata",      0,              AV_OPT_TYPE_CONST,  {.i64 = METADATA_PRINT },  0, 0, FLAGS, "mode" }, \
95     { "key",   "set metadata key",       OFFSET(key),    AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \
96     { "value", "set metadata value",     OFFSET(value),  AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \
97     { "function", "function for comparing values", OFFSET(function), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, METADATAF_NB-1, FLAGS, "function" }, \
98     {   "string",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_STRING  }, 0, 3, FLAGS, "function" }, \
99     {   "less",    NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_LESS    }, 0, 3, FLAGS, "function" }, \
100     {   "equal",   NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_EQUAL   }, 0, 3, FLAGS, "function" }, \
101     {   "greater", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_GREATER }, 0, 3, FLAGS, "function" }, \
102     {   "expr",    NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_EXPR    }, 0, 3, FLAGS, "function" }, \
103     { "expr", "set expression for expr function", OFFSET(expr_str), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \
104     { "length", "compare up to N chars for string function", OFFSET(length), AV_OPT_TYPE_INT,    {.i64 = INT_MAX }, 1, INT_MAX, FLAGS }, \
105     { NULL }                                                            \
106 }
107
108 static int string(MetadataContext *s, const char *value1, const char *value2, size_t length)
109 {
110     return !strncmp(value1, value2, length);
111 }
112
113 static int equal(MetadataContext *s, const char *value1, const char *value2, size_t length)
114 {
115     float f1, f2;
116
117     if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2)
118         return 0;
119
120     return f1 == f2;
121 }
122
123 static int less(MetadataContext *s, const char *value1, const char *value2, size_t length)
124 {
125     float f1, f2;
126
127     if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2)
128         return 0;
129
130     return f1 > f2;
131 }
132
133 static int greater(MetadataContext *s, const char *value1, const char *value2, size_t length)
134 {
135     float f1, f2;
136
137     if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2)
138         return 0;
139
140     return f1 < f2;
141 }
142
143 static int parse_expr(MetadataContext *s, const char *value1, const char *value2, size_t length)
144 {
145     double f1, f2;
146
147     if (sscanf(value1, "%lf", &f1) + sscanf(value2, "%lf", &f2) != 2)
148         return 0;
149
150     s->var_values[VAR_VALUE1] = f1;
151     s->var_values[VAR_VALUE1] = f2;
152
153     return av_expr_eval(s->expr, s->var_values, NULL);
154 }
155
156 static av_cold int init(AVFilterContext *ctx)
157 {
158     MetadataContext *s = ctx->priv;
159     int ret;
160
161     if (!s->key && s->mode != METADATA_PRINT) {
162         av_log(ctx, AV_LOG_WARNING, "Metadata key must be set\n");
163         return AVERROR(EINVAL);
164     }
165
166     if ((s->mode == METADATA_MODIFY ||
167         s->mode == METADATA_ADD) && !s->value) {
168         av_log(ctx, AV_LOG_WARNING, "Missing metadata value\n");
169         return AVERROR(EINVAL);
170     }
171
172     switch (s->function) {
173     case METADATAF_STRING:
174         s->compare = string;
175         break;
176     case METADATAF_LESS:
177         s->compare = less;
178         break;
179     case METADATAF_EQUAL:
180         s->compare = equal;
181         break;
182     case METADATAF_GREATER:
183         s->compare = greater;
184         break;
185     case METADATAF_EXPR:
186         s->compare = parse_expr;
187         break;
188     default:
189         av_assert0(0);
190     };
191
192     if (s->function == METADATAF_EXPR) {
193         if (!s->expr_str) {
194             av_log(ctx, AV_LOG_WARNING, "expr option not set\n");
195             return AVERROR(EINVAL);
196         }
197         if ((ret = av_expr_parse(&s->expr, s->expr_str,
198                                  var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
199             av_log(ctx, AV_LOG_ERROR, "Error while parsing expression '%s'\n", s->expr_str);
200             return ret;
201         }
202     }
203
204     return 0;
205 }
206
207 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
208 {
209     AVFilterContext *ctx = inlink->dst;
210     AVFilterLink *outlink = ctx->outputs[0];
211     MetadataContext *s = ctx->priv;
212     AVDictionary *metadata = av_frame_get_metadata(frame);
213     AVDictionaryEntry *e;
214
215     if (!metadata)
216         return ff_filter_frame(outlink, frame);
217
218     e = av_dict_get(metadata, !s->key ? "" : s->key, NULL,
219                     !s->key ? AV_DICT_IGNORE_SUFFIX: 0);
220
221     switch (s->mode) {
222     case METADATA_SELECT:
223         if (!s->value && e && e->value) {
224             return ff_filter_frame(outlink, frame);
225         } else if (s->value && e && e->value &&
226                    s->compare(s, s->value, e->value, s->length)) {
227             return ff_filter_frame(outlink, frame);
228         }
229         break;
230     case METADATA_ADD:
231         if (e && e->value) {
232             ;
233         } else {
234             av_dict_set(&metadata, s->key, s->value, 0);
235         }
236         return ff_filter_frame(outlink, frame);
237         break;
238     case METADATA_MODIFY:
239         if (e && e->value) {
240             av_dict_set(&metadata, s->key, s->value, 0);
241         }
242         return ff_filter_frame(outlink, frame);
243         break;
244     case METADATA_PRINT:
245         if (!s->key && e) {
246             av_log(ctx, AV_LOG_INFO, "frame %"PRId64" pts %"PRId64"\n", inlink->frame_count, frame->pts);
247             av_log(ctx, AV_LOG_INFO, "%s=%s\n", e->key, e->value);
248             while ((e = av_dict_get(metadata, "", e, AV_DICT_IGNORE_SUFFIX)) != NULL) {
249                 av_log(ctx, AV_LOG_INFO, "%s=%s\n", e->key, e->value);
250             }
251         } else if (e && e->value && (!s->value || (e->value && s->compare(s, s->value, e->value, s->length)))) {
252             av_log(ctx, AV_LOG_INFO, "frame %"PRId64" pts %"PRId64"\n", inlink->frame_count, frame->pts);
253             av_log(ctx, AV_LOG_INFO, "%s=%s\n", s->key, e->value);
254         }
255         return ff_filter_frame(outlink, frame);
256         break;
257     case METADATA_DELETE:
258         if (e && e->value && s->value && s->compare(s, s->value, e->value, s->length)) {
259             av_dict_set(&metadata, s->key, NULL, 0);
260         } else if (e && e->value) {
261             av_dict_set(&metadata, s->key, NULL, 0);
262         }
263         return ff_filter_frame(outlink, frame);
264         break;
265     default:
266         av_assert0(0);
267     };
268
269     av_frame_free(&frame);
270
271     return 0;
272 }
273
274 #if CONFIG_AMETADATA_FILTER
275
276 DEFINE_OPTIONS(ametadata, AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM);
277 AVFILTER_DEFINE_CLASS(ametadata);
278
279 static const AVFilterPad ainputs[] = {
280     {
281         .name         = "default",
282         .type         = AVMEDIA_TYPE_AUDIO,
283         .filter_frame = filter_frame,
284     },
285     { NULL }
286 };
287
288 static const AVFilterPad aoutputs[] = {
289     {
290         .name = "default",
291         .type = AVMEDIA_TYPE_AUDIO,
292     },
293     { NULL }
294 };
295
296 AVFilter ff_af_ametadata = {
297     .name          = "ametadata",
298     .description   = NULL_IF_CONFIG_SMALL("Manipulate audio frame metadata."),
299     .priv_size     = sizeof(MetadataContext),
300     .priv_class    = &ametadata_class,
301     .init          = init,
302     .query_formats = ff_query_formats_all,
303     .inputs        = ainputs,
304     .outputs       = aoutputs,
305     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
306 };
307 #endif /* CONFIG_AMETADATA_FILTER */
308
309 #if CONFIG_METADATA_FILTER
310
311 DEFINE_OPTIONS(metadata, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM);
312 AVFILTER_DEFINE_CLASS(metadata);
313
314 static const AVFilterPad inputs[] = {
315     {
316         .name         = "default",
317         .type         = AVMEDIA_TYPE_VIDEO,
318         .filter_frame = filter_frame,
319     },
320     { NULL }
321 };
322
323 static const AVFilterPad outputs[] = {
324     {
325         .name = "default",
326         .type = AVMEDIA_TYPE_VIDEO,
327     },
328     { NULL }
329 };
330
331 AVFilter ff_vf_metadata = {
332     .name        = "metadata",
333     .description = NULL_IF_CONFIG_SMALL("Manipulate video frame metadata."),
334     .priv_size   = sizeof(MetadataContext),
335     .priv_class  = &metadata_class,
336     .init        = init,
337     .inputs      = inputs,
338     .outputs     = outputs,
339     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
340 };
341 #endif /* CONFIG_METADATA_FILTER */