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 <float.h>
27
28 #include "libavutil/avassert.h"
29 #include "libavutil/avstring.h"
30 #include "libavutil/eval.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/timestamp.h"
34 #include "libavformat/avio.h"
35 #include "avfilter.h"
36 #include "audio.h"
37 #include "formats.h"
38 #include "internal.h"
39 #include "video.h"
40
41 enum MetadataMode {
42 METADATA_SELECT,
43 METADATA_ADD,
44 METADATA_MODIFY,
45 METADATA_DELETE,
46 METADATA_PRINT,
47 METADATA_NB
48 };
49
50 enum MetadataFunction {
51 METADATAF_SAME_STR,
52 METADATAF_STARTS_WITH,
53 METADATAF_LESS,
54 METADATAF_EQUAL,
55 METADATAF_GREATER,
56 METADATAF_EXPR,
57 METADATAF_ENDS_WITH,
58 METADATAF_NB
59 };
60
61 static const char *const var_names[] = {
62 "VALUE1",
63 "VALUE2",
64 NULL
65 };
66
67 enum var_name {
68 VAR_VALUE1,
69 VAR_VALUE2,
70 VAR_VARS_NB
71 };
72
73 typedef struct MetadataContext {
74 const AVClass *class;
75
76 int mode;
77 char *key;
78 char *value;
79 int function;
80
81 char *expr_str;
82 AVExpr *expr;
83 double var_values[VAR_VARS_NB];
84
85 AVIOContext* avio_context;
86 char *file_str;
87
88 int (*compare)(struct MetadataContext *s,
89 const char *value1, const char *value2);
90 void (*print)(AVFilterContext *ctx, const char *msg, ...) av_printf_format(2, 3);
91
92 int direct; // reduces buffering when printing to user-supplied URL
93 } MetadataContext;
94
95 #define OFFSET(x) offsetof(MetadataContext, x)
96 #define DEFINE_OPTIONS(filt_name, FLAGS) \
97 static const AVOption filt_name##_options[] = { \
98 { "mode", "set a mode of operation", OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, METADATA_NB-1, FLAGS, "mode" }, \
99 { "select", "select frame", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_SELECT }, 0, 0, FLAGS, "mode" }, \
100 { "add", "add new metadata", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_ADD }, 0, 0, FLAGS, "mode" }, \
101 { "modify", "modify metadata", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_MODIFY }, 0, 0, FLAGS, "mode" }, \
102 { "delete", "delete metadata", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_DELETE }, 0, 0, FLAGS, "mode" }, \
103 { "print", "print metadata", 0, AV_OPT_TYPE_CONST, {.i64 = METADATA_PRINT }, 0, 0, FLAGS, "mode" }, \
104 { "key", "set metadata key", OFFSET(key), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \
105 { "value", "set metadata value", OFFSET(value), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \
106 { "function", "function for comparing values", OFFSET(function), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, METADATAF_NB-1, FLAGS, "function" }, \
107 { "same_str", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_SAME_STR }, 0, 3, FLAGS, "function" }, \
108 { "starts_with", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_STARTS_WITH }, 0, 0, FLAGS, "function" }, \
109 { "less", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_LESS }, 0, 3, FLAGS, "function" }, \
110 { "equal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_EQUAL }, 0, 3, FLAGS, "function" }, \
111 { "greater", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_GREATER }, 0, 3, FLAGS, "function" }, \
112 { "expr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_EXPR }, 0, 3, FLAGS, "function" }, \
113 { "ends_with", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = METADATAF_ENDS_WITH }, 0, 0, FLAGS, "function" }, \
114 { "expr", "set expression for expr function", OFFSET(expr_str), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS }, \
115 { "file", "set file where to print metadata information", OFFSET(file_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS }, \
116 { "direct", "reduce buffering when printing to user-set file or pipe", OFFSET(direct), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS }, \
117 { NULL } \
118 }
119
same_str(MetadataContext * s,const char * value1,const char * value2)120 static int same_str(MetadataContext *s, const char *value1, const char *value2)
121 {
122 return !strcmp(value1, value2);
123 }
124
starts_with(MetadataContext * s,const char * value1,const char * value2)125 static int starts_with(MetadataContext *s, const char *value1, const char *value2)
126 {
127 return !strncmp(value1, value2, strlen(value2));
128 }
129
ends_with(MetadataContext * s,const char * value1,const char * value2)130 static int ends_with(MetadataContext *s, const char *value1, const char *value2)
131 {
132 const int len1 = strlen(value1);
133 const int len2 = strlen(value2);
134
135 return !strncmp(value1 + FFMAX(len1 - len2, 0), value2, len2);
136 }
137
equal(MetadataContext * s,const char * value1,const char * value2)138 static int equal(MetadataContext *s, const char *value1, const char *value2)
139 {
140 float f1, f2;
141
142 if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2)
143 return 0;
144
145 return fabsf(f1 - f2) < FLT_EPSILON;
146 }
147
less(MetadataContext * s,const char * value1,const char * value2)148 static int less(MetadataContext *s, const char *value1, const char *value2)
149 {
150 float f1, f2;
151
152 if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2)
153 return 0;
154
155 return (f1 - f2) < FLT_EPSILON;
156 }
157
greater(MetadataContext * s,const char * value1,const char * value2)158 static int greater(MetadataContext *s, const char *value1, const char *value2)
159 {
160 float f1, f2;
161
162 if (sscanf(value1, "%f", &f1) + sscanf(value2, "%f", &f2) != 2)
163 return 0;
164
165 return (f2 - f1) < FLT_EPSILON;
166 }
167
parse_expr(MetadataContext * s,const char * value1,const char * value2)168 static int parse_expr(MetadataContext *s, const char *value1, const char *value2)
169 {
170 double f1, f2;
171
172 if (sscanf(value1, "%lf", &f1) + sscanf(value2, "%lf", &f2) != 2)
173 return 0;
174
175 s->var_values[VAR_VALUE1] = f1;
176 s->var_values[VAR_VALUE2] = f2;
177
178 return av_expr_eval(s->expr, s->var_values, NULL);
179 }
180
print_log(AVFilterContext * ctx,const char * msg,...)181 static void print_log(AVFilterContext *ctx, const char *msg, ...)
182 {
183 va_list argument_list;
184
185 va_start(argument_list, msg);
186 if (msg)
187 av_vlog(ctx, AV_LOG_INFO, msg, argument_list);
188 va_end(argument_list);
189 }
190
print_file(AVFilterContext * ctx,const char * msg,...)191 static void print_file(AVFilterContext *ctx, const char *msg, ...)
192 {
193 MetadataContext *s = ctx->priv;
194 va_list argument_list;
195
196 va_start(argument_list, msg);
197 if (msg) {
198 char buf[128];
199 vsnprintf(buf, sizeof(buf), msg, argument_list);
200 avio_write(s->avio_context, buf, av_strnlen(buf, sizeof(buf)));
201 }
202 va_end(argument_list);
203 }
204
init(AVFilterContext * ctx)205 static av_cold int init(AVFilterContext *ctx)
206 {
207 MetadataContext *s = ctx->priv;
208 int ret;
209
210 if (!s->key && s->mode != METADATA_PRINT && s->mode != METADATA_DELETE) {
211 av_log(ctx, AV_LOG_WARNING, "Metadata key must be set\n");
212 return AVERROR(EINVAL);
213 }
214
215 if ((s->mode == METADATA_MODIFY ||
216 s->mode == METADATA_ADD) && !s->value) {
217 av_log(ctx, AV_LOG_WARNING, "Missing metadata value\n");
218 return AVERROR(EINVAL);
219 }
220
221 switch (s->function) {
222 case METADATAF_SAME_STR:
223 s->compare = same_str;
224 break;
225 case METADATAF_STARTS_WITH:
226 s->compare = starts_with;
227 break;
228 case METADATAF_ENDS_WITH:
229 s->compare = ends_with;
230 break;
231 case METADATAF_LESS:
232 s->compare = less;
233 break;
234 case METADATAF_EQUAL:
235 s->compare = equal;
236 break;
237 case METADATAF_GREATER:
238 s->compare = greater;
239 break;
240 case METADATAF_EXPR:
241 s->compare = parse_expr;
242 break;
243 default:
244 av_assert0(0);
245 };
246
247 if (s->function == METADATAF_EXPR) {
248 if (!s->expr_str) {
249 av_log(ctx, AV_LOG_WARNING, "expr option not set\n");
250 return AVERROR(EINVAL);
251 }
252 if ((ret = av_expr_parse(&s->expr, s->expr_str,
253 var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
254 av_log(ctx, AV_LOG_ERROR, "Error while parsing expression '%s'\n", s->expr_str);
255 return ret;
256 }
257 }
258
259 if (s->mode == METADATA_PRINT && s->file_str) {
260 s->print = print_file;
261 } else {
262 s->print = print_log;
263 }
264
265 s->avio_context = NULL;
266 if (s->file_str) {
267 if (!strcmp("-", s->file_str)) {
268 ret = avio_open(&s->avio_context, "pipe:1", AVIO_FLAG_WRITE);
269 } else {
270 ret = avio_open(&s->avio_context, s->file_str, AVIO_FLAG_WRITE);
271 }
272
273 if (ret < 0) {
274 char buf[128];
275 av_strerror(ret, buf, sizeof(buf));
276 av_log(ctx, AV_LOG_ERROR, "Could not open %s: %s\n",
277 s->file_str, buf);
278 return ret;
279 }
280
281 if (s->direct)
282 s->avio_context->direct = AVIO_FLAG_DIRECT;
283 }
284
285 return 0;
286 }
287
uninit(AVFilterContext * ctx)288 static av_cold void uninit(AVFilterContext *ctx)
289 {
290 MetadataContext *s = ctx->priv;
291
292 av_expr_free(s->expr);
293 s->expr = NULL;
294 if (s->avio_context) {
295 avio_closep(&s->avio_context);
296 }
297 }
298
filter_frame(AVFilterLink * inlink,AVFrame * frame)299 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
300 {
301 AVFilterContext *ctx = inlink->dst;
302 AVFilterLink *outlink = ctx->outputs[0];
303 MetadataContext *s = ctx->priv;
304 AVDictionary **metadata = &frame->metadata;
305 AVDictionaryEntry *e;
306
307 e = av_dict_get(*metadata, !s->key ? "" : s->key, NULL,
308 !s->key ? AV_DICT_IGNORE_SUFFIX: 0);
309
310 switch (s->mode) {
311 case METADATA_SELECT:
312 if (!s->value && e && e->value) {
313 return ff_filter_frame(outlink, frame);
314 } else if (s->value && e && e->value &&
315 s->compare(s, e->value, s->value)) {
316 return ff_filter_frame(outlink, frame);
317 }
318 break;
319 case METADATA_ADD:
320 if (e && e->value) {
321 ;
322 } else {
323 av_dict_set(metadata, s->key, s->value, 0);
324 }
325 return ff_filter_frame(outlink, frame);
326 case METADATA_MODIFY:
327 if (e && e->value) {
328 av_dict_set(metadata, s->key, s->value, 0);
329 }
330 return ff_filter_frame(outlink, frame);
331 case METADATA_PRINT:
332 if (!s->key && e) {
333 s->print(ctx, "frame:%-4"PRId64" pts:%-7s pts_time:%s\n",
334 inlink->frame_count_out, av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base));
335 s->print(ctx, "%s=%s\n", e->key, e->value);
336 while ((e = av_dict_get(*metadata, "", e, AV_DICT_IGNORE_SUFFIX)) != NULL) {
337 s->print(ctx, "%s=%s\n", e->key, e->value);
338 }
339 } else if (e && e->value && (!s->value || (e->value && s->compare(s, e->value, s->value)))) {
340 s->print(ctx, "frame:%-4"PRId64" pts:%-7s pts_time:%s\n",
341 inlink->frame_count_out, av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base));
342 s->print(ctx, "%s=%s\n", s->key, e->value);
343 }
344 return ff_filter_frame(outlink, frame);
345 case METADATA_DELETE:
346 if (!s->key) {
347 av_dict_free(metadata);
348 } else if (e && e->value && (!s->value || s->compare(s, e->value, s->value))) {
349 av_dict_set(metadata, s->key, NULL, 0);
350 }
351 return ff_filter_frame(outlink, frame);
352 default:
353 av_assert0(0);
354 };
355
356 av_frame_free(&frame);
357
358 return 0;
359 }
360
361 #if CONFIG_AMETADATA_FILTER
362
363 DEFINE_OPTIONS(ametadata, AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM);
364 AVFILTER_DEFINE_CLASS(ametadata);
365
366 static const AVFilterPad ainputs[] = {
367 {
368 .name = "default",
369 .type = AVMEDIA_TYPE_AUDIO,
370 .filter_frame = filter_frame,
371 },
372 { NULL }
373 };
374
375 static const AVFilterPad aoutputs[] = {
376 {
377 .name = "default",
378 .type = AVMEDIA_TYPE_AUDIO,
379 },
380 { NULL }
381 };
382
383 AVFilter ff_af_ametadata = {
384 .name = "ametadata",
385 .description = NULL_IF_CONFIG_SMALL("Manipulate audio frame metadata."),
386 .priv_size = sizeof(MetadataContext),
387 .priv_class = &ametadata_class,
388 .init = init,
389 .uninit = uninit,
390 .inputs = ainputs,
391 .outputs = aoutputs,
392 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
393 };
394 #endif /* CONFIG_AMETADATA_FILTER */
395
396 #if CONFIG_METADATA_FILTER
397
398 DEFINE_OPTIONS(metadata, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM);
399 AVFILTER_DEFINE_CLASS(metadata);
400
401 static const AVFilterPad inputs[] = {
402 {
403 .name = "default",
404 .type = AVMEDIA_TYPE_VIDEO,
405 .filter_frame = filter_frame,
406 },
407 { NULL }
408 };
409
410 static const AVFilterPad outputs[] = {
411 {
412 .name = "default",
413 .type = AVMEDIA_TYPE_VIDEO,
414 },
415 { NULL }
416 };
417
418 AVFilter ff_vf_metadata = {
419 .name = "metadata",
420 .description = NULL_IF_CONFIG_SMALL("Manipulate video frame metadata."),
421 .priv_size = sizeof(MetadataContext),
422 .priv_class = &metadata_class,
423 .init = init,
424 .uninit = uninit,
425 .inputs = inputs,
426 .outputs = outputs,
427 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
428 };
429 #endif /* CONFIG_METADATA_FILTER */
430