FFmpeg
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  * Main libavfilter public API header
29  */
30 
31 /**
32  * @defgroup lavfi libavfilter
33  * Graph-based frame editing library.
34  *
35  * @{
36  */
37 
38 #include <stddef.h>
39 
40 #include "libavutil/attributes.h"
41 #include "libavutil/avutil.h"
42 #include "libavutil/buffer.h"
43 #include "libavutil/dict.h"
44 #include "libavutil/frame.h"
45 #include "libavutil/log.h"
46 #include "libavutil/samplefmt.h"
47 #include "libavutil/pixfmt.h"
48 #include "libavutil/rational.h"
49 
50 #include "libavfilter/version.h"
51 
52 /**
53  * Return the LIBAVFILTER_VERSION_INT constant.
54  */
55 unsigned avfilter_version(void);
56 
57 /**
58  * Return the libavfilter build-time configuration.
59  */
60 const char *avfilter_configuration(void);
61 
62 /**
63  * Return the libavfilter license.
64  */
65 const char *avfilter_license(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  * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
74  * AVFilter.inputs/outputs).
75  */
76 int avfilter_pad_count(const AVFilterPad *pads);
77 
78 /**
79  * Get the name of an AVFilterPad.
80  *
81  * @param pads an array of AVFilterPads
82  * @param pad_idx index of the pad in the array it; is the caller's
83  * responsibility to ensure the index is valid
84  *
85  * @return name of the pad_idx'th pad in pads
86  */
87 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx);
88 
89 /**
90  * Get the type of an AVFilterPad.
91  *
92  * @param pads an array of AVFilterPads
93  * @param pad_idx index of the pad in the array; it is the caller's
94  * responsibility to ensure the index is valid
95  *
96  * @return type of the pad_idx'th pad in pads
97  */
98 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx);
99 
100 /**
101  * The number of the filter inputs is not determined just by AVFilter.inputs.
102  * The filter might add additional inputs during initialization depending on the
103  * options supplied to it.
104  */
105 #define AVFILTER_FLAG_DYNAMIC_INPUTS (1 << 0)
106 /**
107  * The number of the filter outputs is not determined just by AVFilter.outputs.
108  * The filter might add additional outputs during initialization depending on
109  * the options supplied to it.
110  */
111 #define AVFILTER_FLAG_DYNAMIC_OUTPUTS (1 << 1)
112 /**
113  * The filter supports multithreading by splitting frames into multiple parts
114  * and processing them concurrently.
115  */
116 #define AVFILTER_FLAG_SLICE_THREADS (1 << 2)
117 /**
118  * Some filters support a generic "enable" expression option that can be used
119  * to enable or disable a filter in the timeline. Filters supporting this
120  * option have this flag set. When the enable expression is false, the default
121  * no-op filter_frame() function is called in place of the filter_frame()
122  * callback defined on each input pad, thus the frame is passed unchanged to
123  * the next filters.
124  */
125 #define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC (1 << 16)
126 /**
127  * Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will
128  * have its filter_frame() callback(s) called as usual even when the enable
129  * expression is false. The filter will disable filtering within the
130  * filter_frame() callback(s) itself, for example executing code depending on
131  * the AVFilterContext->is_disabled value.
132  */
133 #define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL (1 << 17)
134 /**
135  * Handy mask to test whether the filter supports or no the timeline feature
136  * (internally or generically).
137  */
138 #define AVFILTER_FLAG_SUPPORT_TIMELINE (AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL)
139 
140 /**
141  * Filter definition. This defines the pads a filter contains, and all the
142  * callback functions used to interact with the filter.
143  */
144 typedef struct AVFilter {
145  /**
146  * Filter name. Must be non-NULL and unique among filters.
147  */
148  const char *name;
149 
150  /**
151  * A description of the filter. May be NULL.
152  *
153  * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
154  */
155  const char *description;
156 
157  /**
158  * List of inputs, terminated by a zeroed element.
159  *
160  * NULL if there are no (static) inputs. Instances of filters with
161  * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in
162  * this list.
163  */
165  /**
166  * List of outputs, terminated by a zeroed element.
167  *
168  * NULL if there are no (static) outputs. Instances of filters with
169  * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in
170  * this list.
171  */
173 
174  /**
175  * A class for the private data, used to declare filter private AVOptions.
176  * This field is NULL for filters that do not declare any options.
177  *
178  * If this field is non-NULL, the first member of the filter private data
179  * must be a pointer to AVClass, which will be set by libavfilter generic
180  * code to this class.
181  */
183 
184  /**
185  * A combination of AVFILTER_FLAG_*
186  */
187  int flags;
188 
189  /*****************************************************************
190  * All fields below this line are not part of the public API. They
191  * may not be used outside of libavfilter and can be changed and
192  * removed at will.
193  * New public fields should be added right above.
194  *****************************************************************
195  */
196 
197  /**
198  * Filter pre-initialization function
199  *
200  * This callback will be called immediately after the filter context is
201  * allocated, to allow allocating and initing sub-objects.
202  *
203  * If this callback is not NULL, the uninit callback will be called on
204  * allocation failure.
205  *
206  * @return 0 on success,
207  * AVERROR code on failure (but the code will be
208  * dropped and treated as ENOMEM by the calling code)
209  */
211 
212  /**
213  * Filter initialization function.
214  *
215  * This callback will be called only once during the filter lifetime, after
216  * all the options have been set, but before links between filters are
217  * established and format negotiation is done.
218  *
219  * Basic filter initialization should be done here. Filters with dynamic
220  * inputs and/or outputs should create those inputs/outputs here based on
221  * provided options. No more changes to this filter's inputs/outputs can be
222  * done after this callback.
223  *
224  * This callback must not assume that the filter links exist or frame
225  * parameters are known.
226  *
227  * @ref AVFilter.uninit "uninit" is guaranteed to be called even if
228  * initialization fails, so this callback does not have to clean up on
229  * failure.
230  *
231  * @return 0 on success, a negative AVERROR on failure
232  */
234 
235  /**
236  * Should be set instead of @ref AVFilter.init "init" by the filters that
237  * want to pass a dictionary of AVOptions to nested contexts that are
238  * allocated during init.
239  *
240  * On return, the options dict should be freed and replaced with one that
241  * contains all the options which could not be processed by this filter (or
242  * with NULL if all the options were processed).
243  *
244  * Otherwise the semantics is the same as for @ref AVFilter.init "init".
245  */
247 
248  /**
249  * Filter uninitialization function.
250  *
251  * Called only once right before the filter is freed. Should deallocate any
252  * memory held by the filter, release any buffer references, etc. It does
253  * not need to deallocate the AVFilterContext.priv memory itself.
254  *
255  * This callback may be called even if @ref AVFilter.init "init" was not
256  * called or failed, so it must be prepared to handle such a situation.
257  */
259 
260  /**
261  * Query formats supported by the filter on its inputs and outputs.
262  *
263  * This callback is called after the filter is initialized (so the inputs
264  * and outputs are fixed), shortly before the format negotiation. This
265  * callback may be called more than once.
266  *
267  * This callback must set AVFilterLink.out_formats on every input link and
268  * AVFilterLink.in_formats on every output link to a list of pixel/sample
269  * formats that the filter supports on that link. For audio links, this
270  * filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" /
271  * @ref AVFilterLink.out_samplerates "out_samplerates" and
272  * @ref AVFilterLink.in_channel_layouts "in_channel_layouts" /
273  * @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously.
274  *
275  * This callback may be NULL for filters with one input, in which case
276  * libavfilter assumes that it supports all input formats and preserves
277  * them on output.
278  *
279  * @return zero on success, a negative value corresponding to an
280  * AVERROR code otherwise
281  */
283 
284  int priv_size; ///< size of private data to allocate for the filter
285 
286  int flags_internal; ///< Additional flags for avfilter internal use only.
287 
288  /**
289  * Used by the filter registration system. Must not be touched by any other
290  * code.
291  */
292  struct AVFilter *next;
293 
294  /**
295  * Make the filter instance process a command.
296  *
297  * @param cmd the command to process, for handling simplicity all commands must be alphanumeric only
298  * @param arg the argument for the command
299  * @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.
300  * @param flags if AVFILTER_CMD_FLAG_FAST is set and the command would be
301  * time consuming then a filter should treat it like an unsupported command
302  *
303  * @returns >=0 on success otherwise an error code.
304  * AVERROR(ENOSYS) on unsupported commands
305  */
306  int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);
307 
308  /**
309  * Filter initialization function, alternative to the init()
310  * callback. Args contains the user-supplied parameters, opaque is
311  * used for providing binary data.
312  */
313  int (*init_opaque)(AVFilterContext *ctx, void *opaque);
314 
315  /**
316  * Filter activation function.
317  *
318  * Called when any processing is needed from the filter, instead of any
319  * filter_frame and request_frame on pads.
320  *
321  * The function must examine inlinks and outlinks and perform a single
322  * step of processing. If there is nothing to do, the function must do
323  * nothing and not return an error. If more steps are or may be
324  * possible, it must use ff_filter_set_ready() to schedule another
325  * activation.
326  */
328 } AVFilter;
329 
330 /**
331  * Process multiple parts of the frame concurrently.
332  */
333 #define AVFILTER_THREAD_SLICE (1 << 0)
334 
335 typedef struct AVFilterInternal AVFilterInternal;
336 
337 /** An instance of a filter */
339  const AVClass *av_class; ///< needed for av_log() and filters common options
340 
341  const AVFilter *filter; ///< the AVFilter of which this is an instance
342 
343  char *name; ///< name of this filter instance
344 
345  AVFilterPad *input_pads; ///< array of input pads
346  AVFilterLink **inputs; ///< array of pointers to input links
347  unsigned nb_inputs; ///< number of input pads
348 
349  AVFilterPad *output_pads; ///< array of output pads
350  AVFilterLink **outputs; ///< array of pointers to output links
351  unsigned nb_outputs; ///< number of output pads
352 
353  void *priv; ///< private data for use by the filter
354 
355  struct AVFilterGraph *graph; ///< filtergraph this filter belongs to
356 
357  /**
358  * Type of multithreading being allowed/used. A combination of
359  * AVFILTER_THREAD_* flags.
360  *
361  * May be set by the caller before initializing the filter to forbid some
362  * or all kinds of multithreading for this filter. The default is allowing
363  * everything.
364  *
365  * When the filter is initialized, this field is combined using bit AND with
366  * AVFilterGraph.thread_type to get the final mask used for determining
367  * allowed threading types. I.e. a threading type needs to be set in both
368  * to be allowed.
369  *
370  * After the filter is initialized, libavfilter sets this field to the
371  * threading type that is actually used (0 for no multithreading).
372  */
374 
375  /**
376  * An opaque struct for libavfilter internal use.
377  */
378  AVFilterInternal *internal;
379 
381 
382  char *enable_str; ///< enable expression string
383  void *enable; ///< parsed expression (AVExpr*)
384  double *var_values; ///< variable values for the enable expression
385  int is_disabled; ///< the enabled state from the last expression evaluation
386 
387  /**
388  * For filters which will create hardware frames, sets the device the
389  * filter should create them in. All other filters will ignore this field:
390  * in particular, a filter which consumes or processes hardware frames will
391  * instead use the hw_frames_ctx field in AVFilterLink to carry the
392  * hardware context information.
393  */
395 
396  /**
397  * Max number of threads allowed in this filter instance.
398  * If <= 0, its value is ignored.
399  * Overrides global number of threads set per filter graph.
400  */
402 
403  /**
404  * Ready status of the filter.
405  * A non-0 value means that the filter needs activating;
406  * a higher value suggests a more urgent activation.
407  */
408  unsigned ready;
409 
410  /**
411  * Sets the number of extra hardware frames which the filter will
412  * allocate on its output links for use in following filters or by
413  * the caller.
414  *
415  * Some hardware filters require all frames that they will use for
416  * output to be defined in advance before filtering starts. For such
417  * filters, any hardware frame pools used for output must therefore be
418  * of fixed size. The extra frames set here are on top of any number
419  * that the filter needs internally in order to operate normally.
420  *
421  * This field must be set before the graph containing this filter is
422  * configured.
423  */
425 };
426 
427 /**
428  * A link between two filters. This contains pointers to the source and
429  * destination filters between which this link exists, and the indexes of
430  * the pads involved. In addition, this link also contains the parameters
431  * which have been negotiated and agreed upon between the filter, such as
432  * image dimensions, format, etc.
433  *
434  * Applications must not normally access the link structure directly.
435  * Use the buffersrc and buffersink API instead.
436  * In the future, access to the header may be reserved for filters
437  * implementation.
438  */
439 struct AVFilterLink {
440  AVFilterContext *src; ///< source filter
441  AVFilterPad *srcpad; ///< output pad on the source filter
442 
443  AVFilterContext *dst; ///< dest filter
444  AVFilterPad *dstpad; ///< input pad on the dest filter
445 
446  enum AVMediaType type; ///< filter media type
447 
448  /* These parameters apply only to video */
449  int w; ///< agreed upon image width
450  int h; ///< agreed upon image height
451  AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio
452  /* These parameters apply only to audio */
453  uint64_t channel_layout; ///< channel layout of current buffer (see libavutil/channel_layout.h)
454  int sample_rate; ///< samples per second
455 
456  int format; ///< agreed upon media format
457 
458  /**
459  * Define the time base used by the PTS of the frames/samples
460  * which will pass through this link.
461  * During the configuration stage, each filter is supposed to
462  * change only the output timebase, while the timebase of the
463  * input link is assumed to be an unchangeable property.
464  */
466 
467  /*****************************************************************
468  * All fields below this line are not part of the public API. They
469  * may not be used outside of libavfilter and can be changed and
470  * removed at will.
471  * New public fields should be added right above.
472  *****************************************************************
473  */
474  /**
475  * Lists of formats and channel layouts supported by the input and output
476  * filters respectively. These lists are used for negotiating the format
477  * to actually be used, which will be loaded into the format and
478  * channel_layout members, above, when chosen.
479  *
480  */
483 
484  /**
485  * Lists of channel layouts and sample rates used for automatic
486  * negotiation.
487  */
492 
493  /**
494  * Audio only, the destination filter sets this to a non-zero value to
495  * request that buffers with the given number of samples should be sent to
496  * it. AVFilterPad.needs_fifo must also be set on the corresponding input
497  * pad.
498  * Last buffer before EOF will be padded with silence.
499  */
501 
502  /** stage of the initialization of the link properties (dimensions, etc) */
503  enum {
504  AVLINK_UNINIT = 0, ///< not started
505  AVLINK_STARTINIT, ///< started, but incomplete
506  AVLINK_INIT ///< complete
507  } init_state;
508 
509  /**
510  * Graph the filter belongs to.
511  */
513 
514  /**
515  * Current timestamp of the link, as defined by the most recent
516  * frame(s), in link time_base units.
517  */
518  int64_t current_pts;
519 
520  /**
521  * Current timestamp of the link, as defined by the most recent
522  * frame(s), in AV_TIME_BASE units.
523  */
524  int64_t current_pts_us;
525 
526  /**
527  * Index in the age array.
528  */
530 
531  /**
532  * Frame rate of the stream on the link, or 1/0 if unknown or variable;
533  * if left to 0/0, will be automatically copied from the first input
534  * of the source filter if it exists.
535  *
536  * Sources should set it to the best estimation of the real frame rate.
537  * If the source frame rate is unknown or variable, set this to 1/0.
538  * Filters should update it if necessary depending on their function.
539  * Sinks can use it to set a default output frame rate.
540  * It is similar to the r_frame_rate field in AVStream.
541  */
543 
544  /**
545  * Buffer partially filled with samples to achieve a fixed/minimum size.
546  */
548 
549  /**
550  * Size of the partial buffer to allocate.
551  * Must be between min_samples and max_samples.
552  */
554 
555  /**
556  * Minimum number of samples to filter at once. If filter_frame() is
557  * called with fewer samples, it will accumulate them in partial_buf.
558  * This field and the related ones must not be changed after filtering
559  * has started.
560  * If 0, all related fields are ignored.
561  */
563 
564  /**
565  * Maximum number of samples to filter at once. If filter_frame() is
566  * called with more samples, it will split them.
567  */
569 
570  /**
571  * Number of channels.
572  */
573  int channels;
574 
575  /**
576  * Link processing flags.
577  */
578  unsigned flags;
579 
580  /**
581  * Number of past frames sent through the link.
582  */
583  int64_t frame_count_in, frame_count_out;
584 
585  /**
586  * A pointer to a FFFramePool struct.
587  */
588  void *frame_pool;
589 
590  /**
591  * True if a frame is currently wanted on the output of this filter.
592  * Set when ff_request_frame() is called by the output,
593  * cleared when a frame is filtered.
594  */
596 
597  /**
598  * For hwaccel pixel formats, this should be a reference to the
599  * AVHWFramesContext describing the frames.
600  */
602 
603 #ifndef FF_INTERNAL_FIELDS
604 
605  /**
606  * Internal structure members.
607  * The fields below this limit are internal for libavfilter's use
608  * and must in no way be accessed by applications.
609  */
610  char reserved[0xF000];
611 
612 #else /* FF_INTERNAL_FIELDS */
613 
614  /**
615  * Queue of frames waiting to be filtered.
616  */
617  FFFrameQueue fifo;
618 
619  /**
620  * If set, the source filter can not generate a frame as is.
621  * The goal is to avoid repeatedly calling the request_frame() method on
622  * the same link.
623  */
624  int frame_blocked_in;
625 
626  /**
627  * Link input status.
628  * If not zero, all attempts of filter_frame will fail with the
629  * corresponding code.
630  */
631  int status_in;
632 
633  /**
634  * Timestamp of the input status change.
635  */
636  int64_t status_in_pts;
637 
638  /**
639  * Link output status.
640  * If not zero, all attempts of request_frame will fail with the
641  * corresponding code.
642  */
643  int status_out;
644 
645 #endif /* FF_INTERNAL_FIELDS */
646 
647 };
648 
649 /**
650  * Link two filters together.
651  *
652  * @param src the source filter
653  * @param srcpad index of the output pad on the source filter
654  * @param dst the destination filter
655  * @param dstpad index of the input pad on the destination filter
656  * @return zero on success
657  */
658 int avfilter_link(AVFilterContext *src, unsigned srcpad,
659  AVFilterContext *dst, unsigned dstpad);
660 
661 /**
662  * Free the link in *link, and set its pointer to NULL.
663  */
665 
666 #if FF_API_FILTER_GET_SET
667 /**
668  * Get the number of channels of a link.
669  * @deprecated Use av_buffersink_get_channels()
670  */
673 #endif
674 
675 /**
676  * Set the closed field of a link.
677  * @deprecated applications are not supposed to mess with links, they should
678  * close the sinks.
679  */
681 void avfilter_link_set_closed(AVFilterLink *link, int closed);
682 
683 /**
684  * Negotiate the media format, dimensions, etc of all inputs to a filter.
685  *
686  * @param filter the filter to negotiate the properties for its inputs
687  * @return zero on successful negotiation
688  */
690 
691 #define AVFILTER_CMD_FLAG_ONE 1 ///< Stop once a filter understood the command (for target=all for example), fast filters are favored automatically
692 #define AVFILTER_CMD_FLAG_FAST 2 ///< Only execute command when its fast (like a video out that supports contrast adjustment in hw)
693 
694 /**
695  * Make the filter instance process a command.
696  * It is recommended to use avfilter_graph_send_command().
697  */
698 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags);
699 
700 /**
701  * Iterate over all registered filters.
702  *
703  * @param opaque a pointer where libavfilter will store the iteration state. Must
704  * point to NULL to start the iteration.
705  *
706  * @return the next registered filter or NULL when the iteration is
707  * finished
708  */
709 const AVFilter *av_filter_iterate(void **opaque);
710 
711 #if FF_API_NEXT
712 /** Initialize the filter system. Register all builtin filters. */
714 void avfilter_register_all(void);
715 
716 /**
717  * Register a filter. This is only needed if you plan to use
718  * avfilter_get_by_name later to lookup the AVFilter structure by name. A
719  * filter can still by instantiated with avfilter_graph_alloc_filter even if it
720  * is not registered.
721  *
722  * @param filter the filter to register
723  * @return 0 if the registration was successful, a negative value
724  * otherwise
725  */
727 int avfilter_register(AVFilter *filter);
728 
729 /**
730  * Iterate over all registered filters.
731  * @return If prev is non-NULL, next registered filter after prev or NULL if
732  * prev is the last filter. If prev is NULL, return the first registered filter.
733  */
735 const AVFilter *avfilter_next(const AVFilter *prev);
736 #endif
737 
738 /**
739  * Get a filter definition matching the given name.
740  *
741  * @param name the filter name to find
742  * @return the filter definition, if any matching one is registered.
743  * NULL if none found.
744  */
745 const AVFilter *avfilter_get_by_name(const char *name);
746 
747 
748 /**
749  * Initialize a filter with the supplied parameters.
750  *
751  * @param ctx uninitialized filter context to initialize
752  * @param args Options to initialize the filter with. This must be a
753  * ':'-separated list of options in the 'key=value' form.
754  * May be NULL if the options have been set directly using the
755  * AVOptions API or there are no options that need to be set.
756  * @return 0 on success, a negative AVERROR on failure
757  */
758 int avfilter_init_str(AVFilterContext *ctx, const char *args);
759 
760 /**
761  * Initialize a filter with the supplied dictionary of options.
762  *
763  * @param ctx uninitialized filter context to initialize
764  * @param options An AVDictionary filled with options for this filter. On
765  * return this parameter will be destroyed and replaced with
766  * a dict containing options that were not found. This dictionary
767  * must be freed by the caller.
768  * May be NULL, then this function is equivalent to
769  * avfilter_init_str() with the second parameter set to NULL.
770  * @return 0 on success, a negative AVERROR on failure
771  *
772  * @note This function and avfilter_init_str() do essentially the same thing,
773  * the difference is in manner in which the options are passed. It is up to the
774  * calling code to choose whichever is more preferable. The two functions also
775  * behave differently when some of the provided options are not declared as
776  * supported by the filter. In such a case, avfilter_init_str() will fail, but
777  * this function will leave those extra options in the options AVDictionary and
778  * continue as usual.
779  */
781 
782 /**
783  * Free a filter context. This will also remove the filter from its
784  * filtergraph's list of filters.
785  *
786  * @param filter the filter to free
787  */
789 
790 /**
791  * Insert a filter in the middle of an existing link.
792  *
793  * @param link the link into which the filter should be inserted
794  * @param filt the filter to be inserted
795  * @param filt_srcpad_idx the input pad on the filter to connect
796  * @param filt_dstpad_idx the output pad on the filter to connect
797  * @return zero on success
798  */
800  unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
801 
802 /**
803  * @return AVClass for AVFilterContext.
804  *
805  * @see av_opt_find().
806  */
807 const AVClass *avfilter_get_class(void);
808 
810 
811 /**
812  * A function pointer passed to the @ref AVFilterGraph.execute callback to be
813  * executed multiple times, possibly in parallel.
814  *
815  * @param ctx the filter context the job belongs to
816  * @param arg an opaque parameter passed through from @ref
817  * AVFilterGraph.execute
818  * @param jobnr the index of the job being executed
819  * @param nb_jobs the total number of jobs
820  *
821  * @return 0 on success, a negative AVERROR on error
822  */
823 typedef int (avfilter_action_func)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
824 
825 /**
826  * A function executing multiple jobs, possibly in parallel.
827  *
828  * @param ctx the filter context to which the jobs belong
829  * @param func the function to be called multiple times
830  * @param arg the argument to be passed to func
831  * @param ret a nb_jobs-sized array to be filled with return values from each
832  * invocation of func
833  * @param nb_jobs the number of jobs to execute
834  *
835  * @return 0 on success, a negative AVERROR on error
836  */
838  void *arg, int *ret, int nb_jobs);
839 
840 typedef struct AVFilterGraph {
843  unsigned nb_filters;
844 
845  char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters
846 #if FF_API_LAVR_OPTS
847  attribute_deprecated char *resample_lavr_opts; ///< libavresample options to use for the auto-inserted resample filters
848 #endif
849 
850  /**
851  * Type of multithreading allowed for filters in this graph. A combination
852  * of AVFILTER_THREAD_* flags.
853  *
854  * May be set by the caller at any point, the setting will apply to all
855  * filters initialized after that. The default is allowing everything.
856  *
857  * When a filter in this graph is initialized, this field is combined using
858  * bit AND with AVFilterContext.thread_type to get the final mask used for
859  * determining allowed threading types. I.e. a threading type needs to be
860  * set in both to be allowed.
861  */
863 
864  /**
865  * Maximum number of threads used by filters in this graph. May be set by
866  * the caller before adding any filters to the filtergraph. Zero (the
867  * default) means that the number of threads is determined automatically.
868  */
870 
871  /**
872  * Opaque object for libavfilter internal use.
873  */
875 
876  /**
877  * Opaque user data. May be set by the caller to an arbitrary value, e.g. to
878  * be used from callbacks like @ref AVFilterGraph.execute.
879  * Libavfilter will not touch this field in any way.
880  */
881  void *opaque;
882 
883  /**
884  * This callback may be set by the caller immediately after allocating the
885  * graph and before adding any filters to it, to provide a custom
886  * multithreading implementation.
887  *
888  * If set, filters with slice threading capability will call this callback
889  * to execute multiple jobs in parallel.
890  *
891  * If this field is left unset, libavfilter will use its internal
892  * implementation, which may or may not be multithreaded depending on the
893  * platform and build options.
894  */
896 
897  char *aresample_swr_opts; ///< swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions
898 
899  /**
900  * Private fields
901  *
902  * The following fields are for internal use only.
903  * Their type, offset, number and semantic can change without notice.
904  */
905 
908 
910 } AVFilterGraph;
911 
912 /**
913  * Allocate a filter graph.
914  *
915  * @return the allocated filter graph on success or NULL.
916  */
918 
919 /**
920  * Create a new filter instance in a filter graph.
921  *
922  * @param graph graph in which the new filter will be used
923  * @param filter the filter to create an instance of
924  * @param name Name to give to the new instance (will be copied to
925  * AVFilterContext.name). This may be used by the caller to identify
926  * different filters, libavfilter itself assigns no semantics to
927  * this parameter. May be NULL.
928  *
929  * @return the context of the newly created filter instance (note that it is
930  * also retrievable directly through AVFilterGraph.filters or with
931  * avfilter_graph_get_filter()) on success or NULL on failure.
932  */
934  const AVFilter *filter,
935  const char *name);
936 
937 /**
938  * Get a filter instance identified by instance name from graph.
939  *
940  * @param graph filter graph to search through.
941  * @param name filter instance name (should be unique in the graph).
942  * @return the pointer to the found filter instance or NULL if it
943  * cannot be found.
944  */
946 
947 /**
948  * Create and add a filter instance into an existing graph.
949  * The filter instance is created from the filter filt and inited
950  * with the parameters args and opaque.
951  *
952  * In case of success put in *filt_ctx the pointer to the created
953  * filter instance, otherwise set *filt_ctx to NULL.
954  *
955  * @param name the instance name to give to the created filter instance
956  * @param graph_ctx the filter graph
957  * @return a negative AVERROR error code in case of failure, a non
958  * negative value otherwise
959  */
961  const char *name, const char *args, void *opaque,
962  AVFilterGraph *graph_ctx);
963 
964 /**
965  * Enable or disable automatic format conversion inside the graph.
966  *
967  * Note that format conversion can still happen inside explicitly inserted
968  * scale and aresample filters.
969  *
970  * @param flags any of the AVFILTER_AUTO_CONVERT_* constants
971  */
973 
974 enum {
975  AVFILTER_AUTO_CONVERT_ALL = 0, /**< all automatic conversions enabled */
976  AVFILTER_AUTO_CONVERT_NONE = -1, /**< all automatic conversions disabled */
977 };
978 
979 /**
980  * Check validity and configure all the links and formats in the graph.
981  *
982  * @param graphctx the filter graph
983  * @param log_ctx context used for logging
984  * @return >= 0 in case of success, a negative AVERROR code otherwise
985  */
986 int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx);
987 
988 /**
989  * Free a graph, destroy its links, and set *graph to NULL.
990  * If *graph is NULL, do nothing.
991  */
992 void avfilter_graph_free(AVFilterGraph **graph);
993 
994 /**
995  * A linked-list of the inputs/outputs of the filter chain.
996  *
997  * This is mainly useful for avfilter_graph_parse() / avfilter_graph_parse2(),
998  * where it is used to communicate open (unlinked) inputs and outputs from and
999  * to the caller.
1000  * This struct specifies, per each not connected pad contained in the graph, the
1001  * filter context and the pad index required for establishing a link.
1002  */
1003 typedef struct AVFilterInOut {
1004  /** unique name for this input/output in the list */
1005  char *name;
1006 
1007  /** filter context associated to this input/output */
1009 
1010  /** index of the filt_ctx pad to use for linking */
1011  int pad_idx;
1012 
1013  /** next input/input in the list, NULL if this is the last */
1015 } AVFilterInOut;
1016 
1017 /**
1018  * Allocate a single AVFilterInOut entry.
1019  * Must be freed with avfilter_inout_free().
1020  * @return allocated AVFilterInOut on success, NULL on failure.
1021  */
1023 
1024 /**
1025  * Free the supplied list of AVFilterInOut and set *inout to NULL.
1026  * If *inout is NULL, do nothing.
1027  */
1028 void avfilter_inout_free(AVFilterInOut **inout);
1029 
1030 /**
1031  * Add a graph described by a string to a graph.
1032  *
1033  * @note The caller must provide the lists of inputs and outputs,
1034  * which therefore must be known before calling the function.
1035  *
1036  * @note The inputs parameter describes inputs of the already existing
1037  * part of the graph; i.e. from the point of view of the newly created
1038  * part, they are outputs. Similarly the outputs parameter describes
1039  * outputs of the already existing filters, which are provided as
1040  * inputs to the parsed filters.
1041  *
1042  * @param graph the filter graph where to link the parsed graph context
1043  * @param filters string to be parsed
1044  * @param inputs linked list to the inputs of the graph
1045  * @param outputs linked list to the outputs of the graph
1046  * @return zero on success, a negative AVERROR code on error
1047  */
1048 int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
1050  void *log_ctx);
1051 
1052 /**
1053  * Add a graph described by a string to a graph.
1054  *
1055  * In the graph filters description, if the input label of the first
1056  * filter is not specified, "in" is assumed; if the output label of
1057  * the last filter is not specified, "out" is assumed.
1058  *
1059  * @param graph the filter graph where to link the parsed graph context
1060  * @param filters string to be parsed
1061  * @param inputs pointer to a linked list to the inputs of the graph, may be NULL.
1062  * If non-NULL, *inputs is updated to contain the list of open inputs
1063  * after the parsing, should be freed with avfilter_inout_free().
1064  * @param outputs pointer to a linked list to the outputs of the graph, may be NULL.
1065  * If non-NULL, *outputs is updated to contain the list of open outputs
1066  * after the parsing, should be freed with avfilter_inout_free().
1067  * @return non negative on success, a negative AVERROR code on error
1068  */
1069 int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters,
1071  void *log_ctx);
1072 
1073 /**
1074  * Add a graph described by a string to a graph.
1075  *
1076  * @param[in] graph the filter graph where to link the parsed graph context
1077  * @param[in] filters string to be parsed
1078  * @param[out] inputs a linked list of all free (unlinked) inputs of the
1079  * parsed graph will be returned here. It is to be freed
1080  * by the caller using avfilter_inout_free().
1081  * @param[out] outputs a linked list of all free (unlinked) outputs of the
1082  * parsed graph will be returned here. It is to be freed by the
1083  * caller using avfilter_inout_free().
1084  * @return zero on success, a negative AVERROR code on error
1085  *
1086  * @note This function returns the inputs and outputs that are left
1087  * unlinked after parsing the graph and the caller then deals with
1088  * them.
1089  * @note This function makes no reference whatsoever to already
1090  * existing parts of the graph and the inputs parameter will on return
1091  * contain inputs of the newly parsed part of the graph. Analogously
1092  * the outputs parameter will contain outputs of the newly created
1093  * filters.
1094  */
1095 int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
1098 
1099 /**
1100  * Send a command to one or more filter instances.
1101  *
1102  * @param graph the filter graph
1103  * @param target the filter(s) to which the command should be sent
1104  * "all" sends to all filters
1105  * otherwise it can be a filter or filter instance name
1106  * which will send the command to all matching filters.
1107  * @param cmd the command to send, for handling simplicity all commands must be alphanumeric only
1108  * @param arg the argument for the command
1109  * @param res a buffer with size res_size where the filter(s) can return a response.
1110  *
1111  * @returns >=0 on success otherwise an error code.
1112  * AVERROR(ENOSYS) on unsupported commands
1113  */
1114 int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags);
1115 
1116 /**
1117  * Queue a command for one or more filter instances.
1118  *
1119  * @param graph the filter graph
1120  * @param target the filter(s) to which the command should be sent
1121  * "all" sends to all filters
1122  * otherwise it can be a filter or filter instance name
1123  * which will send the command to all matching filters.
1124  * @param cmd the command to sent, for handling simplicity all commands must be alphanumeric only
1125  * @param arg the argument for the command
1126  * @param ts time at which the command should be sent to the filter
1127  *
1128  * @note As this executes commands after this function returns, no return code
1129  * from the filter is provided, also AVFILTER_CMD_FLAG_ONE is not supported.
1130  */
1131 int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts);
1132 
1133 
1134 /**
1135  * Dump a graph into a human-readable string representation.
1136  *
1137  * @param graph the graph to dump
1138  * @param options formatting options; currently ignored
1139  * @return a string, or NULL in case of memory allocation failure;
1140  * the string must be freed using av_free
1141  */
1142 char *avfilter_graph_dump(AVFilterGraph *graph, const char *options);
1143 
1144 /**
1145  * Request a frame on the oldest sink link.
1146  *
1147  * If the request returns AVERROR_EOF, try the next.
1148  *
1149  * Note that this function is not meant to be the sole scheduling mechanism
1150  * of a filtergraph, only a convenience function to help drain a filtergraph
1151  * in a balanced way under normal circumstances.
1152  *
1153  * Also note that AVERROR_EOF does not mean that frames did not arrive on
1154  * some of the sinks during the process.
1155  * When there are multiple sink links, in case the requested link
1156  * returns an EOF, this may cause a filter to flush pending frames
1157  * which are sent to another sink link, although unrequested.
1158  *
1159  * @return the return value of ff_request_frame(),
1160  * or AVERROR_EOF if all links returned AVERROR_EOF
1161  */
1163 
1164 /**
1165  * @}
1166  */
1167 
1168 #endif /* AVFILTER_AVFILTER_H */
AVFilterContext ** filters
Definition: avfilter.h:842
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
double * var_values
variable values for the enable expression
Definition: avfilter.h:384
int sink_links_count
Definition: avfilter.h:907
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts)
Queue a command for one or more filter instances.
int thread_type
Type of multithreading allowed for filters in this graph.
Definition: avfilter.h:862
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:760
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:83
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:203
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
Definition: avfilter.h:1014
Queue of AVFrame pointers.
Definition: framequeue.h:53
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:1039
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the status_in
Libavfilter version macros.
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
AVBufferRef * hw_device_ctx
For filters which will create hardware frames, sets the device the filter should create them in...
Definition: avfilter.h:394
Convenience header that includes libavutil&#39;s core.
GLint GLenum type
Definition: opengl_enc.c:105
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: avfilter.h:327
#define src
Definition: vp8dsp.c:254
int thread_type
Type of multithreading being allowed/used.
Definition: avfilter.h:373
void(* uninit)(AVFilterContext *ctx)
Filter uninitialization function.
Definition: avfilter.h:258
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:385
Macro definitions for various function/variable attributes.
int nb_threads
Max number of threads allowed in this filter instance.
Definition: avfilter.h:401
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
Definition: avfilter.h:845
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:355
int(* init_dict)(AVFilterContext *ctx, AVDictionary **options)
Should be set instead of init by the filters that want to pass a dictionary of AVOptions to nested co...
Definition: avfilter.h:246
int priv_size
size of private data to allocate for the filter
Definition: avfilter.h:284
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
char * name
name of this filter instance
Definition: avfilter.h:343
Public dictionary API.
avfilter_execute_func * execute
This callback may be set by the caller immediately after allocating the graph and before adding any f...
Definition: avfilter.h:895
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:135
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:349
const char * avfilter_license(void)
Return the libavfilter license.
Definition: avfilter.c:88
unsigned ready
Ready status of the filter.
Definition: avfilter.h:408
int( avfilter_execute_func)(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
A function executing multiple jobs, possibly in parallel.
Definition: avfilter.h:837
int flags
A combination of AVFILTER_FLAG_*.
Definition: avfilter.h:187
int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx)
Create and add a filter instance into an existing graph.
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:869
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
Definition: avfilter.c:277
AVFilterContext * avfilter_graph_get_filter(AVFilterGraph *graph, const char *name)
Get a filter instance identified by instance name from graph.
int(* preinit)(AVFilterContext *ctx)
Filter pre-initialization function.
Definition: avfilter.h:210
int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs)
Add a graph described by a string to a graph.
Definition: graphparser.c:407
int extra_hw_frames
Sets the number of extra hardware frames which the filter will allocate on its output links for use i...
Definition: avfilter.h:424
A filter pad used for either input or output.
Definition: internal.h:54
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:345
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
const AVClass * av_class
Definition: avfilter.h:841
unsigned nb_outputs
number of output pads
Definition: avfilter.h:351
unsigned avfilter_version(void)
Return the LIBAVFILTER_VERSION_INT constant.
Definition: avfilter.c:77
void * priv
private data for use by the filter
Definition: avfilter.h:353
char * enable_str
enable expression string
Definition: avfilter.h:382
const char * arg
Definition: jacosubdec.c:66
AVFilterLink ** sink_links
Private fields.
Definition: avfilter.h:906
reference-counted frame API
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:475
attribute_deprecated void avfilter_link_set_closed(AVFilterLink *link, int closed)
Set the closed field of a link.
Definition: avfilter.c:235
unsigned nb_inputs
number of input pads
Definition: avfilter.h:347
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
AVFormatContext * ctx
Definition: movenc.c:48
int(* init)(AVFilterContext *ctx)
Filter initialization function.
Definition: avfilter.h:233
int flags_internal
Additional flags for avfilter internal use only.
Definition: avfilter.h:286
AVFilterContext * filter_ctx
filter context associated to this input/output
Definition: avfilter.h:1008
int( avfilter_action_func)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
A function pointer passed to the AVFilterGraph::execute callback to be executed multiple times...
Definition: avfilter.h:823
A list of supported channel layouts.
Definition: formats.h:85
int avfilter_init_str(AVFilterContext *ctx, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:924
const AVFilterPad * inputs
List of inputs, terminated by a zeroed element.
Definition: avfilter.h:164
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1635
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:1003
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
Insert a filter in the middle of an existing link.
Definition: avfilter.c:240
all automatic conversions disabled
Definition: avfilter.h:976
const AVClass * priv_class
A class for the private data, used to declare filter private AVOptions.
Definition: avfilter.h:182
int(* process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
Definition: avfilter.h:306
int avfilter_graph_request_oldest(AVFilterGraph *graph)
Request a frame on the oldest sink link.
int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
Definition: avfilter.c:557
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut *inputs, AVFilterInOut *outputs, void *log_ctx)
Add a graph described by a string to a graph.
Definition: graphparser.c:475
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
int pad_idx
index of the filt_ctx pad to use for linking
Definition: avfilter.h:1011
Rational number (pair of numerator and denominator).
Definition: rational.h:58
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:464
int(* query_formats)(AVFilterContext *)
Query formats supported by the filter on its inputs and outputs.
Definition: avfilter.h:282
struct AVFilter * next
Used by the filter registration system.
Definition: avfilter.h:292
AVMediaType
Definition: avutil.h:199
refcounted data buffer API
const char * name
Filter name.
Definition: avfilter.h:148
unsigned nb_filters
Definition: avfilter.h:843
const char * avfilter_configuration(void)
Return the libavfilter build-time configuration.
Definition: avfilter.c:83
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:1034
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
int avfilter_link_get_channels(AVFilterLink *link)
Definition: avfilter.c:187
char * name
unique name for this input/output in the list
Definition: avfilter.h:1005
static const int8_t filt[NUMTAPS]
Definition: af_earwax.c:39
int(* init_opaque)(AVFilterContext *ctx, void *opaque)
Filter initialization function, alternative to the init() callback.
Definition: avfilter.h:313
#define attribute_deprecated
Definition: attributes.h:94
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
Initialize a filter with the supplied dictionary of options.
Definition: avfilter.c:887
A reference to a data buffer.
Definition: buffer.h:81
void * opaque
Opaque user data.
Definition: avfilter.h:881
int
const OptionDef options[]
Definition: ffmpeg_opt.c:3362
AVFilterInOut * avfilter_inout_alloc(void)
Allocate a single AVFilterInOut entry.
Definition: graphparser.c:198
Utilties for rational number calculation.
struct AVFilterCommand * command_queue
Definition: avfilter.h:380
char * avfilter_graph_dump(AVFilterGraph *graph, const char *options)
Dump a graph into a human-readable string representation.
Definition: graphdump.c:154
int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
Send a command to one or more filter instances.
char * aresample_swr_opts
swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions ...
Definition: avfilter.h:897
pixel format definitions
const char * description
A description of the filter.
Definition: avfilter.h:155
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
void * enable
parsed expression (AVExpr*)
Definition: avfilter.h:383
const AVClass * av_class
needed for av_log() and filters common options
Definition: avfilter.h:339
static const struct PPFilter filters[]
Definition: postprocess.c:134
A list of supported formats for one end of a filter link.
Definition: formats.h:64
int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)
Add a graph described by a string to a graph.
Definition: graphparser.c:538
An instance of a filter.
Definition: avfilter.h:338
int avfilter_pad_count(const AVFilterPad *pads)
Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
Definition: avfilter.c:578
const AVFilterPad * outputs
List of outputs, terminated by a zeroed element.
Definition: avfilter.h:172
void avfilter_link_free(AVFilterLink **link)
Free the link in *link, and set its pointer to NULL.
Definition: avfilter.c:174
all automatic conversions enabled
Definition: avfilter.h:975
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
unsigned disable_auto_convert
Definition: avfilter.h:909
const char * name
Definition: opengl_enc.c:103