ffmpeg/libavfilter/graphparser.c
Andreas Rheinhardt a272c9cffa avfilter: Add a header for internal generic-layer APIs
This commit moves the generic-layer stuff (that is not used
by filters) to a new header of its own, similarly to
5e7b5b0090 for libavcodec.
thread.h and link_internal.h are merged into this header.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2024-02-18 16:38:09 +01:00

1042 lines
27 KiB
C

/*
* filter graph parser
* Copyright (c) 2008 Vitor Sessak
* Copyright (c) 2007 Bobby Bingham
*
* 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
*/
#include <string.h>
#include <stdio.h>
#include "libavutil/avstring.h"
#include "libavutil/dict.h"
#include "libavutil/mem.h"
#include "libavutil/opt.h"
#include "avfilter.h"
#include "avfilter_internal.h"
#include "internal.h"
#define WHITESPACES " \n\t\r"
/**
* Parse the name of a link, which has the format "[linkname]".
*
* @return a pointer (that need to be freed after use) to the name
* between parenthesis
*/
static char *parse_link_name(const char **buf, void *log_ctx)
{
const char *start = *buf;
char *name;
(*buf)++;
name = av_get_token(buf, "]");
if (!name)
return NULL;
if (!name[0]) {
av_log(log_ctx, AV_LOG_ERROR,
"Bad (empty?) label found in the following: \"%s\".\n", start);
goto fail;
}
if (**buf != ']') {
av_log(log_ctx, AV_LOG_ERROR,
"Mismatched '[' found in the following: \"%s\".\n", start);
fail:
av_freep(&name);
return NULL;
}
(*buf)++;
return name;
}
AVFilterInOut *avfilter_inout_alloc(void)
{
return av_mallocz(sizeof(AVFilterInOut));
}
void avfilter_inout_free(AVFilterInOut **inout)
{
while (*inout) {
AVFilterInOut *next = (*inout)->next;
av_freep(&(*inout)->name);
av_freep(inout);
*inout = next;
}
}
static AVFilterInOut *extract_inout(const char *label, AVFilterInOut **links)
{
AVFilterInOut *ret;
while (*links && (!(*links)->name || strcmp((*links)->name, label)))
links = &((*links)->next);
ret = *links;
if (ret) {
*links = ret->next;
ret->next = NULL;
}
return ret;
}
static void append_inout(AVFilterInOut **inouts, AVFilterInOut **element)
{
while (*inouts && (*inouts)->next)
inouts = &((*inouts)->next);
if (!*inouts)
*inouts = *element;
else
(*inouts)->next = *element;
*element = NULL;
}
static int parse_sws_flags(const char **buf, char **dst, void *log_ctx)
{
char *p = strchr(*buf, ';');
if (strncmp(*buf, "sws_flags=", 10))
return 0;
if (!p) {
av_log(log_ctx, AV_LOG_ERROR, "sws_flags not terminated with ';'.\n");
return AVERROR(EINVAL);
}
*buf += 4; // keep the 'flags=' part
av_freep(dst);
if (!(*dst = av_mallocz(p - *buf + 1)))
return AVERROR(ENOMEM);
av_strlcpy(*dst, *buf, p - *buf + 1);
*buf = p + 1;
return 0;
}
int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
AVFilterInOut **inputs,
AVFilterInOut **outputs)
{
AVFilterGraphSegment *seg;
int ret;
ret = avfilter_graph_segment_parse(graph, filters, 0, &seg);
if (ret < 0)
return ret;
ret = avfilter_graph_segment_apply(seg, 0, inputs, outputs);
avfilter_graph_segment_free(&seg);
if (ret < 0)
goto end;
return 0;
end:
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
av_freep(&graph->filters);
return ret;
}
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
AVFilterInOut *open_inputs,
AVFilterInOut *open_outputs, void *log_ctx)
{
int ret;
AVFilterInOut *cur, *match, *inputs = NULL, *outputs = NULL;
if ((ret = avfilter_graph_parse2(graph, filters, &inputs, &outputs)) < 0)
goto fail;
/* First input can be omitted if it is "[in]" */
if (inputs && !inputs->name)
inputs->name = av_strdup("in");
for (cur = inputs; cur; cur = cur->next) {
if (!cur->name) {
av_log(log_ctx, AV_LOG_ERROR,
"Not enough inputs specified for the \"%s\" filter.\n",
cur->filter_ctx->filter->name);
ret = AVERROR(EINVAL);
goto fail;
}
if (!(match = extract_inout(cur->name, &open_outputs)))
continue;
ret = avfilter_link(match->filter_ctx, match->pad_idx,
cur->filter_ctx, cur->pad_idx);
avfilter_inout_free(&match);
if (ret < 0)
goto fail;
}
/* Last output can be omitted if it is "[out]" */
if (outputs && !outputs->name)
outputs->name = av_strdup("out");
for (cur = outputs; cur; cur = cur->next) {
if (!cur->name) {
av_log(log_ctx, AV_LOG_ERROR,
"Invalid filterchain containing an unlabelled output pad: \"%s\"\n",
filters);
ret = AVERROR(EINVAL);
goto fail;
}
if (!(match = extract_inout(cur->name, &open_inputs)))
continue;
ret = avfilter_link(cur->filter_ctx, cur->pad_idx,
match->filter_ctx, match->pad_idx);
avfilter_inout_free(&match);
if (ret < 0)
goto fail;
}
fail:
if (ret < 0) {
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
av_freep(&graph->filters);
}
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
avfilter_inout_free(&open_inputs);
avfilter_inout_free(&open_outputs);
return ret;
}
static void pad_params_free(AVFilterPadParams **pfpp)
{
AVFilterPadParams *fpp = *pfpp;
if (!fpp)
return;
av_freep(&fpp->label);
av_freep(pfpp);
}
static void filter_params_free(AVFilterParams **pp)
{
AVFilterParams *p = *pp;
if (!p)
return;
for (unsigned i = 0; i < p->nb_inputs; i++)
pad_params_free(&p->inputs[i]);
av_freep(&p->inputs);
for (unsigned i = 0; i < p->nb_outputs; i++)
pad_params_free(&p->outputs[i]);
av_freep(&p->outputs);
av_dict_free(&p->opts);
av_freep(&p->filter_name);
av_freep(&p->instance_name);
av_freep(pp);
}
static void chain_free(AVFilterChain **pch)
{
AVFilterChain *ch = *pch;
if (!ch)
return;
for (size_t i = 0; i < ch->nb_filters; i++)
filter_params_free(&ch->filters[i]);
av_freep(&ch->filters);
av_freep(pch);
}
void avfilter_graph_segment_free(AVFilterGraphSegment **pseg)
{
AVFilterGraphSegment *seg = *pseg;
if (!seg)
return;
for (size_t i = 0; i < seg->nb_chains; i++)
chain_free(&seg->chains[i]);
av_freep(&seg->chains);
av_freep(&seg->scale_sws_opts);
av_freep(pseg);
}
static int linklabels_parse(void *logctx, const char **linklabels,
AVFilterPadParams ***res, unsigned *nb_res)
{
AVFilterPadParams **pp = NULL;
int nb = 0;
int ret;
while (**linklabels == '[') {
char *label;
AVFilterPadParams *par;
label = parse_link_name(linklabels, logctx);
if (!label) {
ret = AVERROR(EINVAL);
goto fail;
}
par = av_mallocz(sizeof(*par));
if (!par) {
av_freep(&label);
ret = AVERROR(ENOMEM);
goto fail;
}
par->label = label;
ret = av_dynarray_add_nofree(&pp, &nb, par);
if (ret < 0) {
pad_params_free(&par);
goto fail;
}
*linklabels += strspn(*linklabels, WHITESPACES);
}
*res = pp;
*nb_res = nb;
return 0;
fail:
for (unsigned i = 0; i < nb; i++)
pad_params_free(&pp[i]);
av_freep(&pp);
return ret;
}
static int filter_parse(void *logctx, const char **filter,
AVFilterParams **pp)
{
AVFilterParams *p;
char *inst_name;
int ret;
p = av_mallocz(sizeof(*p));
if (!p)
return AVERROR(ENOMEM);
ret = linklabels_parse(logctx, filter, &p->inputs, &p->nb_inputs);
if (ret < 0)
goto fail;
p->filter_name = av_get_token(filter, "=,;[");
if (!p->filter_name) {
ret = AVERROR(ENOMEM);
goto fail;
}
inst_name = strchr(p->filter_name, '@');
if (inst_name) {
*inst_name++ = 0;
p->instance_name = av_strdup(inst_name);
if (!p->instance_name) {
ret = AVERROR(ENOMEM);
goto fail;
}
}
if (**filter == '=') {
const AVFilter *f = avfilter_get_by_name(p->filter_name);
char *opts;
(*filter)++;
opts = av_get_token(filter, "[],;");
if (!opts) {
ret = AVERROR(ENOMEM);
goto fail;
}
ret = ff_filter_opt_parse(logctx, f ? f->priv_class : NULL,
&p->opts, opts);
av_freep(&opts);
if (ret < 0)
goto fail;
}
ret = linklabels_parse(logctx, filter, &p->outputs, &p->nb_outputs);
if (ret < 0)
goto fail;
*filter += strspn(*filter, WHITESPACES);
*pp = p;
return 0;
fail:
av_log(logctx, AV_LOG_ERROR,
"Error parsing a filter description around: %s\n", *filter);
filter_params_free(&p);
return ret;
}
static int chain_parse(void *logctx, const char **pchain,
AVFilterChain **pch)
{
const char *chain = *pchain;
AVFilterChain *ch;
int ret, nb_filters = 0;
*pch = NULL;
ch = av_mallocz(sizeof(*ch));
if (!ch)
return AVERROR(ENOMEM);
while (*chain) {
AVFilterParams *p;
char chr;
ret = filter_parse(logctx, &chain, &p);
if (ret < 0)
goto fail;
ret = av_dynarray_add_nofree(&ch->filters, &nb_filters, p);
if (ret < 0) {
filter_params_free(&p);
goto fail;
}
ch->nb_filters = nb_filters;
// a filter ends with one of: , ; end-of-string
chr = *chain;
if (chr && chr != ',' && chr != ';') {
av_log(logctx, AV_LOG_ERROR,
"Trailing garbage after a filter: %s\n", chain);
ret = AVERROR(EINVAL);
goto fail;
}
if (chr) {
chain++;
chain += strspn(chain, WHITESPACES);
if (chr == ';')
break;
}
}
*pchain = chain;
*pch = ch;
return 0;
fail:
av_log(logctx, AV_LOG_ERROR,
"Error parsing filterchain '%s' around: %s\n", *pchain, chain);
chain_free(&ch);
return ret;
}
int avfilter_graph_segment_parse(AVFilterGraph *graph, const char *graph_str,
int flags, AVFilterGraphSegment **pseg)
{
AVFilterGraphSegment *seg;
int ret, nb_chains = 0;
*pseg = NULL;
if (flags)
return AVERROR(ENOSYS);
seg = av_mallocz(sizeof(*seg));
if (!seg)
return AVERROR(ENOMEM);
seg->graph = graph;
graph_str += strspn(graph_str, WHITESPACES);
ret = parse_sws_flags(&graph_str, &seg->scale_sws_opts, graph);
if (ret < 0)
goto fail;
graph_str += strspn(graph_str, WHITESPACES);
while (*graph_str) {
AVFilterChain *ch;
ret = chain_parse(graph, &graph_str, &ch);
if (ret < 0)
goto fail;
ret = av_dynarray_add_nofree(&seg->chains, &nb_chains, ch);
if (ret < 0) {
chain_free(&ch);
goto fail;
}
seg->nb_chains = nb_chains;
graph_str += strspn(graph_str, WHITESPACES);
}
if (!seg->nb_chains) {
av_log(graph, AV_LOG_ERROR, "No filters specified in the graph description\n");
ret = AVERROR(EINVAL);
goto fail;
}
*pseg = seg;
return 0;
fail:
avfilter_graph_segment_free(&seg);
return ret;
}
int avfilter_graph_segment_create_filters(AVFilterGraphSegment *seg, int flags)
{
size_t idx = 0;
if (flags)
return AVERROR(ENOSYS);
if (seg->scale_sws_opts) {
av_freep(&seg->graph->scale_sws_opts);
seg->graph->scale_sws_opts = av_strdup(seg->scale_sws_opts);
if (!seg->graph->scale_sws_opts)
return AVERROR(ENOMEM);
}
for (size_t i = 0; i < seg->nb_chains; i++) {
AVFilterChain *ch = seg->chains[i];
for (size_t j = 0; j < ch->nb_filters; j++) {
AVFilterParams *p = ch->filters[j];
const AVFilter *f = avfilter_get_by_name(p->filter_name);
char name[64];
// skip already processed filters
if (p->filter || !p->filter_name)
continue;
if (!f) {
av_log(seg->graph, AV_LOG_ERROR,
"No such filter: '%s'\n", p->filter_name);
return AVERROR_FILTER_NOT_FOUND;
}
if (!p->instance_name)
snprintf(name, sizeof(name), "Parsed_%s_%zu", f->name, idx);
else
snprintf(name, sizeof(name), "%s@%s", f->name, p->instance_name);
p->filter = avfilter_graph_alloc_filter(seg->graph, f, name);
if (!p->filter)
return AVERROR(ENOMEM);
if (!strcmp(f->name, "scale") && seg->graph->scale_sws_opts) {
int ret = av_set_options_string(p->filter, seg->graph->scale_sws_opts,
"=", ":");
if (ret < 0) {
avfilter_free(p->filter);
p->filter = NULL;
return ret;
}
}
av_freep(&p->filter_name);
av_freep(&p->instance_name);
idx++;
}
}
return 0;
}
static int fail_creation_pending(AVFilterGraphSegment *seg, const char *fn,
const char *func)
{
av_log(seg->graph, AV_LOG_ERROR,
"A creation-pending filter '%s' present in the segment. All filters "
"must be created or disabled before calling %s().\n", fn, func);
return AVERROR(EINVAL);
}
int avfilter_graph_segment_apply_opts(AVFilterGraphSegment *seg, int flags)
{
int ret, leftover_opts = 0;
if (flags)
return AVERROR(ENOSYS);
for (size_t i = 0; i < seg->nb_chains; i++) {
AVFilterChain *ch = seg->chains[i];
for (size_t j = 0; j < ch->nb_filters; j++) {
AVFilterParams *p = ch->filters[j];
if (p->filter_name)
return fail_creation_pending(seg, p->filter_name, __func__);
if (!p->filter || !p->opts)
continue;
ret = av_opt_set_dict2(p->filter, &p->opts, AV_OPT_SEARCH_CHILDREN);
if (ret < 0)
return ret;
if (av_dict_count(p->opts))
leftover_opts = 1;
}
}
return leftover_opts ? AVERROR_OPTION_NOT_FOUND : 0;
}
int avfilter_graph_segment_init(AVFilterGraphSegment *seg, int flags)
{
if (flags)
return AVERROR(ENOSYS);
for (size_t i = 0; i < seg->nb_chains; i++) {
AVFilterChain *ch = seg->chains[i];
for (size_t j = 0; j < ch->nb_filters; j++) {
AVFilterParams *p = ch->filters[j];
int ret;
if (p->filter_name)
return fail_creation_pending(seg, p->filter_name, __func__);
if (!p->filter || fffilterctx(p->filter)->initialized)
continue;
ret = avfilter_init_dict(p->filter, NULL);
if (ret < 0)
return ret;
}
}
return 0;
}
static unsigned
find_linklabel(AVFilterGraphSegment *seg, const char *label,
int output, size_t idx_chain, size_t idx_filter,
AVFilterParams **pp)
{
for (; idx_chain < seg->nb_chains; idx_chain++) {
AVFilterChain *ch = seg->chains[idx_chain];
for (; idx_filter < ch->nb_filters; idx_filter++) {
AVFilterParams *p = ch->filters[idx_filter];
AVFilterPadParams **io = output ? p->outputs : p->inputs;
unsigned nb_io = output ? p->nb_outputs : p->nb_inputs;
AVFilterLink **l;
unsigned nb_l;
if (!p->filter)
continue;
l = output ? p->filter->outputs : p->filter->inputs;
nb_l = output ? p->filter->nb_outputs : p->filter->nb_inputs;
for (unsigned i = 0; i < FFMIN(nb_io, nb_l); i++)
if (!l[i] && io[i]->label && !strcmp(io[i]->label, label)) {
*pp = p;
return i;
}
}
idx_filter = 0;
}
*pp = NULL;
return 0;
}
static int inout_add(AVFilterInOut **inouts, AVFilterContext *f, unsigned pad_idx,
const char *label)
{
AVFilterInOut *io = av_mallocz(sizeof(*io));
if (!io)
return AVERROR(ENOMEM);
io->filter_ctx = f;
io->pad_idx = pad_idx;
if (label) {
io->name = av_strdup(label);
if (!io->name) {
avfilter_inout_free(&io);
return AVERROR(ENOMEM);
}
}
append_inout(inouts, &io);
return 0;
}
static int link_inputs(AVFilterGraphSegment *seg, size_t idx_chain,
size_t idx_filter, AVFilterInOut **inputs)
{
AVFilterChain *ch = seg->chains[idx_chain];
AVFilterParams *p = ch->filters[idx_filter];
AVFilterContext *f = p->filter;
int ret;
if (f->nb_inputs < p->nb_inputs) {
av_log(seg->graph, AV_LOG_ERROR,
"More input link labels specified for filter '%s' than "
"it has inputs: %u > %d\n", f->filter->name,
p->nb_inputs, f->nb_inputs);
return AVERROR(EINVAL);
}
for (unsigned in = 0; in < f->nb_inputs; in++) {
const char *label = (in < p->nb_inputs) ? p->inputs[in]->label : NULL;
// skip already linked inputs
if (f->inputs[in])
continue;
if (label) {
AVFilterParams *po = NULL;
unsigned idx = find_linklabel(seg, label, 1, idx_chain, idx_filter, &po);
if (po) {
ret = avfilter_link(po->filter, idx, f, in);
if (ret < 0)
return ret;
continue;
}
}
ret = inout_add(inputs, f, in, label);
if (ret < 0)
return ret;
}
return 0;
}
static int link_outputs(AVFilterGraphSegment *seg, size_t idx_chain,
size_t idx_filter, AVFilterInOut **outputs)
{
AVFilterChain *ch = seg->chains[idx_chain];
AVFilterParams *p = ch->filters[idx_filter];
AVFilterContext *f = p->filter;
int ret;
if (f->nb_outputs < p->nb_outputs) {
av_log(seg->graph, AV_LOG_ERROR,
"More output link labels specified for filter '%s' than "
"it has outputs: %u > %d\n", f->filter->name,
p->nb_outputs, f->nb_outputs);
return AVERROR(EINVAL);
}
for (unsigned out = 0; out < f->nb_outputs; out++) {
char *label = (out < p->nb_outputs) ? p->outputs[out]->label : NULL;
// skip already linked outputs
if (f->outputs[out])
continue;
if (label) {
AVFilterParams *po = NULL;
unsigned idx = find_linklabel(seg, label, 0, idx_chain, idx_filter, &po);
if (po) {
ret = avfilter_link(f, out, po->filter, idx);
if (ret < 0)
return ret;
continue;
}
}
// if this output is unlabeled, try linking it to an unlabeled
// input in the next non-disabled filter in the chain
for (size_t i = idx_filter + 1; i < ch->nb_filters && !label; i++) {
AVFilterParams *p_next = ch->filters[i];
if (!p_next->filter)
continue;
for (unsigned in = 0; in < p_next->filter->nb_inputs; in++) {
if (!p_next->filter->inputs[in] &&
(in >= p_next->nb_inputs || !p_next->inputs[in]->label)) {
ret = avfilter_link(f, out, p_next->filter, in);
if (ret < 0)
return ret;
goto cont;
}
}
break;
}
ret = inout_add(outputs, f, out, label);
if (ret < 0)
return ret;
cont:;
}
return 0;
}
int avfilter_graph_segment_link(AVFilterGraphSegment *seg, int flags,
AVFilterInOut **inputs,
AVFilterInOut **outputs)
{
int ret;
*inputs = NULL;
*outputs = NULL;
if (flags)
return AVERROR(ENOSYS);
for (size_t idx_chain = 0; idx_chain < seg->nb_chains; idx_chain++) {
AVFilterChain *ch = seg->chains[idx_chain];
for (size_t idx_filter = 0; idx_filter < ch->nb_filters; idx_filter++) {
AVFilterParams *p = ch->filters[idx_filter];
if (p->filter_name) {
ret = fail_creation_pending(seg, p->filter_name, __func__);
goto fail;
}
if (!p->filter)
continue;
ret = link_inputs(seg, idx_chain, idx_filter, inputs);
if (ret < 0)
goto fail;
ret = link_outputs(seg, idx_chain, idx_filter, outputs);
if (ret < 0)
goto fail;
}
}
return 0;
fail:
avfilter_inout_free(inputs);
avfilter_inout_free(outputs);
return ret;
}
// print an error message if some options were not found
static void log_unknown_opt(const AVFilterGraphSegment *seg)
{
for (size_t i = 0; i < seg->nb_chains; i++) {
const AVFilterChain *ch = seg->chains[i];
for (size_t j = 0; j < ch->nb_filters; j++) {
const AVFilterParams *p = ch->filters[j];
const AVDictionaryEntry *e;
if (!p->filter)
continue;
e = av_dict_iterate(p->opts, NULL);
if (e) {
av_log(p->filter, AV_LOG_ERROR,
"Could not set non-existent option '%s' to value '%s'\n",
e->key, e->value);
return;
}
}
}
}
int avfilter_graph_segment_apply(AVFilterGraphSegment *seg, int flags,
AVFilterInOut **inputs,
AVFilterInOut **outputs)
{
int ret;
if (flags)
return AVERROR(ENOSYS);
ret = avfilter_graph_segment_create_filters(seg, 0);
if (ret < 0) {
av_log(seg->graph, AV_LOG_ERROR, "Error creating filters\n");
return ret;
}
ret = avfilter_graph_segment_apply_opts(seg, 0);
if (ret < 0) {
if (ret == AVERROR_OPTION_NOT_FOUND)
log_unknown_opt(seg);
av_log(seg->graph, AV_LOG_ERROR, "Error applying filter options\n");
return ret;
}
ret = avfilter_graph_segment_init(seg, 0);
if (ret < 0) {
av_log(seg->graph, AV_LOG_ERROR, "Error initializing filters\n");
return ret;
}
ret = avfilter_graph_segment_link(seg, 0, inputs, outputs);
if (ret < 0) {
av_log(seg->graph, AV_LOG_ERROR, "Error linking filters\n");
return ret;
}
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) {
if (ret == AVERROR_OPTION_NOT_FOUND)
log_unknown_opt(seg);
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) {
av_log(graph, AV_LOG_ERROR, "Error processing filtergraph: %s\n",
av_err2str(ret));
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;
}