mirror of
https://git.ffmpeg.org/ffmpeg.git
synced 2024-12-13 10:44:59 +00:00
eddffbedb3
It differs from query_func() in accepting arrays of input/output format configurations to be filled as callback parameters. This allows to mark the filter context as const, ensuring it is not modified by this function, as it is not supposed to have any side effects beyond returning the supported formats.
607 lines
21 KiB
C
607 lines
21 KiB
C
/*
|
|
* Filters implementation helper functions
|
|
*
|
|
* 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_FILTERS_H
|
|
#define AVFILTER_FILTERS_H
|
|
|
|
/**
|
|
* Filters implementation helper functions
|
|
*/
|
|
|
|
#include "avfilter.h"
|
|
|
|
/**
|
|
* Special return code when activate() did not do anything.
|
|
*/
|
|
#define FFERROR_NOT_READY FFERRTAG('N','R','D','Y')
|
|
|
|
/**
|
|
* A filter pad used for either input or output.
|
|
*/
|
|
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;
|
|
|
|
/**
|
|
* The filter expects writable frames from its input link,
|
|
* duplicating data buffers if needed.
|
|
*
|
|
* input pads only.
|
|
*/
|
|
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE (1 << 0)
|
|
|
|
/**
|
|
* The pad's name is allocated and should be freed generically.
|
|
*/
|
|
#define AVFILTERPAD_FLAG_FREE_NAME (1 << 1)
|
|
|
|
/**
|
|
* A combination of AVFILTERPAD_FLAG_* flags.
|
|
*/
|
|
int flags;
|
|
|
|
/**
|
|
* Callback functions to get a video/audio buffers. If NULL,
|
|
* the filter system will use ff_default_get_video_buffer() for video
|
|
* and ff_default_get_audio_buffer() for audio.
|
|
*
|
|
* The state of the union is determined by type.
|
|
*
|
|
* Input pads only.
|
|
*/
|
|
union {
|
|
AVFrame *(*video)(AVFilterLink *link, int w, int h);
|
|
AVFrame *(*audio)(AVFilterLink *link, int nb_samples);
|
|
} get_buffer;
|
|
|
|
/**
|
|
* 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 frame is properly unreferenced on error if it
|
|
* hasn't been passed on to another filter.
|
|
*/
|
|
int (*filter_frame)(AVFilterLink *link, AVFrame *frame);
|
|
|
|
/**
|
|
* Frame request callback. A call to this should result in some progress
|
|
* towards producing 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);
|
|
};
|
|
|
|
/**
|
|
* Link properties exposed to filter code, but not external callers.
|
|
*
|
|
* Cf. AVFilterLink for public properties, FilterLinkInternal for
|
|
* properties private to the generic layer.
|
|
*/
|
|
typedef struct FilterLink {
|
|
AVFilterLink pub;
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/**
|
|
* Minimum number of samples to filter at once.
|
|
*
|
|
* May be set by the link destination filter in its config_props().
|
|
* If 0, all related fields are ignored.
|
|
*/
|
|
int min_samples;
|
|
|
|
/**
|
|
* Maximum number of samples to filter at once. If filter_frame() is
|
|
* called with more samples, it will split them.
|
|
*
|
|
* May be set by the link destination filter in its config_props().
|
|
*/
|
|
int max_samples;
|
|
|
|
/**
|
|
* Number of past frames sent through the link.
|
|
*/
|
|
int64_t frame_count_in, frame_count_out;
|
|
|
|
/**
|
|
* Number of past samples sent through the link.
|
|
*/
|
|
int64_t sample_count_in, sample_count_out;
|
|
|
|
/**
|
|
* Frame rate of the stream on the link, or 1/0 if unknown or variable.
|
|
*
|
|
* May be set by the link source filter in its config_props(); 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 best estimation of the real 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.
|
|
* It is similar to the r_frame_rate field in AVStream.
|
|
*/
|
|
AVRational frame_rate;
|
|
|
|
/**
|
|
* For hwaccel pixel formats, this should be a reference to the
|
|
* AVHWFramesContext describing the frames.
|
|
*
|
|
* May be set by the link source filter in its config_props().
|
|
*/
|
|
AVBufferRef *hw_frames_ctx;
|
|
} FilterLink;
|
|
|
|
static inline FilterLink* ff_filter_link(AVFilterLink *link)
|
|
{
|
|
return (FilterLink*)link;
|
|
}
|
|
|
|
/**
|
|
* The filter is aware of hardware frames, and any hardware frame context
|
|
* should not be automatically propagated through it.
|
|
*/
|
|
#define FF_FILTER_FLAG_HWFRAME_AWARE (1 << 0)
|
|
|
|
/**
|
|
* Find the index of a link.
|
|
*
|
|
* I.e. find i such that link == ctx->(in|out)puts[i]
|
|
*/
|
|
#define FF_INLINK_IDX(link) ((int)((link)->dstpad - (link)->dst->input_pads))
|
|
#define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads))
|
|
|
|
enum FilterFormatsState {
|
|
/**
|
|
* The default value meaning that this filter supports all formats
|
|
* and (for audio) sample rates and channel layouts/counts as long
|
|
* as these properties agree for all inputs and outputs.
|
|
* This state is only allowed in case all inputs and outputs actually
|
|
* have the same type.
|
|
* The union is unused in this state.
|
|
*
|
|
* This value must always be zero (for default static initialization).
|
|
*/
|
|
FF_FILTER_FORMATS_PASSTHROUGH = 0,
|
|
FF_FILTER_FORMATS_QUERY_FUNC, ///< formats.query active.
|
|
FF_FILTER_FORMATS_QUERY_FUNC2, ///< formats.query_func2 active.
|
|
FF_FILTER_FORMATS_PIXFMT_LIST, ///< formats.pixels_list active.
|
|
FF_FILTER_FORMATS_SAMPLEFMTS_LIST, ///< formats.samples_list active.
|
|
FF_FILTER_FORMATS_SINGLE_PIXFMT, ///< formats.pix_fmt active
|
|
FF_FILTER_FORMATS_SINGLE_SAMPLEFMT, ///< formats.sample_fmt active.
|
|
};
|
|
|
|
#define FILTER_QUERY_FUNC(func) \
|
|
.formats.query_func = func, \
|
|
.formats_state = FF_FILTER_FORMATS_QUERY_FUNC
|
|
#define FILTER_QUERY_FUNC2(func) \
|
|
.formats.query_func2 = func, \
|
|
.formats_state = FF_FILTER_FORMATS_QUERY_FUNC2
|
|
#define FILTER_PIXFMTS_ARRAY(array) \
|
|
.formats.pixels_list = array, \
|
|
.formats_state = FF_FILTER_FORMATS_PIXFMT_LIST
|
|
#define FILTER_SAMPLEFMTS_ARRAY(array) \
|
|
.formats.samples_list = array, \
|
|
.formats_state = FF_FILTER_FORMATS_SAMPLEFMTS_LIST
|
|
#define FILTER_PIXFMTS(...) \
|
|
FILTER_PIXFMTS_ARRAY(((const enum AVPixelFormat []) { __VA_ARGS__, AV_PIX_FMT_NONE }))
|
|
#define FILTER_SAMPLEFMTS(...) \
|
|
FILTER_SAMPLEFMTS_ARRAY(((const enum AVSampleFormat[]) { __VA_ARGS__, AV_SAMPLE_FMT_NONE }))
|
|
#define FILTER_SINGLE_PIXFMT(pix_fmt_) \
|
|
.formats.pix_fmt = pix_fmt_, \
|
|
.formats_state = FF_FILTER_FORMATS_SINGLE_PIXFMT
|
|
#define FILTER_SINGLE_SAMPLEFMT(sample_fmt_) \
|
|
.formats.sample_fmt = sample_fmt_, \
|
|
.formats_state = FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
|
|
|
|
#define FILTER_INOUTPADS(inout, array) \
|
|
.inout = array, \
|
|
.nb_ ## inout = FF_ARRAY_ELEMS(array)
|
|
#define FILTER_INPUTS(array) FILTER_INOUTPADS(inputs, (array))
|
|
#define FILTER_OUTPUTS(array) FILTER_INOUTPADS(outputs, (array))
|
|
|
|
#define AVFILTER_DEFINE_CLASS_EXT(name, desc, options) \
|
|
static const AVClass name##_class = { \
|
|
.class_name = desc, \
|
|
.item_name = av_default_item_name, \
|
|
.option = options, \
|
|
.version = LIBAVUTIL_VERSION_INT, \
|
|
.category = AV_CLASS_CATEGORY_FILTER, \
|
|
}
|
|
#define AVFILTER_DEFINE_CLASS(fname) \
|
|
AVFILTER_DEFINE_CLASS_EXT(fname, #fname, fname##_options)
|
|
|
|
#define D2TS(d) (isnan(d) ? AV_NOPTS_VALUE : (int64_t)(d))
|
|
#define TS2D(ts) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts))
|
|
#define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts) * av_q2d(tb))
|
|
|
|
/**
|
|
* Mark a filter ready and schedule it for activation.
|
|
*
|
|
* This is automatically done when something happens to the filter (queued
|
|
* frame, status change, request on output).
|
|
* Filters implementing the activate callback can call it directly to
|
|
* perform one more round of processing later.
|
|
* It is also useful for filters reacting to external or asynchronous
|
|
* events.
|
|
*/
|
|
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority);
|
|
|
|
/**
|
|
* Get the number of frames available on the link.
|
|
* @return the number of frames available in the link fifo.
|
|
*/
|
|
size_t ff_inlink_queued_frames(AVFilterLink *link);
|
|
|
|
/**
|
|
* Test if a frame is available on the link.
|
|
* @return >0 if a frame is available
|
|
*/
|
|
int ff_inlink_check_available_frame(AVFilterLink *link);
|
|
|
|
|
|
/***
|
|
* Get the number of samples available on the link.
|
|
* @return the numer of samples available on the link.
|
|
*/
|
|
int ff_inlink_queued_samples(AVFilterLink *link);
|
|
|
|
/**
|
|
* Test if enough samples are available on the link.
|
|
* @return >0 if enough samples are available
|
|
* @note on EOF and error, min becomes 1
|
|
*/
|
|
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min);
|
|
|
|
/**
|
|
* Take a frame from the link's FIFO and update the link's stats.
|
|
*
|
|
* If ff_inlink_check_available_frame() was previously called, the
|
|
* preferred way of expressing it is "av_assert1(ret);" immediately after
|
|
* ff_inlink_consume_frame(). Negative error codes must still be checked.
|
|
*
|
|
* @note May trigger process_command() and/or update is_disabled.
|
|
* @return >0 if a frame is available,
|
|
* 0 and set rframe to NULL if no frame available,
|
|
* or AVERROR code
|
|
*/
|
|
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe);
|
|
|
|
/**
|
|
* Take samples from the link's FIFO and update the link's stats.
|
|
*
|
|
* If ff_inlink_check_available_samples() was previously called, the
|
|
* preferred way of expressing it is "av_assert1(ret);" immediately after
|
|
* ff_inlink_consume_samples(). Negative error codes must still be checked.
|
|
*
|
|
* @note May trigger process_command() and/or update is_disabled.
|
|
* @return >0 if a frame is available,
|
|
* 0 and set rframe to NULL if no frame available,
|
|
* or AVERROR code
|
|
*/
|
|
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
|
|
AVFrame **rframe);
|
|
|
|
/**
|
|
* Access a frame in the link fifo without consuming it.
|
|
* The first frame is numbered 0; the designated frame must exist.
|
|
* @return the frame at idx position in the link fifo.
|
|
*/
|
|
AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx);
|
|
|
|
/**
|
|
* Make sure a frame is writable.
|
|
* This is similar to av_frame_make_writable() except it uses the link's
|
|
* buffer allocation callback, and therefore allows direct rendering.
|
|
*/
|
|
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe);
|
|
|
|
/**
|
|
* Test and acknowledge the change of status on the link.
|
|
*
|
|
* Status means EOF or an error condition; a change from the normal (0)
|
|
* status to a non-zero status can be queued in a filter's input link, it
|
|
* becomes relevant after the frames queued in the link's FIFO are
|
|
* processed. This function tests if frames are still queued and if a queued
|
|
* status change has not yet been processed. In that case it performs basic
|
|
* treatment (updating the link's timestamp) and returns a positive value to
|
|
* let the filter do its own treatments (flushing...).
|
|
*
|
|
* Filters implementing the activate callback should call this function when
|
|
* they think it might succeed (usually after checking unsuccessfully for a
|
|
* queued frame).
|
|
* Filters implementing the filter_frame and request_frame callbacks do not
|
|
* need to call that since the same treatment happens in ff_filter_frame().
|
|
*
|
|
* @param[out] rstatus new or current status
|
|
* @param[out] rpts current timestamp of the link in link time base
|
|
* @return >0 if status changed, <0 if status already acked, 0 otherwise
|
|
*/
|
|
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts);
|
|
|
|
/**
|
|
* Mark that a frame is wanted on the link.
|
|
* Unlike ff_filter_frame(), it must not be called when the link has a
|
|
* non-zero status, and thus does not acknowledge it.
|
|
* Also it cannot fail.
|
|
*/
|
|
void ff_inlink_request_frame(AVFilterLink *link);
|
|
|
|
/**
|
|
* Set the status on an input link.
|
|
* Also discard all frames in the link's FIFO.
|
|
*/
|
|
void ff_inlink_set_status(AVFilterLink *link, int status);
|
|
|
|
/**
|
|
* Test if a frame is wanted on an output link.
|
|
*/
|
|
int ff_outlink_frame_wanted(AVFilterLink *link);
|
|
|
|
/**
|
|
* Get the status on an output link.
|
|
*/
|
|
int ff_outlink_get_status(AVFilterLink *link);
|
|
|
|
/**
|
|
* Set the status field of a link from the source filter.
|
|
* The pts should reflect the timestamp of the status change,
|
|
* in link time base and relative to the frames timeline.
|
|
* In particular, for AVERROR_EOF, it should reflect the
|
|
* end time of the last frame.
|
|
*/
|
|
void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts);
|
|
|
|
/**
|
|
* Set the status field of a link from the source filter.
|
|
* The pts should reflect the timestamp of the status change,
|
|
* in link time base and relative to the frames timeline.
|
|
* In particular, for AVERROR_EOF, it should reflect the
|
|
* end time of the last frame.
|
|
*/
|
|
static inline void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
|
|
{
|
|
ff_avfilter_link_set_in_status(link, status, pts);
|
|
}
|
|
|
|
/**
|
|
* Forward the status on an output link to an input link.
|
|
* If the status is set, it will discard all queued frames and this macro
|
|
* will return immediately.
|
|
*/
|
|
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink) do { \
|
|
int ret = ff_outlink_get_status(outlink); \
|
|
if (ret) { \
|
|
ff_inlink_set_status(inlink, ret); \
|
|
return 0; \
|
|
} \
|
|
} while (0)
|
|
|
|
/**
|
|
* Forward the status on an output link to all input links.
|
|
* If the status is set, it will discard all queued frames and this macro
|
|
* will return immediately.
|
|
*/
|
|
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter) do { \
|
|
int ret = ff_outlink_get_status(outlink); \
|
|
if (ret) { \
|
|
unsigned i; \
|
|
for (i = 0; i < filter->nb_inputs; i++) \
|
|
ff_inlink_set_status(filter->inputs[i], ret); \
|
|
return 0; \
|
|
} \
|
|
} while (0)
|
|
|
|
/**
|
|
* Acknowledge the status on an input link and forward it to an output link.
|
|
* If the status is set, this macro will return immediately.
|
|
*/
|
|
#define FF_FILTER_FORWARD_STATUS(inlink, outlink) do { \
|
|
int status; \
|
|
int64_t pts; \
|
|
if (ff_inlink_acknowledge_status(inlink, &status, &pts)) { \
|
|
ff_outlink_set_status(outlink, status, pts); \
|
|
return 0; \
|
|
} \
|
|
} while (0)
|
|
|
|
/**
|
|
* Acknowledge the status on an input link and forward it to an output link.
|
|
* If the status is set, this macro will return immediately.
|
|
*/
|
|
#define FF_FILTER_FORWARD_STATUS_ALL(inlink, filter) do { \
|
|
int status; \
|
|
int64_t pts; \
|
|
if (ff_inlink_acknowledge_status(inlink, &status, &pts)) { \
|
|
unsigned i; \
|
|
for (i = 0; i < filter->nb_outputs; i++) \
|
|
ff_outlink_set_status(filter->outputs[i], status, pts); \
|
|
return 0; \
|
|
} \
|
|
} while (0)
|
|
|
|
/**
|
|
* Forward the frame_wanted_out flag from an output link to an input link.
|
|
* If the flag is set, this macro will return immediately.
|
|
*/
|
|
#define FF_FILTER_FORWARD_WANTED(outlink, inlink) do { \
|
|
if (ff_outlink_frame_wanted(outlink)) { \
|
|
ff_inlink_request_frame(inlink); \
|
|
return 0; \
|
|
} \
|
|
} while (0)
|
|
|
|
/**
|
|
* Check for flow control between input and output.
|
|
* This is necessary for filters that may produce several output frames for
|
|
* a single input event, otherwise they may produce them all at once,
|
|
* causing excessive memory consumption.
|
|
*/
|
|
int ff_inoutlink_check_flow(AVFilterLink *inlink, AVFilterLink *outlink);
|
|
|
|
/**
|
|
* Perform any additional setup required for hardware frames.
|
|
*
|
|
* link->hw_frames_ctx must be set before calling this function.
|
|
* Inside link->hw_frames_ctx, the fields format, sw_format, width and
|
|
* height must be set. If dynamically allocated pools are not supported,
|
|
* then initial_pool_size must also be set, to the minimum hardware frame
|
|
* pool size necessary for the filter to work (taking into account any
|
|
* frames which need to stored for use in operations as appropriate). If
|
|
* default_pool_size is nonzero, then it will be used as the pool size if
|
|
* no other modification takes place (this can be used to preserve
|
|
* compatibility).
|
|
*/
|
|
int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link,
|
|
int default_pool_size);
|
|
|
|
/**
|
|
* Generic processing of user supplied commands that are set
|
|
* in the same way as the filter options.
|
|
* NOTE: 'enable' option is handled separately, and not by
|
|
* this function.
|
|
*/
|
|
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd,
|
|
const char *arg, char *res, int res_len, int flags);
|
|
|
|
/**
|
|
* Get number of threads for current filter instance.
|
|
* This number is always same or less than graph->nb_threads.
|
|
*/
|
|
int ff_filter_get_nb_threads(AVFilterContext *ctx) av_pure;
|
|
|
|
/**
|
|
* Send a frame of data to the next filter.
|
|
*
|
|
* @param link the output link over which the data is being sent
|
|
* @param frame a reference to the buffer of data being sent. The
|
|
* receiving filter will free this reference when it no longer
|
|
* needs it or pass it on to the next filter.
|
|
*
|
|
* @return >= 0 on success, a negative AVERROR on error. The receiving filter
|
|
* is responsible for unreferencing frame in case of error.
|
|
*/
|
|
int ff_filter_frame(AVFilterLink *link, AVFrame *frame);
|
|
|
|
/**
|
|
* Request an input frame from the filter at the other end of the link.
|
|
*
|
|
* This function must not be used by filters using the activate callback,
|
|
* use ff_link_set_frame_wanted() instead.
|
|
*
|
|
* The input filter may pass the request on to its inputs, fulfill the
|
|
* request from an internal buffer or any other means specific to its function.
|
|
*
|
|
* When the end of a stream is reached AVERROR_EOF is returned and no further
|
|
* frames are returned after that.
|
|
*
|
|
* When a filter is unable to output a frame for example due to its sources
|
|
* being unable to do so or because it depends on external means pushing data
|
|
* into it then AVERROR(EAGAIN) is returned.
|
|
* It is important that a AVERROR(EAGAIN) return is returned all the way to the
|
|
* caller (generally eventually a user application) as this step may (but does
|
|
* not have to be) necessary to provide the input with the next frame.
|
|
*
|
|
* If a request is successful then some progress has been made towards
|
|
* providing a frame on the link (through ff_filter_frame()). A filter that
|
|
* needs several frames to produce one is allowed to return success if one
|
|
* more frame has been processed but no output has been produced yet. A
|
|
* filter is also allowed to simply forward a success return value.
|
|
*
|
|
* @param link the input link
|
|
* @return zero on success
|
|
* AVERROR_EOF on end of file
|
|
* AVERROR(EAGAIN) if the previous filter cannot output a frame
|
|
* currently and can neither guarantee that EOF has been reached.
|
|
*/
|
|
int ff_request_frame(AVFilterLink *link);
|
|
|
|
/**
|
|
* Append a new input/output pad to the filter's list of such pads.
|
|
*
|
|
* The *_free_name versions will set the AVFILTERPAD_FLAG_FREE_NAME flag
|
|
* ensuring that the name will be freed generically (even on insertion error).
|
|
*/
|
|
int ff_append_inpad (AVFilterContext *f, AVFilterPad *p);
|
|
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p);
|
|
int ff_append_inpad_free_name (AVFilterContext *f, AVFilterPad *p);
|
|
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p);
|
|
|
|
/**
|
|
* Tell if an integer is contained in the provided -1-terminated list of integers.
|
|
* This is useful for determining (for instance) if an AVPixelFormat is in an
|
|
* array of supported formats.
|
|
*
|
|
* @param fmt provided format
|
|
* @param fmts -1-terminated list of formats
|
|
* @return 1 if present, 0 if absent
|
|
*/
|
|
int ff_fmt_is_in(int fmt, const int *fmts);
|
|
|
|
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func,
|
|
void *arg, int *ret, int nb_jobs);
|
|
|
|
#endif /* AVFILTER_FILTERS_H */
|