mirror of https://git.ffmpeg.org/ffmpeg.git
lavfi/graphparser: reimplement avfilter_graph_parse* using new API
This commit is contained in:
Anton Khirnov
parent
d1b9a3ddb4
commit
f17051eaae
|
|
@ -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;
|
||||
AVFilterGraphSegment *seg;
|
||||
int ret;
|
||||
|
||||
AVFilterInOut *curr_inputs = NULL, *open_inputs = NULL, *open_outputs = NULL;
|
||||
ret = avfilter_graph_segment_parse(graph, filters, 0, &seg);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
filters += strspn(filters, WHITESPACES);
|
||||
|
||||
if ((ret = parse_sws_flags(&filters, &graph->scale_sws_opts, graph)) < 0)
|
||||
ret = avfilter_graph_segment_apply(seg, 0, inputs, outputs);
|
||||
avfilter_graph_segment_free(&seg);
|
||||
if (ret < 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++;
|
||||
|
||||
if (chr == ';' && curr_inputs)
|
||||
append_inout(&open_outputs, &curr_inputs);
|
||||
index++;
|
||||
} while (chr == ',' || chr == ';');
|
||||
|
||||
if (chr) {
|
||||
av_log(graph, AV_LOG_ERROR,
|
||||
"Unable to parse graph description substring: \"%s\"\n",
|
||||
filters - 1);
|
||||
ret = AVERROR(EINVAL);
|
||||
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;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue