avfiltergraph.h 6.37 KB
Newer Older
1 2 3 4
/*
 * Filter graphs
 * copyright (c) 2007 Bobby Bingham
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9 10 11
 * 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.
 *
12
 * Libav is distributed in the hope that it will be useful,
13 14 15 16 17
 * 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
18
 * License along with Libav; if not, write to the Free Software
19 20 21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

22 23
#ifndef AVFILTER_AVFILTERGRAPH_H
#define AVFILTER_AVFILTERGRAPH_H
24 25

#include "avfilter.h"
26
#include "libavutil/log.h"
27

Vitor Sessak's avatar
Vitor Sessak committed
28
typedef struct AVFilterGraph {
29
    const AVClass *av_class;
Vitor Sessak's avatar
Vitor Sessak committed
30 31
    unsigned filter_count;
    AVFilterContext **filters;
32 33

    char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters
34
} AVFilterGraph;
Vitor Sessak's avatar
Vitor Sessak committed
35

36 37 38 39 40
/**
 * Allocate a filter graph.
 */
AVFilterGraph *avfilter_graph_alloc(void);

41
/**
42
 * Get a filter instance with name name from graph.
43 44 45
 *
 * @return the pointer to the found filter instance or NULL if it
 * cannot be found.
46
 */
47
AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name);
48

49
/**
50
 * Add an existing filter instance to a filter graph.
51
 *
52
 * @param graphctx  the filter graph
53
 * @param filter the filter to be added
54
 */
Vitor Sessak's avatar
Vitor Sessak committed
55
int avfilter_graph_add_filter(AVFilterGraph *graphctx, AVFilterContext *filter);
56

57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
/**
 * Create and add a filter instance into an existing graph.
 * The filter instance is created from the filter filt and inited
 * with the parameters args and opaque.
 *
 * In case of success put in *filt_ctx the pointer to the created
 * filter instance, otherwise set *filt_ctx to NULL.
 *
 * @param name the instance name to give to the created filter instance
 * @param graph_ctx the filter graph
 * @return a negative AVERROR error code in case of failure, a non
 * negative value otherwise
 */
int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt,
                                 const char *name, const char *args, void *opaque,
                                 AVFilterGraph *graph_ctx);

74 75 76
/**
 * Check validity and configure all the links and formats in the graph.
 *
77 78 79
 * @param graphctx the filter graph
 * @param log_ctx context used for logging
 * @return 0 in case of success, a negative AVERROR code otherwise
80
 */
81
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx);
82

83
/**
84 85
 * Free a graph, destroy its links, and set *graph to NULL.
 * If *graph is NULL, do nothing.
86
 */
87
void avfilter_graph_free(AVFilterGraph **graph);
88

89 90 91
/**
 * A linked-list of the inputs/outputs of the filter chain.
 *
92 93 94 95 96
 * This is mainly useful for avfilter_graph_parse() / avfilter_graph_parse2(),
 * where it is used to communicate open (unlinked) inputs and outputs from and
 * to the caller.
 * This struct specifies, per each not connected pad contained in the graph, the
 * filter context and the pad index required for establishing a link.
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
 */
typedef struct AVFilterInOut {
    /** unique name for this input/output in the list */
    char *name;

    /** filter context associated to this input/output */
    AVFilterContext *filter_ctx;

    /** index of the filt_ctx pad to use for linking */
    int pad_idx;

    /** next input/input in the list, NULL if this is the last */
    struct AVFilterInOut *next;
} AVFilterInOut;

112 113 114 115 116 117 118 119 120 121 122 123 124
/**
 * Allocate a single AVFilterInOut entry.
 * Must be freed with avfilter_inout_free().
 * @return allocated AVFilterInOut on success, NULL on failure.
 */
AVFilterInOut *avfilter_inout_alloc(void);

/**
 * Free the supplied list of AVFilterInOut and set *inout to NULL.
 * If *inout is NULL, do nothing.
 */
void avfilter_inout_free(AVFilterInOut **inout);

125 126 127 128 129 130 131 132 133 134 135
/**
 * Add a graph described by a string to a graph.
 *
 * @param graph   the filter graph where to link the parsed graph context
 * @param filters string to be parsed
 * @param inputs  linked list to the inputs of the graph
 * @param outputs linked list to the outputs of the graph
 * @return zero on success, a negative AVERROR code on error
 */
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
                         AVFilterInOut *inputs, AVFilterInOut *outputs,
136
                         void *log_ctx);
137

138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
/**
 * Add a graph described by a string to a graph.
 *
 * @param[in]  graph   the filter graph where to link the parsed graph context
 * @param[in]  filters string to be parsed
 * @param[out] inputs  a linked list of all free (unlinked) inputs of the
 *                     parsed graph will be returned here. It is to be freed
 *                     by the caller using avfilter_inout_free().
 * @param[out] outputs a linked list of all free (unlinked) outputs of the
 *                     parsed graph will be returned here. It is to be freed by the
 *                     caller using avfilter_inout_free().
 * @return zero on success, a negative AVERROR code on error
 *
 * @note the difference between avfilter_graph_parse2() and
 * avfilter_graph_parse() is that in avfilter_graph_parse(), the caller provides
 * the lists of inputs and outputs, which therefore must be known before calling
 * the function. On the other hand, avfilter_graph_parse2() \em returns the
 * inputs and outputs that are left unlinked after parsing the graph and the
 * caller then deals with them. Another difference is that in
 * avfilter_graph_parse(), the inputs parameter describes inputs of the
 * <em>already existing</em> part of the graph; i.e. from the point of view of
 * the newly created part, they are outputs. Similarly the outputs parameter
 * describes outputs of the already existing filters, which are provided as
 * inputs to the parsed filters.
 * avfilter_graph_parse2() takes the opposite approach -- it makes no reference
 * whatsoever to already existing parts of the graph and the inputs parameter
 * will on return contain inputs of the newly parsed part of the graph.
 * Analogously the outputs parameter will contain outputs of the newly created
 * filters.
 */
int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
                          AVFilterInOut **inputs,
                          AVFilterInOut **outputs);

172
#endif /* AVFILTER_AVFILTERGRAPH_H */