/* * filter layer * Copyright (c) 2007 Bobby Bingham * * This file is part of FFmpeg. * * FFmpeg 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. * * FFmpeg 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 FFmpeg; 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 <stddef.h> #include "libavutil/attributes.h"#include "libavutil/avutil.h"#include "libavutil/buffer.h"#include "libavutil/dict.h"#include "libavutil/frame.h"#include "libavutil/log.h"#include "libavutil/pixfmt.h"#include "libavutil/rational.h" #include "libavfilter/version_major.h"#ifndef HAVE_AV_CONFIG_H/* When included as part of the ffmpeg build, only include the major version * to avoid unnecessary rebuilds. When included externally, keep including * the full version information. */#include "libavfilter/version.h"#endif /** * 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 AVFilterLink    AVFilterLink;typedef struct AVFilterPad     AVFilterPad;typedef struct AVFilterFormats AVFilterFormats;typedef struct AVFilterChannelLayouts AVFilterChannelLayouts; /** * 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); /** * Lists of formats / etc. supported by an end of a link. * * This structure is directly part of AVFilterLink, in two copies: * one for the source filter, one for the destination filter.  * These lists are used for negotiating the format to actually be used, * which will be loaded into the format and channel_layout members of * AVFilterLink, when chosen. */typedef struct AVFilterFormatsConfig {     /**     * List of supported formats (pixel or sample).     */    AVFilterFormats *formats;     /**     * Lists of supported sample rates, only for audio.     */    AVFilterFormats  *samplerates;     /**     * Lists of supported channel layouts, only for audio.     */    AVFilterChannelLayouts  *channel_layouts;     /**     * Lists of supported YUV color metadata, only for YUV video.     */    AVFilterFormats *color_spaces;  ///< AVColorSpace    AVFilterFormats *color_ranges;  ///< AVColorRange } AVFilterFormatsConfig; /** * 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)/** * The filter is a "metadata" filter - it does not modify the frame data in any * way. It may only affect the metadata (i.e. those fields copied by * av_frame_copy_props()). * * More precisely, this means: * - video: the data of any frame output by the filter must be exactly equal to *   some frame that is received on one of its inputs. Furthermore, all frames *   produced on a given output must correspond to frames received on the same *   input and their order must be unchanged. Note that the filter may still *   drop or duplicate the frames. * - audio: the data produced by the filter on any of its outputs (viewed e.g. *   as an array of interleaved samples) must be exactly equal to the data *   received by the filter on one of its inputs. */#define AVFILTER_FLAG_METADATA_ONLY         (1 << 3) /** * The filter can create hardware frames using AVFilterContext.hw_device_ctx. */#define AVFILTER_FLAG_HWDEVICE              (1 << 4)/** * Some filters support a generic "enable" expression option that can be used * to enable or disable a filter in the timeline. Filters supporting this * option have this flag set. When the enable expression is false, the default * no-op filter_frame() function is called in place of the filter_frame() * callback defined on each input pad, thus the frame is passed unchanged to * the next filters. */#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC  (1 << 16)/** * Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will * have its filter_frame() callback(s) called as usual even when the enable * expression is false. The filter will disable filtering within the * filter_frame() callback(s) itself, for example executing code depending on * the AVFilterContext->is_disabled value. */#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL (1 << 17)/** * Handy mask to test whether the filter supports or no the timeline feature * (internally or generically). */#define AVFILTER_FLAG_SUPPORT_TIMELINE (AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL) /** * 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 static inputs.     *     * 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 static outputs.     *     * 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;} AVFilter; /** * Get the number of elements in an AVFilter's inputs or outputs array. */unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output); /** * Process multiple parts of the frame concurrently. */#define AVFILTER_THREAD_SLICE (1 << 0) /** An instance of a filter */typedef struct AVFilterContext {    const AVClass *av_class;        ///< needed for av_log() and filters common options     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 initialized, libavfilter sets this field to the     * threading type that is actually used (0 for no multithreading).     */    int thread_type;     /**     * Max number of threads allowed in this filter instance.     * If <= 0, its value is ignored.     * Overrides global number of threads set per filter graph.     */    int nb_threads; #if FF_API_CONTEXT_PUBLIC    /**     * @deprecated unused     */    attribute_deprecated    struct AVFilterCommand *command_queue;#endif     char *enable_str;               ///< enable expression string#if FF_API_CONTEXT_PUBLIC    /**     * @deprecated unused     */    attribute_deprecated    void *enable;    /**     * @deprecated unused     */    double *var_values;#endif    /**     * MUST NOT be accessed from outside avfilter.     *     * the enabled state from the last expression evaluation     */    int is_disabled;     /**     * 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.     *     * May be set by the caller on filters flagged with AVFILTER_FLAG_HWDEVICE     * before initializing the filter with avfilter_init_str() or     * avfilter_init_dict().     */    AVBufferRef *hw_device_ctx; #if FF_API_CONTEXT_PUBLIC    /**     * @deprecated this field should never have been accessed by callers     */    attribute_deprecated    unsigned ready;#endif     /**     * Sets the number of extra hardware frames which the filter will     * allocate on its output links for use in following filters or by     * the caller.     *     * Some hardware filters require all frames that they will use for     * output to be defined in advance before filtering starts.  For such     * filters, any hardware frame pools used for output must therefore be     * of fixed size.  The extra frames set here are on top of any number     * that the filter needs internally in order to operate normally.     *     * This field must be set before the graph containing this filter is     * configured.     */    int extra_hw_frames;} AVFilterContext; /** * 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. * * Applications must not normally access the link structure directly. * Use the buffersrc and buffersink API instead. * In the future, access to the header may be reserved for filters * implementation. */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     int format;                 ///< agreed upon media format     /* 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    /**     * For non-YUV links, these are respectively set to fallback values (as     * appropriate for that colorspace).     *     * Note: This includes grayscale formats, as these are currently treated     * as forced full range always.     */    enum AVColorSpace colorspace;   ///< agreed upon YUV color space    enum AVColorRange color_range;  ///< agreed upon YUV color range     /* These parameters apply only to audio */    int sample_rate;            ///< samples per second    AVChannelLayout ch_layout;  ///< channel layout of current buffer (see libavutil/channel_layout.h)     /**     * 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;     AVFrameSideData **side_data;    int nb_side_data;     /*****************************************************************     * 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 supported formats / etc. supported by the input filter.     */    AVFilterFormatsConfig incfg;     /**     * Lists of supported formats / etc. supported by the output filter.     */    AVFilterFormatsConfig outcfg;}; /** * 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); #define AVFILTER_CMD_FLAG_ONE   1 ///< Stop once a filter understood the command (for target=all for example), fast filters are favored automatically#define AVFILTER_CMD_FLAG_FAST  2 ///< Only execute command when its fast (like a video out that supports contrast adjustment in hw) /** * Make the filter instance process a command. * It is recommended to use avfilter_graph_send_command(). */int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags); /** * Iterate over all registered filters. * * @param opaque a pointer where libavfilter will store the iteration state. Must *               point to NULL to start the iteration. * * @return the next registered filter or NULL when the iteration is *         finished */const AVFilter *av_filter_iterate(void **opaque); /** * 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. */const AVFilter *avfilter_get_by_name(const char *name);  /** * Initialize a filter with the supplied parameters. * * @param ctx  uninitialized filter context to initialize * @param args Options to initialize the filter with. This must be a *             ':'-separated list of options in the 'key=value' form. *             May be NULL if the options have been set directly using the *             AVOptions API or there are no options that need to be set. * @return 0 on success, a negative AVERROR on failure */int avfilter_init_str(AVFilterContext *ctx, const char *args); /** * Initialize a filter with the supplied dictionary of options. * * @param ctx     uninitialized filter context to initialize * @param options An AVDictionary filled with options for this filter. On *                return this parameter will be destroyed and replaced with *                a dict containing options that were not found. This dictionary *                must be freed by the caller. *                May be NULL, then this function is equivalent to

Lines 1–500 of 1195. Load more