#ifndef AVFILTER_AVFILTER_H
#define AVFILTER_AVFILTER_H
+/**
+ * @file
+ * @ingroup lavfi
+ * Main libavfilter public API header
+ */
+
+/**
+ * @defgroup lavfi Libavfilter - graph-based frame editing library
+ * @{
+ */
+
+#include "libavutil/attributes.h"
#include "libavutil/avutil.h"
+#include "libavutil/buffer.h"
#include "libavutil/frame.h"
#include "libavutil/log.h"
#include "libavutil/samplefmt.h"
#include "libavutil/pixfmt.h"
#include "libavutil/rational.h"
-#include "libavcodec/avcodec.h"
#include <stddef.h>
typedef struct AVFilterPad AVFilterPad;
typedef struct AVFilterFormats AVFilterFormats;
-#if FF_API_AVFILTERBUFFER
-/**
- * A reference-counted buffer data type used by the filter system. Filters
- * should not store pointers to this structure directly, but instead use the
- * AVFilterBufferRef structure below.
- */
-typedef struct AVFilterBuffer {
- uint8_t *data[8]; ///< buffer data for each plane/channel
-
- /**
- * pointers to the data planes/channels.
- *
- * For video, this should simply point to data[].
- *
- * For planar audio, each channel has a separate data pointer, and
- * linesize[0] contains the size of each channel buffer.
- * For packed audio, there is just one data pointer, and linesize[0]
- * contains the total size of the buffer for all channels.
- *
- * Note: Both data and extended_data will always be set, but for planar
- * audio with more channels that can fit in data, extended_data must be used
- * in order to access all channels.
- */
- uint8_t **extended_data;
- int linesize[8]; ///< number of bytes per line
-
- /** private data to be used by a custom free function */
- void *priv;
- /**
- * A pointer to the function to deallocate this buffer if the default
- * function is not sufficient. This could, for example, add the memory
- * back into a memory pool to be reused later without the overhead of
- * reallocating it from scratch.
- */
- void (*free)(struct AVFilterBuffer *buf);
-
- int format; ///< media format
- int w, h; ///< width and height of the allocated buffer
- unsigned refcount; ///< number of references to this buffer
-} AVFilterBuffer;
-
-#define AV_PERM_READ 0x01 ///< can read from the buffer
-#define AV_PERM_WRITE 0x02 ///< can write to the buffer
-#define AV_PERM_PRESERVE 0x04 ///< nobody else can overwrite the buffer
-#define AV_PERM_REUSE 0x08 ///< can output the buffer multiple times, with the same contents each time
-#define AV_PERM_REUSE2 0x10 ///< can output the buffer multiple times, modified each time
-#define AV_PERM_NEG_LINESIZES 0x20 ///< the buffer requested can have negative linesizes
-
-/**
- * Audio specific properties in a reference to an AVFilterBuffer. Since
- * AVFilterBufferRef is common to different media formats, audio specific
- * per reference properties must be separated out.
- */
-typedef struct AVFilterBufferRefAudioProps {
- uint64_t channel_layout; ///< channel layout of audio buffer
- int nb_samples; ///< number of audio samples
- int sample_rate; ///< audio buffer sample rate
- int planar; ///< audio buffer - planar or packed
-} AVFilterBufferRefAudioProps;
-
-/**
- * Video specific properties in a reference to an AVFilterBuffer. Since
- * AVFilterBufferRef is common to different media formats, video specific
- * per reference properties must be separated out.
- */
-typedef struct AVFilterBufferRefVideoProps {
- int w; ///< image width
- int h; ///< image height
- AVRational pixel_aspect; ///< pixel aspect ratio
- int interlaced; ///< is frame interlaced
- int top_field_first; ///< field order
- enum AVPictureType pict_type; ///< picture type of the frame
- int key_frame; ///< 1 -> keyframe, 0-> not
-} AVFilterBufferRefVideoProps;
-
-/**
- * A reference to an AVFilterBuffer. Since filters can manipulate the origin of
- * a buffer to, for example, crop image without any memcpy, the buffer origin
- * and dimensions are per-reference properties. Linesize is also useful for
- * image flipping, frame to field filters, etc, and so is also per-reference.
- *
- * TODO: add anything necessary for frame reordering
- */
-typedef struct AVFilterBufferRef {
- AVFilterBuffer *buf; ///< the buffer that this is a reference to
- uint8_t *data[8]; ///< picture/audio data for each plane
- /**
- * pointers to the data planes/channels.
- *
- * For video, this should simply point to data[].
- *
- * For planar audio, each channel has a separate data pointer, and
- * linesize[0] contains the size of each channel buffer.
- * For packed audio, there is just one data pointer, and linesize[0]
- * contains the total size of the buffer for all channels.
- *
- * Note: Both data and extended_data will always be set, but for planar
- * audio with more channels that can fit in data, extended_data must be used
- * in order to access all channels.
- */
- uint8_t **extended_data;
- int linesize[8]; ///< number of bytes per line
-
- AVFilterBufferRefVideoProps *video; ///< video buffer specific properties
- AVFilterBufferRefAudioProps *audio; ///< audio buffer specific properties
-
- /**
- * presentation timestamp. The time unit may change during
- * filtering, as it is specified in the link and the filter code
- * may need to rescale the PTS accordingly.
- */
- int64_t pts;
- int64_t pos; ///< byte position in stream, -1 if unknown
-
- int format; ///< media format
-
- int perms; ///< permissions, see the AV_PERM_* flags
-
- enum AVMediaType type; ///< media type of buffer data
-} AVFilterBufferRef;
-
-/**
- * Copy properties of src to dst, without copying the actual data
- */
-attribute_deprecated
-void avfilter_copy_buffer_ref_props(AVFilterBufferRef *dst, AVFilterBufferRef *src);
-
-/**
- * Add a new reference to a buffer.
- *
- * @param ref an existing reference to the buffer
- * @param pmask a bitmask containing the allowable permissions in the new
- * reference
- * @return a new reference to the buffer with the same properties as the
- * old, excluding any permissions denied by pmask
- */
-attribute_deprecated
-AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask);
-
-/**
- * Remove a reference to a buffer. If this is the last reference to the
- * buffer, the buffer itself is also automatically freed.
- *
- * @param ref reference to the buffer, may be NULL
- *
- * @note it is recommended to use avfilter_unref_bufferp() instead of this
- * function
- */
-attribute_deprecated
-void avfilter_unref_buffer(AVFilterBufferRef *ref);
-
-/**
- * Remove a reference to a buffer and set the pointer to NULL.
- * If this is the last reference to the buffer, the buffer itself
- * is also automatically freed.
- *
- * @param ref pointer to the buffer reference
- */
-attribute_deprecated
-void avfilter_unref_bufferp(AVFilterBufferRef **ref);
-#endif
-
-#if FF_API_AVFILTERPAD_PUBLIC
-/**
- * A filter pad used for either input or output.
- *
- * @warning this struct will be removed from public API.
- * users should call avfilter_pad_get_name() and avfilter_pad_get_type()
- * to access the name and type fields; there should be no need to access
- * any other fields from outside of libavfilter.
- */
-struct AVFilterPad {
- /**
- * Pad name. The name is unique among inputs and among outputs, but an
- * input may have the same name as an output. This may be NULL if this
- * pad has no need to ever be referenced by name.
- */
- const char *name;
-
- /**
- * AVFilterPad type.
- */
- enum AVMediaType type;
-
- /**
- * Minimum required permissions on incoming buffers. Any buffer with
- * insufficient permissions will be automatically copied by the filter
- * system to a new buffer which provides the needed access permissions.
- *
- * Input pads only.
- */
- attribute_deprecated int min_perms;
-
- /**
- * Permissions which are not accepted on incoming buffers. Any buffer
- * which has any of these permissions set will be automatically copied
- * by the filter system to a new buffer which does not have those
- * permissions. This can be used to easily disallow buffers with
- * AV_PERM_REUSE.
- *
- * Input pads only.
- */
- attribute_deprecated int rej_perms;
-
- /**
- * @deprecated unused
- */
- int (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref);
-
- /**
- * Callback function to get a video buffer. If NULL, the filter system will
- * use avfilter_default_get_video_buffer().
- *
- * Input video pads only.
- */
- AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h);
-
- /**
- * Callback function to get an audio buffer. If NULL, the filter system will
- * use avfilter_default_get_audio_buffer().
- *
- * Input audio pads only.
- */
- AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples);
-
- /**
- * @deprecated unused
- */
- int (*end_frame)(AVFilterLink *link);
-
- /**
- * @deprecated unused
- */
- int (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir);
-
- /**
- * Filtering callback. This is where a filter receives a frame with
- * audio/video data and should do its processing.
- *
- * Input pads only.
- *
- * @return >= 0 on success, a negative AVERROR on error. This function
- * must ensure that samplesref is properly unreferenced on error if it
- * hasn't been passed on to another filter.
- */
- int (*filter_frame)(AVFilterLink *link, AVFrame *frame);
-
- /**
- * Frame poll callback. This returns the number of immediately available
- * samples. It should return a positive value if the next request_frame()
- * is guaranteed to return one frame (with no delay).
- *
- * Defaults to just calling the source poll_frame() method.
- *
- * Output pads only.
- */
- int (*poll_frame)(AVFilterLink *link);
-
- /**
- * Frame request callback. A call to this should result in at least one
- * frame being output over the given link. This should return zero on
- * success, and another value on error.
- *
- * Output pads only.
- */
- int (*request_frame)(AVFilterLink *link);
-
- /**
- * Link configuration callback.
- *
- * For output pads, this should set the link properties such as
- * width/height. This should NOT set the format property - that is
- * negotiated between filters by the filter system using the
- * query_formats() callback before this function is called.
- *
- * For input pads, this should check the properties of the link, and update
- * the filter's internal state as necessary.
- *
- * For both input and output filters, this should return zero on success,
- * and another value on error.
- */
- int (*config_props)(AVFilterLink *link);
-
- /**
- * The filter expects a fifo to be inserted on its input link,
- * typically because it has a delay.
- *
- * input pads only.
- */
- int needs_fifo;
-
- int needs_writable;
-};
-#endif
-
/**
* Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
* AVFilter.inputs/outputs).
* the options supplied to it.
*/
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS (1 << 1)
+/**
+ * The filter supports multithreading by splitting frames into multiple parts
+ * and processing them concurrently.
+ */
+#define AVFILTER_FLAG_SLICE_THREADS (1 << 2)
/**
* Filter definition. This defines the pads a filter contains, and all the
* callback functions used to interact with the filter.
*/
typedef struct AVFilter {
- const char *name; ///< filter name
+ /**
+ * Filter name. Must be non-NULL and unique among filters.
+ */
+ const char *name;
/**
- * A description for the filter. You should use the
- * NULL_IF_CONFIG_SMALL() macro to define it.
+ * A description of the filter. May be NULL.
+ *
+ * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
*/
const char *description;
- const AVFilterPad *inputs; ///< NULL terminated list of inputs. NULL if none
- const AVFilterPad *outputs; ///< NULL terminated list of outputs. NULL if none
+ /**
+ * List of inputs, terminated by a zeroed element.
+ *
+ * NULL if there are no (static) inputs. Instances of filters with
+ * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in
+ * this list.
+ */
+ const AVFilterPad *inputs;
+ /**
+ * List of outputs, terminated by a zeroed element.
+ *
+ * NULL if there are no (static) outputs. Instances of filters with
+ * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in
+ * this list.
+ */
+ const AVFilterPad *outputs;
/**
- * A class for the private data, used to access filter private
- * AVOptions.
+ * A class for the private data, used to declare filter private AVOptions.
+ * This field is NULL for filters that do not declare any options.
+ *
+ * If this field is non-NULL, the first member of the filter private data
+ * must be a pointer to AVClass, which will be set by libavfilter generic
+ * code to this class.
*/
const AVClass *priv_class;
*/
/**
- * Filter initialization function. Called when all the options have been
- * set.
+ * Filter initialization function.
+ *
+ * This callback will be called only once during the filter lifetime, after
+ * all the options have been set, but before links between filters are
+ * established and format negotiation is done.
+ *
+ * Basic filter initialization should be done here. Filters with dynamic
+ * inputs and/or outputs should create those inputs/outputs here based on
+ * provided options. No more changes to this filter's inputs/outputs can be
+ * done after this callback.
+ *
+ * This callback must not assume that the filter links exist or frame
+ * parameters are known.
+ *
+ * @ref AVFilter.uninit "uninit" is guaranteed to be called even if
+ * initialization fails, so this callback does not have to clean up on
+ * failure.
+ *
+ * @return 0 on success, a negative AVERROR on failure
*/
int (*init)(AVFilterContext *ctx);
/**
- * Should be set instead of init by the filters that want to pass a
- * dictionary of AVOptions to nested contexts that are allocated in
- * init.
+ * Should be set instead of @ref AVFilter.init "init" by the filters that
+ * want to pass a dictionary of AVOptions to nested contexts that are
+ * allocated during init.
+ *
+ * On return, the options dict should be freed and replaced with one that
+ * contains all the options which could not be processed by this filter (or
+ * with NULL if all the options were processed).
+ *
+ * Otherwise the semantics is the same as for @ref AVFilter.init "init".
*/
int (*init_dict)(AVFilterContext *ctx, AVDictionary **options);
/**
- * Filter uninitialization function. Should deallocate any memory held
- * by the filter, release any buffer references, etc. This does not need
- * to deallocate the AVFilterContext->priv memory itself.
+ * Filter uninitialization function.
+ *
+ * Called only once right before the filter is freed. Should deallocate any
+ * memory held by the filter, release any buffer references, etc. It does
+ * not need to deallocate the AVFilterContext.priv memory itself.
+ *
+ * This callback may be called even if @ref AVFilter.init "init" was not
+ * called or failed, so it must be prepared to handle such a situation.
*/
void (*uninit)(AVFilterContext *ctx);
/**
- * Queries formats supported by the filter and its pads, and sets the
- * in_formats for links connected to its output pads, and out_formats
- * for links connected to its input pads.
+ * Query formats supported by the filter on its inputs and outputs.
+ *
+ * This callback is called after the filter is initialized (so the inputs
+ * and outputs are fixed), shortly before the format negotiation. This
+ * callback may be called more than once.
+ *
+ * This callback must set AVFilterLink.out_formats on every input link and
+ * AVFilterLink.in_formats on every output link to a list of pixel/sample
+ * formats that the filter supports on that link. For audio links, this
+ * filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" /
+ * @ref AVFilterLink.out_samplerates "out_samplerates" and
+ * @ref AVFilterLink.in_channel_layouts "in_channel_layouts" /
+ * @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously.
+ *
+ * This callback may be NULL for filters with one input, in which case
+ * libavfilter assumes that it supports all input formats and preserves
+ * them on output.
*
* @return zero on success, a negative value corresponding to an
* AVERROR code otherwise
int priv_size; ///< size of private data to allocate for the filter
+ int flags_internal; ///< Additional flags for avfilter internal use only.
+
+ /**
+ * Used by the filter registration system. Must not be touched by any other
+ * code.
+ */
struct AVFilter *next;
} AVFilter;
+/**
+ * Process multiple parts of the frame concurrently.
+ */
+#define AVFILTER_THREAD_SLICE (1 << 0)
+
+typedef struct AVFilterInternal AVFilterInternal;
+
/** An instance of a filter */
struct AVFilterContext {
const AVClass *av_class; ///< needed for av_log()
AVFilterPad *input_pads; ///< array of input pads
AVFilterLink **inputs; ///< array of pointers to input links
-#if FF_API_FOO_COUNT
- unsigned input_count; ///< @deprecated use nb_inputs
-#endif
unsigned nb_inputs; ///< number of input pads
AVFilterPad *output_pads; ///< array of output pads
AVFilterLink **outputs; ///< array of pointers to output links
-#if FF_API_FOO_COUNT
- unsigned output_count; ///< @deprecated use nb_outputs
-#endif
unsigned nb_outputs; ///< number of output pads
void *priv; ///< private data for use by the filter
struct AVFilterGraph *graph; ///< filtergraph this filter belongs to
+
+ /**
+ * Type of multithreading being allowed/used. A combination of
+ * AVFILTER_THREAD_* flags.
+ *
+ * May be set by the caller before initializing the filter to forbid some
+ * or all kinds of multithreading for this filter. The default is allowing
+ * everything.
+ *
+ * When the filter is initialized, this field is combined using bit AND with
+ * AVFilterGraph.thread_type to get the final mask used for determining
+ * allowed threading types. I.e. a threading type needs to be set in both
+ * to be allowed.
+ *
+ * After the filter is initialzed, libavfilter sets this field to the
+ * threading type that is actually used (0 for no multithreading).
+ */
+ int thread_type;
+
+ /**
+ * An opaque struct for libavfilter internal use.
+ */
+ AVFilterInternal *internal;
+
+ /**
+ * For filters which will create hardware frames, sets the device the
+ * filter should create them in. All other filters will ignore this field:
+ * in particular, a filter which consumes or processes hardware frames will
+ * instead use the hw_frames_ctx field in AVFilterLink to carry the
+ * hardware context information.
+ */
+ AVBufferRef *hw_device_ctx;
};
/**
AVLINK_STARTINIT, ///< started, but incomplete
AVLINK_INIT ///< complete
} init_state;
+
+ /**
+ * Frame rate of the stream on the link, or 1/0 if unknown or variable;
+ * if left to 0/0, will be automatically copied from the first input
+ * of the source filter if it exists.
+ *
+ * Sources should set it to the real constant frame rate.
+ * If the source frame rate is unknown or variable, set this to 1/0.
+ * Filters should update it if necessary depending on their function.
+ * Sinks can use it to set a default output frame rate.
+ */
+ AVRational frame_rate;
+
+ /**
+ * For hwaccel pixel formats, this should be a reference to the
+ * AVHWFramesContext describing the frames.
+ */
+ AVBufferRef *hw_frames_ctx;
};
/**
*/
int avfilter_config_links(AVFilterContext *filter);
-#if FF_API_AVFILTERBUFFER
-/**
- * Create a buffer reference wrapped around an already allocated image
- * buffer.
- *
- * @param data pointers to the planes of the image to reference
- * @param linesize linesizes for the planes of the image to reference
- * @param perms the required access permissions
- * @param w the width of the image specified by the data and linesize arrays
- * @param h the height of the image specified by the data and linesize arrays
- * @param format the pixel format of the image specified by the data and linesize arrays
- */
-attribute_deprecated
-AVFilterBufferRef *
-avfilter_get_video_buffer_ref_from_arrays(uint8_t *data[4], int linesize[4], int perms,
- int w, int h, enum AVPixelFormat format);
-
-/**
- * Create an audio buffer reference wrapped around an already
- * allocated samples buffer.
- *
- * @param data pointers to the samples plane buffers
- * @param linesize linesize for the samples plane buffers
- * @param perms the required access permissions
- * @param nb_samples number of samples per channel
- * @param sample_fmt the format of each sample in the buffer to allocate
- * @param channel_layout the channel layout of the buffer
- */
-attribute_deprecated
-AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
- int linesize,
- int perms,
- int nb_samples,
- enum AVSampleFormat sample_fmt,
- uint64_t channel_layout);
-#endif
-
/** Initialize the filter system. Register all builtin filters. */
void avfilter_register_all(void);
* is not registered.
*
* @param filter the filter to register
- * @return 0 if the registration was succesfull, a negative value
+ * @return 0 if the registration was successful, a negative value
* otherwise
*/
int avfilter_register(AVFilter *filter);
* @return the filter definition, if any matching one is registered.
* NULL if none found.
*/
+#if !FF_API_NOCONST_GET_NAME
+const
+#endif
AVFilter *avfilter_get_by_name(const char *name);
/**
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
-#if FF_API_AVFILTERBUFFER
/**
- * Copy the frame properties of src to dst, without copying the actual
- * image data.
+ * @return AVClass for AVFilterContext.
*
- * @return 0 on success, a negative number on error.
+ * @see av_opt_find().
*/
-attribute_deprecated
-int avfilter_copy_frame_props(AVFilterBufferRef *dst, const AVFrame *src);
+const AVClass *avfilter_get_class(void);
+
+typedef struct AVFilterGraphInternal AVFilterGraphInternal;
/**
- * Copy the frame properties and data pointers of src to dst, without copying
- * the actual data.
+ * A function pointer passed to the @ref AVFilterGraph.execute callback to be
+ * executed multiple times, possibly in parallel.
+ *
+ * @param ctx the filter context the job belongs to
+ * @param arg an opaque parameter passed through from @ref
+ * AVFilterGraph.execute
+ * @param jobnr the index of the job being executed
+ * @param nb_jobs the total number of jobs
*
- * @return 0 on success, a negative number on error.
+ * @return 0 on success, a negative AVERROR on error
*/
-attribute_deprecated
-int avfilter_copy_buf_props(AVFrame *dst, const AVFilterBufferRef *src);
-#endif
+typedef int (avfilter_action_func)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
/**
- * @return AVClass for AVFilterContext.
+ * A function executing multiple jobs, possibly in parallel.
*
- * @see av_opt_find().
+ * @param ctx the filter context to which the jobs belong
+ * @param func the function to be called multiple times
+ * @param arg the argument to be passed to func
+ * @param ret a nb_jobs-sized array to be filled with return values from each
+ * invocation of func
+ * @param nb_jobs the number of jobs to execute
+ *
+ * @return 0 on success, a negative AVERROR on error
*/
-const AVClass *avfilter_get_class(void);
+typedef int (avfilter_execute_func)(AVFilterContext *ctx, avfilter_action_func *func,
+ void *arg, int *ret, int nb_jobs);
typedef struct AVFilterGraph {
const AVClass *av_class;
-#if FF_API_FOO_COUNT
- attribute_deprecated
- unsigned filter_count;
-#endif
AVFilterContext **filters;
-#if !FF_API_FOO_COUNT
unsigned nb_filters;
-#endif
char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters
char *resample_lavr_opts; ///< libavresample options to use for the auto-inserted resample filters
-#if FF_API_FOO_COUNT
- unsigned nb_filters;
-#endif
+
+ /**
+ * Type of multithreading allowed for filters in this graph. A combination
+ * of AVFILTER_THREAD_* flags.
+ *
+ * May be set by the caller at any point, the setting will apply to all
+ * filters initialized after that. The default is allowing everything.
+ *
+ * When a filter in this graph is initialized, this field is combined using
+ * bit AND with AVFilterContext.thread_type to get the final mask used for
+ * determining allowed threading types. I.e. a threading type needs to be
+ * set in both to be allowed.
+ */
+ int thread_type;
+
+ /**
+ * Maximum number of threads used by filters in this graph. May be set by
+ * the caller before adding any filters to the filtergraph. Zero (the
+ * default) means that the number of threads is determined automatically.
+ */
+ int nb_threads;
+
+ /**
+ * Opaque object for libavfilter internal use.
+ */
+ AVFilterGraphInternal *internal;
+
+ /**
+ * Opaque user data. May be set by the caller to an arbitrary value, e.g. to
+ * be used from callbacks like @ref AVFilterGraph.execute.
+ * Libavfilter will not touch this field in any way.
+ */
+ void *opaque;
+
+ /**
+ * This callback may be set by the caller immediately after allocating the
+ * graph and before adding any filters to it, to provide a custom
+ * multithreading implementation.
+ *
+ * If set, filters with slice threading capability will call this callback
+ * to execute multiple jobs in parallel.
+ *
+ * If this field is left unset, libavfilter will use its internal
+ * implementation, which may or may not be multithreaded depending on the
+ * platform and build options.
+ */
+ avfilter_execute_func *execute;
} AVFilterGraph;
/**
* Allocate a filter graph.
+ *
+ * @return the allocated filter graph on success or NULL.
*/
AVFilterGraph *avfilter_graph_alloc(void);
* @return a negative AVERROR error code in case of failure, a non
* negative value otherwise
*/
-int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt,
+int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt,
const char *name, const char *args, void *opaque,
AVFilterGraph *graph_ctx);
AVFilterInOut **inputs,
AVFilterInOut **outputs);
+/**
+ * @}
+ */
+
#endif /* AVFILTER_AVFILTER_H */