/* * 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/imgutils.h"#include "libavutil/internal.h"#include "libavutil/opt.h"#include "libavutil/pixdesc.h" #define FF_INTERNAL_FIELDS 1#include "framequeue.h" #include "avfilter.h"#include "buffersink.h"#include "formats.h"#include "internal.h"#include "thread.h" #define OFFSET(x) offsetof(AVFilterGraph, x)#define F AV_OPT_FLAG_FILTERING_PARAM#define V AV_OPT_FLAG_VIDEO_PARAM#define A AV_OPT_FLAG_AUDIO_PARAMstatic const AVOption filtergraph_options[] = {    { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,        { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, F|V|A, "thread_type" },        { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = F|V|A, .unit = "thread_type" },    { "threads",     "Maximum number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,        { .i64 = 0 }, 0, INT_MAX, F|V|A, "threads"},        {"auto", "autodetect a suitable number of threads to use", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, .flags = F|V|A, .unit = "threads"},    {"scale_sws_opts"       , "default scale filter options"        , OFFSET(scale_sws_opts)        ,        AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, F|V },    {"aresample_swr_opts"   , "default aresample filter options"    , OFFSET(aresample_swr_opts)    ,        AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, F|A },    { 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);    ff_framequeue_global_init(&ret->internal->frame_queues);     return ret;} void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter){    int i, j;    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--;            filter->graph = NULL;            for (j = 0; j<filter->nb_outputs; j++)                if (filter->outputs[j])                    filter->outputs[j]->graph = NULL;             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_opt_free(*graph);     av_freep(&(*graph)->filters);    av_freep(&(*graph)->internal);    av_freep(graph);} 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:    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: %s.\n", av_err2str(ret));                return NULL;            }        }    }     filters = av_realloc_array(graph->filters, graph->nb_filters + 1, sizeof(*filters));    if (!filters)        return NULL;    graph->filters = filters;     s = ff_filter_alloc(filter, name);    if (!s)        return NULL;     graph->filters[graph->nb_filters++] = s;     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, void *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, void *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;} static int graph_check_links(AVFilterGraph *graph, void *log_ctx){    AVFilterContext *f;    AVFilterLink *l;    unsigned i, j;    int ret;     for (i = 0; i < graph->nb_filters; i++) {        f = graph->filters[i];        for (j = 0; j < f->nb_outputs; j++) {            l = f->outputs[j];            if (l->type == AVMEDIA_TYPE_VIDEO) {                ret = av_image_check_size2(l->w, l->h, INT64_MAX, l->format, 0, f);                if (ret < 0)                    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 int filter_link_check_formats(void *log, AVFilterLink *link, AVFilterFormatsConfig *cfg){    int ret;     switch (link->type) {     case AVMEDIA_TYPE_VIDEO:        if ((ret = ff_formats_check_pixel_formats(log, cfg->formats)) < 0)            return ret;        break;     case AVMEDIA_TYPE_AUDIO:        if ((ret = ff_formats_check_sample_formats(log, cfg->formats)) < 0 ||            (ret = ff_formats_check_sample_rates(log, cfg->samplerates)) < 0 ||            (ret = ff_formats_check_channel_layouts(log, cfg->channel_layouts)) < 0)            return ret;        break;     default:        av_assert0(!"reached");    }    return 0;} /** * Check the validity of the formats / etc. lists set by query_formats(). * * In particular, check they do not contain any redundant element. */static int filter_check_formats(AVFilterContext *ctx){    unsigned i;    int ret;     for (i = 0; i < ctx->nb_inputs; i++) {        ret = filter_link_check_formats(ctx, ctx->inputs[i], &ctx->inputs[i]->outcfg);        if (ret < 0)            return ret;    }    for (i = 0; i < ctx->nb_outputs; i++) {        ret = filter_link_check_formats(ctx, ctx->outputs[i], &ctx->outputs[i]->incfg);        if (ret < 0)            return ret;    }    return 0;} static int filter_query_formats(AVFilterContext *ctx){    int ret;    AVFilterFormats *formats;    AVFilterChannelLayouts *chlayouts;    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;    }    ret = filter_check_formats(ctx);    if (ret < 0)        return ret;     formats = ff_all_formats(type);    if ((ret = ff_set_common_formats(ctx, formats)) < 0)        return ret;    if (type == AVMEDIA_TYPE_AUDIO) {        if ((ret = ff_set_common_all_samplerates(ctx)) < 0)            return ret;        chlayouts = ff_all_channel_layouts();        if ((ret = ff_set_common_channel_layouts(ctx, chlayouts)) < 0)            return ret;    }    return 0;} static int formats_declared(AVFilterContext *f){    int i;     for (i = 0; i < f->nb_inputs; i++) {        if (!f->inputs[i]->outcfg.formats)            return 0;        if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&            !(f->inputs[i]->outcfg.samplerates &&              f->inputs[i]->outcfg.channel_layouts))            return 0;    }    for (i = 0; i < f->nb_outputs; i++) {        if (!f->outputs[i]->incfg.formats)            return 0;        if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&            !(f->outputs[i]->incfg.samplerates &&              f->outputs[i]->incfg.channel_layouts))            return 0;    }    return 1;} /** * 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, void *log_ctx){    int i, j, ret;    int converter_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];            const AVFilterNegotiation *neg;            unsigned neg_step;            int convert_needed = 0;             if (!link)                continue;             neg = ff_filter_get_negotiation(link);            av_assert0(neg);            for (neg_step = 1; neg_step < neg->nb_mergers; neg_step++) {                const AVFilterFormatsMerger *m = &neg->mergers[neg_step];                void *a = FF_FIELD_AT(void *, m->offset, link->incfg);                void *b = FF_FIELD_AT(void *, m->offset, link->outcfg);                if (a && b && a != b && !m->can_merge(a, b)) {                    convert_needed = 1;                    break;                }            }            for (neg_step = 0; neg_step < neg->nb_mergers; neg_step++) {                const AVFilterFormatsMerger *m = &neg->mergers[neg_step];                void *a = FF_FIELD_AT(void *, m->offset, link->incfg);                void *b = FF_FIELD_AT(void *, m->offset, link->outcfg);                if (!(a && b)) {                    count_delayed++;                } else if (a == b) {                    count_already_merged++;                } else if (!convert_needed) {                    count_merged++;                    ret = m->merge(a, b);                    if (ret < 0)                        return ret;                    if (!ret)                        convert_needed = 1;                }            }             if (convert_needed) {                AVFilterContext *convert;                const AVFilter *filter;                AVFilterLink *inlink, *outlink;                char inst_name[30];                const char *opts;                 if (graph->disable_auto_convert) {                    av_log(log_ctx, AV_LOG_ERROR,                           "The filters '%s' and '%s' do not have a common format "                           "and automatic conversion is disabled.\n",                           link->src->name, link->dst->name);                    return AVERROR(EINVAL);                }                 /* couldn't merge format lists. auto-insert conversion filter */                if (!(filter = avfilter_get_by_name(neg->conversion_filter))) {                    av_log(log_ctx, AV_LOG_ERROR,                           "'%s' filter not present, cannot convert formats.\n",                           neg->conversion_filter);                    return AVERROR(EINVAL);                }                snprintf(inst_name, sizeof(inst_name), "auto_%s_%d",                         neg->conversion_filter, converter_count++);                opts = FF_FIELD_AT(char *, neg->conversion_opts_offset, *graph);                ret = avfilter_graph_create_filter(&convert, filter, inst_name, opts, NULL, graph);                if (ret < 0)                    return ret;

Lines 1–500 of 1343. Load more