FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavfilter/f_sendcmd.c	Lines:	0	257	0.0 %
Date:	2020-10-23 17:01:47	Branches:	0	152	0.0 %


/*
 * Copyright (c) 2012 Stefano Sabatini
 *
 * 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
 * send commands filter
 */

#include "libavutil/avstring.h"
#include "libavutil/bprint.h"
#include "libavutil/eval.h"
#include "libavutil/file.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
#include "avfilter.h"
#include "internal.h"
#include "audio.h"
#include "video.h"

#define COMMAND_FLAG_ENTER 1
#define COMMAND_FLAG_LEAVE 2
#define COMMAND_FLAG_EXPR  4

static const char *const var_names[] = {
    "N",     /* frame number */
    "T",     /* frame time in seconds */
    "POS",   /* original position in the file of the frame */
    "PTS",   /* frame pts */
    "TS",    /* interval start time in seconds */
    "TE",    /* interval end time in seconds */
    "TI",    /* interval interpolated value: TI = (T - TS) / (TE - TS) */
    NULL
};

enum var_name {
    VAR_N,
    VAR_T,
    VAR_POS,
    VAR_PTS,
    VAR_TS,
    VAR_TE,
    VAR_TI,
    VAR_VARS_NB
};

static inline char *make_command_flags_str(AVBPrint *pbuf, int flags)
{
    static const char * const flag_strings[] = { "enter", "leave", "expr" };
    int i, is_first = 1;

    av_bprint_init(pbuf, 0, AV_BPRINT_SIZE_AUTOMATIC);
    for (i = 0; i < FF_ARRAY_ELEMS(flag_strings); i++) {
        if (flags & 1<<i) {
            if (!is_first)
                av_bprint_chars(pbuf, '+', 1);
            av_bprintf(pbuf, "%s", flag_strings[i]);
            is_first = 0;
        }
    }

    return pbuf->str;
}

typedef struct Command {
    int flags;
    char *target, *command, *arg;
    int index;
} Command;

typedef struct Interval {
    int64_t start_ts;          ///< start timestamp expressed as microseconds units
    int64_t end_ts;            ///< end   timestamp expressed as microseconds units
    int index;                 ///< unique index for these interval commands
    Command *commands;
    int   nb_commands;
    int enabled;               ///< current time detected inside this interval
} Interval;

typedef struct SendCmdContext {
    const AVClass *class;
    Interval *intervals;
    int   nb_intervals;

    char *commands_filename;
    char *commands_str;
} SendCmdContext;

#define OFFSET(x) offsetof(SendCmdContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
static const AVOption options[] = {
    { "commands", "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
    { "c",        "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
    { "filename", "set commands file",  OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
    { "f",        "set commands file",  OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
    { NULL }
};

#define SPACES " \f\t\n\r"

static void skip_comments(const char **buf)
{
    while (**buf) {
        /* skip leading spaces */
        *buf += strspn(*buf, SPACES);
        if (**buf != '#')
            break;

        (*buf)++;

        /* skip comment until the end of line */
        *buf += strcspn(*buf, "\n");
        if (**buf)
            (*buf)++;
    }
}

#define COMMAND_DELIMS " \f\t\n\r,;"

static int parse_command(Command *cmd, int cmd_count, int interval_count,
                         const char **buf, void *log_ctx)
{
    int ret;

    memset(cmd, 0, sizeof(Command));
    cmd->index = cmd_count;

    /* format: [FLAGS] target command arg */
    *buf += strspn(*buf, SPACES);

    /* parse flags */
    if (**buf == '[') {
        (*buf)++; /* skip "[" */

        while (**buf) {
            int len = strcspn(*buf, "|+]");

            if      (!strncmp(*buf, "enter", strlen("enter"))) cmd->flags |= COMMAND_FLAG_ENTER;
            else if (!strncmp(*buf, "leave", strlen("leave"))) cmd->flags |= COMMAND_FLAG_LEAVE;
            else if (!strncmp(*buf, "expr",  strlen("expr")))  cmd->flags |= COMMAND_FLAG_EXPR;
            else {
                char flag_buf[64];
                av_strlcpy(flag_buf, *buf, sizeof(flag_buf));
                av_log(log_ctx, AV_LOG_ERROR,
                       "Unknown flag '%s' in interval #%d, command #%d\n",
                       flag_buf, interval_count, cmd_count);
                return AVERROR(EINVAL);
            }
            *buf += len;
            if (**buf == ']')
                break;
            if (!strspn(*buf, "+|")) {
                av_log(log_ctx, AV_LOG_ERROR,
                       "Invalid flags char '%c' in interval #%d, command #%d\n",
                       **buf, interval_count, cmd_count);
                return AVERROR(EINVAL);
            }
            if (**buf)
                (*buf)++;
        }

        if (**buf != ']') {
            av_log(log_ctx, AV_LOG_ERROR,
                   "Missing flag terminator or extraneous data found at the end of flags "
                   "in interval #%d, command #%d\n", interval_count, cmd_count);
            return AVERROR(EINVAL);
        }
        (*buf)++; /* skip "]" */
    } else {
        cmd->flags = COMMAND_FLAG_ENTER;
    }

    *buf += strspn(*buf, SPACES);
    cmd->target = av_get_token(buf, COMMAND_DELIMS);
    if (!cmd->target || !cmd->target[0]) {
        av_log(log_ctx, AV_LOG_ERROR,
               "No target specified in interval #%d, command #%d\n",
               interval_count, cmd_count);
        ret = AVERROR(EINVAL);
        goto fail;
    }

    *buf += strspn(*buf, SPACES);
    cmd->command = av_get_token(buf, COMMAND_DELIMS);
    if (!cmd->command || !cmd->command[0]) {
        av_log(log_ctx, AV_LOG_ERROR,
               "No command specified in interval #%d, command #%d\n",
               interval_count, cmd_count);
        ret = AVERROR(EINVAL);
        goto fail;
    }

    *buf += strspn(*buf, SPACES);
    cmd->arg = av_get_token(buf, COMMAND_DELIMS);

    return 1;

fail:
    av_freep(&cmd->target);
    av_freep(&cmd->command);
    av_freep(&cmd->arg);
    return ret;
}

static int parse_commands(Command **cmds, int *nb_cmds, int interval_count,
                          const char **buf, void *log_ctx)
{
    int cmd_count = 0;
    int ret, n = 0;
    AVBPrint pbuf;

    *cmds = NULL;
    *nb_cmds = 0;

    while (**buf) {
        Command cmd;

        if ((ret = parse_command(&cmd, cmd_count, interval_count, buf, log_ctx)) < 0)
            return ret;
        cmd_count++;

        /* (re)allocate commands array if required */
        if (*nb_cmds == n) {
            n = FFMAX(16, 2*n); /* first allocation = 16, or double the number */
            *cmds = av_realloc_f(*cmds, n, 2*sizeof(Command));
            if (!*cmds) {
                av_log(log_ctx, AV_LOG_ERROR,
                       "Could not (re)allocate command array\n");
                return AVERROR(ENOMEM);
            }
        }

        (*cmds)[(*nb_cmds)++] = cmd;

        *buf += strspn(*buf, SPACES);
        if (**buf && **buf != ';' && **buf != ',') {
            av_log(log_ctx, AV_LOG_ERROR,
                   "Missing separator or extraneous data found at the end of "
                   "interval #%d, in command #%d\n",
                   interval_count, cmd_count);
            av_log(log_ctx, AV_LOG_ERROR,
                   "Command was parsed as: flags:[%s] target:%s command:%s arg:%s\n",
                   make_command_flags_str(&pbuf, cmd.flags), cmd.target, cmd.command, cmd.arg);
            return AVERROR(EINVAL);
        }
        if (**buf == ';')
            break;
        if (**buf == ',')
            (*buf)++;
    }

    return 0;
}

#define DELIMS " \f\t\n\r,;"

static int parse_interval(Interval *interval, int interval_count,
                          const char **buf, void *log_ctx)
{
    char *intervalstr;
    int ret;

    *buf += strspn(*buf, SPACES);
    if (!**buf)
        return 0;

    /* reset data */
    memset(interval, 0, sizeof(Interval));
    interval->index = interval_count;

    /* format: INTERVAL COMMANDS */

    /* parse interval */
    intervalstr = av_get_token(buf, DELIMS);
    if (intervalstr && intervalstr[0]) {
        char *start, *end;

        start = av_strtok(intervalstr, "-", &end);
        if (!start) {
            ret = AVERROR(EINVAL);
            av_log(log_ctx, AV_LOG_ERROR,
                   "Invalid interval specification '%s' in interval #%d\n",
                   intervalstr, interval_count);
            goto end;
        }
        if ((ret = av_parse_time(&interval->start_ts, start, 1)) < 0) {
            av_log(log_ctx, AV_LOG_ERROR,
                   "Invalid start time specification '%s' in interval #%d\n",
                   start, interval_count);
            goto end;
        }

        if (end) {
            if ((ret = av_parse_time(&interval->end_ts, end, 1)) < 0) {
                av_log(log_ctx, AV_LOG_ERROR,
                       "Invalid end time specification '%s' in interval #%d\n",
                       end, interval_count);
                goto end;
            }
        } else {
            interval->end_ts = INT64_MAX;
        }
        if (interval->end_ts < interval->start_ts) {
            av_log(log_ctx, AV_LOG_ERROR,
                   "Invalid end time '%s' in interval #%d: "
                   "cannot be lesser than start time '%s'\n",
                   end, interval_count, start);
            ret = AVERROR(EINVAL);
            goto end;
        }
    } else {
        av_log(log_ctx, AV_LOG_ERROR,
               "No interval specified for interval #%d\n", interval_count);
        ret = AVERROR(EINVAL);
        goto end;
    }

    /* parse commands */
    ret = parse_commands(&interval->commands, &interval->nb_commands,
                         interval_count, buf, log_ctx);

end:
    av_free(intervalstr);
    return ret;
}

static int parse_intervals(Interval **intervals, int *nb_intervals,
                           const char *buf, void *log_ctx)
{
    int interval_count = 0;
    int ret, n = 0;

    *intervals = NULL;
    *nb_intervals = 0;

    if (!buf)
        return 0;

    while (1) {
        Interval interval;

        skip_comments(&buf);
        if (!(*buf))
            break;

        if ((ret = parse_interval(&interval, interval_count, &buf, log_ctx)) < 0)
            return ret;

        buf += strspn(buf, SPACES);
        if (*buf) {
            if (*buf != ';') {
                av_log(log_ctx, AV_LOG_ERROR,
                       "Missing terminator or extraneous data found at the end of interval #%d\n",
                       interval_count);
                return AVERROR(EINVAL);
            }
            buf++; /* skip ';' */
        }
        interval_count++;

        /* (re)allocate commands array if required */
        if (*nb_intervals == n) {
            n = FFMAX(16, 2*n); /* first allocation = 16, or double the number */
            *intervals = av_realloc_f(*intervals, n, 2*sizeof(Interval));
            if (!*intervals) {
                av_log(log_ctx, AV_LOG_ERROR,
                       "Could not (re)allocate intervals array\n");
                return AVERROR(ENOMEM);
            }
        }

        (*intervals)[(*nb_intervals)++] = interval;
    }

    return 0;
}

static int cmp_intervals(const void *a, const void *b)
{
    const Interval *i1 = a;
    const Interval *i2 = b;
    return 2 * FFDIFFSIGN(i1->start_ts, i2->start_ts) + FFDIFFSIGN(i1->index, i2->index);
}

static av_cold int init(AVFilterContext *ctx)
{
    SendCmdContext *s = ctx->priv;
    int ret, i, j;

    if ((!!s->commands_filename + !!s->commands_str) != 1) {
        av_log(ctx, AV_LOG_ERROR,
               "One and only one of the filename or commands options must be specified\n");
        return AVERROR(EINVAL);
    }

    if (s->commands_filename) {
        uint8_t *file_buf, *buf;
        size_t file_bufsize;
        ret = av_file_map(s->commands_filename,
                          &file_buf, &file_bufsize, 0, ctx);
        if (ret < 0)
            return ret;

        /* create a 0-terminated string based on the read file */
        buf = av_malloc(file_bufsize + 1);
        if (!buf) {
            av_file_unmap(file_buf, file_bufsize);
            return AVERROR(ENOMEM);
        }
        memcpy(buf, file_buf, file_bufsize);
        buf[file_bufsize] = 0;
        av_file_unmap(file_buf, file_bufsize);
        s->commands_str = buf;
    }

    if ((ret = parse_intervals(&s->intervals, &s->nb_intervals,
                               s->commands_str, ctx)) < 0)
        return ret;

    if (s->nb_intervals == 0) {
        av_log(ctx, AV_LOG_ERROR, "No commands were specified\n");
        return AVERROR(EINVAL);
    }

    qsort(s->intervals, s->nb_intervals, sizeof(Interval), cmp_intervals);

    av_log(ctx, AV_LOG_DEBUG, "Parsed commands:\n");
    for (i = 0; i < s->nb_intervals; i++) {
        AVBPrint pbuf;
        Interval *interval = &s->intervals[i];
        av_log(ctx, AV_LOG_VERBOSE, "start_time:%f end_time:%f index:%d\n",
               (double)interval->start_ts/1000000, (double)interval->end_ts/1000000, interval->index);
        for (j = 0; j < interval->nb_commands; j++) {
            Command *cmd = &interval->commands[j];
            av_log(ctx, AV_LOG_VERBOSE,
                   "    [%s] target:%s command:%s arg:%s index:%d\n",
                   make_command_flags_str(&pbuf, cmd->flags), cmd->target, cmd->command, cmd->arg, cmd->index);
        }
    }

    return 0;
}

static av_cold void uninit(AVFilterContext *ctx)
{
    SendCmdContext *s = ctx->priv;
    int i, j;

    for (i = 0; i < s->nb_intervals; i++) {
        Interval *interval = &s->intervals[i];
        for (j = 0; j < interval->nb_commands; j++) {
            Command *cmd = &interval->commands[j];
            av_freep(&cmd->target);
            av_freep(&cmd->command);
            av_freep(&cmd->arg);
        }
        av_freep(&interval->commands);
    }
    av_freep(&s->intervals);
}

static int filter_frame(AVFilterLink *inlink, AVFrame *ref)
{
    AVFilterContext *ctx = inlink->dst;
    SendCmdContext *s = ctx->priv;
    int64_t ts;
    int i, j, ret;

    if (ref->pts == AV_NOPTS_VALUE)
        goto end;

    ts = av_rescale_q(ref->pts, inlink->time_base, AV_TIME_BASE_Q);

#define WITHIN_INTERVAL(ts, start_ts, end_ts) ((ts) >= (start_ts) && (ts) < (end_ts))

    for (i = 0; i < s->nb_intervals; i++) {
        Interval *interval = &s->intervals[i];
        int flags = 0;

        if (!interval->enabled && WITHIN_INTERVAL(ts, interval->start_ts, interval->end_ts)) {
            flags += COMMAND_FLAG_ENTER;
            interval->enabled = 1;
        }
        if (interval->enabled && !WITHIN_INTERVAL(ts, interval->start_ts, interval->end_ts)) {
            flags += COMMAND_FLAG_LEAVE;
            interval->enabled = 0;
        }
        if (interval->enabled)
            flags += COMMAND_FLAG_EXPR;

        if (flags) {
            AVBPrint pbuf;
            av_log(ctx, AV_LOG_VERBOSE,
                   "[%s] interval #%d start_ts:%f end_ts:%f ts:%f\n",
                   make_command_flags_str(&pbuf, flags), interval->index,
                   (double)interval->start_ts/1000000, (double)interval->end_ts/1000000,
                   (double)ts/1000000);

            for (j = 0; flags && j < interval->nb_commands; j++) {
                Command *cmd = &interval->commands[j];
                char *cmd_arg = cmd->arg;
                char buf[1024];

                if (cmd->flags & flags) {
                    if (cmd->flags & COMMAND_FLAG_EXPR) {
                        double var_values[VAR_VARS_NB], res;
                        double start = TS2T(interval->start_ts, AV_TIME_BASE_Q);
                        double end = TS2T(interval->end_ts, AV_TIME_BASE_Q);
                        double current = TS2T(ref->pts, inlink->time_base);

                        var_values[VAR_N]   = inlink->frame_count_in;
                        var_values[VAR_POS] = ref->pkt_pos == -1 ? NAN : ref->pkt_pos;
                        var_values[VAR_PTS] = TS2D(ref->pts);
                        var_values[VAR_T]   = current;
                        var_values[VAR_TS]  = start;
                        var_values[VAR_TE]  = end;
                        var_values[VAR_TI]  = (current - start) / (end - start);

                        if ((ret = av_expr_parse_and_eval(&res, cmd->arg, var_names, var_values,
                                                          NULL, NULL, NULL, NULL, NULL, 0, NULL)) < 0) {
                            av_log(ctx, AV_LOG_ERROR, "Invalid expression '%s' for command argument.\n", cmd->arg);
                            av_frame_free(&ref);
                            return AVERROR(EINVAL);
                        }

                        cmd_arg = av_asprintf("%g", res);
                        if (!cmd_arg) {
                            av_frame_free(&ref);
                            return AVERROR(ENOMEM);
                        }
                    }
                    av_log(ctx, AV_LOG_VERBOSE,
                           "Processing command #%d target:%s command:%s arg:%s\n",
                           cmd->index, cmd->target, cmd->command, cmd_arg);
                    ret = avfilter_graph_send_command(inlink->graph,
                                                      cmd->target, cmd->command, cmd_arg,
                                                      buf, sizeof(buf),
                                                      AVFILTER_CMD_FLAG_ONE);
                    av_log(ctx, AV_LOG_VERBOSE,
                           "Command reply for command #%d: ret:%s res:%s\n",
                           cmd->index, av_err2str(ret), buf);
                    if (cmd->flags & COMMAND_FLAG_EXPR)
                        av_freep(&cmd_arg);
                }
            }
        }
    }

end:
    switch (inlink->type) {
    case AVMEDIA_TYPE_VIDEO:
    case AVMEDIA_TYPE_AUDIO:
        return ff_filter_frame(inlink->dst->outputs[0], ref);
    }

    return AVERROR(ENOSYS);
}

#if CONFIG_SENDCMD_FILTER

#define sendcmd_options options
AVFILTER_DEFINE_CLASS(sendcmd);

static const AVFilterPad sendcmd_inputs[] = {
    {
        .name         = "default",
        .type         = AVMEDIA_TYPE_VIDEO,
        .filter_frame = filter_frame,
    },
    { NULL }
};

static const AVFilterPad sendcmd_outputs[] = {
    {
        .name = "default",
        .type = AVMEDIA_TYPE_VIDEO,
    },
    { NULL }
};

AVFilter ff_vf_sendcmd = {
    .name        = "sendcmd",
    .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),
    .init        = init,
    .uninit      = uninit,
    .priv_size   = sizeof(SendCmdContext),
    .inputs      = sendcmd_inputs,
    .outputs     = sendcmd_outputs,
    .priv_class  = &sendcmd_class,
};

#endif

#if CONFIG_ASENDCMD_FILTER

#define asendcmd_options options
AVFILTER_DEFINE_CLASS(asendcmd);

static const AVFilterPad asendcmd_inputs[] = {
    {
        .name         = "default",
        .type         = AVMEDIA_TYPE_AUDIO,
        .filter_frame = filter_frame,
    },
    { NULL }
};

static const AVFilterPad asendcmd_outputs[] = {
    {
        .name = "default",
        .type = AVMEDIA_TYPE_AUDIO,
    },
    { NULL }
};

AVFilter ff_af_asendcmd = {
    .name        = "asendcmd",
    .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),
    .init        = init,
    .uninit      = uninit,
    .priv_size   = sizeof(SendCmdContext),
    .inputs      = asendcmd_inputs,
    .outputs     = asendcmd_outputs,
    .priv_class  = &asendcmd_class,
};

#endif


Generated by: GCOVR (Version 4.2)

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