/* * filter layer * Copyright (c) 2007 Bobby Bingham * * This file is part of Libav. * * Libav is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * Libav is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #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 <stddef.h> #include "libavfilter/version.h" /** * Return the LIBAVFILTER_VERSION_INT constant. */unsigned avfilter_version(void); /** * Return the libavfilter build-time configuration. */const char *avfilter_configuration(void); /** * Return the libavfilter license. */const char *avfilter_license(void); typedef struct AVFilterContext AVFilterContext;typedef struct AVFilterLink AVFilterLink;typedef struct AVFilterPad AVFilterPad;typedef struct AVFilterFormats AVFilterFormats; /** * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g. * AVFilter.inputs/outputs). */int avfilter_pad_count(const AVFilterPad *pads); /** * Get the name of an AVFilterPad. * * @param pads an array of AVFilterPads * @param pad_idx index of the pad in the array it; is the caller's * responsibility to ensure the index is valid * * @return name of the pad_idx'th pad in pads */const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx); /** * Get the type of an AVFilterPad. * * @param pads an array of AVFilterPads * @param pad_idx index of the pad in the array; it is the caller's * responsibility to ensure the index is valid * * @return type of the pad_idx'th pad in pads */enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx); /** * The number of the filter inputs is not determined just by AVFilter.inputs. * The filter might add additional inputs during initialization depending on the * options supplied to it. */#define AVFILTER_FLAG_DYNAMIC_INPUTS (1 << 0)/** * The number of the filter outputs is not determined just by AVFilter.outputs. * The filter might add additional outputs during initialization depending on * 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 { /** * Filter name. Must be non-NULL and unique among filters. */ const char *name; /** * A description of the filter. May be NULL. * * You should use the NULL_IF_CONFIG_SMALL() macro to define it. */ const char *description; /** * 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 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; /** * A combination of AVFILTER_FLAG_* */ int flags; /***************************************************************** * All fields below this line are not part of the public API. They * may not be used outside of libavfilter and can be changed and * removed at will. * New public fields should be added right above. ***************************************************************** */ /** * 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 @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. * * 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); /** * 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 (*query_formats)(AVFilterContext *); int priv_size; ///< size of private data to allocate for the filter /** * 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() const AVFilter *filter; ///< the AVFilter of which this is an instance char *name; ///< name of this filter instance AVFilterPad *input_pads; ///< array of input pads AVFilterLink **inputs; ///< array of pointers to input links unsigned nb_inputs; ///< number of input pads AVFilterPad *output_pads; ///< array of output pads AVFilterLink **outputs; ///< array of pointers to output links 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;}; /** * A link between two filters. This contains pointers to the source and * destination filters between which this link exists, and the indexes of * the pads involved. In addition, this link also contains the parameters * which have been negotiated and agreed upon between the filter, such as * image dimensions, format, etc. */struct AVFilterLink { AVFilterContext *src; ///< source filter AVFilterPad *srcpad; ///< output pad on the source filter AVFilterContext *dst; ///< dest filter AVFilterPad *dstpad; ///< input pad on the dest filter enum AVMediaType type; ///< filter media type /* These parameters apply only to video */ int w; ///< agreed upon image width int h; ///< agreed upon image height AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio /* These two parameters apply only to audio */ uint64_t channel_layout; ///< channel layout of current buffer (see libavutil/channel_layout.h) int sample_rate; ///< samples per second int format; ///< agreed upon media format /** * Define the time base used by the PTS of the frames/samples * which will pass through this link. * During the configuration stage, each filter is supposed to * change only the output timebase, while the timebase of the * input link is assumed to be an unchangeable property. */ AVRational time_base; /***************************************************************** * All fields below this line are not part of the public API. They * may not be used outside of libavfilter and can be changed and * removed at will. * New public fields should be added right above. ***************************************************************** */ /** * Lists of formats supported by the input and output filters respectively. * These lists are used for negotiating the format to actually be used, * which will be loaded into the format member, above, when chosen. */ AVFilterFormats *in_formats; AVFilterFormats *out_formats; /** * Lists of channel layouts and sample rates used for automatic * negotiation. */ AVFilterFormats *in_samplerates; AVFilterFormats *out_samplerates; struct AVFilterChannelLayouts *in_channel_layouts; struct AVFilterChannelLayouts *out_channel_layouts; /** * Audio only, the destination filter sets this to a non-zero value to * request that buffers with the given number of samples should be sent to * it. AVFilterPad.needs_fifo must also be set on the corresponding input * pad. * Last buffer before EOF will be padded with silence. */ int request_samples; /** stage of the initialization of the link properties (dimensions, etc) */ enum { AVLINK_UNINIT = 0, ///< not started 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;}; /** * Link two filters together. * * @param src the source filter * @param srcpad index of the output pad on the source filter * @param dst the destination filter * @param dstpad index of the input pad on the destination filter * @return zero on success */int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad); /** * Negotiate the media format, dimensions, etc of all inputs to a filter. * * @param filter the filter to negotiate the properties for its inputs * @return zero on successful negotiation */int avfilter_config_links(AVFilterContext *filter); /** Initialize the filter system. Register all builtin filters. */void avfilter_register_all(void); #if FF_API_OLD_FILTER_REGISTER/** Uninitialize the filter system. Unregister all filters. */attribute_deprecatedvoid avfilter_uninit(void);#endif /** * Register a filter. This is only needed if you plan to use * avfilter_get_by_name later to lookup the AVFilter structure by name. A * filter can still by instantiated with avfilter_graph_alloc_filter even if it * is not registered. * * @param filter the filter to register * @return 0 if the registration was succesfull, a negative value * otherwise */int avfilter_register(AVFilter *filter); /** * Get a filter definition matching the given name. * * @param name the filter name to find * @return the filter definition, if any matching one is registered. * NULL if none found. */#if !FF_API_NOCONST_GET_NAMEconst#endifAVFilter *avfilter_get_by_name(const char *name); /** * Iterate over all registered filters. * @return If prev is non-NULL, next registered filter after prev or NULL if * prev is the last filter. If prev is NULL, return the first registered filter. */const AVFilter *avfilter_next(const AVFilter *prev); #if FF_API_OLD_FILTER_REGISTER/** * If filter is NULL, returns a pointer to the first registered filter pointer, * if filter is non-NULL, returns the next pointer after filter. * If the returned pointer points to NULL, the last registered filter * was already reached. * @deprecated use avfilter_next() */attribute_deprecatedAVFilter **av_filter_next(AVFilter **filter);#endif #if FF_API_AVFILTER_OPEN/** * Create a filter instance. * * @param filter_ctx put here a pointer to the created filter context * on success, NULL on failure * @param filter the filter to create an instance of * @param inst_name Name to give to the new instance. Can be NULL for none. * @return >= 0 in case of success, a negative error code otherwise * @deprecated use avfilter_graph_alloc_filter() instead */attribute_deprecatedint avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);#endif #if FF_API_AVFILTER_INIT_FILTER/** * Initialize a filter. * * @param filter the filter to initializeLines 1–500 of 825. Load more
/* * filter layer * Copyright (c) 2007 Bobby Bingham * * This file is part of Libav. * * Libav is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * Libav is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #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 <stddef.h> #include "libavfilter/version.h" /** * Return the LIBAVFILTER_VERSION_INT constant. */ unsigned avfilter_version(void); /** * Return the libavfilter build-time configuration. */ const char *avfilter_configuration(void); /** * Return the libavfilter license. */ const char *avfilter_license(void); typedef struct AVFilterContext AVFilterContext; typedef struct AVFilterLink AVFilterLink; typedef struct AVFilterPad AVFilterPad; typedef struct AVFilterFormats AVFilterFormats; /** * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g. * AVFilter.inputs/outputs). */ int avfilter_pad_count(const AVFilterPad *pads); /** * Get the name of an AVFilterPad. * * @param pads an array of AVFilterPads * @param pad_idx index of the pad in the array it; is the caller's * responsibility to ensure the index is valid * * @return name of the pad_idx'th pad in pads */ const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx); /** * Get the type of an AVFilterPad. * * @param pads an array of AVFilterPads * @param pad_idx index of the pad in the array; it is the caller's * responsibility to ensure the index is valid * * @return type of the pad_idx'th pad in pads */ enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx); /** * The number of the filter inputs is not determined just by AVFilter.inputs. * The filter might add additional inputs during initialization depending on the * options supplied to it. */ #define AVFILTER_FLAG_DYNAMIC_INPUTS (1 << 0) /** * The number of the filter outputs is not determined just by AVFilter.outputs. * The filter might add additional outputs during initialization depending on * 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 { /** * Filter name. Must be non-NULL and unique among filters. */ const char *name; /** * A description of the filter. May be NULL. * * You should use the NULL_IF_CONFIG_SMALL() macro to define it. */ const char *description; /** * 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 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; /** * A combination of AVFILTER_FLAG_* */ int flags; /***************************************************************** * All fields below this line are not part of the public API. They * may not be used outside of libavfilter and can be changed and * removed at will. * New public fields should be added right above. ***************************************************************** */ /** * 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 @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. * * 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); /** * 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 (*query_formats)(AVFilterContext *); int priv_size; ///< size of private data to allocate for the filter /** * 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() const AVFilter *filter; ///< the AVFilter of which this is an instance char *name; ///< name of this filter instance AVFilterPad *input_pads; ///< array of input pads AVFilterLink **inputs; ///< array of pointers to input links unsigned nb_inputs; ///< number of input pads AVFilterPad *output_pads; ///< array of output pads AVFilterLink **outputs; ///< array of pointers to output links 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; }; /** * A link between two filters. This contains pointers to the source and * destination filters between which this link exists, and the indexes of * the pads involved. In addition, this link also contains the parameters * which have been negotiated and agreed upon between the filter, such as * image dimensions, format, etc. */ struct AVFilterLink { AVFilterContext *src; ///< source filter AVFilterPad *srcpad; ///< output pad on the source filter AVFilterContext *dst; ///< dest filter AVFilterPad *dstpad; ///< input pad on the dest filter enum AVMediaType type; ///< filter media type /* These parameters apply only to video */ int w; ///< agreed upon image width int h; ///< agreed upon image height AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio /* These two parameters apply only to audio */ uint64_t channel_layout; ///< channel layout of current buffer (see libavutil/channel_layout.h) int sample_rate; ///< samples per second int format; ///< agreed upon media format /** * Define the time base used by the PTS of the frames/samples * which will pass through this link. * During the configuration stage, each filter is supposed to * change only the output timebase, while the timebase of the * input link is assumed to be an unchangeable property. */ AVRational time_base; /***************************************************************** * All fields below this line are not part of the public API. They * may not be used outside of libavfilter and can be changed and * removed at will. * New public fields should be added right above. ***************************************************************** */ /** * Lists of formats supported by the input and output filters respectively. * These lists are used for negotiating the format to actually be used, * which will be loaded into the format member, above, when chosen. */ AVFilterFormats *in_formats; AVFilterFormats *out_formats; /** * Lists of channel layouts and sample rates used for automatic * negotiation. */ AVFilterFormats *in_samplerates; AVFilterFormats *out_samplerates; struct AVFilterChannelLayouts *in_channel_layouts; struct AVFilterChannelLayouts *out_channel_layouts; /** * Audio only, the destination filter sets this to a non-zero value to * request that buffers with the given number of samples should be sent to * it. AVFilterPad.needs_fifo must also be set on the corresponding input * pad. * Last buffer before EOF will be padded with silence. */ int request_samples; /** stage of the initialization of the link properties (dimensions, etc) */ enum { AVLINK_UNINIT = 0, ///< not started 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; }; /** * Link two filters together. * * @param src the source filter * @param srcpad index of the output pad on the source filter * @param dst the destination filter * @param dstpad index of the input pad on the destination filter * @return zero on success */ int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad); /** * Negotiate the media format, dimensions, etc of all inputs to a filter. * * @param filter the filter to negotiate the properties for its inputs * @return zero on successful negotiation */ int avfilter_config_links(AVFilterContext *filter); /** Initialize the filter system. Register all builtin filters. */ void avfilter_register_all(void); #if FF_API_OLD_FILTER_REGISTER /** Uninitialize the filter system. Unregister all filters. */ attribute_deprecated void avfilter_uninit(void); #endif /** * Register a filter. This is only needed if you plan to use * avfilter_get_by_name later to lookup the AVFilter structure by name. A * filter can still by instantiated with avfilter_graph_alloc_filter even if it * is not registered. * * @param filter the filter to register * @return 0 if the registration was succesfull, a negative value * otherwise */ int avfilter_register(AVFilter *filter); /** * Get a filter definition matching the given name. * * @param name the filter name to find * @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); /** * Iterate over all registered filters. * @return If prev is non-NULL, next registered filter after prev or NULL if * prev is the last filter. If prev is NULL, return the first registered filter. */ const AVFilter *avfilter_next(const AVFilter *prev); #if FF_API_OLD_FILTER_REGISTER /** * If filter is NULL, returns a pointer to the first registered filter pointer, * if filter is non-NULL, returns the next pointer after filter. * If the returned pointer points to NULL, the last registered filter * was already reached. * @deprecated use avfilter_next() */ attribute_deprecated AVFilter **av_filter_next(AVFilter **filter); #endif #if FF_API_AVFILTER_OPEN /** * Create a filter instance. * * @param filter_ctx put here a pointer to the created filter context * on success, NULL on failure * @param filter the filter to create an instance of * @param inst_name Name to give to the new instance. Can be NULL for none. * @return >= 0 in case of success, a negative error code otherwise * @deprecated use avfilter_graph_alloc_filter() instead */ attribute_deprecated int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name); #endif #if FF_API_AVFILTER_INIT_FILTER /** * Initialize a filter. * * @param filter the filter to initialize