FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
avfilter.h
Go to the documentation of this file.
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 AVFILTER_AVFILTER_H
23 #define AVFILTER_AVFILTER_H
24 
25 /**
26  * @file
27  * @ingroup lavfi
28  * external API header
29  */
30 
31 /**
32  * @defgroup lavfi Libavfilter
33  * @{
34  */
35 
36 #include <stddef.h>
37 
38 #include "libavutil/avutil.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/log.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/pixfmt.h"
43 #include "libavutil/rational.h"
44 
45 #include "libavfilter/version.h"
46 
47 /**
48  * Return the LIBAVFILTER_VERSION_INT constant.
49  */
50 unsigned avfilter_version(void);
51 
52 /**
53  * Return the libavfilter build-time configuration.
54  */
55 const char *avfilter_configuration(void);
56 
57 /**
58  * Return the libavfilter license.
59  */
60 const char *avfilter_license(void);
61 
62 /**
63  * Get the class for the AVFilterContext struct.
64  */
65 const AVClass *avfilter_get_class(void);
66 
67 typedef struct AVFilterContext AVFilterContext;
68 typedef struct AVFilterLink AVFilterLink;
69 typedef struct AVFilterPad AVFilterPad;
70 typedef struct AVFilterFormats AVFilterFormats;
71 
72 /**
73  * A reference-counted buffer data type used by the filter system. Filters
74  * should not store pointers to this structure directly, but instead use the
75  * AVFilterBufferRef structure below.
76  */
77 typedef struct AVFilterBuffer {
78  uint8_t *data[8]; ///< buffer data for each plane/channel
79 
80  /**
81  * pointers to the data planes/channels.
82  *
83  * For video, this should simply point to data[].
84  *
85  * For planar audio, each channel has a separate data pointer, and
86  * linesize[0] contains the size of each channel buffer.
87  * For packed audio, there is just one data pointer, and linesize[0]
88  * contains the total size of the buffer for all channels.
89  *
90  * Note: Both data and extended_data will always be set, but for planar
91  * audio with more channels that can fit in data, extended_data must be used
92  * in order to access all channels.
93  */
95  int linesize[8]; ///< number of bytes per line
96 
97  /** private data to be used by a custom free function */
98  void *priv;
99  /**
100  * A pointer to the function to deallocate this buffer if the default
101  * function is not sufficient. This could, for example, add the memory
102  * back into a memory pool to be reused later without the overhead of
103  * reallocating it from scratch.
104  */
105  void (*free)(struct AVFilterBuffer *buf);
106 
107  int format; ///< media format
108  int w, h; ///< width and height of the allocated buffer
109  unsigned refcount; ///< number of references to this buffer
111 
112 #define AV_PERM_READ 0x01 ///< can read from the buffer
113 #define AV_PERM_WRITE 0x02 ///< can write to the buffer
114 #define AV_PERM_PRESERVE 0x04 ///< nobody else can overwrite the buffer
115 #define AV_PERM_REUSE 0x08 ///< can output the buffer multiple times, with the same contents each time
116 #define AV_PERM_REUSE2 0x10 ///< can output the buffer multiple times, modified each time
117 #define AV_PERM_NEG_LINESIZES 0x20 ///< the buffer requested can have negative linesizes
118 #define AV_PERM_ALIGN 0x40 ///< the buffer must be aligned
119 
120 #define AVFILTER_ALIGN 16 //not part of ABI
121 
122 /**
123  * Audio specific properties in a reference to an AVFilterBuffer. Since
124  * AVFilterBufferRef is common to different media formats, audio specific
125  * per reference properties must be separated out.
126  */
128  uint64_t channel_layout; ///< channel layout of audio buffer
129  int nb_samples; ///< number of audio samples per channel
130  int sample_rate; ///< audio buffer sample rate
131  int channels; ///< number of channels (do not access directly)
133 
134 /**
135  * Video specific properties in a reference to an AVFilterBuffer. Since
136  * AVFilterBufferRef is common to different media formats, video specific
137  * per reference properties must be separated out.
138  */
140  int w; ///< image width
141  int h; ///< image height
142  AVRational sample_aspect_ratio; ///< sample aspect ratio
143  int interlaced; ///< is frame interlaced
144  int top_field_first; ///< field order
145  enum AVPictureType pict_type; ///< picture type of the frame
146  int key_frame; ///< 1 -> keyframe, 0-> not
147  int qp_table_linesize; ///< qp_table stride
148  int qp_table_size; ///< qp_table size
149  int8_t *qp_table; ///< array of Quantization Parameters
151 
152 /**
153  * A reference to an AVFilterBuffer. Since filters can manipulate the origin of
154  * a buffer to, for example, crop image without any memcpy, the buffer origin
155  * and dimensions are per-reference properties. Linesize is also useful for
156  * image flipping, frame to field filters, etc, and so is also per-reference.
157  *
158  * TODO: add anything necessary for frame reordering
159  */
160 typedef struct AVFilterBufferRef {
161  AVFilterBuffer *buf; ///< the buffer that this is a reference to
162  uint8_t *data[8]; ///< picture/audio data for each plane
163  /**
164  * pointers to the data planes/channels.
165  *
166  * For video, this should simply point to data[].
167  *
168  * For planar audio, each channel has a separate data pointer, and
169  * linesize[0] contains the size of each channel buffer.
170  * For packed audio, there is just one data pointer, and linesize[0]
171  * contains the total size of the buffer for all channels.
172  *
173  * Note: Both data and extended_data will always be set, but for planar
174  * audio with more channels that can fit in data, extended_data must be used
175  * in order to access all channels.
176  */
178  int linesize[8]; ///< number of bytes per line
179 
180  AVFilterBufferRefVideoProps *video; ///< video buffer specific properties
181  AVFilterBufferRefAudioProps *audio; ///< audio buffer specific properties
182 
183  /**
184  * presentation timestamp. The time unit may change during
185  * filtering, as it is specified in the link and the filter code
186  * may need to rescale the PTS accordingly.
187  */
188  int64_t pts;
189  int64_t pos; ///< byte position in stream, -1 if unknown
190 
191  int format; ///< media format
192 
193  int perms; ///< permissions, see the AV_PERM_* flags
194 
195  enum AVMediaType type; ///< media type of buffer data
196 
197  AVDictionary *metadata; ///< dictionary containing metadata key=value tags
199 
200 /**
201  * Copy properties of src to dst, without copying the actual data
202  */
204 
205 /**
206  * Add a new reference to a buffer.
207  *
208  * @param ref an existing reference to the buffer
209  * @param pmask a bitmask containing the allowable permissions in the new
210  * reference
211  * @return a new reference to the buffer with the same properties as the
212  * old, excluding any permissions denied by pmask
213  */
215 
216 /**
217  * Remove a reference to a buffer. If this is the last reference to the
218  * buffer, the buffer itself is also automatically freed.
219  *
220  * @param ref reference to the buffer, may be NULL
221  *
222  * @note it is recommended to use avfilter_unref_bufferp() instead of this
223  * function
224  */
226 
227 /**
228  * Remove a reference to a buffer and set the pointer to NULL.
229  * If this is the last reference to the buffer, the buffer itself
230  * is also automatically freed.
231  *
232  * @param ref pointer to the buffer reference
233  */
235 
236 /**
237  * Get the number of channels of a buffer reference.
238  */
240 
241 #if FF_API_AVFILTERPAD_PUBLIC
242 /**
243  * A filter pad used for either input or output.
244  *
245  * See doc/filter_design.txt for details on how to implement the methods.
246  *
247  * @warning this struct might be removed from public API.
248  * users should call avfilter_pad_get_name() and avfilter_pad_get_type()
249  * to access the name and type fields; there should be no need to access
250  * any other fields from outside of libavfilter.
251  */
252 struct AVFilterPad {
253  /**
254  * Pad name. The name is unique among inputs and among outputs, but an
255  * input may have the same name as an output. This may be NULL if this
256  * pad has no need to ever be referenced by name.
257  */
258  const char *name;
259 
260  /**
261  * AVFilterPad type.
262  */
263  enum AVMediaType type;
264 
265  /**
266  * Input pads:
267  * Minimum required permissions on incoming buffers. Any buffer with
268  * insufficient permissions will be automatically copied by the filter
269  * system to a new buffer which provides the needed access permissions.
270  *
271  * Output pads:
272  * Guaranteed permissions on outgoing buffers. Any buffer pushed on the
273  * link must have at least these permissions; this fact is checked by
274  * asserts. It can be used to optimize buffer allocation.
275  */
276  int min_perms;
277 
278  /**
279  * Input pads:
280  * Permissions which are not accepted on incoming buffers. Any buffer
281  * which has any of these permissions set will be automatically copied
282  * by the filter system to a new buffer which does not have those
283  * permissions. This can be used to easily disallow buffers with
284  * AV_PERM_REUSE.
285  *
286  * Output pads:
287  * Permissions which are automatically removed on outgoing buffers. It
288  * can be used to optimize buffer allocation.
289  */
290  int rej_perms;
291 
292  /**
293  * @deprecated unused
294  */
295  int (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref);
296 
297  /**
298  * Callback function to get a video buffer. If NULL, the filter system will
299  * use ff_default_get_video_buffer().
300  *
301  * Input video pads only.
302  */
303  AVFilterBufferRef *(*get_video_buffer)(AVFilterLink *link, int perms, int w, int h);
304 
305  /**
306  * Callback function to get an audio buffer. If NULL, the filter system will
307  * use ff_default_get_audio_buffer().
308  *
309  * Input audio pads only.
310  */
311  AVFilterBufferRef *(*get_audio_buffer)(AVFilterLink *link, int perms,
312  int nb_samples);
313 
314  /**
315  * @deprecated unused
316  */
317  int (*end_frame)(AVFilterLink *link);
318 
319  /**
320  * @deprecated unused
321  */
322  int (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir);
323 
324  /**
325  * Filtering callback. This is where a filter receives a frame with
326  * audio/video data and should do its processing.
327  *
328  * Input pads only.
329  *
330  * @return >= 0 on success, a negative AVERROR on error. This function
331  * must ensure that frame is properly unreferenced on error if it
332  * hasn't been passed on to another filter.
333  */
335 
336  /**
337  * Frame poll callback. This returns the number of immediately available
338  * samples. It should return a positive value if the next request_frame()
339  * is guaranteed to return one frame (with no delay).
340  *
341  * Defaults to just calling the source poll_frame() method.
342  *
343  * Output pads only.
344  */
345  int (*poll_frame)(AVFilterLink *link);
346 
347  /**
348  * Frame request callback. A call to this should result in at least one
349  * frame being output over the given link. This should return zero on
350  * success, and another value on error.
351  * See ff_request_frame() for the error codes with a specific
352  * meaning.
353  *
354  * Output pads only.
355  */
356  int (*request_frame)(AVFilterLink *link);
357 
358  /**
359  * Link configuration callback.
360  *
361  * For output pads, this should set the following link properties:
362  * video: width, height, sample_aspect_ratio, time_base
363  * audio: sample_rate.
364  *
365  * This should NOT set properties such as format, channel_layout, etc which
366  * are negotiated between filters by the filter system using the
367  * query_formats() callback before this function is called.
368  *
369  * For input pads, this should check the properties of the link, and update
370  * the filter's internal state as necessary.
371  *
372  * For both input and output pads, this should return zero on success,
373  * and another value on error.
374  */
375  int (*config_props)(AVFilterLink *link);
376 
377  /**
378  * The filter expects a fifo to be inserted on its input link,
379  * typically because it has a delay.
380  *
381  * input pads only.
382  */
383  int needs_fifo;
384 };
385 #endif
386 
387 /**
388  * Get the name of an AVFilterPad.
389  *
390  * @param pads an array of AVFilterPads
391  * @param pad_idx index of the pad in the array it; is the caller's
392  * responsibility to ensure the index is valid
393  *
394  * @return name of the pad_idx'th pad in pads
395  */
396 const char *avfilter_pad_get_name(AVFilterPad *pads, int pad_idx);
397 
398 /**
399  * Get the type of an AVFilterPad.
400  *
401  * @param pads an array of AVFilterPads
402  * @param pad_idx index of the pad in the array; it is the caller's
403  * responsibility to ensure the index is valid
404  *
405  * @return type of the pad_idx'th pad in pads
406  */
407 enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx);
408 
409 /**
410  * Filter definition. This defines the pads a filter contains, and all the
411  * callback functions used to interact with the filter.
412  */
413 typedef struct AVFilter {
414  const char *name; ///< filter name
415 
416  /**
417  * A description for the filter. You should use the
418  * NULL_IF_CONFIG_SMALL() macro to define it.
419  */
420  const char *description;
421 
422  const AVFilterPad *inputs; ///< NULL terminated list of inputs. NULL if none
423  const AVFilterPad *outputs; ///< NULL terminated list of outputs. NULL if none
424 
425  /*****************************************************************
426  * All fields below this line are not part of the public API. They
427  * may not be used outside of libavfilter and can be changed and
428  * removed at will.
429  * New public fields should be added right above.
430  *****************************************************************
431  */
432 
433  /**
434  * Filter initialization function. Args contains the user-supplied
435  * parameters. FIXME: maybe an AVOption-based system would be better?
436  */
437  int (*init)(AVFilterContext *ctx, const char *args);
438 
439  /**
440  * Filter uninitialization function. Should deallocate any memory held
441  * by the filter, release any buffer references, etc. This does not need
442  * to deallocate the AVFilterContext->priv memory itself.
443  */
445 
446  /**
447  * Queries formats/layouts supported by the filter and its pads, and sets
448  * the in_formats/in_chlayouts for links connected to its output pads,
449  * and out_formats/out_chlayouts for links connected to its input pads.
450  *
451  * @return zero on success, a negative value corresponding to an
452  * AVERROR code otherwise
453  */
455 
456  int priv_size; ///< size of private data to allocate for the filter
457 
458  /**
459  * Make the filter instance process a command.
460  *
461  * @param cmd the command to process, for handling simplicity all commands must be alphanumeric only
462  * @param arg the argument for the command
463  * @param res a buffer with size res_size where the filter(s) can return a response. This must not change when the command is not supported.
464  * @param flags if AVFILTER_CMD_FLAG_FAST is set and the command would be
465  * time consuming then a filter should treat it like an unsupported command
466  *
467  * @returns >=0 on success otherwise an error code.
468  * AVERROR(ENOSYS) on unsupported commands
469  */
470  int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);
471 
472  /**
473  * Filter initialization function, alternative to the init()
474  * callback. Args contains the user-supplied parameters, opaque is
475  * used for providing binary data.
476  */
477  int (*init_opaque)(AVFilterContext *ctx, const char *args, void *opaque);
478 
479  const AVClass *priv_class; ///< private class, containing filter specific options
480 } AVFilter;
481 
482 /** An instance of a filter */
484  const AVClass *av_class; ///< needed for av_log()
485 
486  AVFilter *filter; ///< the AVFilter of which this is an instance
487 
488  char *name; ///< name of this filter instance
489 
490  AVFilterPad *input_pads; ///< array of input pads
491  AVFilterLink **inputs; ///< array of pointers to input links
492 #if FF_API_FOO_COUNT
493  unsigned input_count; ///< @deprecated use nb_inputs
494 #endif
495  unsigned nb_inputs; ///< number of input pads
496 
497  AVFilterPad *output_pads; ///< array of output pads
498  AVFilterLink **outputs; ///< array of pointers to output links
499 #if FF_API_FOO_COUNT
500  unsigned output_count; ///< @deprecated use nb_outputs
501 #endif
502  unsigned nb_outputs; ///< number of output pads
503 
504  void *priv; ///< private data for use by the filter
505 
507 };
508 
509 /**
510  * A link between two filters. This contains pointers to the source and
511  * destination filters between which this link exists, and the indexes of
512  * the pads involved. In addition, this link also contains the parameters
513  * which have been negotiated and agreed upon between the filter, such as
514  * image dimensions, format, etc.
515  */
516 struct AVFilterLink {
517  AVFilterContext *src; ///< source filter
518  AVFilterPad *srcpad; ///< output pad on the source filter
519 
520  AVFilterContext *dst; ///< dest filter
521  AVFilterPad *dstpad; ///< input pad on the dest filter
522 
523  enum AVMediaType type; ///< filter media type
524 
525  /* These parameters apply only to video */
526  int w; ///< agreed upon image width
527  int h; ///< agreed upon image height
528  AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio
529  /* These parameters apply only to audio */
530  uint64_t channel_layout; ///< channel layout of current buffer (see libavutil/channel_layout.h)
531  int sample_rate; ///< samples per second
532 
533  int format; ///< agreed upon media format
534 
535  /**
536  * Define the time base used by the PTS of the frames/samples
537  * which will pass through this link.
538  * During the configuration stage, each filter is supposed to
539  * change only the output timebase, while the timebase of the
540  * input link is assumed to be an unchangeable property.
541  */
543 
544  /*****************************************************************
545  * All fields below this line are not part of the public API. They
546  * may not be used outside of libavfilter and can be changed and
547  * removed at will.
548  * New public fields should be added right above.
549  *****************************************************************
550  */
551  /**
552  * Lists of formats and channel layouts supported by the input and output
553  * filters respectively. These lists are used for negotiating the format
554  * to actually be used, which will be loaded into the format and
555  * channel_layout members, above, when chosen.
556  *
557  */
560 
561  /**
562  * Lists of channel layouts and sample rates used for automatic
563  * negotiation.
564  */
569 
570  /**
571  * Audio only, the destination filter sets this to a non-zero value to
572  * request that buffers with the given number of samples should be sent to
573  * it. AVFilterPad.needs_fifo must also be set on the corresponding input
574  * pad.
575  * Last buffer before EOF will be padded with silence.
576  */
578 
579  /** stage of the initialization of the link properties (dimensions, etc) */
580  enum {
581  AVLINK_UNINIT = 0, ///< not started
582  AVLINK_STARTINIT, ///< started, but incomplete
583  AVLINK_INIT ///< complete
584  } init_state;
585 
587 
588  /**
589  * Graph the filter belongs to.
590  */
592 
593  /**
594  * Current timestamp of the link, as defined by the most recent
595  * frame(s), in AV_TIME_BASE units.
596  */
597  int64_t current_pts;
598 
599  /**
600  * Index in the age array.
601  */
603 
604  /**
605  * Frame rate of the stream on the link, or 1/0 if unknown;
606  * if left to 0/0, will be automatically be copied from the first input
607  * of the source filter if it exists.
608  *
609  * Sources should set it to the best estimation of the real frame rate.
610  * Filters should update it if necessary depending on their function.
611  * Sinks can use it to set a default output frame rate.
612  * It is similar to the r_frame_rate field in AVStream.
613  */
615 
616  /**
617  * Buffer partially filled with samples to achieve a fixed/minimum size.
618  */
620 
621  /**
622  * Size of the partial buffer to allocate.
623  * Must be between min_samples and max_samples.
624  */
626 
627  /**
628  * Minimum number of samples to filter at once. If filter_frame() is
629  * called with fewer samples, it will accumulate them in partial_buf.
630  * This field and the related ones must not be changed after filtering
631  * has started.
632  * If 0, all related fields are ignored.
633  */
635 
636  /**
637  * Maximum number of samples to filter at once. If filter_frame() is
638  * called with more samples, it will split them.
639  */
641 
642  /**
643  * The buffer reference currently being received across the link by the
644  * destination filter. This is used internally by the filter system to
645  * allow automatic copying of buffers which do not have sufficient
646  * permissions for the destination. This should not be accessed directly
647  * by the filters.
648  */
650 
651  /**
652  * True if the link is closed.
653  * If set, all attemps of start_frame, filter_frame or request_frame
654  * will fail with AVERROR_EOF, and if necessary the reference will be
655  * destroyed.
656  * If request_frame returns AVERROR_EOF, this flag is set on the
657  * corresponding link.
658  * It can be set also be set by either the source or the destination
659  * filter.
660  */
661  int closed;
662 
663  /**
664  * Number of channels.
665  */
666  int channels;
667 };
668 
669 /**
670  * Link two filters together.
671  *
672  * @param src the source filter
673  * @param srcpad index of the output pad on the source filter
674  * @param dst the destination filter
675  * @param dstpad index of the input pad on the destination filter
676  * @return zero on success
677  */
678 int avfilter_link(AVFilterContext *src, unsigned srcpad,
679  AVFilterContext *dst, unsigned dstpad);
680 
681 /**
682  * Free the link in *link, and set its pointer to NULL.
683  */
684 void avfilter_link_free(AVFilterLink **link);
685 
686 /**
687  * Get the number of channels of a link.
688  */
690 
691 /**
692  * Set the closed field of a link.
693  */
694 void avfilter_link_set_closed(AVFilterLink *link, int closed);
695 
696 /**
697  * Negotiate the media format, dimensions, etc of all inputs to a filter.
698  *
699  * @param filter the filter to negotiate the properties for its inputs
700  * @return zero on successful negotiation
701  */
703 
704 /**
705  * Create a buffer reference wrapped around an already allocated image
706  * buffer.
707  *
708  * @param data pointers to the planes of the image to reference
709  * @param linesize linesizes for the planes of the image to reference
710  * @param perms the required access permissions
711  * @param w the width of the image specified by the data and linesize arrays
712  * @param h the height of the image specified by the data and linesize arrays
713  * @param format the pixel format of the image specified by the data and linesize arrays
714  */
716 avfilter_get_video_buffer_ref_from_arrays(uint8_t * const data[4], const int linesize[4], int perms,
717  int w, int h, enum AVPixelFormat format);
718 
719 /**
720  * Create an audio buffer reference wrapped around an already
721  * allocated samples buffer.
722  *
723  * See avfilter_get_audio_buffer_ref_from_arrays_channels() for a version
724  * that can handle unknown channel layouts.
725  *
726  * @param data pointers to the samples plane buffers
727  * @param linesize linesize for the samples plane buffers
728  * @param perms the required access permissions
729  * @param nb_samples number of samples per channel
730  * @param sample_fmt the format of each sample in the buffer to allocate
731  * @param channel_layout the channel layout of the buffer
732  */
734  int linesize,
735  int perms,
736  int nb_samples,
737  enum AVSampleFormat sample_fmt,
738  uint64_t channel_layout);
739 /**
740  * Create an audio buffer reference wrapped around an already
741  * allocated samples buffer.
742  *
743  * @param data pointers to the samples plane buffers
744  * @param linesize linesize for the samples plane buffers
745  * @param perms the required access permissions
746  * @param nb_samples number of samples per channel
747  * @param sample_fmt the format of each sample in the buffer to allocate
748  * @param channels the number of channels of the buffer
749  * @param channel_layout the channel layout of the buffer,
750  * must be either 0 or consistent with channels
751  */
753  int linesize,
754  int perms,
755  int nb_samples,
756  enum AVSampleFormat sample_fmt,
757  int channels,
758  uint64_t channel_layout);
759 
760 
761 
762 #define AVFILTER_CMD_FLAG_ONE 1 ///< Stop once a filter understood the command (for target=all for example), fast filters are favored automatically
763 #define AVFILTER_CMD_FLAG_FAST 2 ///< Only execute command when its fast (like a video out that supports contrast adjustment in hw)
764 
765 /**
766  * Make the filter instance process a command.
767  * It is recommended to use avfilter_graph_send_command().
768  */
769 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags);
770 
771 /** Initialize the filter system. Register all builtin filters. */
772 void avfilter_register_all(void);
773 
774 /** Uninitialize the filter system. Unregister all filters. */
775 void avfilter_uninit(void);
776 
777 /**
778  * Register a filter. This is only needed if you plan to use
779  * avfilter_get_by_name later to lookup the AVFilter structure by name. A
780  * filter can still by instantiated with avfilter_open even if it is not
781  * registered.
782  *
783  * @param filter the filter to register
784  * @return 0 if the registration was successful, a negative value
785  * otherwise
786  */
788 
789 /**
790  * Get a filter definition matching the given name.
791  *
792  * @param name the filter name to find
793  * @return the filter definition, if any matching one is registered.
794  * NULL if none found.
795  */
796 AVFilter *avfilter_get_by_name(const char *name);
797 
798 /**
799  * If filter is NULL, returns a pointer to the first registered filter pointer,
800  * if filter is non-NULL, returns the next pointer after filter.
801  * If the returned pointer points to NULL, the last registered filter
802  * was already reached.
803  */
805 
806 /**
807  * Create a filter instance.
808  *
809  * @param filter_ctx put here a pointer to the created filter context
810  * on success, NULL on failure
811  * @param filter the filter to create an instance of
812  * @param inst_name Name to give to the new instance. Can be NULL for none.
813  * @return >= 0 in case of success, a negative error code otherwise
814  */
815 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);
816 
817 /**
818  * Initialize a filter.
819  *
820  * @param filter the filter to initialize
821  * @param args A string of parameters to use when initializing the filter.
822  * The format and meaning of this string varies by filter.
823  * @param opaque Any extra non-string data needed by the filter. The meaning
824  * of this parameter varies by filter.
825  * @return zero on success
826  */
827 int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque);
828 
829 /**
830  * Free a filter context.
831  *
832  * @param filter the filter to free
833  */
835 
836 /**
837  * Insert a filter in the middle of an existing link.
838  *
839  * @param link the link into which the filter should be inserted
840  * @param filt the filter to be inserted
841  * @param filt_srcpad_idx the input pad on the filter to connect
842  * @param filt_dstpad_idx the output pad on the filter to connect
843  * @return zero on success
844  */
846  unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
847 
848 /**
849  * @}
850  */
851 
852 #endif /* AVFILTER_AVFILTER_H */