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 | ||
d224d73a VS |
189 | int avfilter_poll_frame(AVFilterLink *link); |
190 | ||
35f3fdf4 | 191 | /** |
13ff8fd0 VS |
192 | * A filter pad used for either input or output |
193 | */ | |
a5cbb2f4 VS |
194 | struct AVFilterPad |
195 | { | |
196 | /** | |
13ff8fd0 VS |
197 | * Pad name. The name is unique among inputs and among outputs, but an |
198 | * input may have the same name as an output. This may be NULL if this | |
199 | * pad has no need to ever be referenced by name. | |
a5cbb2f4 | 200 | */ |
2844dd39 | 201 | const char *name; |
a5cbb2f4 VS |
202 | |
203 | /** | |
204 | * AVFilterPad type. Only video supported now, hopefully someone will | |
205 | * add audio in the future. | |
206 | */ | |
207 | int type; | |
13ff8fd0 | 208 | #define AV_PAD_VIDEO 0 ///< video pad |
a5cbb2f4 VS |
209 | |
210 | /** | |
60bf6ce3 VS |
211 | * Minimum required permissions on incoming buffers. Any buffers with |
212 | * insufficient permissions will be automatically copied by the filter | |
213 | * system to a new buffer which provides the needed access permissions. | |
214 | * | |
215 | * Input pads only. | |
216 | */ | |
217 | int min_perms; | |
218 | ||
219 | /** | |
220 | * Permissions which are not accepted on incoming buffers. Any buffer | |
221 | * which has any of these permissions set be automatically copied by the | |
222 | * filter system to a new buffer which does not have those permissions. | |
223 | * This can be used to easily disallow buffers with AV_PERM_REUSE. | |
224 | * | |
225 | * Input pads only. | |
226 | */ | |
227 | int rej_perms; | |
228 | ||
229 | /** | |
a5cbb2f4 VS |
230 | * Callback called before passing the first slice of a new frame. If |
231 | * NULL, the filter layer will default to storing a reference to the | |
232 | * picture inside the link structure. | |
13ff8fd0 VS |
233 | * |
234 | * Input video pads only. | |
a5cbb2f4 VS |
235 | */ |
236 | void (*start_frame)(AVFilterLink *link, AVFilterPicRef *picref); | |
237 | ||
238 | /** | |
239 | * Callback function to get a buffer. If NULL, the filter system will | |
13ff8fd0 VS |
240 | * handle buffer requests. |
241 | * | |
242 | * Input video pads only. | |
a5cbb2f4 VS |
243 | */ |
244 | AVFilterPicRef *(*get_video_buffer)(AVFilterLink *link, int perms); | |
245 | ||
246 | /** | |
247 | * Callback called after the slices of a frame are completely sent. If | |
248 | * NULL, the filter layer will default to releasing the reference stored | |
249 | * in the link structure during start_frame(). | |
13ff8fd0 VS |
250 | * |
251 | * Input video pads only. | |
a5cbb2f4 VS |
252 | */ |
253 | void (*end_frame)(AVFilterLink *link); | |
254 | ||
255 | /** | |
256 | * Slice drawing callback. This is where a filter receives video data | |
13ff8fd0 VS |
257 | * and should do its processing. |
258 | * | |
259 | * Input video pads only. | |
a5cbb2f4 | 260 | */ |
72f6d631 | 261 | void (*draw_slice)(AVFilterLink *link, int y, int height); |
a5cbb2f4 VS |
262 | |
263 | /** | |
d224d73a VS |
264 | * Frame poll callback. This returns the number of immediately available |
265 | * frames. It should return a positive value if the next request_frame() | |
266 | * is guaranteed to return one frame (with no delay). | |
267 | * | |
268 | * Defaults to just calling the source poll_frame() method. | |
269 | * | |
270 | * Output video pads only. | |
271 | */ | |
272 | int (*poll_frame)(AVFilterLink *link); | |
273 | ||
274 | /** | |
a5cbb2f4 | 275 | * Frame request callback. A call to this should result in at least one |
13ff8fd0 VS |
276 | * frame being output over the given link. This should return zero on |
277 | * success, and another value on error. | |
278 | * | |
279 | * Output video pads only. | |
a5cbb2f4 | 280 | */ |
63f64e6f | 281 | int (*request_frame)(AVFilterLink *link); |
a5cbb2f4 VS |
282 | |
283 | /** | |
13ff8fd0 VS |
284 | * Link configuration callback. |
285 | * | |
286 | * For output pads, this should set the link properties such as | |
287 | * width/height. This should NOT set the format property - that is | |
288 | * negotiated between filters by the filter system using the | |
289 | * query_formats() callback before this function is called. | |
d3e57c15 VS |
290 | * |
291 | * For input pads, this should check the properties of the link, and update | |
292 | * the filter's internal state as necessary. | |
13ff8fd0 VS |
293 | * |
294 | * For both input and output filters, this should return zero on success, | |
295 | * and another value on error. | |
a5cbb2f4 | 296 | */ |
d3e57c15 | 297 | int (*config_props)(AVFilterLink *link); |
a5cbb2f4 VS |
298 | }; |
299 | ||
13ff8fd0 | 300 | /** Default handler for start_frame() for video inputs */ |
a5cbb2f4 | 301 | void avfilter_default_start_frame(AVFilterLink *link, AVFilterPicRef *picref); |
13ff8fd0 | 302 | /** Default handler for end_frame() for video inputs */ |
a5cbb2f4 | 303 | void avfilter_default_end_frame(AVFilterLink *link); |
13ff8fd0 | 304 | /** Default handler for config_props() for video outputs */ |
901e6b39 | 305 | int avfilter_default_config_output_link(AVFilterLink *link); |
13ff8fd0 | 306 | /** Default handler for config_props() for video inputs */ |
85322466 | 307 | int avfilter_default_config_input_link (AVFilterLink *link); |
13ff8fd0 | 308 | /** Default handler for get_video_buffer() for video inputs */ |
901e6b39 VS |
309 | AVFilterPicRef *avfilter_default_get_video_buffer(AVFilterLink *link, |
310 | int perms); | |
35f3fdf4 VS |
311 | /** |
312 | * A helper for query_formats() which sets all links to the same list of | |
313 | * formats. If there are no links hooked to this filter, the list of formats is | |
314 | * freed. | |
315 | */ | |
316 | void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats); | |
317 | /** Default handler for query_formats() */ | |
318 | int avfilter_default_query_formats(AVFilterContext *ctx); | |
a5cbb2f4 | 319 | |
3afcca9d VS |
320 | void avfilter_formats_changeref(AVFilterFormats **oldref, |
321 | AVFilterFormats **newref); | |
322 | ||
13ff8fd0 VS |
323 | /** |
324 | * Filter definition. This defines the pads a filter contains, and all the | |
325 | * callback functions used to interact with the filter. | |
326 | */ | |
a5cbb2f4 VS |
327 | typedef struct |
328 | { | |
2844dd39 VS |
329 | const char *name; ///< filter name |
330 | const char *author; ///< filter author | |
a5cbb2f4 | 331 | |
13ff8fd0 | 332 | int priv_size; ///< size of private data to allocate for the filter |
a5cbb2f4 | 333 | |
4d96a914 VS |
334 | /** |
335 | * Filter initialization function. Args contains the user-supplied | |
336 | * parameters. FIXME: maybe an AVOption-based system would be better? | |
6e365c57 VS |
337 | * opaque is data provided by the code requesting creation of the filter, |
338 | * and is used to pass data to the filter. | |
4d96a914 | 339 | */ |
95bcf498 | 340 | int (*init)(AVFilterContext *ctx, const char *args, void *opaque); |
13ff8fd0 VS |
341 | |
342 | /** | |
343 | * Filter uninitialization function. Should deallocate any memory held | |
344 | * by the filter, release any picture references, etc. This does not need | |
345 | * to deallocate the AVFilterContext->priv memory itself. | |
346 | */ | |
a5cbb2f4 VS |
347 | void (*uninit)(AVFilterContext *ctx); |
348 | ||
35f3fdf4 VS |
349 | /** |
350 | * Query formats supported by the filter and its pads. Should set the | |
351 | * in_formats for links connected to its output pads, and out_formats | |
352 | * for links connected to its input pads. | |
353 | * | |
354 | * Should return zero on success. | |
355 | */ | |
356 | int (*query_formats)(AVFilterContext *); | |
357 | ||
13ff8fd0 VS |
358 | const AVFilterPad *inputs; ///< NULL terminated list of inputs. NULL if none |
359 | const AVFilterPad *outputs; ///< NULL terminated list of outputs. NULL if none | |
a5cbb2f4 VS |
360 | } AVFilter; |
361 | ||
13ff8fd0 | 362 | /** An instance of a filter */ |
a5cbb2f4 VS |
363 | struct AVFilterContext |
364 | { | |
13ff8fd0 | 365 | AVClass *av_class; ///< Needed for av_log() |
a5cbb2f4 | 366 | |
13ff8fd0 | 367 | AVFilter *filter; ///< The AVFilter of which this is an instance |
a5cbb2f4 | 368 | |
13ff8fd0 | 369 | char *name; ///< name of this filter instance |
dcea2482 | 370 | |
13ff8fd0 VS |
371 | unsigned input_count; ///< number of input pads |
372 | AVFilterPad *input_pads; ///< array of input pads | |
373 | AVFilterLink **inputs; ///< array of pointers to input links | |
25f8e601 | 374 | |
13ff8fd0 VS |
375 | unsigned output_count; ///< number of output pads |
376 | AVFilterPad *output_pads; ///< array of output pads | |
377 | AVFilterLink **outputs; ///< array of pointers to output links | |
a5cbb2f4 | 378 | |
13ff8fd0 | 379 | void *priv; ///< private data for use by the filter |
a5cbb2f4 VS |
380 | }; |
381 | ||
13ff8fd0 VS |
382 | /** |
383 | * A links between two filters. This contains pointers to the source and | |
384 | * destination filters between which this link exists, and the indices of | |
385 | * the pads involved. In addition, this link also contains the parameters | |
386 | * which have been negotiated and agreed upon between the filter, such as | |
387 | * image dimensions, format, etc | |
388 | */ | |
a5cbb2f4 VS |
389 | struct AVFilterLink |
390 | { | |
13ff8fd0 VS |
391 | AVFilterContext *src; ///< source filter |
392 | unsigned int srcpad; ///< index of the output pad on the source filter | |
a5cbb2f4 | 393 | |
13ff8fd0 VS |
394 | AVFilterContext *dst; ///< dest filter |
395 | unsigned int dstpad; ///< index of the input pad on the dest filter | |
a5cbb2f4 | 396 | |
24c4eff6 VS |
397 | /** stage of the initialization of the link properties (dimensions, etc) */ |
398 | enum { | |
399 | AVLINK_UNINIT = 0, ///< not started | |
400 | AVLINK_STARTINIT, ///< started, but incomplete | |
401 | AVLINK_INIT ///< complete | |
402 | } init_state; | |
403 | ||
13ff8fd0 VS |
404 | int w; ///< agreed upon image width |
405 | int h; ///< agreed upon image height | |
406 | enum PixelFormat format; ///< agreed upon image colorspace | |
a5cbb2f4 | 407 | |
60bf6ce3 | 408 | /** |
35f3fdf4 VS |
409 | * Lists of formats supported by the input and output filters respectively. |
410 | * These lists are used for negotiating the format to actually be used, | |
411 | * which will be loaded into the format member, above, when chosen. | |
412 | */ | |
413 | AVFilterFormats *in_formats; | |
414 | AVFilterFormats *out_formats; | |
415 | ||
416 | /** | |
60bf6ce3 VS |
417 | * The picture reference currently being sent across the link by the source |
418 | * filter. This is used internally by the filter system to allow | |
419 | * automatic copying of pictures which d not have sufficient permissions | |
420 | * for the destination. This should not be accessed directly by the | |
421 | * filters. | |
422 | */ | |
423 | AVFilterPicRef *srcpic; | |
424 | ||
a5cbb2f4 | 425 | AVFilterPicRef *cur_pic; |
462f57db | 426 | AVFilterPicRef *outpic; |
a5cbb2f4 VS |
427 | }; |
428 | ||
13ff8fd0 VS |
429 | /** |
430 | * Link two filters together | |
431 | * @param src The source filter | |
432 | * @param srcpad Index of the output pad on the source filter | |
433 | * @param dst The destination filter | |
434 | * @param dstpad Index of the input pad on the destination filter | |
435 | * @return Zero on success | |
436 | */ | |
a5cbb2f4 VS |
437 | int avfilter_link(AVFilterContext *src, unsigned srcpad, |
438 | AVFilterContext *dst, unsigned dstpad); | |
439 | ||
13ff8fd0 | 440 | /** |
24c4eff6 VS |
441 | * Negotiate the colorspace, dimensions, etc of all inputs to a filter. |
442 | * @param filter The filter to negotiate the properties for its inputs | |
d177bd18 | 443 | * @return Zero on successful negotiation |
13ff8fd0 | 444 | */ |
24c4eff6 | 445 | int avfilter_config_links(AVFilterContext *filter); |
85322466 | 446 | |
13ff8fd0 VS |
447 | /** |
448 | * Request a picture buffer with a specific set of permissions | |
449 | * @param link The output link to the filter from which the picture will | |
450 | * be requested | |
451 | * @param perms The required access permissions | |
452 | * @return A reference to the picture. This must be unreferenced with | |
453 | * avfilter_unref_pic when you are finished with it. | |
454 | */ | |
a5cbb2f4 | 455 | AVFilterPicRef *avfilter_get_video_buffer(AVFilterLink *link, int perms); |
13ff8fd0 VS |
456 | |
457 | /** | |
458 | * Request an input frame from the filter at the other end of the link. | |
459 | * @param link The input link | |
460 | * @return Zero on success | |
461 | */ | |
63f64e6f | 462 | int avfilter_request_frame(AVFilterLink *link); |
13ff8fd0 VS |
463 | |
464 | /** | |
b42a6a92 | 465 | * Notify the next filter of the start of a frame. |
13ff8fd0 VS |
466 | * @param link The output link the frame will be sent over |
467 | * @param picref A reference to the frame about to be sent. The data for this | |
468 | * frame need only be valid once draw_slice() is called for that | |
469 | * portion. The receiving filter will free this reference when | |
470 | * it no longer needs it. | |
471 | */ | |
a5cbb2f4 | 472 | void avfilter_start_frame(AVFilterLink *link, AVFilterPicRef *picref); |
13ff8fd0 VS |
473 | |
474 | /** | |
475 | * Notify the next filter that the current frame has finished | |
476 | * @param link The output link the frame was sent over | |
477 | */ | |
a5cbb2f4 | 478 | void avfilter_end_frame(AVFilterLink *link); |
13ff8fd0 VS |
479 | |
480 | /** | |
481 | * Send a slice to the next filter | |
482 | * @param link The output link over which the frame is being sent | |
13ff8fd0 VS |
483 | * @param y Offset in pixels from the top of the image for this slice |
484 | * @param h Height of this slice in pixels | |
485 | */ | |
72f6d631 | 486 | void avfilter_draw_slice(AVFilterLink *link, int y, int h); |
a5cbb2f4 | 487 | |
13ff8fd0 | 488 | /** Initialize the filter system. Registers all builtin filters */ |
a5cbb2f4 | 489 | void avfilter_init(void); |
13ff8fd0 VS |
490 | |
491 | /** Uninitialize the filter system. Unregisters all filters */ | |
a5cbb2f4 | 492 | void avfilter_uninit(void); |
13ff8fd0 VS |
493 | |
494 | /** | |
fc815c56 VS |
495 | * Register a filter. This is only needed if you plan to use |
496 | * avfilter_get_by_name later to lookup the AVFilter structure by name. A | |
497 | * filter can still by instantiated with avfilter_open even if it is not | |
498 | * registered. | |
13ff8fd0 VS |
499 | * @param filter The filter to register |
500 | */ | |
a5cbb2f4 | 501 | void avfilter_register(AVFilter *filter); |
13ff8fd0 VS |
502 | |
503 | /** | |
504 | * Gets a filter definition matching the given name | |
505 | * @param name The filter name to find | |
506 | * @return The filter definition, if any matching one is registered. | |
507 | * NULL if none found. | |
508 | */ | |
2844dd39 | 509 | AVFilter *avfilter_get_by_name(const char *name); |
a5cbb2f4 | 510 | |
13ff8fd0 VS |
511 | /** |
512 | * Create a filter instance | |
513 | * @param filter The filter to create an instance of | |
514 | * @param inst_name Name to give to the new instance. Can be NULL for none. | |
515 | * @return Pointer to the new instance on success. NULL on failure. | |
516 | */ | |
2844dd39 | 517 | AVFilterContext *avfilter_open(AVFilter *filter, const char *inst_name); |
13ff8fd0 VS |
518 | |
519 | /** | |
520 | * Initialize a filter | |
521 | * @param filter The filter to initialize | |
522 | * @param args A string of parameters to use when initializing the filter. | |
523 | * The format and meaning of this string varies by filter. | |
524 | * @param opaque Any extra non-string data needed by the filter. The meaning | |
525 | * of this parameter varies by filter. | |
526 | * @return Zero on success | |
527 | */ | |
6e365c57 | 528 | int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque); |
13ff8fd0 VS |
529 | |
530 | /** | |
531 | * Destroy a filter | |
532 | * @param filter The filter to destroy | |
533 | */ | |
a5cbb2f4 VS |
534 | void avfilter_destroy(AVFilterContext *filter); |
535 | ||
13ff8fd0 | 536 | /** |
35f3fdf4 VS |
537 | * Insert a filter in the middle of an existing link. |
538 | * @param link The link into which the filter should be inserted | |
539 | * @param filt The filter to be inserted | |
540 | * @param in The input pad on the filter to connect | |
541 | * @param out The output pad on the filter to connect | |
542 | * @return Zero on success | |
13ff8fd0 | 543 | */ |
35f3fdf4 VS |
544 | int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, |
545 | unsigned in, unsigned out); | |
d3e57c15 | 546 | |
a9c81431 VS |
547 | /** |
548 | * Insert a new pad | |
549 | * @param idx Insertion point. Pad is inserted at the end if this point | |
550 | * is beyond the end of the list of pads. | |
551 | * @param count Pointer to the number of pads in the list | |
552 | * @param padidx_off Offset within an AVFilterLink structure to the element | |
553 | * to increment when inserting a new pad causes link | |
554 | * numbering to change | |
555 | * @param pads Pointer to the pointer to the beginning of the list of pads | |
556 | * @param links Pointer to the pointer to the beginning of the list of links | |
557 | * @param newpad The new pad to add. A copy is made when adding. | |
558 | */ | |
559 | void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, | |
560 | AVFilterPad **pads, AVFilterLink ***links, | |
561 | AVFilterPad *newpad); | |
562 | ||
563 | /** insert a new input pad for the filter */ | |
564 | static inline void avfilter_insert_inpad(AVFilterContext *f, unsigned index, | |
565 | AVFilterPad *p) | |
566 | { | |
567 | avfilter_insert_pad(index, &f->input_count, offsetof(AVFilterLink, dstpad), | |
568 | &f->input_pads, &f->inputs, p); | |
569 | } | |
570 | ||
571 | /** insert a new output pad for the filter */ | |
572 | static inline void avfilter_insert_outpad(AVFilterContext *f, unsigned index, | |
573 | AVFilterPad *p) | |
574 | { | |
575 | avfilter_insert_pad(index, &f->output_count, offsetof(AVFilterLink, srcpad), | |
576 | &f->output_pads, &f->outputs, p); | |
577 | } | |
578 | ||
a5cbb2f4 | 579 | #endif /* FFMPEG_AVFILTER_H */ |