/* * 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/samplefmt.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 AVFilterContext AVFilterContext;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;     /*****************************************************************     * 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.     *****************************************************************     */     /**     * The number of entries in the list of inputs.     */    uint8_t nb_inputs;     /**     * The number of entries in the list of outputs.     */    uint8_t nb_outputs;     /**     * This field determines the state of the formats union.     * It is an enum FilterFormatsState value.     */    uint8_t formats_state;     /**     * Filter pre-initialization function     *     * This callback will be called immediately after the filter context is     * allocated, to allow allocating and initing sub-objects.     *     * If this callback is not NULL, the uninit callback will be called on     * allocation failure.     *     * @return 0 on success,     *         AVERROR code on failure (but the code will be     *           dropped and treated as ENOMEM by the calling code)     */    int (*preinit)(AVFilterContext *ctx);     /**     * 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);     /**     * 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);     /**     * The state of the following union is determined by formats_state.     * See the documentation of enum FilterFormatsState in internal.h.     */    union {        /**         * 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's         * @ref AVFilterFormatsConfig.formats "outcfg.formats"         * on every input link and         * @ref AVFilterFormatsConfig.formats "incfg.formats"         * on every output link to a list of pixel/sample formats that the filter         * supports on that link.         * For video links, this filter may also set         * @ref AVFilterFormatsConfig.color_spaces "incfg.color_spaces"         *  /         * @ref AVFilterFormatsConfig.color_spaces "outcfg.color_spaces"         * and @ref AVFilterFormatsConfig.color_ranges "incfg.color_ranges"         *  /         * @ref AVFilterFormatsConfig.color_ranges "outcfg.color_ranges"         * analogously.         * For audio links, this filter must also set         * @ref AVFilterFormatsConfig.samplerates "incfg.samplerates"         *  /         * @ref AVFilterFormatsConfig.samplerates "outcfg.samplerates"         * and @ref AVFilterFormatsConfig.channel_layouts "incfg.channel_layouts"         *  /         * @ref AVFilterFormatsConfig.channel_layouts "outcfg.channel_layouts"         * analogously.         *         * This callback must never be NULL if the union is in this state.         *         * @return zero on success, a negative value corresponding to an         * AVERROR code otherwise         */        int (*query_func)(AVFilterContext *);         /**         * Same as query_func(), except this function writes the results into         * provided arrays.         *         * @param cfg_in  array of input format configurations with as many         *                members as the filters has inputs (NULL when there are         *                no inputs);         * @param cfg_out array of output format configurations with as many         *                members as the filters has outputs (NULL when there         *                are no outputs);         */        int (*query_func2)(const AVFilterContext *,                           struct AVFilterFormatsConfig **cfg_in,                           struct AVFilterFormatsConfig **cfg_out);        /**         * A pointer to an array of admissible pixel formats delimited         * by AV_PIX_FMT_NONE. The generic code will use this list         * to indicate that this filter supports each of these pixel formats,         * provided that all inputs and outputs use the same pixel format.         *         * In addition to that the generic code will mark all inputs         * and all outputs as supporting all color spaces and ranges, as         * long as all inputs and outputs use the same color space/range.         *         * This list must never be NULL if the union is in this state.         * The type of all inputs and outputs of filters using this must         * be AVMEDIA_TYPE_VIDEO.         */        const enum AVPixelFormat *pixels_list;        /**         * Analogous to pixels, but delimited by AV_SAMPLE_FMT_NONE         * and restricted to filters that only have AVMEDIA_TYPE_AUDIO         * inputs and outputs.         *         * In addition to that the generic code will mark all inputs         * and all outputs as supporting all sample rates and every         * channel count and channel layout, as long as all inputs         * and outputs use the same sample rate and channel count/layout.         */        const enum AVSampleFormat *samples_list;        /**         * Equivalent to { pix_fmt, AV_PIX_FMT_NONE } as pixels_list.         */        enum AVPixelFormat  pix_fmt;        /**         * Equivalent to { sample_fmt, AV_SAMPLE_FMT_NONE } as samples_list.         */        enum AVSampleFormat sample_fmt;    } formats;     int priv_size;      ///< size of private data to allocate for the filter     int flags_internal; ///< Additional flags for avfilter internal use only.     /**     * Make the filter instance process a command.     *     * @param cmd    the command to process, for handling simplicity all commands must be alphanumeric only     * @param arg    the argument for the command     * @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.     * @param flags  if AVFILTER_CMD_FLAG_FAST is set and the command would be     *               time consuming then a filter should treat it like an unsupported command     *     * @returns >=0 on success otherwise an error code.     *          AVERROR(ENOSYS) on unsupported commands     */    int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);     /**     * Filter activation function.     *     * Called when any processing is needed from the filter, instead of any     * filter_frame and request_frame on pads.     *     * The function must examine inlinks and outlinks and perform a single     * step of processing. If there is nothing to do, the function must do     * nothing and not return an error. If more steps are or may be     * possible, it must use ff_filter_set_ready() to schedule another     * activation.     */    int (*activate)(AVFilterContext *ctx);} 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 */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; 

Lines 1–500 of 1379. Load more