Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

lavfi/graphparser: reimplement avfilter_graph_parse* using new API

Browse Source
release/6.0
Anton Khirnov 2 years ago
parent d1b9a3ddb4
commit f17051eaae
1 changed files with 126 additions and 411 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 537
      libavfilter/graphparser.c

537
libavfilter/graphparser.c
Unescape View File

@ -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;
@ -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;
}

Write Preview
Loading…
Cancel
Save