lavfi/graphparser: reimplement avfilter_graph_parse* using new API

1 files changed, 126 insertions, 411 deletions

diff --git a/libavfilter/graphparser.c b/libavfilter/graphparser.c
index 84d86a6441..8e12416ccb 100644
--- a/libavfilter/graphparser.c
+++ b/libavfilter/graphparser.c
@@ -34,26 +34,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]".
  *
  * @return a pointer (that need to be freed after use) to the name
@@ -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;
@@ -1288,3 +885,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;
+}