Commit | Line | Data |
---|---|---|
a5cbb2f4 VS |
1 | /* |
2 | * Filter layer | |
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 FFMPEG_AVFILTER_H | |
23 | #define FFMPEG_AVFILTER_H | |
24 | ||
a9c81431 | 25 | #include <stddef.h> |
a5cbb2f4 VS |
26 | #include "avcodec.h" |
27 | ||
28 | typedef struct AVFilterContext AVFilterContext; | |
29 | typedef struct AVFilterLink AVFilterLink; | |
30 | typedef struct AVFilterPad AVFilterPad; | |
31 | ||
32 | /* TODO: look for other flags which may be useful in this structure (interlace | |
33 | * flags, etc) | |
34 | */ | |
35 | /** | |
36 | * A reference-counted picture data type used by the filter system. Filters | |
37 | * should not store pointers to this structure directly, but instead use the | |
38 | * AVFilterPicRef structure below | |
39 | */ | |
40 | typedef struct AVFilterPic | |
41 | { | |
13ff8fd0 VS |
42 | uint8_t *data[4]; ///< picture data for each plane |
43 | int linesize[4]; ///< number of bytes per line | |
44 | enum PixelFormat format; ///< colorspace | |
a5cbb2f4 | 45 | |
13ff8fd0 VS |
46 | unsigned refcount; ///< number of references to this image |
47 | ||
48 | /** private data to be used by a custom free function */ | |
a5cbb2f4 | 49 | void *priv; |
13ff8fd0 VS |
50 | /** |
51 | * A pointer to the function to deallocate this image if the default | |
52 | * function is not sufficient. This could, for example, add the memory | |
53 | * back into a memory pool to be reused later without the overhead of | |
54 | * reallocating it from scratch. | |
55 | */ | |
a5cbb2f4 VS |
56 | void (*free)(struct AVFilterPic *pic); |
57 | } AVFilterPic; | |
58 | ||
59 | /** | |
60 | * A reference to an AVFilterPic. Since filters can manipulate the origin of | |
61 | * a picture to, for example, crop image without any memcpy, the picture origin | |
bbf42679 VS |
62 | * and dimensions are per-reference properties. Linesize is also useful for |
63 | * image flipping, frame to field filters, etc, and so is also per-reference. | |
a5cbb2f4 | 64 | * |
1a18860a | 65 | * TODO: add anything necessary for frame reordering |
a5cbb2f4 VS |
66 | */ |
67 | typedef struct AVFilterPicRef | |
68 | { | |
13ff8fd0 VS |
69 | AVFilterPic *pic; ///< the picture that this is a reference to |
70 | uint8_t *data[4]; ///< picture data for each plane | |
71 | int linesize[4]; ///< number of bytes per line | |
72 | int w; ///< image width | |
73 | int h; ///< image height | |
a5cbb2f4 | 74 | |
056f0431 | 75 | int64_t pts; ///< presentation timestamp in units of 1/AV_TIME_BASE |
1a18860a | 76 | |
2621f4a3 VS |
77 | AVRational pixel_aspect; ///< pixel aspect ratio |
78 | ||
a5cbb2f4 VS |
79 | int perms; ///< permissions |
80 | #define AV_PERM_READ 0x01 ///< can read from the buffer | |
81 | #define AV_PERM_WRITE 0x02 ///< can write to the buffer | |
82 | #define AV_PERM_PRESERVE 0x04 ///< nobody else can overwrite the buffer | |
b3ab2f7e VS |
83 | #define AV_PERM_REUSE 0x08 ///< can output the buffer multiple times, with the same contents each time |
84 | #define AV_PERM_REUSE2 0x10 ///< can output the buffer multiple times, modified each time | |
a5cbb2f4 VS |
85 | } AVFilterPicRef; |
86 | ||
87 | /** | |
88 | * Add a new reference to a picture. | |
13ff8fd0 VS |
89 | * @param ref An existing reference to the picture |
90 | * @param pmask A bitmask containing the allowable permissions in the new | |
91 | * reference | |
92 | * @return A new reference to the picture with the same properties as the | |
93 | * old, excluding any permissions denied by pmask | |
a5cbb2f4 | 94 | */ |
16415eaf | 95 | AVFilterPicRef *avfilter_ref_pic(AVFilterPicRef *ref, int pmask); |
a5cbb2f4 VS |
96 | |
97 | /** | |
98 | * Remove a reference to a picture. If this is the last reference to the | |
99 | * picture, the picture itself is also automatically freed. | |
100 | * @param ref Reference to the picture. | |
101 | */ | |
102 | void avfilter_unref_pic(AVFilterPicRef *ref); | |
103 | ||
13ff8fd0 | 104 | /** |
35f3fdf4 VS |
105 | * A list of supported formats for one end of a filter link. This is used |
106 | * during the format negotiation process to try to pick the best format to | |
107 | * use to minimize the number of necessary conversions. Each filter gives a | |
108 | * list of the formats supported by each input and output pad. The list | |
109 | * given for each pad need not be distinct - they may be references to the | |
110 | * same list of formats, as is often the case when a filter supports multiple | |
111 | * formats, but will always outut the same format as it is given in input. | |
112 | * | |
113 | * In this way, a list of possible input formats and a list of possible | |
114 | * output formats are associated with each link. When a set of formats is | |
115 | * negotiated over a link, the input and output lists are merged to form a | |
116 | * new list containing only the common elements of each list. In the case | |
117 | * that there were no common elements, a format conversion is necessary. | |
118 | * Otherwise, the lists are merged, and all other links which reference | |
119 | * either of the format lists involved in the merge are also affected. | |
120 | * | |
121 | * For example, consider the filter chain: | |
122 | * filter (a) --> (b) filter (b) --> (c) filter | |
123 | * | |
124 | * where the letters in parenthesis indicate a list of formats supported on | |
125 | * the input or output of the link. Suppose the lists are as follows: | |
126 | * (a) = {A, B} | |
127 | * (b) = {A, B, C} | |
128 | * (c) = {B, C} | |
129 | * | |
130 | * First, the first link's lists are merged, yielding: | |
131 | * filter (a) --> (a) filter (a) --> (c) filter | |
132 | * | |
133 | * Notice that format list (b) now refers to the same list as filter list (a). | |
134 | * Next, the lists for the second link are merged, yielding: | |
135 | * filter (a) --> (a) filter (a) --> (a) filter | |
136 | * | |
137 | * where (a) = {B}. | |
138 | * | |
139 | * Unfortunately, when the format lists at the two ends of a link are merged, | |
140 | * we must ensure that all links which reference either pre-merge format list | |
141 | * get updated as well. Therefore, we have the format list structure store a | |
142 | * pointer to each of the pointers to itself. | |
143 | */ | |
144 | typedef struct AVFilterFormats AVFilterFormats; | |
145 | struct AVFilterFormats | |
146 | { | |
147 | unsigned format_count; ///< number of formats | |
148 | int *formats; ///< list of formats | |
149 | ||
150 | unsigned refcount; ///< number of references to this list | |
151 | AVFilterFormats ***refs; ///< references to this list | |
152 | }; | |
153 | ||
154 | /** | |
155 | * Helper function to create a list of supported formats. This is intended | |
156 | * for use in AVFilter->query_formats(). | |
157 | * @param len The number of formats supported | |
158 | * @param ... A list of the supported formats | |
159 | * @return The format list, with no existing references | |
160 | */ | |
161 | AVFilterFormats *avfilter_make_format_list(int len, ...); | |
162 | ||
163 | /** | |
164 | * Returns a fairly comprehensive list of colorspaces which are supported by | |
165 | * many of the included filters. This is not truly "all" the colorspaces, but | |
166 | * it is most of them, and it is the most commonly supported large subset. | |
167 | */ | |
168 | AVFilterFormats *avfilter_all_colorspaces(void); | |
169 | ||
170 | /** | |
171 | * If a and b share at least one common format, they are merged into a new | |
172 | * format list which is returned. All the references to a and b are updated | |
173 | * to point to this new list, and a and b are deallocated. | |
174 | * | |
175 | * If a and b do not share any common formats, neither is modified, and NULL | |
176 | * is returned. | |
177 | */ | |
178 | AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b); | |
179 | ||
180 | /** Adds *ref as a new reference to f */ | |
181 | void avfilter_formats_ref(AVFilterFormats *f, AVFilterFormats **ref); | |
182 | ||
183 | /** | |
184 | * Remove *ref as a reference to the format list it currently points to, | |
185 | * deallocate that list if this was the last reference, and set *ref to NULL | |
186 | */ | |
187 | void avfilter_formats_unref(AVFilterFormats **ref); | |
188 | ||
189 | /** | |
13ff8fd0 VS |
190 | * A filter pad used for either input or output |
191 | */ | |
a5cbb2f4 VS |
192 | struct AVFilterPad |
193 | { | |
194 | /** | |
13ff8fd0 VS |
195 | * Pad name. The name is unique among inputs and among outputs, but an |
196 | * input may have the same name as an output. This may be NULL if this | |
197 | * pad has no need to ever be referenced by name. | |
a5cbb2f4 VS |
198 | */ |
199 | char *name; | |
200 | ||
201 | /** | |
202 | * AVFilterPad type. Only video supported now, hopefully someone will | |
203 | * add audio in the future. | |
204 | */ | |
205 | int type; | |
13ff8fd0 | 206 | #define AV_PAD_VIDEO 0 ///< video pad |
a5cbb2f4 VS |
207 | |
208 | /** | |
60bf6ce3 VS |
209 | * Minimum required permissions on incoming buffers. Any buffers with |
210 | * insufficient permissions will be automatically copied by the filter | |
211 | * system to a new buffer which provides the needed access permissions. | |
212 | * | |
213 | * Input pads only. | |
214 | */ | |
215 | int min_perms; | |
216 | ||
217 | /** | |
218 | * Permissions which are not accepted on incoming buffers. Any buffer | |
219 | * which has any of these permissions set be automatically copied by the | |
220 | * filter system to a new buffer which does not have those permissions. | |
221 | * This can be used to easily disallow buffers with AV_PERM_REUSE. | |
222 | * | |
223 | * Input pads only. | |
224 | */ | |
225 | int rej_perms; | |
226 | ||
227 | /** | |
a5cbb2f4 VS |
228 | * Callback called before passing the first slice of a new frame. If |
229 | * NULL, the filter layer will default to storing a reference to the | |
230 | * picture inside the link structure. | |
13ff8fd0 VS |
231 | * |
232 | * Input video pads only. | |
a5cbb2f4 VS |
233 | */ |
234 | void (*start_frame)(AVFilterLink *link, AVFilterPicRef *picref); | |
235 | ||
236 | /** | |
237 | * Callback function to get a buffer. If NULL, the filter system will | |
13ff8fd0 VS |
238 | * handle buffer requests. |
239 | * | |
240 | * Input video pads only. | |
a5cbb2f4 VS |
241 | */ |
242 | AVFilterPicRef *(*get_video_buffer)(AVFilterLink *link, int perms); | |
243 | ||
244 | /** | |
245 | * Callback called after the slices of a frame are completely sent. If | |
246 | * NULL, the filter layer will default to releasing the reference stored | |
247 | * in the link structure during start_frame(). | |
13ff8fd0 VS |
248 | * |
249 | * Input video pads only. | |
a5cbb2f4 VS |
250 | */ |
251 | void (*end_frame)(AVFilterLink *link); | |
252 | ||
253 | /** | |
254 | * Slice drawing callback. This is where a filter receives video data | |
13ff8fd0 VS |
255 | * and should do its processing. |
256 | * | |
257 | * Input video pads only. | |
a5cbb2f4 | 258 | */ |
72f6d631 | 259 | void (*draw_slice)(AVFilterLink *link, int y, int height); |
a5cbb2f4 VS |
260 | |
261 | /** | |
262 | * Frame request callback. A call to this should result in at least one | |
13ff8fd0 VS |
263 | * frame being output over the given link. This should return zero on |
264 | * success, and another value on error. | |
265 | * | |
266 | * Output video pads only. | |
a5cbb2f4 | 267 | */ |
63f64e6f | 268 | int (*request_frame)(AVFilterLink *link); |
a5cbb2f4 VS |
269 | |
270 | /** | |
13ff8fd0 VS |
271 | * Link configuration callback. |
272 | * | |
273 | * For output pads, this should set the link properties such as | |
274 | * width/height. This should NOT set the format property - that is | |
275 | * negotiated between filters by the filter system using the | |
276 | * query_formats() callback before this function is called. | |
d3e57c15 VS |
277 | * |
278 | * For input pads, this should check the properties of the link, and update | |
279 | * the filter's internal state as necessary. | |
13ff8fd0 VS |
280 | * |
281 | * For both input and output filters, this should return zero on success, | |
282 | * and another value on error. | |
a5cbb2f4 | 283 | */ |
d3e57c15 | 284 | int (*config_props)(AVFilterLink *link); |
a5cbb2f4 VS |
285 | }; |
286 | ||
13ff8fd0 | 287 | /** Default handler for start_frame() for video inputs */ |
a5cbb2f4 | 288 | void avfilter_default_start_frame(AVFilterLink *link, AVFilterPicRef *picref); |
13ff8fd0 | 289 | /** Default handler for end_frame() for video inputs */ |
a5cbb2f4 | 290 | void avfilter_default_end_frame(AVFilterLink *link); |
13ff8fd0 | 291 | /** Default handler for config_props() for video outputs */ |
901e6b39 | 292 | int avfilter_default_config_output_link(AVFilterLink *link); |
13ff8fd0 | 293 | /** Default handler for config_props() for video inputs */ |
85322466 | 294 | int avfilter_default_config_input_link (AVFilterLink *link); |
13ff8fd0 | 295 | /** Default handler for get_video_buffer() for video inputs */ |
901e6b39 VS |
296 | AVFilterPicRef *avfilter_default_get_video_buffer(AVFilterLink *link, |
297 | int perms); | |
35f3fdf4 VS |
298 | /** |
299 | * A helper for query_formats() which sets all links to the same list of | |
300 | * formats. If there are no links hooked to this filter, the list of formats is | |
301 | * freed. | |
302 | */ | |
303 | void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats); | |
304 | /** Default handler for query_formats() */ | |
305 | int avfilter_default_query_formats(AVFilterContext *ctx); | |
a5cbb2f4 | 306 | |
3afcca9d VS |
307 | void avfilter_formats_changeref(AVFilterFormats **oldref, |
308 | AVFilterFormats **newref); | |
309 | ||
13ff8fd0 VS |
310 | /** |
311 | * Filter definition. This defines the pads a filter contains, and all the | |
312 | * callback functions used to interact with the filter. | |
313 | */ | |
a5cbb2f4 VS |
314 | typedef struct |
315 | { | |
13ff8fd0 VS |
316 | char *name; ///< filter name |
317 | char *author; ///< filter author | |
a5cbb2f4 | 318 | |
13ff8fd0 | 319 | int priv_size; ///< size of private data to allocate for the filter |
a5cbb2f4 | 320 | |
4d96a914 VS |
321 | /** |
322 | * Filter initialization function. Args contains the user-supplied | |
323 | * parameters. FIXME: maybe an AVOption-based system would be better? | |
6e365c57 VS |
324 | * opaque is data provided by the code requesting creation of the filter, |
325 | * and is used to pass data to the filter. | |
4d96a914 | 326 | */ |
95bcf498 | 327 | int (*init)(AVFilterContext *ctx, const char *args, void *opaque); |
13ff8fd0 VS |
328 | |
329 | /** | |
330 | * Filter uninitialization function. Should deallocate any memory held | |
331 | * by the filter, release any picture references, etc. This does not need | |
332 | * to deallocate the AVFilterContext->priv memory itself. | |
333 | */ | |
a5cbb2f4 VS |
334 | void (*uninit)(AVFilterContext *ctx); |
335 | ||
35f3fdf4 VS |
336 | /** |
337 | * Query formats supported by the filter and its pads. Should set the | |
338 | * in_formats for links connected to its output pads, and out_formats | |
339 | * for links connected to its input pads. | |
340 | * | |
341 | * Should return zero on success. | |
342 | */ | |
343 | int (*query_formats)(AVFilterContext *); | |
344 | ||
13ff8fd0 VS |
345 | const AVFilterPad *inputs; ///< NULL terminated list of inputs. NULL if none |
346 | const AVFilterPad *outputs; ///< NULL terminated list of outputs. NULL if none | |
a5cbb2f4 VS |
347 | } AVFilter; |
348 | ||
13ff8fd0 | 349 | /** An instance of a filter */ |
a5cbb2f4 VS |
350 | struct AVFilterContext |
351 | { | |
13ff8fd0 | 352 | AVClass *av_class; ///< Needed for av_log() |
a5cbb2f4 | 353 | |
13ff8fd0 | 354 | AVFilter *filter; ///< The AVFilter of which this is an instance |
a5cbb2f4 | 355 | |
13ff8fd0 | 356 | char *name; ///< name of this filter instance |
dcea2482 | 357 | |
13ff8fd0 VS |
358 | unsigned input_count; ///< number of input pads |
359 | AVFilterPad *input_pads; ///< array of input pads | |
360 | AVFilterLink **inputs; ///< array of pointers to input links | |
25f8e601 | 361 | |
13ff8fd0 VS |
362 | unsigned output_count; ///< number of output pads |
363 | AVFilterPad *output_pads; ///< array of output pads | |
364 | AVFilterLink **outputs; ///< array of pointers to output links | |
a5cbb2f4 | 365 | |
13ff8fd0 | 366 | void *priv; ///< private data for use by the filter |
a5cbb2f4 VS |
367 | }; |
368 | ||
13ff8fd0 VS |
369 | /** |
370 | * A links between two filters. This contains pointers to the source and | |
371 | * destination filters between which this link exists, and the indices of | |
372 | * the pads involved. In addition, this link also contains the parameters | |
373 | * which have been negotiated and agreed upon between the filter, such as | |
374 | * image dimensions, format, etc | |
375 | */ | |
a5cbb2f4 VS |
376 | struct AVFilterLink |
377 | { | |
13ff8fd0 VS |
378 | AVFilterContext *src; ///< source filter |
379 | unsigned int srcpad; ///< index of the output pad on the source filter | |
a5cbb2f4 | 380 | |
13ff8fd0 VS |
381 | AVFilterContext *dst; ///< dest filter |
382 | unsigned int dstpad; ///< index of the input pad on the dest filter | |
a5cbb2f4 | 383 | |
13ff8fd0 VS |
384 | int w; ///< agreed upon image width |
385 | int h; ///< agreed upon image height | |
386 | enum PixelFormat format; ///< agreed upon image colorspace | |
a5cbb2f4 | 387 | |
60bf6ce3 | 388 | /** |
35f3fdf4 VS |
389 | * Lists of formats supported by the input and output filters respectively. |
390 | * These lists are used for negotiating the format to actually be used, | |
391 | * which will be loaded into the format member, above, when chosen. | |
392 | */ | |
393 | AVFilterFormats *in_formats; | |
394 | AVFilterFormats *out_formats; | |
395 | ||
396 | /** | |
60bf6ce3 VS |
397 | * The picture reference currently being sent across the link by the source |
398 | * filter. This is used internally by the filter system to allow | |
399 | * automatic copying of pictures which d not have sufficient permissions | |
400 | * for the destination. This should not be accessed directly by the | |
401 | * filters. | |
402 | */ | |
403 | AVFilterPicRef *srcpic; | |
404 | ||
a5cbb2f4 | 405 | AVFilterPicRef *cur_pic; |
462f57db | 406 | AVFilterPicRef *outpic; |
a5cbb2f4 VS |
407 | }; |
408 | ||
13ff8fd0 VS |
409 | /** |
410 | * Link two filters together | |
411 | * @param src The source filter | |
412 | * @param srcpad Index of the output pad on the source filter | |
413 | * @param dst The destination filter | |
414 | * @param dstpad Index of the input pad on the destination filter | |
415 | * @return Zero on success | |
416 | */ | |
a5cbb2f4 VS |
417 | int avfilter_link(AVFilterContext *src, unsigned srcpad, |
418 | AVFilterContext *dst, unsigned dstpad); | |
419 | ||
13ff8fd0 VS |
420 | /** |
421 | * Negotiate the colorspace, dimensions, etc of a link | |
422 | * @param link The link to negotiate the properties of | |
423 | * @return Zero on successful negotiation | |
424 | */ | |
85322466 VS |
425 | int avfilter_config_link(AVFilterLink *link); |
426 | ||
13ff8fd0 VS |
427 | /** |
428 | * Request a picture buffer with a specific set of permissions | |
429 | * @param link The output link to the filter from which the picture will | |
430 | * be requested | |
431 | * @param perms The required access permissions | |
432 | * @return A reference to the picture. This must be unreferenced with | |
433 | * avfilter_unref_pic when you are finished with it. | |
434 | */ | |
a5cbb2f4 | 435 | AVFilterPicRef *avfilter_get_video_buffer(AVFilterLink *link, int perms); |
13ff8fd0 VS |
436 | |
437 | /** | |
438 | * Request an input frame from the filter at the other end of the link. | |
439 | * @param link The input link | |
440 | * @return Zero on success | |
441 | */ | |
63f64e6f | 442 | int avfilter_request_frame(AVFilterLink *link); |
13ff8fd0 VS |
443 | |
444 | /** | |
b42a6a92 | 445 | * Notify the next filter of the start of a frame. |
13ff8fd0 VS |
446 | * @param link The output link the frame will be sent over |
447 | * @param picref A reference to the frame about to be sent. The data for this | |
448 | * frame need only be valid once draw_slice() is called for that | |
449 | * portion. The receiving filter will free this reference when | |
450 | * it no longer needs it. | |
451 | */ | |
a5cbb2f4 | 452 | void avfilter_start_frame(AVFilterLink *link, AVFilterPicRef *picref); |
13ff8fd0 VS |
453 | |
454 | /** | |
455 | * Notify the next filter that the current frame has finished | |
456 | * @param link The output link the frame was sent over | |
457 | */ | |
a5cbb2f4 | 458 | void avfilter_end_frame(AVFilterLink *link); |
13ff8fd0 VS |
459 | |
460 | /** | |
461 | * Send a slice to the next filter | |
462 | * @param link The output link over which the frame is being sent | |
13ff8fd0 VS |
463 | * @param y Offset in pixels from the top of the image for this slice |
464 | * @param h Height of this slice in pixels | |
465 | */ | |
72f6d631 | 466 | void avfilter_draw_slice(AVFilterLink *link, int y, int h); |
a5cbb2f4 | 467 | |
13ff8fd0 | 468 | /** Initialize the filter system. Registers all builtin filters */ |
a5cbb2f4 | 469 | void avfilter_init(void); |
13ff8fd0 VS |
470 | |
471 | /** Uninitialize the filter system. Unregisters all filters */ | |
a5cbb2f4 | 472 | void avfilter_uninit(void); |
13ff8fd0 VS |
473 | |
474 | /** | |
fc815c56 VS |
475 | * Register a filter. This is only needed if you plan to use |
476 | * avfilter_get_by_name later to lookup the AVFilter structure by name. A | |
477 | * filter can still by instantiated with avfilter_open even if it is not | |
478 | * registered. | |
13ff8fd0 VS |
479 | * @param filter The filter to register |
480 | */ | |
a5cbb2f4 | 481 | void avfilter_register(AVFilter *filter); |
13ff8fd0 VS |
482 | |
483 | /** | |
484 | * Gets a filter definition matching the given name | |
485 | * @param name The filter name to find | |
486 | * @return The filter definition, if any matching one is registered. | |
487 | * NULL if none found. | |
488 | */ | |
a5cbb2f4 VS |
489 | AVFilter *avfilter_get_by_name(char *name); |
490 | ||
13ff8fd0 VS |
491 | /** |
492 | * Create a filter instance | |
493 | * @param filter The filter to create an instance of | |
494 | * @param inst_name Name to give to the new instance. Can be NULL for none. | |
495 | * @return Pointer to the new instance on success. NULL on failure. | |
496 | */ | |
fc815c56 | 497 | AVFilterContext *avfilter_open(AVFilter *filter, char *inst_name); |
13ff8fd0 VS |
498 | |
499 | /** | |
500 | * Initialize a filter | |
501 | * @param filter The filter to initialize | |
502 | * @param args A string of parameters to use when initializing the filter. | |
503 | * The format and meaning of this string varies by filter. | |
504 | * @param opaque Any extra non-string data needed by the filter. The meaning | |
505 | * of this parameter varies by filter. | |
506 | * @return Zero on success | |
507 | */ | |
6e365c57 | 508 | int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque); |
13ff8fd0 VS |
509 | |
510 | /** | |
511 | * Destroy a filter | |
512 | * @param filter The filter to destroy | |
513 | */ | |
a5cbb2f4 VS |
514 | void avfilter_destroy(AVFilterContext *filter); |
515 | ||
13ff8fd0 | 516 | /** |
35f3fdf4 VS |
517 | * Insert a filter in the middle of an existing link. |
518 | * @param link The link into which the filter should be inserted | |
519 | * @param filt The filter to be inserted | |
520 | * @param in The input pad on the filter to connect | |
521 | * @param out The output pad on the filter to connect | |
522 | * @return Zero on success | |
13ff8fd0 | 523 | */ |
35f3fdf4 VS |
524 | int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, |
525 | unsigned in, unsigned out); | |
d3e57c15 | 526 | |
a9c81431 VS |
527 | /** |
528 | * Insert a new pad | |
529 | * @param idx Insertion point. Pad is inserted at the end if this point | |
530 | * is beyond the end of the list of pads. | |
531 | * @param count Pointer to the number of pads in the list | |
532 | * @param padidx_off Offset within an AVFilterLink structure to the element | |
533 | * to increment when inserting a new pad causes link | |
534 | * numbering to change | |
535 | * @param pads Pointer to the pointer to the beginning of the list of pads | |
536 | * @param links Pointer to the pointer to the beginning of the list of links | |
537 | * @param newpad The new pad to add. A copy is made when adding. | |
538 | */ | |
539 | void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, | |
540 | AVFilterPad **pads, AVFilterLink ***links, | |
541 | AVFilterPad *newpad); | |
542 | ||
543 | /** insert a new input pad for the filter */ | |
544 | static inline void avfilter_insert_inpad(AVFilterContext *f, unsigned index, | |
545 | AVFilterPad *p) | |
546 | { | |
547 | avfilter_insert_pad(index, &f->input_count, offsetof(AVFilterLink, dstpad), | |
548 | &f->input_pads, &f->inputs, p); | |
549 | } | |
550 | ||
551 | /** insert a new output pad for the filter */ | |
552 | static inline void avfilter_insert_outpad(AVFilterContext *f, unsigned index, | |
553 | AVFilterPad *p) | |
554 | { | |
555 | avfilter_insert_pad(index, &f->output_count, offsetof(AVFilterLink, srcpad), | |
556 | &f->output_pads, &f->outputs, p); | |
557 | } | |
558 | ||
a5cbb2f4 | 559 | #endif /* FFMPEG_AVFILTER_H */ |