/* * 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.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)/** * 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 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;     /**     * 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 initialization function, alternative to the init()     * callback. Args contains the user-supplied parameters, opaque is     * used for providing binary data.     */    int (*init_opaque)(AVFilterContext *ctx, void *opaque);     /**     * 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; /** * 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() 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;     /**     * An opaque struct for libavfilter internal use.     */    AVFilterInternal *internal;     struct AVFilterCommand *command_queue;     char *enable_str;               ///< enable expression string    void *enable;                   ///< parsed expression (AVExpr*)    double *var_values;             ///< variable values for the enable expression    int is_disabled;                ///< the enabled state from the last expression evaluation     /**     * 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;     /**     * 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;     /**     * Ready status of the filter.     * A non-0 value means that the filter needs activating;     * a higher value suggests a more urgent activation.     */    unsigned ready;}; /** * 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     /* 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 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 and channel layouts 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 and     * channel_layout members, 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;     /**     * Graph the filter belongs to.     */    struct AVFilterGraph *graph;     /**     * Current timestamp of the link, as defined by the most recent     * frame(s), in link time_base units.     */    int64_t current_pts;     /**     * Current timestamp of the link, as defined by the most recent     * frame(s), in AV_TIME_BASE units.     */    int64_t current_pts_us;     /**     * Index in the age array.     */    int age_index;     /**     * 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

Lines 1–500 of 1178. Load more