avfilter/af_headphone: do not free frame that's gonna be reused later
[ffmpeg.git] / libavfilter / f_sendcmd.c
1 /*
2  * Copyright (c) 2012 Stefano Sabatini
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  * send commands filter
24  */
25
26 #include "libavutil/avstring.h"
27 #include "libavutil/bprint.h"
28 #include "libavutil/file.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/parseutils.h"
31 #include "avfilter.h"
32 #include "internal.h"
33 #include "avfiltergraph.h"
34 #include "audio.h"
35 #include "video.h"
36
37 #define COMMAND_FLAG_ENTER 1
38 #define COMMAND_FLAG_LEAVE 2
39
40 static inline char *make_command_flags_str(AVBPrint *pbuf, int flags)
41 {
42     static const char * const flag_strings[] = { "enter", "leave" };
43     int i, is_first = 1;
44
45     av_bprint_init(pbuf, 0, AV_BPRINT_SIZE_AUTOMATIC);
46     for (i = 0; i < FF_ARRAY_ELEMS(flag_strings); i++) {
47         if (flags & 1<<i) {
48             if (!is_first)
49                 av_bprint_chars(pbuf, '+', 1);
50             av_bprintf(pbuf, "%s", flag_strings[i]);
51             is_first = 0;
52         }
53     }
54
55     return pbuf->str;
56 }
57
58 typedef struct Command {
59     int flags;
60     char *target, *command, *arg;
61     int index;
62 } Command;
63
64 typedef struct Interval {
65     int64_t start_ts;          ///< start timestamp expressed as microseconds units
66     int64_t end_ts;            ///< end   timestamp expressed as microseconds units
67     int index;                 ///< unique index for these interval commands
68     Command *commands;
69     int   nb_commands;
70     int enabled;               ///< current time detected inside this interval
71 } Interval;
72
73 typedef struct SendCmdContext {
74     const AVClass *class;
75     Interval *intervals;
76     int   nb_intervals;
77
78     char *commands_filename;
79     char *commands_str;
80 } SendCmdContext;
81
82 #define OFFSET(x) offsetof(SendCmdContext, x)
83 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
84 static const AVOption options[] = {
85     { "commands", "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
86     { "c",        "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
87     { "filename", "set commands file",  OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
88     { "f",        "set commands file",  OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
89     { NULL }
90 };
91
92 #define SPACES " \f\t\n\r"
93
94 static void skip_comments(const char **buf)
95 {
96     while (**buf) {
97         /* skip leading spaces */
98         *buf += strspn(*buf, SPACES);
99         if (**buf != '#')
100             break;
101
102         (*buf)++;
103
104         /* skip comment until the end of line */
105         *buf += strcspn(*buf, "\n");
106         if (**buf)
107             (*buf)++;
108     }
109 }
110
111 #define COMMAND_DELIMS " \f\t\n\r,;"
112
113 static int parse_command(Command *cmd, int cmd_count, int interval_count,
114                          const char **buf, void *log_ctx)
115 {
116     int ret;
117
118     memset(cmd, 0, sizeof(Command));
119     cmd->index = cmd_count;
120
121     /* format: [FLAGS] target command arg */
122     *buf += strspn(*buf, SPACES);
123
124     /* parse flags */
125     if (**buf == '[') {
126         (*buf)++; /* skip "[" */
127
128         while (**buf) {
129             int len = strcspn(*buf, "|+]");
130
131             if      (!strncmp(*buf, "enter", strlen("enter"))) cmd->flags |= COMMAND_FLAG_ENTER;
132             else if (!strncmp(*buf, "leave", strlen("leave"))) cmd->flags |= COMMAND_FLAG_LEAVE;
133             else {
134                 char flag_buf[64];
135                 av_strlcpy(flag_buf, *buf, sizeof(flag_buf));
136                 av_log(log_ctx, AV_LOG_ERROR,
137                        "Unknown flag '%s' in interval #%d, command #%d\n",
138                        flag_buf, interval_count, cmd_count);
139                 return AVERROR(EINVAL);
140             }
141             *buf += len;
142             if (**buf == ']')
143                 break;
144             if (!strspn(*buf, "+|")) {
145                 av_log(log_ctx, AV_LOG_ERROR,
146                        "Invalid flags char '%c' in interval #%d, command #%d\n",
147                        **buf, interval_count, cmd_count);
148                 return AVERROR(EINVAL);
149             }
150             if (**buf)
151                 (*buf)++;
152         }
153
154         if (**buf != ']') {
155             av_log(log_ctx, AV_LOG_ERROR,
156                    "Missing flag terminator or extraneous data found at the end of flags "
157                    "in interval #%d, command #%d\n", interval_count, cmd_count);
158             return AVERROR(EINVAL);
159         }
160         (*buf)++; /* skip "]" */
161     } else {
162         cmd->flags = COMMAND_FLAG_ENTER;
163     }
164
165     *buf += strspn(*buf, SPACES);
166     cmd->target = av_get_token(buf, COMMAND_DELIMS);
167     if (!cmd->target || !cmd->target[0]) {
168         av_log(log_ctx, AV_LOG_ERROR,
169                "No target specified in interval #%d, command #%d\n",
170                interval_count, cmd_count);
171         ret = AVERROR(EINVAL);
172         goto fail;
173     }
174
175     *buf += strspn(*buf, SPACES);
176     cmd->command = av_get_token(buf, COMMAND_DELIMS);
177     if (!cmd->command || !cmd->command[0]) {
178         av_log(log_ctx, AV_LOG_ERROR,
179                "No command specified in interval #%d, command #%d\n",
180                interval_count, cmd_count);
181         ret = AVERROR(EINVAL);
182         goto fail;
183     }
184
185     *buf += strspn(*buf, SPACES);
186     cmd->arg = av_get_token(buf, COMMAND_DELIMS);
187
188     return 1;
189
190 fail:
191     av_freep(&cmd->target);
192     av_freep(&cmd->command);
193     av_freep(&cmd->arg);
194     return ret;
195 }
196
197 static int parse_commands(Command **cmds, int *nb_cmds, int interval_count,
198                           const char **buf, void *log_ctx)
199 {
200     int cmd_count = 0;
201     int ret, n = 0;
202     AVBPrint pbuf;
203
204     *cmds = NULL;
205     *nb_cmds = 0;
206
207     while (**buf) {
208         Command cmd;
209
210         if ((ret = parse_command(&cmd, cmd_count, interval_count, buf, log_ctx)) < 0)
211             return ret;
212         cmd_count++;
213
214         /* (re)allocate commands array if required */
215         if (*nb_cmds == n) {
216             n = FFMAX(16, 2*n); /* first allocation = 16, or double the number */
217             *cmds = av_realloc_f(*cmds, n, 2*sizeof(Command));
218             if (!*cmds) {
219                 av_log(log_ctx, AV_LOG_ERROR,
220                        "Could not (re)allocate command array\n");
221                 return AVERROR(ENOMEM);
222             }
223         }
224
225         (*cmds)[(*nb_cmds)++] = cmd;
226
227         *buf += strspn(*buf, SPACES);
228         if (**buf && **buf != ';' && **buf != ',') {
229             av_log(log_ctx, AV_LOG_ERROR,
230                    "Missing separator or extraneous data found at the end of "
231                    "interval #%d, in command #%d\n",
232                    interval_count, cmd_count);
233             av_log(log_ctx, AV_LOG_ERROR,
234                    "Command was parsed as: flags:[%s] target:%s command:%s arg:%s\n",
235                    make_command_flags_str(&pbuf, cmd.flags), cmd.target, cmd.command, cmd.arg);
236             return AVERROR(EINVAL);
237         }
238         if (**buf == ';')
239             break;
240         if (**buf == ',')
241             (*buf)++;
242     }
243
244     return 0;
245 }
246
247 #define DELIMS " \f\t\n\r,;"
248
249 static int parse_interval(Interval *interval, int interval_count,
250                           const char **buf, void *log_ctx)
251 {
252     char *intervalstr;
253     int ret;
254
255     *buf += strspn(*buf, SPACES);
256     if (!**buf)
257         return 0;
258
259     /* reset data */
260     memset(interval, 0, sizeof(Interval));
261     interval->index = interval_count;
262
263     /* format: INTERVAL COMMANDS */
264
265     /* parse interval */
266     intervalstr = av_get_token(buf, DELIMS);
267     if (intervalstr && intervalstr[0]) {
268         char *start, *end;
269
270         start = av_strtok(intervalstr, "-", &end);
271         if (!start) {
272             ret = AVERROR(EINVAL);
273             av_log(log_ctx, AV_LOG_ERROR,
274                    "Invalid interval specification '%s' in interval #%d\n",
275                    intervalstr, interval_count);
276             goto end;
277         }
278         if ((ret = av_parse_time(&interval->start_ts, start, 1)) < 0) {
279             av_log(log_ctx, AV_LOG_ERROR,
280                    "Invalid start time specification '%s' in interval #%d\n",
281                    start, interval_count);
282             goto end;
283         }
284
285         if (end) {
286             if ((ret = av_parse_time(&interval->end_ts, end, 1)) < 0) {
287                 av_log(log_ctx, AV_LOG_ERROR,
288                        "Invalid end time specification '%s' in interval #%d\n",
289                        end, interval_count);
290                 goto end;
291             }
292         } else {
293             interval->end_ts = INT64_MAX;
294         }
295         if (interval->end_ts < interval->start_ts) {
296             av_log(log_ctx, AV_LOG_ERROR,
297                    "Invalid end time '%s' in interval #%d: "
298                    "cannot be lesser than start time '%s'\n",
299                    end, interval_count, start);
300             ret = AVERROR(EINVAL);
301             goto end;
302         }
303     } else {
304         av_log(log_ctx, AV_LOG_ERROR,
305                "No interval specified for interval #%d\n", interval_count);
306         ret = AVERROR(EINVAL);
307         goto end;
308     }
309
310     /* parse commands */
311     ret = parse_commands(&interval->commands, &interval->nb_commands,
312                          interval_count, buf, log_ctx);
313
314 end:
315     av_free(intervalstr);
316     return ret;
317 }
318
319 static int parse_intervals(Interval **intervals, int *nb_intervals,
320                            const char *buf, void *log_ctx)
321 {
322     int interval_count = 0;
323     int ret, n = 0;
324
325     *intervals = NULL;
326     *nb_intervals = 0;
327
328     if (!buf)
329         return 0;
330
331     while (1) {
332         Interval interval;
333
334         skip_comments(&buf);
335         if (!(*buf))
336             break;
337
338         if ((ret = parse_interval(&interval, interval_count, &buf, log_ctx)) < 0)
339             return ret;
340
341         buf += strspn(buf, SPACES);
342         if (*buf) {
343             if (*buf != ';') {
344                 av_log(log_ctx, AV_LOG_ERROR,
345                        "Missing terminator or extraneous data found at the end of interval #%d\n",
346                        interval_count);
347                 return AVERROR(EINVAL);
348             }
349             buf++; /* skip ';' */
350         }
351         interval_count++;
352
353         /* (re)allocate commands array if required */
354         if (*nb_intervals == n) {
355             n = FFMAX(16, 2*n); /* first allocation = 16, or double the number */
356             *intervals = av_realloc_f(*intervals, n, 2*sizeof(Interval));
357             if (!*intervals) {
358                 av_log(log_ctx, AV_LOG_ERROR,
359                        "Could not (re)allocate intervals array\n");
360                 return AVERROR(ENOMEM);
361             }
362         }
363
364         (*intervals)[(*nb_intervals)++] = interval;
365     }
366
367     return 0;
368 }
369
370 static int cmp_intervals(const void *a, const void *b)
371 {
372     const Interval *i1 = a;
373     const Interval *i2 = b;
374     return 2 * FFDIFFSIGN(i1->start_ts, i2->start_ts) + FFDIFFSIGN(i1->index, i2->index);
375 }
376
377 static av_cold int init(AVFilterContext *ctx)
378 {
379     SendCmdContext *s = ctx->priv;
380     int ret, i, j;
381
382     if ((!!s->commands_filename + !!s->commands_str) != 1) {
383         av_log(ctx, AV_LOG_ERROR,
384                "One and only one of the filename or commands options must be specified\n");
385         return AVERROR(EINVAL);
386     }
387
388     if (s->commands_filename) {
389         uint8_t *file_buf, *buf;
390         size_t file_bufsize;
391         ret = av_file_map(s->commands_filename,
392                           &file_buf, &file_bufsize, 0, ctx);
393         if (ret < 0)
394             return ret;
395
396         /* create a 0-terminated string based on the read file */
397         buf = av_malloc(file_bufsize + 1);
398         if (!buf) {
399             av_file_unmap(file_buf, file_bufsize);
400             return AVERROR(ENOMEM);
401         }
402         memcpy(buf, file_buf, file_bufsize);
403         buf[file_bufsize] = 0;
404         av_file_unmap(file_buf, file_bufsize);
405         s->commands_str = buf;
406     }
407
408     if ((ret = parse_intervals(&s->intervals, &s->nb_intervals,
409                                s->commands_str, ctx)) < 0)
410         return ret;
411
412     if (s->nb_intervals == 0) {
413         av_log(ctx, AV_LOG_ERROR, "No commands were specified\n");
414         return AVERROR(EINVAL);
415     }
416
417     qsort(s->intervals, s->nb_intervals, sizeof(Interval), cmp_intervals);
418
419     av_log(ctx, AV_LOG_DEBUG, "Parsed commands:\n");
420     for (i = 0; i < s->nb_intervals; i++) {
421         AVBPrint pbuf;
422         Interval *interval = &s->intervals[i];
423         av_log(ctx, AV_LOG_VERBOSE, "start_time:%f end_time:%f index:%d\n",
424                (double)interval->start_ts/1000000, (double)interval->end_ts/1000000, interval->index);
425         for (j = 0; j < interval->nb_commands; j++) {
426             Command *cmd = &interval->commands[j];
427             av_log(ctx, AV_LOG_VERBOSE,
428                    "    [%s] target:%s command:%s arg:%s index:%d\n",
429                    make_command_flags_str(&pbuf, cmd->flags), cmd->target, cmd->command, cmd->arg, cmd->index);
430         }
431     }
432
433     return 0;
434 }
435
436 static av_cold void uninit(AVFilterContext *ctx)
437 {
438     SendCmdContext *s = ctx->priv;
439     int i, j;
440
441     for (i = 0; i < s->nb_intervals; i++) {
442         Interval *interval = &s->intervals[i];
443         for (j = 0; j < interval->nb_commands; j++) {
444             Command *cmd = &interval->commands[j];
445             av_freep(&cmd->target);
446             av_freep(&cmd->command);
447             av_freep(&cmd->arg);
448         }
449         av_freep(&interval->commands);
450     }
451     av_freep(&s->intervals);
452 }
453
454 static int filter_frame(AVFilterLink *inlink, AVFrame *ref)
455 {
456     AVFilterContext *ctx = inlink->dst;
457     SendCmdContext *s = ctx->priv;
458     int64_t ts;
459     int i, j, ret;
460
461     if (ref->pts == AV_NOPTS_VALUE)
462         goto end;
463
464     ts = av_rescale_q(ref->pts, inlink->time_base, AV_TIME_BASE_Q);
465
466 #define WITHIN_INTERVAL(ts, start_ts, end_ts) ((ts) >= (start_ts) && (ts) < (end_ts))
467
468     for (i = 0; i < s->nb_intervals; i++) {
469         Interval *interval = &s->intervals[i];
470         int flags = 0;
471
472         if (!interval->enabled && WITHIN_INTERVAL(ts, interval->start_ts, interval->end_ts)) {
473             flags += COMMAND_FLAG_ENTER;
474             interval->enabled = 1;
475         }
476         if (interval->enabled && !WITHIN_INTERVAL(ts, interval->start_ts, interval->end_ts)) {
477             flags += COMMAND_FLAG_LEAVE;
478             interval->enabled = 0;
479         }
480
481         if (flags) {
482             AVBPrint pbuf;
483             av_log(ctx, AV_LOG_VERBOSE,
484                    "[%s] interval #%d start_ts:%f end_ts:%f ts:%f\n",
485                    make_command_flags_str(&pbuf, flags), interval->index,
486                    (double)interval->start_ts/1000000, (double)interval->end_ts/1000000,
487                    (double)ts/1000000);
488
489             for (j = 0; flags && j < interval->nb_commands; j++) {
490                 Command *cmd = &interval->commands[j];
491                 char buf[1024];
492
493                 if (cmd->flags & flags) {
494                     av_log(ctx, AV_LOG_VERBOSE,
495                            "Processing command #%d target:%s command:%s arg:%s\n",
496                            cmd->index, cmd->target, cmd->command, cmd->arg);
497                     ret = avfilter_graph_send_command(inlink->graph,
498                                                       cmd->target, cmd->command, cmd->arg,
499                                                       buf, sizeof(buf),
500                                                       AVFILTER_CMD_FLAG_ONE);
501                     av_log(ctx, AV_LOG_VERBOSE,
502                            "Command reply for command #%d: ret:%s res:%s\n",
503                            cmd->index, av_err2str(ret), buf);
504                 }
505             }
506         }
507     }
508
509 end:
510     switch (inlink->type) {
511     case AVMEDIA_TYPE_VIDEO:
512     case AVMEDIA_TYPE_AUDIO:
513         return ff_filter_frame(inlink->dst->outputs[0], ref);
514     }
515
516     return AVERROR(ENOSYS);
517 }
518
519 #if CONFIG_SENDCMD_FILTER
520
521 #define sendcmd_options options
522 AVFILTER_DEFINE_CLASS(sendcmd);
523
524 static const AVFilterPad sendcmd_inputs[] = {
525     {
526         .name         = "default",
527         .type         = AVMEDIA_TYPE_VIDEO,
528         .filter_frame = filter_frame,
529     },
530     { NULL }
531 };
532
533 static const AVFilterPad sendcmd_outputs[] = {
534     {
535         .name = "default",
536         .type = AVMEDIA_TYPE_VIDEO,
537     },
538     { NULL }
539 };
540
541 AVFilter ff_vf_sendcmd = {
542     .name        = "sendcmd",
543     .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),
544     .init        = init,
545     .uninit      = uninit,
546     .priv_size   = sizeof(SendCmdContext),
547     .inputs      = sendcmd_inputs,
548     .outputs     = sendcmd_outputs,
549     .priv_class  = &sendcmd_class,
550 };
551
552 #endif
553
554 #if CONFIG_ASENDCMD_FILTER
555
556 #define asendcmd_options options
557 AVFILTER_DEFINE_CLASS(asendcmd);
558
559 static const AVFilterPad asendcmd_inputs[] = {
560     {
561         .name         = "default",
562         .type         = AVMEDIA_TYPE_AUDIO,
563         .filter_frame = filter_frame,
564     },
565     { NULL }
566 };
567
568 static const AVFilterPad asendcmd_outputs[] = {
569     {
570         .name = "default",
571         .type = AVMEDIA_TYPE_AUDIO,
572     },
573     { NULL }
574 };
575
576 AVFilter ff_af_asendcmd = {
577     .name        = "asendcmd",
578     .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),
579     .init        = init,
580     .uninit      = uninit,
581     .priv_size   = sizeof(SendCmdContext),
582     .inputs      = asendcmd_inputs,
583     .outputs     = asendcmd_outputs,
584     .priv_class  = &asendcmd_class,
585 };
586
587 #endif