FFmpeg
Main Page
Related Pages
Modules
Data Structures
Files
Examples
File List
Globals
All
Data Structures
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
libavfilter
avfiltergraph.h
Go to the documentation of this file.
1
/*
2
* Filter graphs
3
* copyright (c) 2007 Bobby Bingham
4
*
5
* This file is part of FFmpeg.
6
*
7
* FFmpeg is free software; you can redistribute it and/or
8
* modify it under the terms of the GNU Lesser General Public
9
* License as published by the Free Software Foundation; either
10
* version 2.1 of the License, or (at your option) any later version.
11
*
12
* FFmpeg is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
* Lesser General Public License for more details.
16
*
17
* You should have received a copy of the GNU Lesser General Public
18
* License along with FFmpeg; if not, write to the Free Software
19
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
*/
21
22
#ifndef AVFILTER_AVFILTERGRAPH_H
23
#define AVFILTER_AVFILTERGRAPH_H
24
25
#include "
avfilter.h
"
26
#include "
libavutil/log.h
"
27
28
typedef
struct
AVFilterGraph
{
29
const
AVClass
*
av_class
;
30
unsigned
filter_count
;
31
AVFilterContext
**
filters
;
32
33
char
*
scale_sws_opts
;
///< sws options to use for the auto-inserted scale filters
34
char
*
resample_lavr_opts
;
///< libavresample options to use for the auto-inserted resample filters
35
char
*
aresample_swr_opts
;
///< swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions
36
37
/**
38
* Private fields
39
*
40
* The following fields are for internal use only.
41
* Their type, offset, number and semantic can change without notice.
42
*/
43
44
AVFilterLink
**
sink_links
;
45
int
sink_links_count
;
46
47
unsigned
disable_auto_convert
;
48
}
AVFilterGraph
;
49
50
/**
51
* Allocate a filter graph.
52
*/
53
AVFilterGraph
*
avfilter_graph_alloc
(
void
);
54
55
/**
56
* Get a filter instance with name name from graph.
57
*
58
* @return the pointer to the found filter instance or NULL if it
59
* cannot be found.
60
*/
61
AVFilterContext
*
avfilter_graph_get_filter
(
AVFilterGraph
*graph,
char
*
name
);
62
63
/**
64
* Add an existing filter instance to a filter graph.
65
*
66
* @param graphctx the filter graph
67
* @param filter the filter to be added
68
*/
69
int
avfilter_graph_add_filter
(
AVFilterGraph
*graphctx,
AVFilterContext
*
filter
);
70
71
/**
72
* Create and add a filter instance into an existing graph.
73
* The filter instance is created from the filter filt and inited
74
* with the parameters args and opaque.
75
*
76
* In case of success put in *filt_ctx the pointer to the created
77
* filter instance, otherwise set *filt_ctx to NULL.
78
*
79
* @param name the instance name to give to the created filter instance
80
* @param graph_ctx the filter graph
81
* @return a negative AVERROR error code in case of failure, a non
82
* negative value otherwise
83
*/
84
int
avfilter_graph_create_filter
(
AVFilterContext
**filt_ctx,
AVFilter
*
filt
,
85
const
char
*
name
,
const
char
*args,
void
*opaque,
86
AVFilterGraph
*graph_ctx);
87
88
/**
89
* Enable or disable automatic format conversion inside the graph.
90
*
91
* Note that format conversion can still happen inside explicitly inserted
92
* scale and aconvert filters.
93
*
94
* @param flags any of the AVFILTER_AUTO_CONVERT_* constants
95
*/
96
void
avfilter_graph_set_auto_convert
(
AVFilterGraph
*graph,
unsigned
flags
);
97
98
enum
{
99
AVFILTER_AUTO_CONVERT_ALL
= 0,
/**< all automatic conversions enabled */
100
AVFILTER_AUTO_CONVERT_NONE
= -1,
/**< all automatic conversions disabled */
101
};
102
103
/**
104
* Check validity and configure all the links and formats in the graph.
105
*
106
* @param graphctx the filter graph
107
* @param log_ctx context used for logging
108
* @return 0 in case of success, a negative AVERROR code otherwise
109
*/
110
int
avfilter_graph_config
(
AVFilterGraph
*graphctx,
void
*log_ctx);
111
112
/**
113
* Free a graph, destroy its links, and set *graph to NULL.
114
* If *graph is NULL, do nothing.
115
*/
116
void
avfilter_graph_free
(
AVFilterGraph
**graph);
117
118
/**
119
* A linked-list of the inputs/outputs of the filter chain.
120
*
121
* This is mainly useful for avfilter_graph_parse() / avfilter_graph_parse2(),
122
* where it is used to communicate open (unlinked) inputs and outputs from and
123
* to the caller.
124
* This struct specifies, per each not connected pad contained in the graph, the
125
* filter context and the pad index required for establishing a link.
126
*/
127
typedef
struct
AVFilterInOut
{
128
/** unique name for this input/output in the list */
129
char
*
name
;
130
131
/** filter context associated to this input/output */
132
AVFilterContext
*
filter_ctx
;
133
134
/** index of the filt_ctx pad to use for linking */
135
int
pad_idx
;
136
137
/** next input/input in the list, NULL if this is the last */
138
struct
AVFilterInOut
*
next
;
139
}
AVFilterInOut
;
140
141
/**
142
* Allocate a single AVFilterInOut entry.
143
* Must be freed with avfilter_inout_free().
144
* @return allocated AVFilterInOut on success, NULL on failure.
145
*/
146
AVFilterInOut
*
avfilter_inout_alloc
(
void
);
147
148
/**
149
* Free the supplied list of AVFilterInOut and set *inout to NULL.
150
* If *inout is NULL, do nothing.
151
*/
152
void
avfilter_inout_free
(
AVFilterInOut
**inout);
153
154
/**
155
* Add a graph described by a string to a graph.
156
*
157
* @param graph the filter graph where to link the parsed graph context
158
* @param filters string to be parsed
159
* @param inputs pointer to a linked list to the inputs of the graph, may be NULL.
160
* If non-NULL, *inputs is updated to contain the list of open inputs
161
* after the parsing, should be freed with avfilter_inout_free().
162
* @param outputs pointer to a linked list to the outputs of the graph, may be NULL.
163
* If non-NULL, *outputs is updated to contain the list of open outputs
164
* after the parsing, should be freed with avfilter_inout_free().
165
* @return non negative on success, a negative AVERROR code on error
166
*/
167
int
avfilter_graph_parse
(
AVFilterGraph
*graph,
const
char
*
filters
,
168
AVFilterInOut
**
inputs
,
AVFilterInOut
**
outputs
,
169
void
*log_ctx);
170
171
/**
172
* Add a graph described by a string to a graph.
173
*
174
* @param[in] graph the filter graph where to link the parsed graph context
175
* @param[in] filters string to be parsed
176
* @param[out] inputs a linked list of all free (unlinked) inputs of the
177
* parsed graph will be returned here. It is to be freed
178
* by the caller using avfilter_inout_free().
179
* @param[out] outputs a linked list of all free (unlinked) outputs of the
180
* parsed graph will be returned here. It is to be freed by the
181
* caller using avfilter_inout_free().
182
* @return zero on success, a negative AVERROR code on error
183
*
184
* @note the difference between avfilter_graph_parse2() and
185
* avfilter_graph_parse() is that in avfilter_graph_parse(), the caller provides
186
* the lists of inputs and outputs, which therefore must be known before calling
187
* the function. On the other hand, avfilter_graph_parse2() \em returns the
188
* inputs and outputs that are left unlinked after parsing the graph and the
189
* caller then deals with them. Another difference is that in
190
* avfilter_graph_parse(), the inputs parameter describes inputs of the
191
* <em>already existing</em> part of the graph; i.e. from the point of view of
192
* the newly created part, they are outputs. Similarly the outputs parameter
193
* describes outputs of the already existing filters, which are provided as
194
* inputs to the parsed filters.
195
* avfilter_graph_parse2() takes the opposite approach -- it makes no reference
196
* whatsoever to already existing parts of the graph and the inputs parameter
197
* will on return contain inputs of the newly parsed part of the graph.
198
* Analogously the outputs parameter will contain outputs of the newly created
199
* filters.
200
*/
201
int
avfilter_graph_parse2
(
AVFilterGraph
*graph,
const
char
*
filters
,
202
AVFilterInOut
**
inputs
,
203
AVFilterInOut
**
outputs
);
204
205
206
/**
207
* Send a command to one or more filter instances.
208
*
209
* @param graph the filter graph
210
* @param target the filter(s) to which the command should be sent
211
* "all" sends to all filters
212
* otherwise it can be a filter or filter instance name
213
* which will send the command to all matching filters.
214
* @param cmd the command to sent, for handling simplicity all commands must be alphanumeric only
215
* @param arg the argument for the command
216
* @param res a buffer with size res_size where the filter(s) can return a response.
217
*
218
* @returns >=0 on success otherwise an error code.
219
* AVERROR(ENOSYS) on unsupported commands
220
*/
221
int
avfilter_graph_send_command
(
AVFilterGraph
*graph,
const
char
*target,
const
char
*cmd,
const
char
*
arg
,
char
*res,
int
res_len,
int
flags
);
222
223
/**
224
* Queue a command for one or more filter instances.
225
*
226
* @param graph the filter graph
227
* @param target the filter(s) to which the command should be sent
228
* "all" sends to all filters
229
* otherwise it can be a filter or filter instance name
230
* which will send the command to all matching filters.
231
* @param cmd the command to sent, for handling simplicity all commands must be alphanummeric only
232
* @param arg the argument for the command
233
* @param ts time at which the command should be sent to the filter
234
*
235
* @note As this executes commands after this function returns, no return code
236
* from the filter is provided, also AVFILTER_CMD_FLAG_ONE is not supported.
237
*/
238
int
avfilter_graph_queue_command
(
AVFilterGraph
*graph,
const
char
*target,
const
char
*cmd,
const
char
*
arg
,
int
flags
,
double
ts);
239
240
241
/**
242
* Dump a graph into a human-readable string representation.
243
*
244
* @param graph the graph to dump
245
* @param options formatting options; currently ignored
246
* @return a string, or NULL in case of memory allocation failure;
247
* the string must be freed using av_free
248
*/
249
char
*
avfilter_graph_dump
(
AVFilterGraph
*graph,
const
char
*
options
);
250
251
/**
252
* Request a frame on the oldest sink link.
253
*
254
* If the request returns AVERROR_EOF, try the next.
255
*
256
* Note that this function is not meant to be the sole scheduling mechanism
257
* of a filtergraph, only a convenience function to help drain a filtergraph
258
* in a balanced way under normal circumstances.
259
*
260
* Also note that AVERROR_EOF does not mean that frames did not arrive on
261
* some of the sinks during the process.
262
* When there are multiple sink links, in case the requested link
263
* returns an EOF, this may cause a filter to flush pending frames
264
* which are sent to another sink link, although unrequested.
265
*
266
* @return the return value of ff_request_frame(),
267
* or AVERROR_EOF if all links returned AVERROR_EOF
268
*/
269
int
avfilter_graph_request_oldest
(
AVFilterGraph
*graph);
270
271
#endif
/* AVFILTER_AVFILTERGRAPH_H */
Generated on Sat May 25 2013 04:01:14 for FFmpeg by
1.8.2