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