mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-02 03:06:28 +02:00
4abf42ab96
When an option could not be found, print its name and value. Note that this is not done while applying the options in avfilter_graph_segment_apply_opts() to give the caller the option of handling the missing options in some other way.
1041 lines
27 KiB
C
1041 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 "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 || p->filter->internal->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;
|
|
}
|