[FFmpeg-devel] [PATCH 4/5] lavfi/graphparser: reimplement avfilter_graph_parse* using new API
Anton Khirnov
anton at khirnov.net
Fri Jan 20 21:31:31 EET 2023
---
libavfilter/graphparser.c | 537 +++++++++-----------------------------
1 file changed, 126 insertions(+), 411 deletions(-)
diff --git a/libavfilter/graphparser.c b/libavfilter/graphparser.c
index ac6171e0c4..5db8b95a0c 100644
--- a/libavfilter/graphparser.c
+++ b/libavfilter/graphparser.c
@@ -33,26 +33,6 @@
#define WHITESPACES " \n\t\r"
-/**
- * Link two filters together.
- *
- * @see avfilter_link()
- */
-static int link_filter(AVFilterContext *src, int srcpad,
- AVFilterContext *dst, int dstpad,
- void *log_ctx)
-{
- int ret;
- if ((ret = avfilter_link(src, srcpad, dst, dstpad))) {
- av_log(log_ctx, AV_LOG_ERROR,
- "Cannot create the link %s:%d -> %s:%d\n",
- src->filter->name, srcpad, dst->filter->name, dstpad);
- return ret;
- }
-
- return 0;
-}
-
/**
* Parse the name of a link, which has the format "[linkname]".
*
@@ -87,119 +67,6 @@ static char *parse_link_name(const char **buf, void *log_ctx)
return name;
}
-/**
- * Create an instance of a filter, initialize and insert it in the
- * filtergraph in *ctx.
- *
- * @param filt_ctx put here a filter context in case of successful creation and configuration, NULL otherwise.
- * @param ctx the filtergraph context
- * @param index an index which is supposed to be unique for each filter instance added to the filtergraph
- * @param name the name of the filter to create, can be filter name or filter_name\@id as instance name
- * @param args the arguments provided to the filter during its initialization
- * @param log_ctx the log context to use
- * @return >= 0 in case of success, a negative AVERROR code otherwise
- */
-static int create_filter(AVFilterContext **filt_ctx, AVFilterGraph *ctx, int index,
- const char *name, const char *args, void *log_ctx)
-{
- const AVFilter *filt;
- char name2[30];
- const char *inst_name = NULL, *filt_name = NULL;
- int ret, k;
-
- av_strlcpy(name2, name, sizeof(name2));
-
- for (k = 0; name2[k]; k++) {
- if (name2[k] == '@' && name[k+1]) {
- name2[k] = 0;
- inst_name = name;
- filt_name = name2;
- break;
- }
- }
-
- if (!inst_name) {
- snprintf(name2, sizeof(name2), "Parsed_%s_%d", name, index);
- inst_name = name2;
- filt_name = name;
- }
-
- filt = avfilter_get_by_name(filt_name);
-
- if (!filt) {
- av_log(log_ctx, AV_LOG_ERROR,
- "No such filter: '%s'\n", filt_name);
- return AVERROR(EINVAL);
- }
-
- *filt_ctx = avfilter_graph_alloc_filter(ctx, filt, inst_name);
- if (!*filt_ctx) {
- av_log(log_ctx, AV_LOG_ERROR,
- "Error creating filter '%s'\n", filt_name);
- return AVERROR(ENOMEM);
- }
-
- if (!strcmp(filt_name, "scale") && ctx->scale_sws_opts) {
- ret = av_set_options_string(*filt_ctx, ctx->scale_sws_opts, "=", ":");
- if (ret < 0)
- return ret;
- }
-
- ret = avfilter_init_str(*filt_ctx, args);
- if (ret < 0) {
- av_log(log_ctx, AV_LOG_ERROR,
- "Error initializing filter '%s'", filt_name);
- if (args)
- av_log(log_ctx, AV_LOG_ERROR, " with args '%s'", args);
- av_log(log_ctx, AV_LOG_ERROR, "\n");
- avfilter_free(*filt_ctx);
- *filt_ctx = NULL;
- }
-
- return ret;
-}
-
-/**
- * Parse a string of the form FILTER_NAME[=PARAMS], and create a
- * corresponding filter instance which is added to graph with
- * create_filter().
- *
- * @param filt_ctx Pointer that is set to the created and configured filter
- * context on success, set to NULL on failure.
- * @param filt_ctx put here a pointer to the created filter context on
- * success, NULL otherwise
- * @param buf pointer to the buffer to parse, *buf will be updated to
- * point to the char next after the parsed string
- * @param index an index which is assigned to the created filter
- * instance, and which is supposed to be unique for each filter
- * instance added to the filtergraph
- * @return >= 0 in case of success, a negative AVERROR code otherwise
- */
-static int parse_filter(AVFilterContext **filt_ctx, const char **buf, AVFilterGraph *graph,
- int index, void *log_ctx)
-{
- char *opts = NULL;
- char *name = av_get_token(buf, "=,;[");
- int ret;
-
- if (!name)
- return AVERROR(ENOMEM);
-
- if (**buf == '=') {
- (*buf)++;
- opts = av_get_token(buf, "[],;");
- if (!opts) {
- av_free(name);
- return AVERROR(ENOMEM);
- }
- }
-
- ret = create_filter(filt_ctx, graph, index, name, opts, log_ctx);
- av_free(name);
- av_free(opts);
- return ret;
-}
-
AVFilterInOut *avfilter_inout_alloc(void)
{
return av_mallocz(sizeof(AVFilterInOut));
@@ -232,12 +99,6 @@ static AVFilterInOut *extract_inout(const char *label, AVFilterInOut **links)
return ret;
}
-static void insert_inout(AVFilterInOut **inouts, AVFilterInOut *element)
-{
- element->next = *inouts;
- *inouts = element;
-}
-
static void append_inout(AVFilterInOut **inouts, AVFilterInOut **element)
{
while (*inouts && (*inouts)->next)
@@ -250,144 +111,6 @@ static void append_inout(AVFilterInOut **inouts, AVFilterInOut **element)
*element = NULL;
}
-static int link_filter_inouts(AVFilterContext *filt_ctx,
- AVFilterInOut **curr_inputs,
- AVFilterInOut **open_inputs, void *log_ctx)
-{
- int pad, ret;
-
- for (pad = 0; pad < filt_ctx->nb_inputs; pad++) {
- AVFilterInOut *p = *curr_inputs;
-
- if (p) {
- *curr_inputs = (*curr_inputs)->next;
- p->next = NULL;
- } else if (!(p = av_mallocz(sizeof(*p))))
- return AVERROR(ENOMEM);
-
- if (p->filter_ctx) {
- ret = link_filter(p->filter_ctx, p->pad_idx, filt_ctx, pad, log_ctx);
- av_freep(&p->name);
- av_freep(&p);
- if (ret < 0)
- return ret;
- } else {
- p->filter_ctx = filt_ctx;
- p->pad_idx = pad;
- append_inout(open_inputs, &p);
- }
- }
-
- if (*curr_inputs) {
- av_log(log_ctx, AV_LOG_ERROR,
- "Too many inputs specified for the \"%s\" filter.\n",
- filt_ctx->filter->name);
- return AVERROR(EINVAL);
- }
-
- pad = filt_ctx->nb_outputs;
- while (pad--) {
- AVFilterInOut *currlinkn = av_mallocz(sizeof(AVFilterInOut));
- if (!currlinkn)
- return AVERROR(ENOMEM);
- currlinkn->filter_ctx = filt_ctx;
- currlinkn->pad_idx = pad;
- insert_inout(curr_inputs, currlinkn);
- }
-
- return 0;
-}
-
-static int parse_inputs(const char **buf, AVFilterInOut **curr_inputs,
- AVFilterInOut **open_outputs, void *log_ctx)
-{
- AVFilterInOut *parsed_inputs = NULL;
- int pad = 0;
-
- while (**buf == '[') {
- char *name = parse_link_name(buf, log_ctx);
- AVFilterInOut *match;
-
- if (!name) {
- avfilter_inout_free(&parsed_inputs);
- return AVERROR(EINVAL);
- }
-
- /* First check if the label is not in the open_outputs list */
- match = extract_inout(name, open_outputs);
-
- if (match) {
- av_free(name);
- } else {
- /* Not in the list, so add it as an input */
- if (!(match = av_mallocz(sizeof(AVFilterInOut)))) {
- avfilter_inout_free(&parsed_inputs);
- av_free(name);
- return AVERROR(ENOMEM);
- }
- match->name = name;
- match->pad_idx = pad;
- }
-
- append_inout(&parsed_inputs, &match);
-
- *buf += strspn(*buf, WHITESPACES);
- pad++;
- }
-
- append_inout(&parsed_inputs, curr_inputs);
- *curr_inputs = parsed_inputs;
-
- return pad;
-}
-
-static int parse_outputs(const char **buf, AVFilterInOut **curr_inputs,
- AVFilterInOut **open_inputs,
- AVFilterInOut **open_outputs, void *log_ctx)
-{
- int ret, pad = 0;
-
- while (**buf == '[') {
- char *name = parse_link_name(buf, log_ctx);
- AVFilterInOut *match;
-
- AVFilterInOut *input = *curr_inputs;
-
- if (!name)
- return AVERROR(EINVAL);
-
- if (!input) {
- av_log(log_ctx, AV_LOG_ERROR,
- "No output pad can be associated to link label '%s'.\n", name);
- av_free(name);
- return AVERROR(EINVAL);
- }
- *curr_inputs = (*curr_inputs)->next;
-
- /* First check if the label is not in the open_inputs list */
- match = extract_inout(name, open_inputs);
-
- if (match) {
- ret = link_filter(input->filter_ctx, input->pad_idx,
- match->filter_ctx, match->pad_idx, log_ctx);
- av_freep(&match->name);
- av_freep(&name);
- av_freep(&match);
- av_freep(&input);
- if (ret < 0)
- return ret;
- } else {
- /* Not in the list, so add the first input as an open_output */
- input->name = name;
- insert_inout(open_outputs, input);
- }
- *buf += strspn(*buf, WHITESPACES);
- pad++;
- }
-
- return pad;
-}
-
static int parse_sws_flags(const char **buf, char **dst, void *log_ctx)
{
char *p = strchr(*buf, ';');
@@ -415,66 +138,24 @@ int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
AVFilterInOut **inputs,
AVFilterInOut **outputs)
{
- int index = 0, ret = 0;
- char chr = 0;
-
- AVFilterInOut *curr_inputs = NULL, *open_inputs = NULL, *open_outputs = NULL;
-
- filters += strspn(filters, WHITESPACES);
-
- if ((ret = parse_sws_flags(&filters, &graph->scale_sws_opts, graph)) < 0)
- goto end;
-
- do {
- AVFilterContext *filter;
- filters += strspn(filters, WHITESPACES);
-
- if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, graph)) < 0)
- goto end;
- if ((ret = parse_filter(&filter, &filters, graph, index, graph)) < 0)
- goto end;
-
-
- if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, graph)) < 0)
- goto end;
-
- if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,
- graph)) < 0)
- goto end;
-
- filters += strspn(filters, WHITESPACES);
- chr = *filters++;
+ AVFilterGraphSegment *seg;
+ int ret;
- if (chr == ';' && curr_inputs)
- append_inout(&open_outputs, &curr_inputs);
- index++;
- } while (chr == ',' || chr == ';');
+ ret = avfilter_graph_segment_parse(graph, filters, 0, &seg);
+ if (ret < 0)
+ return ret;
- if (chr) {
- av_log(graph, AV_LOG_ERROR,
- "Unable to parse graph description substring: \"%s\"\n",
- filters - 1);
- ret = AVERROR(EINVAL);
+ ret = avfilter_graph_segment_apply(seg, 0, inputs, outputs);
+ avfilter_graph_segment_free(&seg);
+ if (ret < 0)
goto end;
- }
-
- append_inout(&open_outputs, &curr_inputs);
-
- *inputs = open_inputs;
- *outputs = open_outputs;
return 0;
end:
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
av_freep(&graph->filters);
- avfilter_inout_free(&open_inputs);
- avfilter_inout_free(&open_outputs);
- avfilter_inout_free(&curr_inputs);
-
- *inputs = NULL;
- *outputs = NULL;
return ret;
}
@@ -542,90 +223,6 @@ int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
return ret;
}
-int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters,
- AVFilterInOut **open_inputs_ptr, AVFilterInOut **open_outputs_ptr,
- void *log_ctx)
-{
- int index = 0, ret = 0;
- char chr = 0;
-
- AVFilterInOut *curr_inputs = NULL;
- AVFilterInOut *open_inputs = open_inputs_ptr ? *open_inputs_ptr : NULL;
- AVFilterInOut *open_outputs = open_outputs_ptr ? *open_outputs_ptr : NULL;
-
- if ((ret = parse_sws_flags(&filters, &graph->scale_sws_opts, graph)) < 0)
- goto end;
-
- do {
- AVFilterContext *filter;
- const char *filterchain = filters;
- filters += strspn(filters, WHITESPACES);
-
- if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, log_ctx)) < 0)
- goto end;
-
- if ((ret = parse_filter(&filter, &filters, graph, index, log_ctx)) < 0)
- goto end;
-
- if (filter->nb_inputs == 1 && !curr_inputs && !index) {
- /* First input pad, assume it is "[in]" if not specified */
- const char *tmp = "[in]";
- if ((ret = parse_inputs(&tmp, &curr_inputs, &open_outputs, log_ctx)) < 0)
- goto end;
- }
-
- if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, log_ctx)) < 0)
- goto end;
-
- if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,
- log_ctx)) < 0)
- goto end;
-
- filters += strspn(filters, WHITESPACES);
- chr = *filters++;
-
- if (chr == ';' && curr_inputs) {
- av_log(log_ctx, AV_LOG_ERROR,
- "Invalid filterchain containing an unlabelled output pad: \"%s\"\n",
- filterchain);
- ret = AVERROR(EINVAL);
- goto end;
- }
- index++;
- } while (chr == ',' || chr == ';');
-
- if (chr) {
- av_log(log_ctx, AV_LOG_ERROR,
- "Unable to parse graph description substring: \"%s\"\n",
- filters - 1);
- ret = AVERROR(EINVAL);
- goto end;
- }
-
- if (curr_inputs) {
- /* Last output pad, assume it is "[out]" if not specified */
- const char *tmp = "[out]";
- if ((ret = parse_outputs(&tmp, &curr_inputs, &open_inputs, &open_outputs,
- log_ctx)) < 0)
- goto end;
- }
-
-end:
- /* clear open_in/outputs only if not passed as parameters */
- if (open_inputs_ptr) *open_inputs_ptr = open_inputs;
- else avfilter_inout_free(&open_inputs);
- if (open_outputs_ptr) *open_outputs_ptr = open_outputs;
- else avfilter_inout_free(&open_outputs);
- avfilter_inout_free(&curr_inputs);
-
- if (ret < 0) {
- while (graph->nb_filters)
- avfilter_free(graph->filters[0]);
- av_freep(&graph->filters);
- }
- return ret;
-}
-
static void pad_params_free(AVFilterPadParams **pfpp)
{
AVFilterPadParams *fpp = *pfpp;
@@ -1298,3 +895,121 @@ int avfilter_graph_segment_apply(AVFilterGraphSegment *seg, int flags,
return 0;
}
+
+int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters,
+ AVFilterInOut **open_inputs_ptr, AVFilterInOut **open_outputs_ptr,
+ void *log_ctx)
+{
+ AVFilterInOut *user_inputs = open_inputs_ptr ? *open_inputs_ptr : NULL;
+ AVFilterInOut *user_outputs = open_outputs_ptr ? *open_outputs_ptr : NULL;
+
+ AVFilterInOut *inputs = NULL, *outputs = NULL;
+ AVFilterGraphSegment *seg = NULL;
+ AVFilterChain *ch;
+ AVFilterParams *p;
+ int ret;
+
+ ret = avfilter_graph_segment_parse(graph, filters, 0, &seg);
+ if (ret < 0)
+ goto end;
+
+ ret = avfilter_graph_segment_create_filters(seg, 0);
+ if (ret < 0)
+ goto end;
+
+ ret = avfilter_graph_segment_apply_opts(seg, 0);
+ if (ret < 0)
+ goto end;
+
+ ret = avfilter_graph_segment_init(seg, 0);
+ if (ret < 0)
+ goto end;
+
+ /* First input pad, assume it is "[in]" if not specified */
+ p = seg->chains[0]->filters[0];
+ if (p->filter->nb_inputs == 1 && !p->inputs) {
+ const char *tmp = "[in]";
+
+ ret = linklabels_parse(graph, &tmp, &p->inputs, &p->nb_inputs);
+ if (ret < 0)
+ goto end;
+ }
+
+ /* Last output pad, assume it is "[out]" if not specified */
+ ch = seg->chains[seg->nb_chains - 1];
+ p = ch->filters[ch->nb_filters - 1];
+ if (p->filter->nb_outputs == 1 && !p->outputs) {
+ const char *tmp = "[out]";
+
+ ret = linklabels_parse(graph, &tmp, &p->outputs, &p->nb_outputs);
+ if (ret < 0)
+ goto end;
+ }
+
+ ret = avfilter_graph_segment_apply(seg, 0, &inputs, &outputs);
+ avfilter_graph_segment_free(&seg);
+ if (ret < 0)
+ goto end;
+
+ // process user-supplied inputs/outputs
+ while (inputs) {
+ AVFilterInOut *cur, *match = NULL;
+
+ cur = inputs;
+ inputs = cur->next;
+ cur->next = NULL;
+
+ if (cur->name)
+ match = extract_inout(cur->name, &user_outputs);
+
+ if (match) {
+ ret = avfilter_link(match->filter_ctx, match->pad_idx,
+ cur->filter_ctx, cur->pad_idx);
+ avfilter_inout_free(&match);
+ avfilter_inout_free(&cur);
+ if (ret < 0)
+ goto end;
+ } else
+ append_inout(&user_inputs, &cur);
+ }
+ while (outputs) {
+ AVFilterInOut *cur, *match = NULL;
+
+ cur = outputs;
+ outputs = cur->next;
+ cur->next = NULL;
+
+ if (cur->name)
+ match = extract_inout(cur->name, &user_inputs);
+
+ if (match) {
+ ret = avfilter_link(cur->filter_ctx, cur->pad_idx,
+ match->filter_ctx, match->pad_idx);
+ avfilter_inout_free(&match);
+ avfilter_inout_free(&cur);
+ if (ret < 0)
+ goto end;
+ } else
+ append_inout(&user_outputs, &cur);
+ }
+
+end:
+ avfilter_graph_segment_free(&seg);
+
+ if (ret < 0) {
+ while (graph->nb_filters)
+ avfilter_free(graph->filters[0]);
+ av_freep(&graph->filters);
+ }
+
+ /* clear open_in/outputs only if not passed as parameters */
+ if (open_inputs_ptr) *open_inputs_ptr = user_inputs;
+ else avfilter_inout_free(&user_inputs);
+ if (open_outputs_ptr) *open_outputs_ptr = user_outputs;
+ else avfilter_inout_free(&user_outputs);
+
+ avfilter_inout_free(&inputs);
+ avfilter_inout_free(&outputs);
+
+ return ret;
+}
--
2.35.1
More information about the ffmpeg-devel
mailing list