/* * 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 },    {"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_freep(&(*graph)->scale_sws_opts);    av_freep(&(*graph)->aresample_swr_opts);    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:    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: %s.\n", av_err2str(ret));                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;     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;} static int graph_check_links(AVFilterGraph *graph, AVClass *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 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_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, 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;    }    ret = filter_check_formats(ctx);    if (ret < 0)        return ret;     for (i = 0; i < ctx->nb_inputs; i++)        sanitize_channel_layouts(ctx, ctx->inputs[i]->outcfg.channel_layouts);    for (i = 0; i < ctx->nb_outputs; i++)        sanitize_channel_layouts(ctx, ctx->outputs[i]->incfg.channel_layouts);     formats = ff_all_formats(type);    if ((ret = ff_set_common_formats(ctx, formats)) < 0)        return ret;    if (type == AVMEDIA_TYPE_AUDIO) {        samplerates = ff_all_samplerates();        if ((ret = ff_set_common_samplerates(ctx, samplerates)) < 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, 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->incfg.formats != link->outcfg.formats                && link->incfg.formats && link->outcfg.formats)                if (!ff_can_merge_formats(link->incfg.formats, link->outcfg.formats,                                          link->type))                    convert_needed = 1;            if (link->type == AVMEDIA_TYPE_AUDIO) {                if (link->incfg.samplerates != link->outcfg.samplerates                    && link->incfg.samplerates && link->outcfg.samplerates)                    if (!ff_can_merge_samplerates(link->incfg.samplerates,                                                  link->outcfg.samplerates))                        convert_needed = 1;            } #define CHECKED_MERGE(field, ...) ((ret = ff_merge_ ## field(__VA_ARGS__)) <= 0)#define MERGE_DISPATCH(field, ...)                                           \            if (!(link->incfg.field && link->outcfg.field)) {                \                count_delayed++;                                             \            } else if (link->incfg.field == link->outcfg.field) {            \                count_already_merged++;                                      \            } else if (!convert_needed) {                                    \                count_merged++;                                              \                if (CHECKED_MERGE(field, __VA_ARGS__)) {                     \                    if (ret < 0)                                             \                        return ret;                                          \                    convert_needed = 1;                                      \                }                                                            \            }             if (link->type == AVMEDIA_TYPE_AUDIO) {                MERGE_DISPATCH(channel_layouts, link->incfg.channel_layouts,                                                link->outcfg.channel_layouts)                MERGE_DISPATCH(samplerates, link->incfg.samplerates,                                            link->outcfg.samplerates)            }            MERGE_DISPATCH(formats, link->incfg.formats,

Lines 1–500 of 1401. Load more