* internal API functions
*/
+#include "libavutil/internal.h"
#include "avfilter.h"
+#include "thread.h"
+#include "version.h"
-#if !FF_API_AVFILTERPAD_PUBLIC
/**
* A filter pad used for either input or output.
*/
*/
enum AVMediaType type;
- /**
- * Minimum required permissions on incoming buffers. Any buffer with
- * insufficient permissions will be automatically copied by the filter
- * system to a new buffer which provides the needed access permissions.
- *
- * Input pads only.
- */
- int min_perms;
-
- /**
- * Permissions which are not accepted on incoming buffers. Any buffer
- * which has any of these permissions set will be automatically copied
- * by the filter system to a new buffer which does not have those
- * permissions. This can be used to easily disallow buffers with
- * AV_PERM_REUSE.
- *
- * Input pads only.
- */
- int rej_perms;
-
- /**
- * Callback called before passing the first slice of a new frame. If
- * NULL, the filter layer will default to storing a reference to the
- * picture inside the link structure.
- *
- * Input video pads only.
- */
- void (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref);
-
/**
* Callback function to get a video buffer. If NULL, the filter system will
* use avfilter_default_get_video_buffer().
*
* Input video pads only.
*/
- AVFilterBufferRef *(*get_video_buffer)(AVFilterLink *link, int perms, int w, int h);
+ AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h);
/**
* Callback function to get an audio buffer. If NULL, the filter system will
*
* Input audio pads only.
*/
- AVFilterBufferRef *(*get_audio_buffer)(AVFilterLink *link, int perms,
- int nb_samples);
+ AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples);
/**
- * Callback called after the slices of a frame are completely sent. If
- * NULL, the filter layer will default to releasing the reference stored
- * in the link structure during start_frame().
+ * Filtering callback. This is where a filter receives a frame with
+ * audio/video data and should do its processing.
*
- * Input video pads only.
- */
- void (*end_frame)(AVFilterLink *link);
-
- /**
- * Slice drawing callback. This is where a filter receives video data
- * and should do its processing.
- *
- * Input video pads only.
- */
- void (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir);
-
- /**
- * Samples filtering callback. This is where a filter receives audio data
- * and should do its processing.
+ * Input pads only.
*
- * Input audio 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.
*/
- void (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
+ int (*filter_frame)(AVFilterLink *link, AVFrame *frame);
/**
* Frame poll callback. This returns the number of immediately available
* 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;
+
+ /**
+ * The filter expects writable frames from its input link,
+ * duplicating data buffers if needed.
+ *
+ * input pads only.
+ */
+ int needs_writable;
};
-#endif
-/** default handler for freeing audio/video buffer when there are no references left */
-void ff_avfilter_default_free_buffer(AVFilterBuffer *buf);
+struct AVFilterGraphInternal {
+ void *thread;
+ avfilter_execute_func *thread_execute;
+};
+
+struct AVFilterInternal {
+ avfilter_execute_func *execute;
+};
/** 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)
+#define FF_DPRINTF_START(ctx, func) av_log(NULL, AV_LOG_TRACE, "%-16s: ", #func)
void ff_dlog_link(void *ctx, AVFilterLink *link, int end);
{
ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad),
&f->input_pads, &f->inputs, p);
-#if FF_API_FOO_COUNT
- f->input_count = f->nb_inputs;
-#endif
}
/** Insert a new output pad for the filter. */
{
ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad),
&f->output_pads, &f->outputs, p);
-#if FF_API_FOO_COUNT
- f->output_count = f->nb_outputs;
-#endif
}
/**
*/
int ff_request_frame(AVFilterLink *link);
+/**
+ * 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);
+
+/**
+ * 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);
+
+/**
+ * Remove a filter from a graph;
+ */
+void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter);
+
+/**
+ * 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)
+
#endif /* AVFILTER_INTERNAL_H */
projects / ffmpeg / blobdiff