/* * filter graphs * 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 "config.h" #include <string.h> #include "libavutil/avassert.h"#include "libavutil/avstring.h"#include "libavutil/bprint.h"#include "libavutil/channel_layout.h"#include "libavutil/internal.h"#include "libavutil/opt.h"#include "libavutil/pixdesc.h" #include "avfilter.h"#include "formats.h"#include "internal.h"#include "thread.h" #define OFFSET(x) offsetof(AVFilterGraph, x)#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAMstatic const AVOption filtergraph_options[] = {    { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,        { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },        { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },    { "threads",     "Maximum number of threads", OFFSET(nb_threads),        AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, INT_MAX, FLAGS },    {"scale_sws_opts"       , "default scale filter options"        , OFFSET(scale_sws_opts)        ,        AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },    {"aresample_swr_opts"   , "default aresample filter options"    , OFFSET(aresample_swr_opts)    ,        AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },    { NULL },}; static const AVClass filtergraph_class = {    .class_name = "AVFilterGraph",    .item_name  = av_default_item_name,    .version    = LIBAVUTIL_VERSION_INT,    .option     = filtergraph_options,    .category   = AV_CLASS_CATEGORY_FILTER,}; #if !HAVE_THREADSvoid ff_graph_thread_free(AVFilterGraph *graph){} int ff_graph_thread_init(AVFilterGraph *graph){    graph->thread_type = 0;    graph->nb_threads  = 1;    return 0;}#endif AVFilterGraph *avfilter_graph_alloc(void){    AVFilterGraph *ret = av_mallocz(sizeof(*ret));    if (!ret)        return NULL;     ret->internal = av_mallocz(sizeof(*ret->internal));    if (!ret->internal) {        av_freep(&ret);        return NULL;    }     ret->av_class = &filtergraph_class;    av_opt_set_defaults(ret);     return ret;} void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter){    int i;    for (i = 0; i < graph->nb_filters; i++) {        if (graph->filters[i] == filter) {            FFSWAP(AVFilterContext*, graph->filters[i],                   graph->filters[graph->nb_filters - 1]);            graph->nb_filters--;            return;        }    }} void avfilter_graph_free(AVFilterGraph **graph){    if (!*graph)        return;     while ((*graph)->nb_filters)        avfilter_free((*graph)->filters[0]);     ff_graph_thread_free(*graph);     av_freep(&(*graph)->sink_links);     av_freep(&(*graph)->scale_sws_opts);    av_freep(&(*graph)->aresample_swr_opts);    av_freep(&(*graph)->resample_lavr_opts);    av_freep(&(*graph)->filters);    av_freep(&(*graph)->internal);    av_freep(graph);} #if FF_API_AVFILTER_OPENint avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter){    AVFilterContext **filters = av_realloc(graph->filters,                                           sizeof(*filters) * (graph->nb_filters + 1));    if (!filters)        return AVERROR(ENOMEM);     graph->filters = filters;    graph->filters[graph->nb_filters++] = filter; #if FF_API_FOO_COUNTFF_DISABLE_DEPRECATION_WARNINGS    graph->filter_count_unused = graph->nb_filters;FF_ENABLE_DEPRECATION_WARNINGS#endif     filter->graph = graph;     return 0;}#endif int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt,                                 const char *name, const char *args, void *opaque,                                 AVFilterGraph *graph_ctx){    int ret;     *filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name);    if (!*filt_ctx)        return AVERROR(ENOMEM);     ret = avfilter_init_str(*filt_ctx, args);    if (ret < 0)        goto fail;     return 0; fail:    if (*filt_ctx)        avfilter_free(*filt_ctx);    *filt_ctx = NULL;    return ret;} void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags){    graph->disable_auto_convert = flags;} AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,                                             const AVFilter *filter,                                             const char *name){    AVFilterContext **filters, *s;     if (graph->thread_type && !graph->internal->thread_execute) {        if (graph->execute) {            graph->internal->thread_execute = graph->execute;        } else {            int ret = ff_graph_thread_init(graph);            if (ret < 0) {                av_log(graph, AV_LOG_ERROR, "Error initializing threading.\n");                return NULL;            }        }    }     s = ff_filter_alloc(filter, name);    if (!s)        return NULL;     filters = av_realloc(graph->filters, sizeof(*filters) * (graph->nb_filters + 1));    if (!filters) {        avfilter_free(s);        return NULL;    }     graph->filters = filters;    graph->filters[graph->nb_filters++] = s; #if FF_API_FOO_COUNTFF_DISABLE_DEPRECATION_WARNINGS    graph->filter_count_unused = graph->nb_filters;FF_ENABLE_DEPRECATION_WARNINGS#endif     s->graph = graph;     return s;} /** * Check for the validity of graph. * * A graph is considered valid if all its input and output pads are * connected. * * @return >= 0 in case of success, a negative value otherwise */static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx){    AVFilterContext *filt;    int i, j;     for (i = 0; i < graph->nb_filters; i++) {        const AVFilterPad *pad;        filt = graph->filters[i];         for (j = 0; j < filt->nb_inputs; j++) {            if (!filt->inputs[j] || !filt->inputs[j]->src) {                pad = &filt->input_pads[j];                av_log(log_ctx, AV_LOG_ERROR,                       "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",                       pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);                return AVERROR(EINVAL);            }        }         for (j = 0; j < filt->nb_outputs; j++) {            if (!filt->outputs[j] || !filt->outputs[j]->dst) {                pad = &filt->output_pads[j];                av_log(log_ctx, AV_LOG_ERROR,                       "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",                       pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);                return AVERROR(EINVAL);            }        }    }     return 0;} /** * Configure all the links of graphctx. * * @return >= 0 in case of success, a negative value otherwise */static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx){    AVFilterContext *filt;    int i, ret;     for (i = 0; i < graph->nb_filters; i++) {        filt = graph->filters[i];         if (!filt->nb_outputs) {            if ((ret = avfilter_config_links(filt)))                return ret;        }    }     return 0;} AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, const char *name){    int i;     for (i = 0; i < graph->nb_filters; i++)        if (graph->filters[i]->name && !strcmp(name, graph->filters[i]->name))            return graph->filters[i];     return NULL;} static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l){    if (!l)        return;    if (l->nb_channel_layouts) {        if (l->all_layouts || l->all_counts)            av_log(log, AV_LOG_WARNING, "All layouts set on non-empty list\n");        l->all_layouts = l->all_counts = 0;    } else {        if (l->all_counts && !l->all_layouts)            av_log(log, AV_LOG_WARNING, "All counts without all layouts\n");        l->all_layouts = 1;    }} static int filter_query_formats(AVFilterContext *ctx){    int ret, i;    AVFilterFormats *formats;    AVFilterChannelLayouts *chlayouts;    AVFilterFormats *samplerates;    enum AVMediaType type = ctx->inputs  && ctx->inputs [0] ? ctx->inputs [0]->type :                            ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :                            AVMEDIA_TYPE_VIDEO;     if ((ret = ctx->filter->query_formats(ctx)) < 0) {        if (ret != AVERROR(EAGAIN))            av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",                   ctx->name, av_err2str(ret));        return ret;    }     for (i = 0; i < ctx->nb_inputs; i++)        sanitize_channel_layouts(ctx, ctx->inputs[i]->out_channel_layouts);    for (i = 0; i < ctx->nb_outputs; i++)        sanitize_channel_layouts(ctx, ctx->outputs[i]->in_channel_layouts);     formats = ff_all_formats(type);    if (!formats)        return AVERROR(ENOMEM);    ff_set_common_formats(ctx, formats);    if (type == AVMEDIA_TYPE_AUDIO) {        samplerates = ff_all_samplerates();        if (!samplerates)            return AVERROR(ENOMEM);        ff_set_common_samplerates(ctx, samplerates);        chlayouts = ff_all_channel_layouts();        if (!chlayouts)            return AVERROR(ENOMEM);        ff_set_common_channel_layouts(ctx, chlayouts);    }    return 0;} static int formats_declared(AVFilterContext *f){    int i;     for (i = 0; i < f->nb_inputs; i++) {        if (!f->inputs[i]->out_formats)            return 0;        if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&            !(f->inputs[i]->out_samplerates &&              f->inputs[i]->out_channel_layouts))            return 0;    }    for (i = 0; i < f->nb_outputs; i++) {        if (!f->outputs[i]->in_formats)            return 0;        if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&            !(f->outputs[i]->in_samplerates &&              f->outputs[i]->in_channel_layouts))            return 0;    }    return 1;} static AVFilterFormats *clone_filter_formats(AVFilterFormats *arg){    AVFilterFormats *a = av_memdup(arg, sizeof(*arg));    if (a) {        a->refcount = 0;        a->refs     = NULL;        a->formats  = av_memdup(a->formats, sizeof(*a->formats) * a->nb_formats);        if (!a->formats && arg->formats)            av_freep(&a);    }    return a;} static int can_merge_formats(AVFilterFormats *a_arg,                             AVFilterFormats *b_arg,                             enum AVMediaType type,                             int is_sample_rate){    AVFilterFormats *a, *b, *ret;    if (a_arg == b_arg)        return 1;    a = clone_filter_formats(a_arg);    b = clone_filter_formats(b_arg);     if (!a || !b) {        if (a)            av_freep(&a->formats);        if (b)            av_freep(&b->formats);         av_freep(&a);        av_freep(&b);         return 0;    }     if (is_sample_rate) {        ret = ff_merge_samplerates(a, b);    } else {        ret = ff_merge_formats(a, b, type);    }    if (ret) {        av_freep(&ret->formats);        av_freep(&ret->refs);        av_freep(&ret);        return 1;    } else {        av_freep(&a->formats);        av_freep(&b->formats);        av_freep(&a);        av_freep(&b);        return 0;    }} /** * Perform one round of query_formats() and merging formats lists on the * filter graph. * @return  >=0 if all links formats lists could be queried and merged; *          AVERROR(EAGAIN) some progress was made in the queries or merging *          and a later call may succeed; *          AVERROR(EIO) (may be changed) plus a log message if no progress *          was made and the negotiation is stuck; *          a negative error code if some other error happened */static int query_formats(AVFilterGraph *graph, AVClass *log_ctx){    int i, j, ret;    int scaler_count = 0, resampler_count = 0;    int count_queried = 0;        /* successful calls to query_formats() */    int count_merged = 0;         /* successful merge of formats lists */    int count_already_merged = 0; /* lists already merged */    int count_delayed = 0;        /* lists that need to be merged later */     for (i = 0; i < graph->nb_filters; i++) {        AVFilterContext *f = graph->filters[i];        if (formats_declared(f))            continue;        if (f->filter->query_formats)            ret = filter_query_formats(f);        else            ret = ff_default_query_formats(f);        if (ret < 0 && ret != AVERROR(EAGAIN))            return ret;        /* note: EAGAIN could indicate a partial success, not counted yet */        count_queried += ret >= 0;    }     /* go through and merge as many format lists as possible */    for (i = 0; i < graph->nb_filters; i++) {        AVFilterContext *filter = graph->filters[i];         for (j = 0; j < filter->nb_inputs; j++) {            AVFilterLink *link = filter->inputs[j];            int convert_needed = 0;             if (!link)                continue;             if (link->in_formats != link->out_formats                && link->in_formats && link->out_formats)                if (!can_merge_formats(link->in_formats, link->out_formats,                                      link->type, 0))                    convert_needed = 1;            if (link->type == AVMEDIA_TYPE_AUDIO) {                if (link->in_samplerates != link->out_samplerates                    && link->in_samplerates && link->out_samplerates)                    if (!can_merge_formats(link->in_samplerates,                                           link->out_samplerates,                                           0, 1))                        convert_needed = 1;            } #define MERGE_DISPATCH(field, statement)                                     \            if (!(link->in_ ## field && link->out_ ## field)) {              \                count_delayed++;                                             \            } else if (link->in_ ## field == link->out_ ## field) {          \                count_already_merged++;                                      \            } else if (!convert_needed) {                                    \                count_merged++;                                              \                statement                                                    \            }             if (link->type == AVMEDIA_TYPE_AUDIO) {                MERGE_DISPATCH(channel_layouts,                    if (!ff_merge_channel_layouts(link->in_channel_layouts,                                                  link->out_channel_layouts))                        convert_needed = 1;                )                MERGE_DISPATCH(samplerates,

Lines 1–500 of 1341. Load more