/* * 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/bprint.h"#include "libavutil/channel_layout.h"#include "libavutil/imgutils.h"#include "libavutil/mem.h"#include "libavutil/opt.h"#include "libavutil/pixdesc.h"  #include "avfilter.h"#include "avfilter_internal.h"#include "buffersink.h"#include "filters.h"#include "formats.h"#include "framequeue.h"#include "video.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, .unit = "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, .unit = "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 },    {"max_buffered_frames"  , "maximum number of buffered frames allowed", OFFSET(max_buffered_frames),        AV_OPT_TYPE_UINT,   {.i64 = 0}, 0, UINT_MAX, F|V|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(FFFilterGraph *graph){} int ff_graph_thread_init(FFFilterGraph *graph){    graph->p.thread_type = 0;    graph->p.nb_threads  = 1;    return 0;}#endif AVFilterGraph *avfilter_graph_alloc(void){    FFFilterGraph *graph = av_mallocz(sizeof(*graph));    AVFilterGraph *ret;     if (!graph)        return NULL;     ret = &graph->p;    ret->av_class = &filtergraph_class;    av_opt_set_defaults(ret);    ff_framequeue_global_init(&graph->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])                    ff_filter_link(filter->outputs[j])->graph = NULL;             return;        }    }} void avfilter_graph_free(AVFilterGraph **graphp){    AVFilterGraph *graph = *graphp;    FFFilterGraph *graphi = fffiltergraph(graph);     if (!graph)        return;     while (graph->nb_filters)        avfilter_free(graph->filters[0]);     ff_graph_thread_free(graphi);     av_freep(&graphi->sink_links);     av_opt_free(graph);     av_freep(&graph->filters);    av_freep(graphp);} 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){    fffiltergraph(graph)->disable_auto_convert = flags;} AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,                                             const AVFilter *filter,                                             const char *name){    AVFilterContext **filters, *s;    FFFilterGraph *graphi = fffiltergraph(graph);     if (graph->thread_type && !graphi->thread_execute) {        if (graph->execute) {            graphi->thread_execute = graph->execute;        } else {            int ret = ff_graph_thread_init(graphi);            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 = ff_filter_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 ||            (ret = ff_formats_check_color_spaces(log, cfg->color_spaces)) < 0 ||            (ret = ff_formats_check_color_ranges(log, cfg->color_ranges)) < 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){    const FFFilter *const filter = fffilter(ctx->filter);    int ret;     if (filter->formats_state == FF_FILTER_FORMATS_QUERY_FUNC) {        if ((ret = filter->formats.query_func(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;        }    } else if (filter->formats_state == FF_FILTER_FORMATS_QUERY_FUNC2) {        AVFilterFormatsConfig *cfg_in_stack[64], *cfg_out_stack[64];        AVFilterFormatsConfig **cfg_in_dyn = NULL, **cfg_out_dyn = NULL;        AVFilterFormatsConfig **cfg_in, **cfg_out;         if (ctx->nb_inputs > FF_ARRAY_ELEMS(cfg_in_stack)) {            cfg_in_dyn = av_malloc_array(ctx->nb_inputs, sizeof(*cfg_in_dyn));            if (!cfg_in_dyn)                return AVERROR(ENOMEM);            cfg_in = cfg_in_dyn;        } else            cfg_in = ctx->nb_inputs ? cfg_in_stack : NULL;         for (unsigned i = 0; i < ctx->nb_inputs; i++) {            AVFilterLink *l = ctx->inputs[i];            cfg_in[i] = &l->outcfg;        }         if (ctx->nb_outputs > FF_ARRAY_ELEMS(cfg_out_stack)) {            cfg_out_dyn = av_malloc_array(ctx->nb_outputs, sizeof(*cfg_out_dyn));            if (!cfg_out_dyn) {                av_freep(&cfg_in_dyn);                return AVERROR(ENOMEM);            }            cfg_out = cfg_out_dyn;        } else            cfg_out = ctx->nb_outputs ? cfg_out_stack : NULL;         for (unsigned i = 0; i < ctx->nb_outputs; i++) {            AVFilterLink *l = ctx->outputs[i];            cfg_out[i] = &l->incfg;        }         ret = filter->formats.query_func2(ctx, cfg_in, cfg_out);        av_freep(&cfg_in_dyn);        av_freep(&cfg_out_dyn);        if (ret < 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;        }    }     if (filter->formats_state == FF_FILTER_FORMATS_QUERY_FUNC ||        filter->formats_state == FF_FILTER_FORMATS_QUERY_FUNC2) {        ret = filter_check_formats(ctx);        if (ret < 0)            return ret;    }     return ff_default_query_formats(ctx);} 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_VIDEO &&            !(f->inputs[i]->outcfg.color_ranges &&              f->inputs[i]->outcfg.color_spaces))            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_VIDEO &&            !(f->outputs[i]->incfg.color_ranges &&              f->outputs[i]->incfg.color_spaces))            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;} static void print_formats(void *log_ctx, int level, enum AVMediaType type,                          const AVFilterFormats *formats){    AVBPrint bp;    av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);     switch (type) {    case AVMEDIA_TYPE_VIDEO:        for (unsigned i = 0; i < formats->nb_formats; i++)            av_bprintf(&bp, "%s%s", bp.len ? " " : "", av_get_pix_fmt_name(formats->formats[i]));        break;    case AVMEDIA_TYPE_AUDIO:        for (unsigned i = 0; i < formats->nb_formats; i++)            av_bprintf(&bp, "%s%s", bp.len ? " " : "", av_get_sample_fmt_name(formats->formats[i]));        break;    default:        av_bprintf(&bp, "(unknown)");        break;    }     if (av_bprint_is_complete(&bp)) {        av_log(log_ctx, level, "%s\n", bp.str);    } else {        av_log(log_ctx, level, "(out of memory)\n");    }    av_bprint_finalize(&bp, NULL);} static void print_link_formats(void *log_ctx, int level, const AVFilterLink *l){    if (av_log_get_level() < level)        return;     av_log(log_ctx, level, "Link '%s.%s' -> '%s.%s':\n"                           "  src: ", l->src->name, l->srcpad->name, l->dst->name, l->dstpad->name);    print_formats(log_ctx, level, l->type, l->incfg.formats);    av_log(log_ctx, level, "  dst: ");    print_formats(log_ctx, level, l->type, l->outcfg.formats);} static void print_filter_formats(void *log_ctx, int level, const AVFilterContext *f){    if (av_log_get_level() < level)        return;     av_log(log_ctx, level, "Filter '%s' formats:\n", f->name);    for (int i = 0; i < f->nb_inputs; i++) {        av_log(log_ctx, level, "  in[%d] '%s': ", i, f->input_pads[i].name);        print_formats(log_ctx, level, f->inputs[i]->type, f->inputs[i]->outcfg.formats);    }    for (int i = 0; i < f->nb_outputs; i++) {        av_log(log_ctx, level, "  out[%d] '%s': ", i, f->output_pads[i].name);        print_formats(log_ctx, level, f->outputs[i]->type, f->outputs[i]->incfg.formats);    }} /** * Perform one round of query_formats() and merging formats lists on the

Lines 1–500 of 1558. Load more