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 
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  */
86 int avfilter_pad_count(const AVFilterPad *pads);
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  */
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  */
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  */
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  */
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  */
356  /**
357  * Equivalent to { sample_fmt, AV_SAMPLE_FMT_NONE } as samples_list.
358  */
360  } formats;
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  */
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 
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
598  } init_state;
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  */
767 const AVFilter *av_filter_iterate(void **opaque);
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  */
838 const AVClass *avfilter_get_class(void);
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  */
1020 void avfilter_graph_free(AVFilterGraph **graph);
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  */
1056 void avfilter_inout_free(AVFilterInOut **inout);
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,
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,
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,
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 */
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:68
AVFilterGraph::execute
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
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVFilterContext::nb_threads
int nb_threads
Max number of threads allowed in this filter instance.
Definition: avfilter.h:471
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVFilterFormatsConfig::samplerates
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:517
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
avfilter_filter_pad_count
unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
Get the number of elements in an AVFilter's inputs or outputs array.
Definition: avfilter.c:574
AVFilterGraph::nb_threads
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:897
avfilter_pad_get_name
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:953
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:522
AVFilter::pixels_list
enum AVPixelFormat * pixels_list
A pointer to an array of admissible pixel formats delimited by AV_PIX_FMT_NONE.
Definition: avfilter.h:340
AVFilter::priv_class
const AVClass * priv_class
A class for the private data, used to declare filter private AVOptions.
Definition: avfilter.h:210
avfilter_action_func
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
AVFilterContext::var_values
double * var_values
variable values for the enable expression
Definition: avfilter.h:454
AVFilter::pix_fmt
enum AVPixelFormat pix_fmt
Equivalent to { pix_fmt, AV_PIX_FMT_NONE } as pixels_list.
Definition: avfilter.h:355
rational.h
AVFilterContext::is_disabled
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:455
AVFilter::process_command
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
AVFilterInOut::next
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
Definition: avfilter.h:1042
AVFilterContext::nb_outputs
unsigned nb_outputs
number of output pads
Definition: avfilter.h:421
AVFilterContext::av_class
const AVClass * av_class
needed for av_log() and filters common options
Definition: avfilter.h:409
AVFilterGraph::disable_auto_convert
unsigned disable_auto_convert
Definition: avfilter.h:937
AVFilterContext::hw_device_ctx
AVBufferRef * hw_device_ctx
For filters which will create hardware frames, sets the device the filter should create them in.
Definition: avfilter.h:464
AVFilterGraphInternal
Definition: internal.h:132
filter
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
Definition: filter_design.txt:228
AVDictionary
Definition: dict.c:30
AVFilterContext::output_pads
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:419
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
avfilter_graph_free
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
Definition: avfiltergraph.c:119
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
avfilter_graph_create_filter
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.
Definition: avfiltergraph.c:138
avfilter_graph_alloc_filter
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
Definition: avfiltergraph.c:165
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:423
AVFilterContext::graph
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:425
AVFilterContext::enable_str
char * enable_str
enable expression string
Definition: avfilter.h:452
avfilter_graph_alloc
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:82
AVFilter::formats_state
uint8_t formats_state
This field determines the state of the formats union.
Definition: avfilter.h:239
avfilter_insert_filter
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:233
av_filter_iterate
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:585
samplefmt.h
AVFilterContext::extra_hw_frames
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
avfilter_config_links
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
Definition: avfilter.c:270
AVFilterGraph::opaque
void * opaque
Opaque user data.
Definition: avfilter.h:909
AVFilter::flags_internal
int flags_internal
Additional flags for avfilter internal use only.
Definition: avfilter.h:364
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
avfilter_license
const char * avfilter_license(void)
Return the libavfilter license.
Definition: version.c:40
AVFilterContext::input_pads
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:415
avfilter_inout_free
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:212
AVFilter::samples_list
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
avfilter_process_command
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:532
filters
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
Definition: af_crystalizer.c:55
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:172
AVFilter::flags
int flags
A combination of AVFILTER_FLAG_*.
Definition: avfilter.h:215
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AVFilterGraph::aresample_swr_opts
char * aresample_swr_opts
swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions
Definition: avfilter.h:925
link
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
Definition: filter_design.txt:23
arg
const char * arg
Definition: jacosubdec.c:67
AVFilter::activate
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: avfilter.h:392
avfilter_get_by_name
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:596
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVFilterContext::thread_type
int thread_type
Type of multithreading being allowed/used.
Definition: avfilter.h:443
avfilter_graph_config
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
Definition: avfiltergraph.c:1167
AVFILTER_AUTO_CONVERT_NONE
@ AVFILTER_AUTO_CONVERT_NONE
all automatic conversions disabled
Definition: avfilter.h:1004
AVFilter::outputs
const AVFilterPad * outputs
List of static outputs.
Definition: avfilter.h:200
avfilter_graph_set_auto_convert
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
Definition: avfiltergraph.c:160
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVFilterGraph::filters
AVFilterContext ** filters
Definition: avfilter.h:873
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:416
AVFilterInternal
Definition: internal.h:138
AVFilterContext::name
char * name
name of this filter instance
Definition: avfilter.h:413
avfilter_inout_alloc
AVFilterInOut * avfilter_inout_alloc(void)
Allocate a single AVFilterInOut entry.
Definition: graphparser.c:207
avfilter_graph_get_filter
AVFilterContext * avfilter_graph_get_filter(AVFilterGraph *graph, const char *name)
Get a filter instance identified by instance name from graph.
Definition: avfiltergraph.c:283
avfilter_graph_request_oldest
int avfilter_graph_request_oldest(AVFilterGraph *graph)
Request a frame on the oldest sink link.
Definition: avfiltergraph.c:1295
AVFILTER_AUTO_CONVERT_ALL
@ AVFILTER_AUTO_CONVERT_ALL
all automatic conversions enabled
Definition: avfilter.h:1003
AVFilterGraph
Definition: avfilter.h:871
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
avfilter_graph_parse2
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:418
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:507
AVFilterInOut::pad_idx
int pad_idx
index of the filt_ctx pad to use for linking
Definition: avfilter.h:1039
FFFrameQueue
Queue of AVFrame pointers.
Definition: framequeue.h:53
AVFilterGraph::scale_sws_opts
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
Definition: avfilter.h:876
options
const OptionDef options[]
AVFilterContext::nb_inputs
unsigned nb_inputs
number of input pads
Definition: avfilter.h:417
AVFilterGraph::av_class
const AVClass * av_class
Definition: avfilter.h:872
AVMediaType
AVMediaType
Definition: avutil.h:199
AVFilterContext::command_queue
struct AVFilterCommand * command_queue
Definition: avfilter.h:450
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
AVFilterInOut::filter_ctx
AVFilterContext * filter_ctx
filter context associated to this input/output
Definition: avfilter.h:1036
avfilter_execute_func
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
AVFilter::preinit
int(* preinit)(AVFilterContext *ctx)
Filter pre-initialization function.
Definition: avfilter.h:254
avfilter_link
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:140
avfilter_graph_queue_command
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.
Definition: avfiltergraph.c:1215
frame.h
AVFilter::description
const char * description
A description of the filter.
Definition: avfilter.h:182
avfilter_link_free
void avfilter_link_free(AVFilterLink **link)
Free the link in *link, and set its pointer to NULL.
Definition: avfilter.c:179
buffer.h
attribute_deprecated
#define attribute_deprecated
Definition: attributes.h:104
attributes.h
AVFilter::nb_inputs
uint8_t nb_inputs
The number of entries in the list of inputs.
Definition: avfilter.h:228
AVFilter::init
int(* init)(AVFilterContext *ctx)
Filter initialization function.
Definition: avfilter.h:277
avfilter_init_str
int avfilter_init_str(AVFilterContext *ctx, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:919
AVFilter::query_func
int(* query_func)(AVFilterContext *)
Query formats supported by the filter on its inputs and outputs.
Definition: avfilter.h:329
log.h
avfilter_graph_parse_ptr
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:549
AVFilterCommand
Definition: internal.h:33
version_major.h
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AVFilterGraph::thread_type
int thread_type
Type of multithreading allowed for filters in this graph.
Definition: avfilter.h:890
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:39
AVFilter::priv_size
int priv_size
size of private data to allocate for the filter
Definition: avfilter.h:362
AVFilter::formats
union AVFilter::@208 formats
The state of the following union is determined by formats_state.
AVFilter
Filter definition.
Definition: avfilter.h:171
ret
ret
Definition: filter_design.txt:187
AVFilterGraph::sink_links
AVFilterLink ** sink_links
Private fields.
Definition: avfilter.h:934
pixfmt.h
avfilter_configuration
const char * avfilter_configuration(void)
Return the libavfilter build-time configuration.
Definition: version.c:35
avfilter_graph_dump
char * avfilter_graph_dump(AVFilterGraph *graph, const char *options)
Dump a graph into a human-readable string representation.
Definition: graphdump.c:157
dict.h
AVFilter::nb_outputs
uint8_t nb_outputs
The number of entries in the list of outputs.
Definition: avfilter.h:233
avfilter_pad_get_type
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:958
avfilter_init_dict
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
Initialize a filter with the supplied dictionary of options.
Definition: avfilter.c:876
version.h
AVFilterContext::enable
void * enable
parsed expression (AVExpr*)
Definition: avfilter.h:453
AVFilterContext
An instance of a filter.
Definition: avfilter.h:408
avfilter_graph_parse
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:486
avutil.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:512
AVFilter::inputs
const AVFilterPad * inputs
List of static inputs.
Definition: avfilter.h:191
AVFilter::uninit
void(* uninit)(AVFilterContext *ctx)
Filter uninitialization function.
Definition: avfilter.h:302
avfilter_free
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:737
AVFilter::sample_fmt
enum AVSampleFormat sample_fmt
Equivalent to { sample_fmt, AV_SAMPLE_FMT_NONE } as samples_list.
Definition: avfilter.h:359
status_in
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
Definition: filter_design.txt:154
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVFilterInOut::name
char * name
unique name for this input/output in the list
Definition: avfilter.h:1033
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
avfilter_graph_send_command
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.
Definition: avfiltergraph.c:1185
AVFilterGraph::nb_filters
unsigned nb_filters
Definition: avfilter.h:874
AVFilterContext::filter
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:411
AVFilter::init_dict
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
int
int
Definition: ffmpeg_filter.c:155
avfilter_version
unsigned avfilter_version(void)
Return the LIBAVFILTER_VERSION_INT constant.
Definition: version.c:29
avfilter_get_class
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1547
AVFilterInOut
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:1031
AVFilterGraph::sink_links_count
int sink_links_count
Definition: avfilter.h:935
AVFilterContext::ready
unsigned ready
Ready status of the filter.
Definition: avfilter.h:478
AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:420