X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavfilter%2Finternal.h;h=12655bc3e608bedc6de85a2537ef7e19f4f12274;hb=7950e519bb094897f957b9a9531cc60ba46cbc91;hp=0630e9b7d65ecec224860b77f74f5b2ab751019c;hpb=8fe0c527f33fe6d2e89d62a23ae912553572452b;p=ffmpeg diff --git a/libavfilter/internal.h b/libavfilter/internal.h index 0630e9b7d65..12655bc3e60 100644 --- a/libavfilter/internal.h +++ b/libavfilter/internal.h @@ -24,35 +24,211 @@ * internal API functions */ +#include "libavutil/internal.h" #include "avfilter.h" -#include "avfiltergraph.h" +#include "thread.h" +#include "version.h" +#if !FF_API_AVFILTERPAD_PUBLIC /** - * Check for the validity of graph. + * 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; + + /** + * Callback function to get a video buffer. If NULL, the filter system will + * use avfilter_default_get_video_buffer(). + * + * Input video pads only. + */ + AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h); + + /** + * Callback function to get an audio buffer. If NULL, the filter system will + * use avfilter_default_get_audio_buffer(). + * + * Input audio pads only. + */ + AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples); + + /** + * 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 samplesref is properly unreferenced on error if it + * hasn't been passed on to another filter. + */ + int (*filter_frame)(AVFilterLink *link, AVFrame *frame); + + /** + * Frame poll callback. This returns the number of immediately available + * samples. It should return a positive value if the next request_frame() + * is guaranteed to return one frame (with no delay). + * + * Defaults to just calling the source poll_frame() method. + * + * Output pads only. + */ + int (*poll_frame)(AVFilterLink *link); + + /** + * Frame request callback. A call to this should result in at least one + * frame being 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); + + /** + * The filter expects a fifo to be inserted on its input link, + * typically because it has a delay. + * + * input pads only. + */ + int needs_fifo; +}; +#endif + +struct AVFilterGraphInternal { + void *thread; + int (*thread_execute)(AVFilterContext *ctx, action_func *func, void *arg, + int *ret, int nb_jobs); +}; + +struct AVFilterInternal { + int (*execute)(AVFilterContext *ctx, action_func *func, void *arg, + int *ret, int nb_jobs); +}; + +#if FF_API_AVFILTERBUFFER +/** default handler for freeing audio/video buffer when there are no references left */ +void ff_avfilter_default_free_buffer(AVFilterBuffer *buf); +#endif + +/** Tell is a format is contained in the provided list terminated by -1. */ +int ff_fmt_is_in(int fmt, const int *fmts); + +#define FF_DPRINTF_START(ctx, func) av_dlog(NULL, "%-16s: ", #func) + +void ff_dlog_link(void *ctx, AVFilterLink *link, int end); + +/** + * Insert a new pad. * - * A graph is considered valid if all its input and output pads are - * connected. + * @param idx Insertion point. Pad is inserted at the end if this point + * is beyond the end of the list of pads. + * @param count Pointer to the number of pads in the list + * @param padidx_off Offset within an AVFilterLink structure to the element + * to increment when inserting a new pad causes link + * numbering to change + * @param pads Pointer to the pointer to the beginning of the list of pads + * @param links Pointer to the pointer to the beginning of the list of links + * @param newpad The new pad to add. A copy is made when adding. + */ +void ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, + AVFilterPad **pads, AVFilterLink ***links, + AVFilterPad *newpad); + +/** Insert a new input pad for the filter. */ +static inline void ff_insert_inpad(AVFilterContext *f, unsigned index, + AVFilterPad *p) +{ + ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad), + &f->input_pads, &f->inputs, p); +#if FF_API_FOO_COUNT +FF_DISABLE_DEPRECATION_WARNINGS + f->input_count = f->nb_inputs; +FF_ENABLE_DEPRECATION_WARNINGS +#endif +} + +/** Insert a new output pad for the filter. */ +static inline void ff_insert_outpad(AVFilterContext *f, unsigned index, + AVFilterPad *p) +{ + ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad), + &f->output_pads, &f->outputs, p); +#if FF_API_FOO_COUNT +FF_DISABLE_DEPRECATION_WARNINGS + f->output_count = f->nb_outputs; +FF_ENABLE_DEPRECATION_WARNINGS +#endif +} + +/** + * Poll a frame from the filter chain. * - * @return 0 in case of success, a negative value otherwise + * @param link the input link + * @return the number of immediately available frames, a negative + * number in case of error */ -int ff_avfilter_graph_check_validity(AVFilterGraph *graphctx, AVClass *log_ctx); +int ff_poll_frame(AVFilterLink *link); /** - * Configure all the links of graphctx. + * Request an input frame from the filter at the other end of the link. * - * @return 0 in case of success, a negative value otherwise + * @param link the input link + * @return zero on success */ -int ff_avfilter_graph_config_links(AVFilterGraph *graphctx, AVClass *log_ctx); +int ff_request_frame(AVFilterLink *link); /** - * Configure the formats of all the links in the graph. + * 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_avfilter_graph_config_formats(AVFilterGraph *graphctx, AVClass *log_ctx); +int ff_filter_frame(AVFilterLink *link, AVFrame *frame); -/** default handler for freeing audio/video buffer when there are no references left */ -void ff_avfilter_default_free_buffer(AVFilterBuffer *buf); +/** + * Allocate a new filter context and return it. + * + * @param filter what filter to create an instance of + * @param inst_name name to give to the new filter context + * + * @return newly created filter context or NULL on failure + */ +AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name); -/** Tell is a format is contained in the provided list terminated by -1. */ -int ff_fmt_is_in(int fmt, const int *fmts); +/** + * Remove a filter from a graph; + */ +void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter); #endif /* AVFILTER_INTERNAL_H */