Merge remote-tracking branch 'qatar/master'

* qatar/master:
  vorbis: Validate that the floor 1 X values contain no duplicates.
  avprobe: Identify codec probe failures rather than calling them unsupported codecs.
  avformat: Probe codecs at score 0 on buffer exhaustion conditions.
  avformat: Factorize codec probing.
  Indeo Audio decoder
  imc: make IMDCT support stereo output
  imc: move channel-specific data into separate context
  lavfi: remove request/poll and drawing functions from public API on next bump
  lavfi: make avfilter_insert_pad and pals private on next bump.
  lavfi: make formats API private on next bump.
  avplay: use buffersrc instead of custom input filter.
  avtools: move buffer management code from avconv to cmdutils.
  avconv: don't use InputStream in the buffer management code.
  avconv: fix exiting when max frames is reached.
  mpc8: fix maximum bands handling
  aacdec: Turn PS off when switching to stereo and turn it to implicit when switching to mono.

Conflicts:
	Changelog
	cmdutils.h
	ffmpeg.c
	ffplay.c
	ffprobe.c
	libavcodec/avcodec.h
	libavcodec/mpc8.c
	libavcodec/v210dec.h
	libavcodec/version.h
	libavcodec/vorbisdec.c
	libavfilter/avfilter.c
	libavfilter/avfilter.h
	libavfilter/buffersrc.c
	libavfilter/formats.c
	libavfilter/src_movie.c
	libavfilter/vf_aspect.c
	libavfilter/vf_blackframe.c
	libavfilter/vf_boxblur.c
	libavfilter/vf_crop.c
	libavfilter/vf_cropdetect.c
	libavfilter/vf_delogo.c
	libavfilter/vf_drawbox.c
	libavfilter/vf_drawtext.c
	libavfilter/vf_fade.c
	libavfilter/vf_fifo.c
	libavfilter/vf_format.c
	libavfilter/vf_frei0r.c
	libavfilter/vf_gradfun.c
	libavfilter/vf_hflip.c
	libavfilter/vf_hqdn3d.c
	libavfilter/vf_libopencv.c
	libavfilter/vf_lut.c
	libavfilter/vf_overlay.c
	libavfilter/vf_pad.c
	libavfilter/vf_scale.c
	libavfilter/vf_select.c
	libavfilter/vf_showinfo.c
	libavfilter/vf_transpose.c
	libavfilter/vf_unsharp.c
	libavfilter/vf_yadif.c
	libavfilter/vsrc_color.c
	libavfilter/vsrc_testsrc.c
	libavformat/utils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>

50 files changed, 625 insertions, 340 deletions

diff --git a/libavfilter/af_aformat.c b/libavfilter/af_aformat.c
index 35e7db880a..cdd5d12d9c 100644
--- a/libavfilter/af_aformat.c
+++ b/libavfilter/af_aformat.c
@@ -106,8 +106,8 @@ static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
     }
 
     PARSE_FORMATS(s->formats_str, enum AVSampleFormat, s->formats,
-                  avfilter_add_format, av_get_sample_fmt, AV_SAMPLE_FMT_NONE, "sample format");
-    PARSE_FORMATS(s->sample_rates_str, int, s->sample_rates, avfilter_add_format,
+                  ff_add_format, av_get_sample_fmt, AV_SAMPLE_FMT_NONE, "sample format");
+    PARSE_FORMATS(s->sample_rates_str, int, s->sample_rates, ff_add_format,
                   get_sample_rate, 0, "sample rate");
     PARSE_FORMATS(s->channel_layouts_str, uint64_t, s->channel_layouts,
                   ff_add_channel_layout, av_get_channel_layout, 0,
@@ -122,8 +122,8 @@ static int query_formats(AVFilterContext *ctx)
 {
     AFormatContext *s = ctx->priv;
 
-    avfilter_set_common_formats(ctx, s->formats ? s->formats :
-                                                  avfilter_all_formats(AVMEDIA_TYPE_AUDIO));
+    ff_set_common_formats(ctx, s->formats ? s->formats :
+                                                  ff_all_formats(AVMEDIA_TYPE_AUDIO));
     ff_set_common_samplerates(ctx, s->sample_rates ? s->sample_rates :
                                                      ff_all_samplerates());
     ff_set_common_channel_layouts(ctx, s->channel_layouts ? s->channel_layouts :
diff --git a/libavfilter/af_amix.c b/libavfilter/af_amix.c
index d4af9a4234..3fc2e8499a 100644
--- a/libavfilter/af_amix.c
+++ b/libavfilter/af_amix.c
@@ -349,7 +349,7 @@ static int request_samples(AVFilterContext *ctx, int min_samples)
         if (s->input_state[i] == INPUT_OFF)
             continue;
         while (!ret && av_audio_fifo_size(s->fifos[i]) < min_samples)
-            ret = avfilter_request_frame(ctx->inputs[i]);
+            ret = ff_request_frame(ctx->inputs[i]);
         if (ret == AVERROR_EOF) {
             if (av_audio_fifo_size(s->fifos[i]) == 0) {
                 s->input_state[i] = INPUT_OFF;
@@ -410,7 +410,7 @@ static int request_frame(AVFilterLink *outlink)
     }
 
     if (s->frame_list->nb_frames == 0) {
-        ret = avfilter_request_frame(ctx->inputs[0]);
+        ret = ff_request_frame(ctx->inputs[0]);
         if (ret == AVERROR_EOF) {
             s->input_state[0] = INPUT_OFF;
             if (s->nb_inputs == 1)
@@ -497,7 +497,7 @@ static int init(AVFilterContext *ctx, const char *args, void *opaque)
         pad.name           = av_strdup(name);
         pad.filter_samples = filter_samples;
 
-        avfilter_insert_inpad(ctx, i, &pad);
+        ff_insert_inpad(ctx, i, &pad);
     }
 
     return 0;
@@ -525,8 +525,8 @@ static void uninit(AVFilterContext *ctx)
 static int query_formats(AVFilterContext *ctx)
 {
     AVFilterFormats *formats = NULL;
-    avfilter_add_format(&formats, AV_SAMPLE_FMT_FLT);
-    avfilter_set_common_formats(ctx, formats);
+    ff_add_format(&formats, AV_SAMPLE_FMT_FLT);
+    ff_set_common_formats(ctx, formats);
     ff_set_common_channel_layouts(ctx, ff_all_channel_layouts());
     ff_set_common_samplerates(ctx, ff_all_samplerates());
     return 0;
diff --git a/libavfilter/af_asyncts.c b/libavfilter/af_asyncts.c
index adb5347a80..252b32278d 100644
--- a/libavfilter/af_asyncts.c
+++ b/libavfilter/af_asyncts.c
@@ -24,6 +24,7 @@
 
 #include "audio.h"
 #include "avfilter.h"
+#include "internal.h"
 
 typedef struct ASyncContext {
     const AVClass *class;
@@ -116,7 +117,7 @@ static int request_frame(AVFilterLink *link)
 {
     AVFilterContext *ctx = link->src;
     ASyncContext      *s = ctx->priv;
-    int ret = avfilter_request_frame(ctx->inputs[0]);
+    int ret = ff_request_frame(ctx->inputs[0]);
     int nb_samples;
 
     /* flush the fifo */
diff --git a/libavfilter/af_resample.c b/libavfilter/af_resample.c
index 1fc8c04b4a..8a02cfe976 100644
--- a/libavfilter/af_resample.c
+++ b/libavfilter/af_resample.c
@@ -55,18 +55,18 @@ static int query_formats(AVFilterContext *ctx)
     AVFilterLink *inlink  = ctx->inputs[0];
     AVFilterLink *outlink = ctx->outputs[0];
 
-    AVFilterFormats        *in_formats      = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);
-    AVFilterFormats        *out_formats     = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);
+    AVFilterFormats        *in_formats      = ff_all_formats(AVMEDIA_TYPE_AUDIO);
+    AVFilterFormats        *out_formats     = ff_all_formats(AVMEDIA_TYPE_AUDIO);
     AVFilterFormats        *in_samplerates  = ff_all_samplerates();
     AVFilterFormats        *out_samplerates = ff_all_samplerates();
     AVFilterChannelLayouts *in_layouts      = ff_all_channel_layouts();
     AVFilterChannelLayouts *out_layouts     = ff_all_channel_layouts();
 
-    avfilter_formats_ref(in_formats,  &inlink->out_formats);
-    avfilter_formats_ref(out_formats, &outlink->in_formats);
+    ff_formats_ref(in_formats,  &inlink->out_formats);
+    ff_formats_ref(out_formats, &outlink->in_formats);
 
-    avfilter_formats_ref(in_samplerates,  &inlink->out_samplerates);
-    avfilter_formats_ref(out_samplerates, &outlink->in_samplerates);
+    ff_formats_ref(in_samplerates,  &inlink->out_samplerates);
+    ff_formats_ref(out_samplerates, &outlink->in_samplerates);
 
     ff_channel_layouts_ref(in_layouts,  &inlink->out_channel_layouts);
     ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
@@ -130,7 +130,7 @@ static int request_frame(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     ResampleContext   *s = ctx->priv;
-    int ret = avfilter_request_frame(ctx->inputs[0]);
+    int ret = ff_request_frame(ctx->inputs[0]);
 
     /* flush the lavr delay buffer */
     if (ret == AVERROR_EOF && s->avr) {
diff --git a/libavfilter/avfilter.c b/libavfilter/avfilter.c
index 041ba1b9c0..98c35ee00f 100644
--- a/libavfilter/avfilter.c
+++ b/libavfilter/avfilter.c
@@ -96,9 +96,9 @@ void ff_command_queue_pop(AVFilterContext *filter)
     av_free(c);
 }
 
-void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
-                         AVFilterPad **pads, AVFilterLink ***links,
-                         AVFilterPad *newpad)
+void ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
+                   AVFilterPad **pads, AVFilterLink ***links,
+                   AVFilterPad *newpad)
 {
     unsigned i;
 
@@ -183,14 +183,15 @@ int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
     /* if any information on supported media formats already exists on the
      * link, we need to preserve that */
     if (link->out_formats)
-        avfilter_formats_changeref(&link->out_formats,
+        ff_formats_changeref(&link->out_formats,
                                    &filt->outputs[filt_dstpad_idx]->out_formats);
+
+    if (link->out_samplerates)
+        ff_formats_changeref(&link->out_samplerates,
+                                   &filt->outputs[filt_dstpad_idx]->out_samplerates);
     if (link->out_channel_layouts)
         ff_channel_layouts_changeref(&link->out_channel_layouts,
                                      &filt->outputs[filt_dstpad_idx]->out_channel_layouts);
-    if (link->out_samplerates)
-        avfilter_formats_changeref(&link->out_samplerates,
-                                   &filt->outputs[filt_dstpad_idx]->out_samplerates);
 
     return 0;
 }
@@ -307,18 +308,18 @@ void ff_dlog_link(void *ctx, AVFilterLink *link, int end)
     }
 }
 
-int avfilter_request_frame(AVFilterLink *link)
+int ff_request_frame(AVFilterLink *link)
 {
     FF_DPRINTF_START(NULL, request_frame); ff_dlog_link(NULL, link, 1);
 
     if (link->srcpad->request_frame)
         return link->srcpad->request_frame(link);
     else if (link->src->inputs[0])
-        return avfilter_request_frame(link->src->inputs[0]);
+        return ff_request_frame(link->src->inputs[0]);
     else return -1;
 }
 
-int avfilter_poll_frame(AVFilterLink *link)
+int ff_poll_frame(AVFilterLink *link)
 {
     int i, min = INT_MAX;
 
@@ -329,7 +330,7 @@ int avfilter_poll_frame(AVFilterLink *link)
         int val;
         if (!link->src->inputs[i])
             return -1;
-        val = avfilter_poll_frame(link->src->inputs[i]);
+        val = ff_poll_frame(link->src->inputs[i]);
         min = FFMIN(min, val);
     }
 
@@ -492,10 +493,10 @@ void avfilter_free(AVFilterContext *filter)
         if ((link = filter->inputs[i])) {
             if (link->src)
                 link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
-            avfilter_formats_unref(&link->in_formats);
-            avfilter_formats_unref(&link->out_formats);
-            avfilter_formats_unref(&link->in_samplerates);
-            avfilter_formats_unref(&link->out_samplerates);
+            ff_formats_unref(&link->in_formats);
+            ff_formats_unref(&link->out_formats);
+            ff_formats_unref(&link->in_samplerates);
+            ff_formats_unref(&link->out_samplerates);
             ff_channel_layouts_unref(&link->in_channel_layouts);
             ff_channel_layouts_unref(&link->out_channel_layouts);
         }
@@ -505,10 +506,10 @@ void avfilter_free(AVFilterContext *filter)
         if ((link = filter->outputs[i])) {
             if (link->dst)
                 link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
-            avfilter_formats_unref(&link->in_formats);
-            avfilter_formats_unref(&link->out_formats);
-            avfilter_formats_unref(&link->in_samplerates);
-            avfilter_formats_unref(&link->out_samplerates);
+            ff_formats_unref(&link->in_formats);
+            ff_formats_unref(&link->out_formats);
+            ff_formats_unref(&link->in_samplerates);
+            ff_formats_unref(&link->out_samplerates);
             ff_channel_layouts_unref(&link->in_channel_layouts);
             ff_channel_layouts_unref(&link->out_channel_layouts);
         }
@@ -535,3 +536,32 @@ int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque
         ret = filter->filter->init(filter, args, opaque);
     return ret;
 }
+
+#if FF_API_DEFAULT_CONFIG_OUTPUT_LINK
+void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
+                         AVFilterPad **pads, AVFilterLink ***links,
+                         AVFilterPad *newpad)
+{
+    ff_insert_pad(idx, count, padidx_off, pads, links, newpad);
+}
+void avfilter_insert_inpad(AVFilterContext *f, unsigned index,
+                           AVFilterPad *p)
+{
+    ff_insert_pad(index, &f->input_count, offsetof(AVFilterLink, dstpad),
+                  &f->input_pads, &f->inputs, p);
+}
+void avfilter_insert_outpad(AVFilterContext *f, unsigned index,
+                            AVFilterPad *p)
+{
+    ff_insert_pad(index, &f->output_count, offsetof(AVFilterLink, srcpad),
+                  &f->output_pads, &f->outputs, p);
+}
+int avfilter_poll_frame(AVFilterLink *link)
+{
+    return ff_poll_frame(link);
+}
+int avfilter_request_frame(AVFilterLink *link)
+{
+    return ff_request_frame(link);
+}
+#endif
diff --git a/libavfilter/avfilter.h b/libavfilter/avfilter.h
index 10803c54fa..334a1c104f 100644
--- a/libavfilter/avfilter.h
+++ b/libavfilter/avfilter.h
@@ -60,6 +60,7 @@ const char *avfilter_license(void);
 typedef struct AVFilterContext AVFilterContext;
 typedef struct AVFilterLink    AVFilterLink;
 typedef struct AVFilterPad     AVFilterPad;
+typedef struct AVFilterFormats AVFilterFormats;
 
 /**
  * A reference-counted buffer data type used by the filter system. Filters
@@ -210,6 +211,7 @@ AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask);
  */
 void avfilter_unref_buffer(AVFilterBufferRef *ref);
 
+#if FF_API_FILTERS_PUBLIC
 /**
  * Remove a reference to a buffer and set the pointer to NULL.
  * If this is the last reference to the buffer, the buffer itself
@@ -258,14 +260,18 @@ void avfilter_unref_bufferp(AVFilterBufferRef **ref);
  * we must ensure that all links which reference either pre-merge format list
  * get updated as well. Therefore, we have the format list structure store a
  * pointer to each of the pointers to itself.
+ * @addtogroup lavfi_deprecated
+ * @deprecated Those functions are only useful inside filters and
+ * user filters are not supported at this point.
+ * @{
  */
-typedef struct AVFilterFormats {
+struct AVFilterFormats {
     unsigned format_count;      ///< number of formats
     int *formats;               ///< list of media formats
 
     unsigned refcount;          ///< number of references to this list
     struct AVFilterFormats ***refs; ///< references to this list
-}  AVFilterFormats;
+};
 
 /**
  * Create a list of supported formats. This is intended for use in
@@ -275,6 +281,7 @@ typedef struct AVFilterFormats {
  *        empty list is created.
  * @return the format list, with no existing references
  */
+attribute_deprecated
 AVFilterFormats *avfilter_make_format_list(const int *fmts);
 
 /**
@@ -284,16 +291,12 @@ AVFilterFormats *avfilter_make_format_list(const int *fmts);
  *
  * @return a non negative value in case of success, or a negative
  * value corresponding to an AVERROR code in case of error
- */
-int avfilter_add_format(AVFilterFormats **avff, int64_t fmt);
-
-#if FF_API_OLD_ALL_FORMATS_API
-/**
  * @deprecated Use avfilter_make_all_formats() instead.
  */
 attribute_deprecated
+int avfilter_add_format(AVFilterFormats **avff, int64_t fmt);
+attribute_deprecated
 AVFilterFormats *avfilter_all_formats(enum AVMediaType type);
-#endif
 
 /**
  * Return a list of all formats supported by FFmpeg for the given media type.
@@ -320,6 +323,7 @@ AVFilterFormats *avfilter_make_all_packing_formats(void);
  * If a and b do not share any common formats, neither is modified, and NULL
  * is returned.
  */
+attribute_deprecated
 AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b);
 
 /**
@@ -334,40 +338,36 @@ AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b);
  *  | |____| |    | |____|
  *  |________|    |________________________
  */
+attribute_deprecated
 void avfilter_formats_ref(AVFilterFormats *formats, AVFilterFormats **ref);
-
+attribute_deprecated
+void avfilter_formats_unref(AVFilterFormats **ref);
+attribute_deprecated
+void avfilter_formats_changeref(AVFilterFormats **oldref,
+                                AVFilterFormats **newref);
 /**
- * If *ref is non-NULL, remove *ref as a reference to the format list
- * it currently points to, deallocates that list if this was the last
- * reference, and sets *ref to NULL.
- *
- *         Before                                 After
- *   ________                               ________         NULL
- *  |formats |<--------.                   |formats |         ^
- *  |  ____  |     ____|________________   |  ____  |     ____|________________
- *  | |refs| |    |  __|_                  | |refs| |    |  __|_
- *  | |* * | |    | |  | |  AVFilterLink   | |* * | |    | |  | |  AVFilterLink
- *  | |* *--------->|*ref|                 | |*   | |    | |*ref|
- *  | |____| |    | |____|                 | |____| |    | |____|
- *  |________|    |_____________________   |________|    |_____________________
+ * Helpers for query_formats() which set all links to the same list of
+ * formats/layouts. If there are no links hooked to this filter, the list
+ * of formats is freed.
  */
-void avfilter_formats_unref(AVFilterFormats **ref);
+attribute_deprecated
+void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats);
+
+attribute_deprecated
+void avfilter_set_common_pixel_formats(AVFilterContext *ctx, AVFilterFormats *formats);
+attribute_deprecated
+void avfilter_set_common_sample_formats(AVFilterContext *ctx, AVFilterFormats *formats);
+attribute_deprecated
+void avfilter_set_common_channel_layouts(AVFilterContext *ctx, AVFilterFormats *formats);
+#if FF_API_PACKING
+attribute_deprecated
+void avfilter_set_common_packing_formats(AVFilterContext *ctx, AVFilterFormats *formats);
+#endif
 
 /**
- *
- *         Before                                 After
- *   ________                         ________
- *  |formats |<---------.            |formats |<---------.
- *  |  ____  |       ___|___         |  ____  |       ___|___
- *  | |refs| |      |   |   |        | |refs| |      |   |   |   NULL
- *  | |* *--------->|*oldref|        | |* *--------->|*newref|     ^
- *  | |* * | |      |_______|        | |* * | |      |_______|  ___|___
- *  | |____| |                       | |____| |                |   |   |
- *  |________|                       |________|                |*oldref|
- *                                                             |_______|
+ * @}
  */
-void avfilter_formats_changeref(AVFilterFormats **oldref,
-                                AVFilterFormats **newref);
+#endif
 
 /**
  * A filter pad used for either input or output.
@@ -523,19 +523,6 @@ attribute_deprecated
 int avfilter_default_query_formats(AVFilterContext *ctx);
 #endif
 
-/**
- * Helpers for query_formats() which set all links to the same list of
- * formats/layouts. If there are no links hooked to this filter, the list
- * of formats is freed.
- */
-void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats);
-void avfilter_set_common_pixel_formats(AVFilterContext *ctx, AVFilterFormats *formats);
-void avfilter_set_common_sample_formats(AVFilterContext *ctx, AVFilterFormats *formats);
-void avfilter_set_common_channel_layouts(AVFilterContext *ctx, AVFilterFormats *formats);
-#if FF_API_PACKING
-void avfilter_set_common_packing_formats(AVFilterContext *ctx, AVFilterFormats *formats);
-#endif
-
 #if FF_API_FILTERS_PUBLIC
 /** start_frame() handler for filters which simply pass video along */
 attribute_deprecated
@@ -831,6 +818,7 @@ AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
                                                              enum AVSampleFormat sample_fmt,
                                                              uint64_t channel_layout);
 
+#if FF_API_FILTERS_PUBLIC
 /**
  * Request an input frame from the filter at the other end of the link.
  *
@@ -842,24 +830,10 @@ AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
  */
 int avfilter_request_frame(AVFilterLink *link);
 
-/**
- * Poll a frame from the filter chain.
- *
- * @param  link the input link
- * @return the number of immediately available frames, a negative
- * number in case of error
- */
+attribute_deprecated
 int avfilter_poll_frame(AVFilterLink *link);
 
-/**
- * Notify the next filter of the start of a frame.
- *
- * @param link   the output link the frame will be sent over
- * @param picref A reference to the frame about to be sent. The data for this
- *               frame need only be valid once draw_slice() is called for that
- *               portion. The receiving filter will free this reference when
- *               it no longer needs it.
- */
+attribute_deprecated
 void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
 
 /**
@@ -867,24 +841,11 @@ void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
  *
  * @param link the output link the frame was sent over
  */
+attribute_deprecated
 void avfilter_end_frame(AVFilterLink *link);
-
-/**
- * Send a slice to the next filter.
- *
- * Slices have to be provided in sequential order, either in
- * top-bottom or bottom-top order. If slices are provided in
- * non-sequential order the behavior of the function is undefined.
- *
- * @param link the output link over which the frame is being sent
- * @param y    offset in pixels from the top of the image for this slice
- * @param h    height of this slice in pixels
- * @param slice_dir the assumed direction for sending slices,
- *             from the top slice to the bottom slice if the value is 1,
- *             from the bottom slice to the top slice if the value is -1,
- *             for other values the behavior of the function is undefined.
- */
+attribute_deprecated
 void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
+#endif
 
 #define AVFILTER_CMD_FLAG_ONE   1 ///< Stop once a filter understood the command (for target=all for example), fast filters are favored automatically
 #define AVFILTER_CMD_FLAG_FAST  2 ///< Only execute command when its fast (like a video out that supports contrast adjustment in hw)
@@ -972,37 +933,18 @@ void avfilter_free(AVFilterContext *filter);
 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
                            unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
 
-/**
- * Insert a new pad.
- *
- * @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.
- */
+#if FF_API_FILTERS_PUBLIC
+attribute_deprecated
 void avfilter_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 avfilter_insert_inpad(AVFilterContext *f, unsigned index,
-                                         AVFilterPad *p)
-{
-    avfilter_insert_pad(index, &f->input_count, offsetof(AVFilterLink, dstpad),
-                        &f->input_pads, &f->inputs, p);
-}
-
-/** Insert a new output pad for the filter. */
-static inline void avfilter_insert_outpad(AVFilterContext *f, unsigned index,
-                                          AVFilterPad *p)
-{
-    avfilter_insert_pad(index, &f->output_count, offsetof(AVFilterLink, srcpad),
-                        &f->output_pads, &f->outputs, p);
-}
+attribute_deprecated
+void avfilter_insert_inpad(AVFilterContext *f, unsigned index,
+                           AVFilterPad *p);
+attribute_deprecated
+void avfilter_insert_outpad(AVFilterContext *f, unsigned index,
+                            AVFilterPad *p);
+#endif
 
 #endif /* AVFILTER_AVFILTER_H */
diff --git a/libavfilter/avfiltergraph.c b/libavfilter/avfiltergraph.c
index 80715ee7df..09bbe106cf 100644
--- a/libavfilter/avfiltergraph.c
+++ b/libavfilter/avfiltergraph.c
@@ -324,7 +324,7 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
                 continue;
 
             if (link->in_formats != link->out_formats &&
-                !avfilter_merge_formats(link->in_formats,
+                !ff_merge_formats(link->in_formats,
                                         link->out_formats))
                 convert_needed = 1;
             if (link->type == AVMEDIA_TYPE_AUDIO) {
@@ -381,8 +381,8 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
                 filter_query_formats(convert);
                 inlink  = convert->inputs[0];
                 outlink = convert->outputs[0];
-                if (!avfilter_merge_formats( inlink->in_formats,  inlink->out_formats) ||
-                    !avfilter_merge_formats(outlink->in_formats, outlink->out_formats))
+                if (!ff_merge_formats( inlink->in_formats,  inlink->out_formats) ||
+                    !ff_merge_formats(outlink->in_formats, outlink->out_formats))
                     ret |= AVERROR(ENOSYS);
                 if (inlink->type == AVMEDIA_TYPE_AUDIO &&
                     (!ff_merge_samplerates(inlink->in_samplerates,
@@ -452,10 +452,10 @@ static int pick_format(AVFilterLink *link, AVFilterLink *ref)
         link->channel_layout = link->in_channel_layouts->channel_layouts[0];
     }
 
-    avfilter_formats_unref(&link->in_formats);
-    avfilter_formats_unref(&link->out_formats);
-    avfilter_formats_unref(&link->in_samplerates);
-    avfilter_formats_unref(&link->out_samplerates);
+    ff_formats_unref(&link->in_formats);
+    ff_formats_unref(&link->out_formats);
+    ff_formats_unref(&link->in_samplerates);
+    ff_formats_unref(&link->out_samplerates);
     ff_channel_layouts_unref(&link->in_channel_layouts);
     ff_channel_layouts_unref(&link->out_channel_layouts);
 
@@ -502,9 +502,9 @@ static int reduce_formats_on_filter(AVFilterContext *filter)
     int i, j, k, ret = 0;
 
     REDUCE_FORMATS(int,      AVFilterFormats,        formats,         formats,
-                   format_count, avfilter_add_format);
+                   format_count, ff_add_format);
     REDUCE_FORMATS(int,      AVFilterFormats,        samplerates,     formats,
-                   format_count, avfilter_add_format);
+                   format_count, ff_add_format);
     REDUCE_FORMATS(uint64_t, AVFilterChannelLayouts, channel_layouts,
                    channel_layouts, nb_channel_layouts, ff_add_channel_layout);
 
diff --git a/libavfilter/buffersink.c b/libavfilter/buffersink.c
index 90ebd93908..bd693baca8 100644
--- a/libavfilter/buffersink.c
+++ b/libavfilter/buffersink.c
@@ -31,6 +31,7 @@
 #include "audio.h"
 #include "avfilter.h"
 #include "buffersink.h"
+#include "internal.h"
 
 typedef struct {
     AVFifoBuffer *fifo;          ///< FIFO buffer of frame references
@@ -102,11 +103,11 @@ int av_buffersink_read(AVFilterContext *ctx, AVFilterBufferRef **buf)
         if (av_fifo_size(sink->fifo))
             return av_fifo_size(sink->fifo)/sizeof(*buf);
         else
-            return avfilter_poll_frame(ctx->inputs[0]);
+            return ff_poll_frame(ctx->inputs[0]);
     }
 
     if (!av_fifo_size(sink->fifo) &&
-        (ret = avfilter_request_frame(link)) < 0)
+        (ret = ff_request_frame(link)) < 0)
         return ret;
 
     if (!av_fifo_size(sink->fifo))
diff --git a/libavfilter/buffersrc.c b/libavfilter/buffersrc.c
index 0c60caf942..7a392f64f1 100644
--- a/libavfilter/buffersrc.c
+++ b/libavfilter/buffersrc.c
@@ -28,6 +28,7 @@
 #include "buffersrc.h"
 #include "formats.h"
 #include "internal.h"
+#include "video.h"
 #include "vsrc_buffer.h"
 #include "avcodec.h"
 
@@ -328,14 +329,14 @@ static int query_formats(AVFilterContext *ctx)
 
     switch (ctx->outputs[0]->type) {
     case AVMEDIA_TYPE_VIDEO:
-        avfilter_add_format(&formats, c->pix_fmt);
-        avfilter_set_common_formats(ctx, formats);
+        ff_add_format(&formats, c->pix_fmt);
+        ff_set_common_formats(ctx, formats);
         break;
     case AVMEDIA_TYPE_AUDIO:
-        avfilter_add_format(&formats,           c->sample_fmt);
-        avfilter_set_common_formats(ctx, formats);
+        ff_add_format(&formats,           c->sample_fmt);
+        ff_set_common_formats(ctx, formats);
 
-        avfilter_add_format(&samplerates,       c->sample_rate);
+        ff_add_format(&samplerates,       c->sample_rate);
         ff_set_common_samplerates(ctx, samplerates);
 
         ff_add_channel_layout(&channel_layouts, c->channel_layout);
@@ -385,9 +386,9 @@ static int request_frame(AVFilterLink *link)
 
     switch (link->type) {
     case AVMEDIA_TYPE_VIDEO:
-        avfilter_start_frame(link, avfilter_ref_buffer(buf, ~0));
-        avfilter_draw_slice(link, 0, link->h, 1);
-        avfilter_end_frame(link);
+        ff_start_frame(link, avfilter_ref_buffer(buf, ~0));
+        ff_draw_slice(link, 0, link->h, 1);
+        ff_end_frame(link);
         break;
     case AVMEDIA_TYPE_AUDIO:
         ff_filter_samples(link, avfilter_ref_buffer(buf, ~0));
diff --git a/libavfilter/formats.c b/libavfilter/formats.c
index 1fd95eb174..930ed16f5a 100644
--- a/libavfilter/formats.c
+++ b/libavfilter/formats.c
@@ -85,7 +85,7 @@ do {
     MERGE_REF(ret, b, fmts, type, fail);                                        \
 } while (0)
 
-AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b)
+AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b)
 {
     AVFilterFormats *ret = NULL;
 
@@ -213,7 +213,7 @@ int64_t *ff_copy_int64_list(const int64_t * const list)
         }                                                               \
     }
 
-AVFilterFormats *avfilter_make_format_list(const int *fmts)
+AVFilterFormats *ff_make_format_list(const int *fmts)
 {
     MAKE_FORMAT_LIST(AVFilterFormats, formats, format_count);
     while (count--)
@@ -250,7 +250,7 @@ do {                                                        \
     return 0;                                               \
 } while (0)
 
-int avfilter_add_format(AVFilterFormats **avff, int64_t fmt)
+int ff_add_format(AVFilterFormats **avff, int64_t fmt)
 {
     ADD_FORMAT(avff, fmt, int, formats, format_count);
 }
@@ -260,12 +260,10 @@ int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
     ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
 }
 
-#if FF_API_OLD_ALL_FORMATS_API
-AVFilterFormats *avfilter_all_formats(enum AVMediaType type)
+AVFilterFormats *ff_all_formats(enum AVMediaType type)
 {
     return avfilter_make_all_formats(type);
 }
-#endif
 
 AVFilterFormats *avfilter_make_all_formats(enum AVMediaType type)
 {
@@ -277,7 +275,7 @@ AVFilterFormats *avfilter_make_all_formats(enum AVMediaType type)
     for (fmt = 0; fmt < num_formats; fmt++)
         if ((type != AVMEDIA_TYPE_VIDEO) ||
             (type == AVMEDIA_TYPE_VIDEO && !(av_pix_fmt_descriptors[fmt].flags & PIX_FMT_HWACCEL)))
-            avfilter_add_format(&ret, fmt);
+            ff_add_format(&ret, fmt);
 
     return ret;
 }
@@ -329,7 +327,7 @@ void ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **
     FORMATS_REF(f, ref);
 }
 
-void avfilter_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
+void ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
 {
     FORMATS_REF(f, ref);
 }
@@ -365,7 +363,7 @@ do {                                                               \
     *ref = NULL;                                                   \
 } while (0)
 
-void avfilter_formats_unref(AVFilterFormats **ref)
+void ff_formats_unref(AVFilterFormats **ref)
 {
     FORMATS_UNREF(ref, formats);
 }
@@ -394,8 +392,7 @@ void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
     FORMATS_CHANGEREF(oldref, newref);
 }
 
-void avfilter_formats_changeref(AVFilterFormats **oldref,
-                                AVFilterFormats **newref)
+void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
 {
     FORMATS_CHANGEREF(oldref, newref);
 }
@@ -435,7 +432,7 @@ void ff_set_common_samplerates(AVFilterContext *ctx,
                                AVFilterFormats *samplerates)
 {
     SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
-                       avfilter_formats_ref, formats);
+                       ff_formats_ref, formats);
 }
 
 /**
@@ -443,10 +440,10 @@ void ff_set_common_samplerates(AVFilterContext *ctx,
  * formats. If there are no links hooked to this filter, the list of formats is
  * freed.
  */
-void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
+void ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
 {
     SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
-                       avfilter_formats_ref, formats);
+                       ff_formats_ref, formats);
 }
 
 int ff_default_query_formats(AVFilterContext *ctx)
@@ -455,7 +452,7 @@ int ff_default_query_formats(AVFilterContext *ctx)
                             ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
                             AVMEDIA_TYPE_VIDEO;
 
-    avfilter_set_common_formats(ctx, avfilter_all_formats(type));
+    ff_set_common_formats(ctx, ff_all_formats(type));
     if (type == AVMEDIA_TYPE_AUDIO) {
         ff_set_common_channel_layouts(ctx, ff_all_channel_layouts());
         ff_set_common_samplerates(ctx, ff_all_samplerates());
@@ -539,6 +536,39 @@ int avfilter_default_query_formats(AVFilterContext *ctx)
 {
     return ff_default_query_formats(ctx);
 }
+void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
+{
+    ff_set_common_formats(ctx, formats);
+}
+AVFilterFormats *avfilter_make_format_list(const int *fmts)
+{
+    return ff_make_format_list(fmts);
+}
+int avfilter_add_format(AVFilterFormats **avff, int64_t fmt)
+{
+    return ff_add_format(avff, fmt);
+}
+AVFilterFormats *avfilter_all_formats(enum AVMediaType type)
+{
+    return ff_all_formats(type);
+}
+AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b)
+{
+    return ff_merge_formats(a, b);
+}
+void avfilter_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
+{
+    ff_formats_ref(f, ref);
+}
+void avfilter_formats_unref(AVFilterFormats **ref)
+{
+    ff_formats_unref(ref);
+}
+void avfilter_formats_changeref(AVFilterFormats **oldref,
+                                AVFilterFormats **newref)
+{
+    ff_formats_changeref(oldref, newref);
+}
 #endif
 #ifdef TEST
 
diff --git a/libavfilter/formats.h b/libavfilter/formats.h
index c7503d649a..7e16733b74 100644
--- a/libavfilter/formats.h
+++ b/libavfilter/formats.h
@@ -21,6 +21,56 @@
 
 #include "avfilter.h"
 
+/**
+ * A list of supported formats for one end of a filter link. This is used
+ * during the format negotiation process to try to pick the best format to
+ * use to minimize the number of necessary conversions. Each filter gives a
+ * list of the formats supported by each input and output pad. The list
+ * given for each pad need not be distinct - they may be references to the
+ * same list of formats, as is often the case when a filter supports multiple
+ * formats, but will always output the same format as it is given in input.
+ *
+ * In this way, a list of possible input formats and a list of possible
+ * output formats are associated with each link. When a set of formats is
+ * negotiated over a link, the input and output lists are merged to form a
+ * new list containing only the common elements of each list. In the case
+ * that there were no common elements, a format conversion is necessary.
+ * Otherwise, the lists are merged, and all other links which reference
+ * either of the format lists involved in the merge are also affected.
+ *
+ * For example, consider the filter chain:
+ * filter (a) --> (b) filter (b) --> (c) filter
+ *
+ * where the letters in parenthesis indicate a list of formats supported on
+ * the input or output of the link. Suppose the lists are as follows:
+ * (a) = {A, B}
+ * (b) = {A, B, C}
+ * (c) = {B, C}
+ *
+ * First, the first link's lists are merged, yielding:
+ * filter (a) --> (a) filter (a) --> (c) filter
+ *
+ * Notice that format list (b) now refers to the same list as filter list (a).
+ * Next, the lists for the second link are merged, yielding:
+ * filter (a) --> (a) filter (a) --> (a) filter
+ *
+ * where (a) = {B}.
+ *
+ * Unfortunately, when the format lists at the two ends of a link are merged,
+ * we must ensure that all links which reference either pre-merge format list
+ * get updated as well. Therefore, we have the format list structure store a
+ * pointer to each of the pointers to itself.
+ */
+#if !FF_API_FILTERS_PUBLIC
+struct AVFilterFormats {
+    unsigned format_count;      ///< number of formats
+    int *formats;               ///< list of media formats
+
+    unsigned refcount;          ///< number of references to this list
+    struct AVFilterFormats ***refs; ///< references to this list
+};
+#endif
+
 typedef struct AVFilterChannelLayouts {
     uint64_t *channel_layouts;  ///< list of channel layouts
     int    nb_channel_layouts;  ///< number of channel layouts
@@ -62,6 +112,13 @@ void ff_set_common_channel_layouts(AVFilterContext *ctx,
 void ff_set_common_samplerates(AVFilterContext *ctx,
                                AVFilterFormats *samplerates);
 
+/**
+ * A helper for query_formats() which sets all links to the same list of
+ * formats. If there are no links hooked to this filter, the list of formats is
+ * freed.
+ */
+void ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats);
+
 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout);
 
 /**
@@ -80,4 +137,85 @@ void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
 
 int ff_default_query_formats(AVFilterContext *ctx);
 
+
+/**
+ * Create a list of supported formats. This is intended for use in
+ * AVFilter->query_formats().
+ *
+ * @param fmts list of media formats, terminated by -1
+ * @return the format list, with no existing references
+ */
+AVFilterFormats *ff_make_format_list(const int *fmts);
+
+/**
+ * Add fmt to the list of media formats contained in *avff.
+ * If *avff is NULL the function allocates the filter formats struct
+ * and puts its pointer in *avff.
+ *
+ * @return a non negative value in case of success, or a negative
+ * value corresponding to an AVERROR code in case of error
+ */
+int ff_add_format(AVFilterFormats **avff, int64_t fmt);
+
+/**
+ * Return a list of all formats supported by Libav for the given media type.
+ */
+AVFilterFormats *ff_all_formats(enum AVMediaType type);
+
+/**
+ * Return a format list which contains the intersection of the formats of
+ * a and b. Also, all the references of a, all the references of b, and
+ * a and b themselves will be deallocated.
+ *
+ * If a and b do not share any common formats, neither is modified, and NULL
+ * is returned.
+ */
+AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b);
+
+/**
+ * Add *ref as a new reference to formats.
+ * That is the pointers will point like in the ascii art below:
+ *   ________
+ *  |formats |<--------.
+ *  |  ____  |     ____|___________________
+ *  | |refs| |    |  __|_
+ *  | |* * | |    | |  | |  AVFilterLink
+ *  | |* *--------->|*ref|
+ *  | |____| |    | |____|
+ *  |________|    |________________________
+ */
+void ff_formats_ref(AVFilterFormats *formats, AVFilterFormats **ref);
+
+/**
+ * If *ref is non-NULL, remove *ref as a reference to the format list
+ * it currently points to, deallocates that list if this was the last
+ * reference, and sets *ref to NULL.
+ *
+ *         Before                                 After
+ *   ________                               ________         NULL
+ *  |formats |<--------.                   |formats |         ^
+ *  |  ____  |     ____|________________   |  ____  |     ____|________________
+ *  | |refs| |    |  __|_                  | |refs| |    |  __|_
+ *  | |* * | |    | |  | |  AVFilterLink   | |* * | |    | |  | |  AVFilterLink
+ *  | |* *--------->|*ref|                 | |*   | |    | |*ref|
+ *  | |____| |    | |____|                 | |____| |    | |____|
+ *  |________|    |_____________________   |________|    |_____________________
+ */
+void ff_formats_unref(AVFilterFormats **ref);
+
+/**
+ *
+ *         Before                                 After
+ *   ________                         ________
+ *  |formats |<---------.            |formats |<---------.
+ *  |  ____  |       ___|___         |  ____  |       ___|___
+ *  | |refs| |      |   |   |        | |refs| |      |   |   |   NULL
+ *  | |* *--------->|*oldref|        | |* *--------->|*newref|     ^
+ *  | |* * | |      |_______|        | |* * | |      |_______|  ___|___
+ *  | |____| |                       | |____| |                |   |   |
+ *  |________|                       |________|                |*oldref|
+ *                                                             |_______|
+ */
+void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref);
+
 #endif // AVFILTER_FORMATS_H
diff --git a/libavfilter/internal.h b/libavfilter/internal.h
index 0b294d83aa..c208edf229 100644
--- a/libavfilter/internal.h
+++ b/libavfilter/internal.h
@@ -144,4 +144,54 @@ void ff_dlog_ref(void *ctx, AVFilterBufferRef *ref, int end);
 
 void ff_dlog_link(void *ctx, AVFilterLink *link, int end);
 
+/**
+ * Insert a new pad.
+ *
+ * @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->input_count, offsetof(AVFilterLink, dstpad),
+                  &f->input_pads, &f->inputs, p);
+}
+
+/** 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->output_count, offsetof(AVFilterLink, srcpad),
+                  &f->output_pads, &f->outputs, p);
+}
+
+/**
+ * Poll a frame from the filter chain.
+ *
+ * @param  link the input link
+ * @return the number of immediately available frames, a negative
+ * number in case of error
+ */
+int ff_poll_frame(AVFilterLink *link);
+
+/**
+ * Request an input frame from the filter at the other end of the link.
+ *
+ * @param link the input link
+ * @return     zero on success
+ */
+int ff_request_frame(AVFilterLink *link);
+
 #endif /* AVFILTER_INTERNAL_H */
diff --git a/libavfilter/split.c b/libavfilter/split.c
index 97e5265a30..b7d8b87e68 100644
--- a/libavfilter/split.c
+++ b/libavfilter/split.c
@@ -25,6 +25,7 @@
 
 #include "avfilter.h"
 #include "audio.h"
+#include "internal.h"
 #include "video.h"
 
 static int split_init(AVFilterContext *ctx, const char *args, void *opaque)
@@ -48,7 +49,7 @@ static int split_init(AVFilterContext *ctx, const char *args, void *opaque)
         pad.type = ctx->filter->inputs[0].type;
         pad.name = av_strdup(name);
 
-        avfilter_insert_outpad(ctx, i, &pad);
+        ff_insert_outpad(ctx, i, &pad);
     }
 
     return 0;
@@ -68,8 +69,8 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
     int i;
 
     for (i = 0; i < ctx->output_count; i++)
-        avfilter_start_frame(ctx->outputs[i],
-                             avfilter_ref_buffer(picref, ~AV_PERM_WRITE));
+        ff_start_frame(ctx->outputs[i],
+                       avfilter_ref_buffer(picref, ~AV_PERM_WRITE));
 }
 
 static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
@@ -78,7 +79,7 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
     int i;
 
     for (i = 0; i < ctx->output_count; i++)
-        avfilter_draw_slice(ctx->outputs[i], y, h, slice_dir);
+        ff_draw_slice(ctx->outputs[i], y, h, slice_dir);
 }
 
 static void end_frame(AVFilterLink *inlink)
@@ -87,7 +88,7 @@ static void end_frame(AVFilterLink *inlink)
     int i;
 
     for (i = 0; i < ctx->output_count; i++)
-        avfilter_end_frame(ctx->outputs[i]);
+        ff_end_frame(ctx->outputs[i]);
 
     avfilter_unref_buffer(inlink->cur_buf);
 }
diff --git a/libavfilter/src_movie.c b/libavfilter/src_movie.c
index ca73ad064a..354d67c941 100644
--- a/libavfilter/src_movie.c
+++ b/libavfilter/src_movie.c
@@ -39,6 +39,7 @@
 #include "avcodec.h"
 #include "avfilter.h"
 #include "formats.h"
+#include "video.h"
 
 typedef struct {
     /* common A/V fields */
@@ -219,7 +220,7 @@ static int movie_query_formats(AVFilterContext *ctx)
     MovieContext *movie = ctx->priv;
     enum PixelFormat pix_fmts[] = { movie->codec_ctx->pix_fmt, PIX_FMT_NONE };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -318,9 +319,9 @@ static int movie_request_frame(AVFilterLink *outlink)
         return ret;
 
     outpicref = avfilter_ref_buffer(movie->picref, ~0);
-    avfilter_start_frame(outlink, outpicref);
-    avfilter_draw_slice(outlink, 0, outlink->h, 1);
-    avfilter_end_frame(outlink);
+    ff_start_frame(outlink, outpicref);
+    ff_draw_slice(outlink, 0, outlink->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(movie->picref);
     movie->picref = NULL;
 
diff --git a/libavfilter/vf_aspect.c b/libavfilter/vf_aspect.c
index 685c96f2d2..179ef292b7 100644
--- a/libavfilter/vf_aspect.c
+++ b/libavfilter/vf_aspect.c
@@ -55,7 +55,7 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
     AspectContext *aspect = link->dst->priv;
 
     picref->video->sample_aspect_ratio = aspect->ratio;
-    avfilter_start_frame(link->dst->outputs[0], picref);
+    ff_start_frame(link->dst->outputs[0], picref);
 }
 
 #if CONFIG_SETDAR_FILTER
diff --git a/libavfilter/vf_blackframe.c b/libavfilter/vf_blackframe.c
index c54a8e1b45..4a415b0e38 100644
--- a/libavfilter/vf_blackframe.c
+++ b/libavfilter/vf_blackframe.c
@@ -29,6 +29,7 @@
 
 #include "avfilter.h"
 #include "internal.h"
+#include "formats.h"
 #include "video.h"
 
 typedef struct {
@@ -47,7 +48,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -89,7 +90,7 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
         p += picref->linesize[0];
     }
 
-    avfilter_draw_slice(ctx->outputs[0], y, h, slice_dir);
+    ff_draw_slice(ctx->outputs[0], y, h, slice_dir);
 }
 
 static void end_frame(AVFilterLink *inlink)
@@ -113,7 +114,7 @@ static void end_frame(AVFilterLink *inlink)
     blackframe->frame++;
     blackframe->nblack = 0;
     avfilter_unref_buffer(picref);
-    avfilter_end_frame(inlink->dst->outputs[0]);
+    ff_end_frame(inlink->dst->outputs[0]);
 }
 
 AVFilter avfilter_vf_blackframe = {
diff --git a/libavfilter/vf_boxblur.c b/libavfilter/vf_boxblur.c
index 60c9be9a0b..d8aa764d9a 100644
--- a/libavfilter/vf_boxblur.c
+++ b/libavfilter/vf_boxblur.c
@@ -29,6 +29,8 @@
 #include "libavutil/eval.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 
 static const char *const var_names[] = {
     "w",
@@ -129,7 +131,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -324,7 +326,7 @@ static void end_frame(AVFilterLink *inlink)
               w[plane], h[plane], boxblur->radius[plane], boxblur->power[plane],
               boxblur->temp);
 
-    avfilter_draw_slice(outlink, 0, inlink->h, 1);
+    ff_draw_slice(outlink, 0, inlink->h, 1);
     avfilter_default_end_frame(inlink);
 }
 
diff --git a/libavfilter/vf_crop.c b/libavfilter/vf_crop.c
index b8cfd440aa..48af9c8127 100644
--- a/libavfilter/vf_crop.c
+++ b/libavfilter/vf_crop.c
@@ -26,6 +26,7 @@
 /* #define DEBUG */
 
 #include "avfilter.h"
+#include "formats.h"
 #include "video.h"
 #include "libavutil/eval.h"
 #include "libavutil/avstring.h"
@@ -113,7 +114,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 
     return 0;
 }
@@ -308,7 +309,7 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
         ref2->data[3] += crop->x * crop->max_step[3];
     }
 
-    avfilter_start_frame(link->dst->outputs[0], ref2);
+    ff_start_frame(link->dst->outputs[0], ref2);
 }
 
 static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
@@ -326,7 +327,7 @@ static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
     if (y + h > crop->y + crop->h)
         h = crop->y + crop->h - y;
 
-    avfilter_draw_slice(ctx->outputs[0], y - crop->y, h, slice_dir);
+    ff_draw_slice(ctx->outputs[0], y - crop->y, h, slice_dir);
 }
 
 static void end_frame(AVFilterLink *link)
@@ -335,7 +336,7 @@ static void end_frame(AVFilterLink *link)
 
     crop->var_values[VAR_N] += 1.0;
     avfilter_unref_buffer(link->cur_buf);
-    avfilter_end_frame(link->dst->outputs[0]);
+    ff_end_frame(link->dst->outputs[0]);
 }
 
 AVFilter avfilter_vf_crop = {
diff --git a/libavfilter/vf_cropdetect.c b/libavfilter/vf_cropdetect.c
index 19e6e8d375..ed5d04eea8 100644
--- a/libavfilter/vf_cropdetect.c
+++ b/libavfilter/vf_cropdetect.c
@@ -25,6 +25,7 @@
 
 #include "libavutil/imgutils.h"
 #include "avfilter.h"
+#include "formats.h"
 #include "video.h"
 
 typedef struct {
@@ -47,7 +48,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -189,7 +190,7 @@ static void end_frame(AVFilterLink *inlink)
                w, h, x, y);
     }
 
-    avfilter_end_frame(inlink->dst->outputs[0]);
+    ff_end_frame(inlink->dst->outputs[0]);
 }
 
 AVFilter avfilter_vf_cropdetect = {
diff --git a/libavfilter/vf_delogo.c b/libavfilter/vf_delogo.c
index a9ba442699..2949d7e931 100644
--- a/libavfilter/vf_delogo.c
+++ b/libavfilter/vf_delogo.c
@@ -29,6 +29,7 @@
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "formats.h"
 #include "video.h"
 
 /**
@@ -164,7 +165,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -226,7 +227,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
         outpicref = inpicref;
 
     outlink->out_buf = outpicref;
-    avfilter_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
+    ff_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
 }
 
 static void null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir) { }
@@ -255,8 +256,8 @@ static void end_frame(AVFilterLink *inlink)
                      delogo->show, direct);
     }
 
-    avfilter_draw_slice(outlink, 0, inlink->h, 1);
-    avfilter_end_frame(outlink);
+    ff_draw_slice(outlink, 0, inlink->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(inpicref);
     if (!direct)
         avfilter_unref_buffer(outpicref);
diff --git a/libavfilter/vf_drawbox.c b/libavfilter/vf_drawbox.c
index c23406ad0a..c792faf5b4 100644
--- a/libavfilter/vf_drawbox.c
+++ b/libavfilter/vf_drawbox.c
@@ -28,6 +28,7 @@
 #include "libavutil/pixdesc.h"
 #include "libavutil/parseutils.h"
 #include "avfilter.h"
+#include "formats.h"
 #include "video.h"
 
 enum { Y, U, V, A };
@@ -71,7 +72,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -118,7 +119,7 @@ static void draw_slice(AVFilterLink *inlink, int y0, int h, int slice_dir)
         }
     }
 
-    avfilter_draw_slice(inlink->dst->outputs[0], y0, h, 1);
+    ff_draw_slice(inlink->dst->outputs[0], y0, h, 1);
 }
 
 AVFilter avfilter_vf_drawbox = {
diff --git a/libavfilter/vf_drawtext.c b/libavfilter/vf_drawtext.c
index 18fd7d832c..ce290edb69 100644
--- a/libavfilter/vf_drawtext.c
+++ b/libavfilter/vf_drawtext.c
@@ -41,6 +41,7 @@
 #include "libavutil/lfg.h"
 #include "avfilter.h"
 #include "drawutils.h"
+#include "formats.h"
 #include "video.h"
 
 #undef time
@@ -492,7 +493,7 @@ static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
 
 static int query_formats(AVFilterContext *ctx)
 {
-    avfilter_set_common_pixel_formats(ctx, ff_draw_supported_pixel_formats(0));
+    ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
     return 0;
 }
 
@@ -812,8 +813,8 @@ static void end_frame(AVFilterLink *inlink)
 
     dtext->var_values[VAR_N] += 1.0;
 
-    avfilter_draw_slice(outlink, 0, picref->video->h, 1);
-    avfilter_end_frame(outlink);
+    ff_draw_slice(outlink, 0, picref->video->h, 1);
+    ff_end_frame(outlink);
 }
 
 AVFilter avfilter_vf_drawtext = {
diff --git a/libavfilter/vf_fade.c b/libavfilter/vf_fade.c
index d4303d0b0c..8ff5af9f3b 100644
--- a/libavfilter/vf_fade.c
+++ b/libavfilter/vf_fade.c
@@ -32,6 +32,7 @@
 #include "avfilter.h"
 #include "drawutils.h"
 #include "internal.h"
+#include "formats.h"
 #include "video.h"
 
 #define R 0
@@ -158,7 +159,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -257,14 +258,14 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
         }
     }
 
-    avfilter_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
+    ff_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
 }
 
 static void end_frame(AVFilterLink *inlink)
 {
     FadeContext *fade = inlink->dst->priv;
 
-    avfilter_end_frame(inlink->dst->outputs[0]);
+    ff_end_frame(inlink->dst->outputs[0]);
 
     if (fade->frame_index >= fade->start_frame &&
         fade->frame_index <= fade->stop_frame)
diff --git a/libavfilter/vf_fieldorder.c b/libavfilter/vf_fieldorder.c
index 88abe54c5a..24c23e219e 100644
--- a/libavfilter/vf_fieldorder.c
+++ b/libavfilter/vf_fieldorder.c
@@ -28,6 +28,8 @@
 #include "libavutil/imgutils.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 
 typedef struct
 {
@@ -76,12 +78,12 @@ static int query_formats(AVFilterContext *ctx)
                  || av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_BITSTREAM)
                 && av_pix_fmt_descriptors[pix_fmt].nb_components
                 && !av_pix_fmt_descriptors[pix_fmt].log2_chroma_h
-                && (ret = avfilter_add_format(&formats, pix_fmt)) < 0) {
-                avfilter_formats_unref(&formats);
+                && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
+                ff_formats_unref(&formats);
                 return ret;
             }
-        avfilter_formats_ref(formats, &ctx->inputs[0]->out_formats);
-        avfilter_formats_ref(formats, &ctx->outputs[0]->in_formats);
+        ff_formats_ref(formats, &ctx->inputs[0]->out_formats);
+        ff_formats_ref(formats, &ctx->outputs[0]->in_formats);
     }
 
     return 0;
@@ -123,7 +125,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
     outpicref = avfilter_ref_buffer(inpicref, ~0);
     outlink->out_buf = outpicref;
 
-    avfilter_start_frame(outlink, outpicref);
+    ff_start_frame(outlink, outpicref);
 }
 
 static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
@@ -140,7 +142,7 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
      *  and that complexity will be added later */
     if (  !inpicref->video->interlaced
         || inpicref->video->top_field_first == fieldorder->dst_tff) {
-        avfilter_draw_slice(outlink, y, h, slice_dir);
+        ff_draw_slice(outlink, y, h, slice_dir);
     }
 }
 
@@ -202,13 +204,13 @@ static void end_frame(AVFilterLink *inlink)
             }
         }
         outpicref->video->top_field_first = fieldorder->dst_tff;
-        avfilter_draw_slice(outlink, 0, h, 1);
+        ff_draw_slice(outlink, 0, h, 1);
     } else {
         av_dlog(ctx,
                 "not interlaced or field order already correct\n");
     }
 
-    avfilter_end_frame(outlink);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(inpicref);
 }
 
diff --git a/libavfilter/vf_fifo.c b/libavfilter/vf_fifo.c
index 91e4b9d111..d9200d770a 100644
--- a/libavfilter/vf_fifo.c
+++ b/libavfilter/vf_fifo.c
@@ -24,6 +24,7 @@
  */
 
 #include "avfilter.h"
+#include "internal.h"
 #include "video.h"
 
 typedef struct BufPic {
@@ -83,9 +84,9 @@ static int request_frame(AVFilterLink *outlink)
 
     /* by doing this, we give ownership of the reference to the next filter,
      * so we don't have to worry about dereferencing it ourselves. */
-    avfilter_start_frame(outlink, fifo->root.next->picref);
-    avfilter_draw_slice (outlink, 0, outlink->h, 1);
-    avfilter_end_frame  (outlink);
+    ff_start_frame(outlink, fifo->root.next->picref);
+    ff_draw_slice (outlink, 0, outlink->h, 1);
+    ff_end_frame  (outlink);
 
     if (fifo->last == fifo->root.next)
         fifo->last = &fifo->root;
diff --git a/libavfilter/vf_format.c b/libavfilter/vf_format.c
index d8b3a40a7d..665ec2f423 100644
--- a/libavfilter/vf_format.c
+++ b/libavfilter/vf_format.c
@@ -26,6 +26,7 @@
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
 #include "internal.h"
+#include "formats.h"
 #include "video.h"
 
 typedef struct {
@@ -87,7 +88,7 @@ static AVFilterFormats *make_format_list(FormatContext *format, int flag)
 #if CONFIG_FORMAT_FILTER
 static int query_formats_format(AVFilterContext *ctx)
 {
-    avfilter_set_common_pixel_formats(ctx, make_format_list(ctx->priv, 1));
+    ff_set_common_formats(ctx, make_format_list(ctx->priv, 1));
     return 0;
 }
 
@@ -117,7 +118,7 @@ AVFilter avfilter_vf_format = {
 #if CONFIG_NOFORMAT_FILTER
 static int query_formats_noformat(AVFilterContext *ctx)
 {
-    avfilter_set_common_pixel_formats(ctx, make_format_list(ctx->priv, 0));
+    ff_set_common_formats(ctx, make_format_list(ctx->priv, 0));
     return 0;
 }
 
diff --git a/libavfilter/vf_fps.c b/libavfilter/vf_fps.c
index d12070c49a..bbe1bdd6ea 100644
--- a/libavfilter/vf_fps.c
+++ b/libavfilter/vf_fps.c
@@ -31,6 +31,8 @@
 #include "libavutil/parseutils.h"
 
 #include "avfilter.h"
+#include "internal.h"
+#include "video.h"
 
 typedef struct FPSContext {
     const AVClass *class;
@@ -133,7 +135,7 @@ static int request_frame(AVFilterLink *outlink)
     int ret = 0;
 
     while (ret >= 0 && s->frames_out == frames_out)
-        ret = avfilter_request_frame(ctx->inputs[0]);
+        ret = ff_request_frame(ctx->inputs[0]);
 
     /* flush the fifo */
     if (ret == AVERROR_EOF && av_fifo_size(s->fifo)) {
@@ -145,9 +147,9 @@ static int request_frame(AVFilterLink *outlink)
             buf->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base,
                                     outlink->time_base) + s->frames_out;
 
-            avfilter_start_frame(outlink, buf);
-            avfilter_draw_slice(outlink, 0, outlink->h, 1);
-            avfilter_end_frame(outlink);
+            ff_start_frame(outlink, buf);
+            ff_draw_slice(outlink, 0, outlink->h, 1);
+            ff_end_frame(outlink);
             s->frames_out++;
         }
         return 0;
@@ -233,9 +235,9 @@ static void end_frame(AVFilterLink *inlink)
         buf_out->pts = av_rescale_q(s->first_pts, inlink->time_base,
                                     outlink->time_base) + s->frames_out;
 
-        avfilter_start_frame(outlink, buf_out);
-        avfilter_draw_slice(outlink, 0, outlink->h, 1);
-        avfilter_end_frame(outlink);
+        ff_start_frame(outlink, buf_out);
+        ff_draw_slice(outlink, 0, outlink->h, 1);
+        ff_end_frame(outlink);
         s->frames_out++;
     }
     flush_fifo(s->fifo);
diff --git a/libavfilter/vf_frei0r.c b/libavfilter/vf_frei0r.c
index a77cedf59c..e3dbf06e45 100644
--- a/libavfilter/vf_frei0r.c
+++ b/libavfilter/vf_frei0r.c
@@ -31,6 +31,8 @@
 #include "libavutil/mathematics.h"
 #include "libavutil/parseutils.h"
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 
 typedef f0r_instance_t (*f0r_construct_f)(unsigned int width, unsigned int height);
 typedef void (*f0r_destruct_f)(f0r_instance_t instance);
@@ -320,20 +322,20 @@ static int query_formats(AVFilterContext *ctx)
     AVFilterFormats *formats = NULL;
 
     if        (frei0r->plugin_info.color_model == F0R_COLOR_MODEL_BGRA8888) {
-        avfilter_add_format(&formats, PIX_FMT_BGRA);
+        ff_add_format(&formats, PIX_FMT_BGRA);
     } else if (frei0r->plugin_info.color_model == F0R_COLOR_MODEL_RGBA8888) {
-        avfilter_add_format(&formats, PIX_FMT_RGBA);
+        ff_add_format(&formats, PIX_FMT_RGBA);
     } else {                                   /* F0R_COLOR_MODEL_PACKED32 */
         static const enum PixelFormat pix_fmts[] = {
             PIX_FMT_BGRA, PIX_FMT_ARGB, PIX_FMT_ABGR, PIX_FMT_ARGB, PIX_FMT_NONE
         };
-        formats = avfilter_make_format_list(pix_fmts);
+        formats = ff_make_format_list(pix_fmts);
     }
 
     if (!formats)
         return AVERROR(ENOMEM);
 
-    avfilter_set_common_pixel_formats(ctx, formats);
+    ff_set_common_formats(ctx, formats);
     return 0;
 }
 
@@ -350,8 +352,8 @@ static void end_frame(AVFilterLink *inlink)
                    (const uint32_t *)inpicref->data[0],
                    (uint32_t *)outpicref->data[0]);
     avfilter_unref_buffer(inpicref);
-    avfilter_draw_slice(outlink, 0, outlink->h, 1);
-    avfilter_end_frame(outlink);
+    ff_draw_slice(outlink, 0, outlink->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(outpicref);
 }
 
@@ -436,11 +438,11 @@ static int source_request_frame(AVFilterLink *outlink)
     picref->pts = frei0r->pts++;
     picref->pos = -1;
 
-    avfilter_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
+    ff_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
     frei0r->update(frei0r->instance, av_rescale_q(picref->pts, frei0r->time_base, (AVRational){1,1000}),
                    NULL, (uint32_t *)picref->data[0]);
-    avfilter_draw_slice(outlink, 0, outlink->h, 1);
-    avfilter_end_frame(outlink);
+    ff_draw_slice(outlink, 0, outlink->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(picref);
 
     return 0;
diff --git a/libavfilter/vf_gradfun.c b/libavfilter/vf_gradfun.c
index 49e525507f..1b3a32933d 100644
--- a/libavfilter/vf_gradfun.c
+++ b/libavfilter/vf_gradfun.c
@@ -36,7 +36,9 @@
 #include "libavutil/cpu.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "formats.h"
 #include "gradfun.h"
+#include "video.h"
 
 DECLARE_ALIGNED(16, static const uint16_t, dither)[8][8] = {
     {0x00,0x60,0x18,0x78,0x06,0x66,0x1E,0x7E},
@@ -160,7 +162,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 
     return 0;
 }
@@ -196,7 +198,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
         outpicref = inpicref;
 
     outlink->out_buf = outpicref;
-    avfilter_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
+    ff_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
 }
 
 static void null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir) { }
@@ -225,8 +227,8 @@ static void end_frame(AVFilterLink *inlink)
             av_image_copy_plane(outpic->data[p], outpic->linesize[p], inpic->data[p], inpic->linesize[p], w, h);
     }
 
-    avfilter_draw_slice(outlink, 0, inlink->h, 1);
-    avfilter_end_frame(outlink);
+    ff_draw_slice(outlink, 0, inlink->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(inpic);
     if (outpic != inpic)
         avfilter_unref_buffer(outpic);
diff --git a/libavfilter/vf_hflip.c b/libavfilter/vf_hflip.c
index ba8e100019..b32992f34c 100644
--- a/libavfilter/vf_hflip.c
+++ b/libavfilter/vf_hflip.c
@@ -25,6 +25,8 @@
  */
 
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/imgutils.h"
@@ -64,7 +66,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -156,7 +158,7 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
         }
     }
 
-    avfilter_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
+    ff_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
 }
 
 AVFilter avfilter_vf_hflip = {
diff --git a/libavfilter/vf_hqdn3d.c b/libavfilter/vf_hqdn3d.c
index d1fcc7db8e..1d6ca78415 100644
--- a/libavfilter/vf_hqdn3d.c
+++ b/libavfilter/vf_hqdn3d.c
@@ -27,6 +27,8 @@
 
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 
 typedef struct {
     int Coefs[4][512*16];
@@ -268,7 +270,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 
     return 0;
 }
@@ -317,8 +319,8 @@ static void end_frame(AVFilterLink *inlink)
             hqdn3d->Coefs[2],
             hqdn3d->Coefs[3]);
 
-    avfilter_draw_slice(outlink, 0, inpic->video->h, 1);
-    avfilter_end_frame(outlink);
+    ff_draw_slice(outlink, 0, inpic->video->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(inpic);
     avfilter_unref_buffer(outpic);
 }
diff --git a/libavfilter/vf_libopencv.c b/libavfilter/vf_libopencv.c
index 2255241138..dc92c0be71 100644
--- a/libavfilter/vf_libopencv.c
+++ b/libavfilter/vf_libopencv.c
@@ -61,7 +61,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_BGR24, PIX_FMT_BGRA, PIX_FMT_GRAY8, PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -364,8 +364,8 @@ static void end_frame(AVFilterLink *inlink)
     fill_picref_from_iplimage(outpicref, &outimg, inlink->format);
 
     avfilter_unref_buffer(inpicref);
-    avfilter_draw_slice(outlink, 0, outlink->h, 1);
-    avfilter_end_frame(outlink);
+    ff_draw_slice(outlink, 0, outlink->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(outpicref);
 }
 
diff --git a/libavfilter/vf_lut.c b/libavfilter/vf_lut.c
index ba8a85a214..9c8b4123cf 100644
--- a/libavfilter/vf_lut.c
+++ b/libavfilter/vf_lut.c
@@ -28,7 +28,9 @@
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "formats.h"
 #include "internal.h"
+#include "video.h"
 
 static const char *const var_names[] = {
     "w",        ///< width of the input video
@@ -146,7 +148,7 @@ static int query_formats(AVFilterContext *ctx)
     const enum PixelFormat *pix_fmts = lut->is_rgb ? rgb_pix_fmts :
                                        lut->is_yuv ? yuv_pix_fmts : all_pix_fmts;
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -334,7 +336,7 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
         }
     }
 
-    avfilter_draw_slice(outlink, y, h, slice_dir);
+    ff_draw_slice(outlink, y, h, slice_dir);
 }
 
 #define DEFINE_LUT_FILTER(name_, description_, init_)                   \
diff --git a/libavfilter/vf_overlay.c b/libavfilter/vf_overlay.c
index 97a3e080c4..5bcd7afb2c 100644
--- a/libavfilter/vf_overlay.c
+++ b/libavfilter/vf_overlay.c
@@ -28,6 +28,7 @@
 /* #define DEBUG */
 
 #include "avfilter.h"
+#include "formats.h"
 #include "libavutil/eval.h"
 #include "libavutil/avstring.h"
 #include "libavutil/opt.h"
@@ -38,6 +39,7 @@
 #include "internal.h"
 #include "bufferqueue.h"
 #include "drawutils.h"
+#include "video.h"
 
 static const char *const var_names[] = {
     "main_w",    "W", ///< width  of the main    video
@@ -176,16 +178,16 @@ static int query_formats(AVFilterContext *ctx)
     AVFilterFormats *overlay_formats;
 
     if (over->allow_packed_rgb) {
-        main_formats    = avfilter_make_format_list(main_pix_fmts_rgb);
-        overlay_formats = avfilter_make_format_list(overlay_pix_fmts_rgb);
+        main_formats    = ff_make_format_list(main_pix_fmts_rgb);
+        overlay_formats = ff_make_format_list(overlay_pix_fmts_rgb);
     } else {
-        main_formats    = avfilter_make_format_list(main_pix_fmts_yuv);
-        overlay_formats = avfilter_make_format_list(overlay_pix_fmts_yuv);
+        main_formats    = ff_make_format_list(main_pix_fmts_yuv);
+        overlay_formats = ff_make_format_list(overlay_pix_fmts_yuv);
     }
 
-    avfilter_formats_ref(main_formats,    &ctx->inputs [MAIN   ]->out_formats);
-    avfilter_formats_ref(overlay_formats, &ctx->inputs [OVERLAY]->out_formats);
-    avfilter_formats_ref(main_formats,    &ctx->outputs[MAIN   ]->in_formats );
+    ff_formats_ref(main_formats,    &ctx->inputs [MAIN   ]->out_formats);
+    ff_formats_ref(overlay_formats, &ctx->inputs [OVERLAY]->out_formats);
+    ff_formats_ref(main_formats,    &ctx->outputs[MAIN   ]->in_formats );
 
     return 0;
 }
@@ -470,7 +472,7 @@ static int try_start_frame(AVFilterContext *ctx, AVFilterBufferRef *mainpic)
                 av_ts2str(over->overpicref->pts), av_ts2timestr(over->overpicref->pts, &outlink->time_base));
     av_dlog(ctx, "\n");
 
-    avfilter_start_frame(ctx->outputs[0], avfilter_ref_buffer(outpicref, ~0));
+    ff_start_frame(ctx->outputs[0], avfilter_ref_buffer(outpicref, ~0));
     over->frame_requested = 0;
     return 0;
 }
@@ -498,9 +500,9 @@ static int try_push_frame(AVFilterContext *ctx)
         blend_slice(ctx, outpicref, over->overpicref, over->x, over->y,
                     over->overpicref->video->w, over->overpicref->video->h,
                     0, outpicref->video->w, outpicref->video->h);
-    avfilter_draw_slice(outlink, 0, outpicref->video->h, +1);
+    ff_draw_slice(outlink, 0, outpicref->video->h, +1);
     avfilter_unref_bufferp(&outlink->out_buf);
-    avfilter_end_frame(outlink);
+    ff_end_frame(outlink);
     return 0;
 }
 
@@ -536,7 +538,7 @@ static void draw_slice_main(AVFilterLink *inlink, int y, int h, int slice_dir)
                     over->overpicref->video->w, over->overpicref->video->h,
                     y, outpicref->video->w, h);
     }
-    avfilter_draw_slice(outlink, y, h, slice_dir);
+    ff_draw_slice(outlink, y, h, slice_dir);
 }
 
 static void end_frame_main(AVFilterLink *inlink)
@@ -550,7 +552,7 @@ static void end_frame_main(AVFilterLink *inlink)
         return;
     avfilter_unref_bufferp(&inlink->cur_buf);
     avfilter_unref_bufferp(&outlink->out_buf);
-    avfilter_end_frame(ctx->outputs[0]);
+    ff_end_frame(ctx->outputs[0]);
 }
 
 static void start_frame_over(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
@@ -584,7 +586,7 @@ static int request_frame(AVFilterLink *outlink)
         input = !over->overlay_eof && (over->queue_main.available ||
                                        over->queue_over.available < 2) ?
                 OVERLAY : MAIN;
-        ret = avfilter_request_frame(ctx->inputs[input]);
+        ret = ff_request_frame(ctx->inputs[input]);
         /* EOF on main is reported immediately */
         if (ret == AVERROR_EOF && input == OVERLAY) {
             over->overlay_eof = 1;
diff --git a/libavfilter/vf_pad.c b/libavfilter/vf_pad.c
index 2a3c17ea18..31702b7318 100644
--- a/libavfilter/vf_pad.c
+++ b/libavfilter/vf_pad.c
@@ -25,6 +25,8 @@
  */
 
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 #include "libavutil/avstring.h"
 #include "libavutil/eval.h"
 #include "libavutil/pixdesc.h"
@@ -67,7 +69,7 @@ enum var_name {
 
 static int query_formats(AVFilterContext *ctx)
 {
-    avfilter_set_common_pixel_formats(ctx, ff_draw_supported_pixel_formats(0));
+    ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
     return 0;
 }
 
@@ -296,7 +298,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
     outpicref->video->w = pad->w;
     outpicref->video->h = pad->h;
 
-    avfilter_start_frame(inlink->dst->outputs[0], avfilter_ref_buffer(outpicref, ~0));
+    ff_start_frame(inlink->dst->outputs[0], avfilter_ref_buffer(outpicref, ~0));
 }
 
 static void draw_send_bar_slice(AVFilterLink *link, int y, int h, int slice_dir, int before_slice)
@@ -319,7 +321,7 @@ static void draw_send_bar_slice(AVFilterLink *link, int y, int h, int slice_dir,
                           link->dst->outputs[0]->out_buf->data,
                           link->dst->outputs[0]->out_buf->linesize,
                           0, bar_y, pad->w, bar_h);
-        avfilter_draw_slice(link->dst->outputs[0], bar_y, bar_h, slice_dir);
+        ff_draw_slice(link->dst->outputs[0], bar_y, bar_h, slice_dir);
     }
 }
 
@@ -352,7 +354,7 @@ static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
     /* right border */
     ff_fill_rectangle(&pad->draw, &pad->color, outpic->data, outpic->linesize,
                       pad->x + pad->in_w, y, pad->w - pad->x - pad->in_w, h);
-    avfilter_draw_slice(link->dst->outputs[0], y, h, slice_dir);
+    ff_draw_slice(link->dst->outputs[0], y, h, slice_dir);
 
     draw_send_bar_slice(link, y, h, slice_dir, -1);
 }
diff --git a/libavfilter/vf_pixdesctest.c b/libavfilter/vf_pixdesctest.c
index 9aee482874..9b7b373ecd 100644
--- a/libavfilter/vf_pixdesctest.c
+++ b/libavfilter/vf_pixdesctest.c
@@ -25,6 +25,7 @@
 
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "video.h"
 
 typedef struct {
     const AVPixFmtDescriptor *pix_desc;
@@ -76,7 +77,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
         priv->pix_desc->flags & PIX_FMT_PSEUDOPAL)
         memcpy(outpicref->data[1], picref->data[1], AVPALETTE_SIZE);
 
-    avfilter_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
+    ff_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
 }
 
 static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
@@ -106,7 +107,7 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
         }
     }
 
-    avfilter_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
+    ff_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
 }
 
 AVFilter avfilter_vf_pixdesctest = {
diff --git a/libavfilter/vf_scale.c b/libavfilter/vf_scale.c
index 3106ccfa72..fab0568d9a 100644
--- a/libavfilter/vf_scale.c
+++ b/libavfilter/vf_scale.c
@@ -24,6 +24,8 @@
  */
 
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 #include "libavutil/avstring.h"
 #include "libavutil/eval.h"
 #include "libavutil/mathematics.h"
@@ -130,21 +132,21 @@ static int query_formats(AVFilterContext *ctx)
         formats = NULL;
         for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++)
             if (   sws_isSupportedInput(pix_fmt)
-                && (ret = avfilter_add_format(&formats, pix_fmt)) < 0) {
-                avfilter_formats_unref(&formats);
+                && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
+                ff_formats_unref(&formats);
                 return ret;
             }
-        avfilter_formats_ref(formats, &ctx->inputs[0]->out_formats);
+        ff_formats_ref(formats, &ctx->inputs[0]->out_formats);
     }
     if (ctx->outputs[0]) {
         formats = NULL;
         for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++)
             if (   (sws_isSupportedOutput(pix_fmt) || pix_fmt == PIX_FMT_PAL8)
-                && (ret = avfilter_add_format(&formats, pix_fmt)) < 0) {
-                avfilter_formats_unref(&formats);
+                && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
+                ff_formats_unref(&formats);
                 return ret;
             }
-        avfilter_formats_ref(formats, &ctx->outputs[0]->in_formats);
+        ff_formats_ref(formats, &ctx->outputs[0]->in_formats);
     }
 
     return 0;
@@ -293,7 +295,7 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
 
 
     if (!scale->sws) {
-        avfilter_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
+        ff_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
         return;
     }
 
@@ -315,7 +317,7 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
               INT_MAX);
 
     scale->slice_y = 0;
-    avfilter_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
+    ff_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
 }
 
 static int scale_slice(AVFilterLink *link, struct SwsContext *sws, int y, int h, int mul, int field)
@@ -350,7 +352,7 @@ static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
     int out_h;
 
     if (!scale->sws) {
-        avfilter_draw_slice(link->dst->outputs[0], y, h, slice_dir);
+        ff_draw_slice(link->dst->outputs[0], y, h, slice_dir);
         return;
     }
 
@@ -367,7 +369,7 @@ static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
 
     if (slice_dir == -1)
         scale->slice_y -= out_h;
-    avfilter_draw_slice(link->dst->outputs[0], scale->slice_y, out_h, slice_dir);
+    ff_draw_slice(link->dst->outputs[0], scale->slice_y, out_h, slice_dir);
     if (slice_dir == 1)
         scale->slice_y += out_h;
 }
diff --git a/libavfilter/vf_select.c b/libavfilter/vf_select.c
index be0bfc9cf0..aa996cb36e 100644
--- a/libavfilter/vf_select.c
+++ b/libavfilter/vf_select.c
@@ -28,6 +28,7 @@
 #include "libavcodec/dsputil.h"
 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 
 static const char *const var_names[] = {
@@ -284,7 +285,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
                                       sizeof(picref), NULL);
             return;
         }
-        avfilter_start_frame(inlink->dst->outputs[0], avfilter_ref_buffer(picref, ~0));
+        ff_start_frame(inlink->dst->outputs[0], avfilter_ref_buffer(picref, ~0));
     }
 }
 
@@ -293,7 +294,7 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
     SelectContext *select = inlink->dst->priv;
 
     if (select->select && !select->cache_frames)
-        avfilter_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
+        ff_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
 }
 
 static void end_frame(AVFilterLink *inlink)
@@ -304,7 +305,7 @@ static void end_frame(AVFilterLink *inlink)
     if (select->select) {
         if (select->cache_frames)
             return;
-        avfilter_end_frame(inlink->dst->outputs[0]);
+        ff_end_frame(inlink->dst->outputs[0]);
     }
     avfilter_unref_buffer(picref);
 }
@@ -319,15 +320,15 @@ static int request_frame(AVFilterLink *outlink)
     if (av_fifo_size(select->pending_frames)) {
         AVFilterBufferRef *picref;
         av_fifo_generic_read(select->pending_frames, &picref, sizeof(picref), NULL);
-        avfilter_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
-        avfilter_draw_slice(outlink, 0, outlink->h, 1);
-        avfilter_end_frame(outlink);
+        ff_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
+        ff_draw_slice(outlink, 0, outlink->h, 1);
+        ff_end_frame(outlink);
         avfilter_unref_buffer(picref);
         return 0;
     }
 
     while (!select->select) {
-        int ret = avfilter_request_frame(inlink);
+        int ret = ff_request_frame(inlink);
         if (ret < 0)
             return ret;
     }
@@ -342,12 +343,12 @@ static int poll_frame(AVFilterLink *outlink)
     int count, ret;
 
     if (!av_fifo_size(select->pending_frames)) {
-        if ((count = avfilter_poll_frame(inlink)) <= 0)
+        if ((count = ff_poll_frame(inlink)) <= 0)
             return count;
         /* request frame from input, and apply select condition to it */
         select->cache_frames = 1;
         while (count-- && av_fifo_space(select->pending_frames)) {
-            ret = avfilter_request_frame(inlink);
+            ret = ff_request_frame(inlink);
             if (ret < 0)
                 break;
         }
diff --git a/libavfilter/vf_setpts.c b/libavfilter/vf_setpts.c
index 9a5170037f..e1f773483b 100644
--- a/libavfilter/vf_setpts.c
+++ b/libavfilter/vf_setpts.c
@@ -120,7 +120,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
     setpts->var_values[VAR_N] += 1.0;
     setpts->var_values[VAR_PREV_INPTS ] = TS2D(inpicref ->pts);
     setpts->var_values[VAR_PREV_OUTPTS] = TS2D(outpicref->pts);
-    avfilter_start_frame(inlink->dst->outputs[0], outpicref);
+    ff_start_frame(inlink->dst->outputs[0], outpicref);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
diff --git a/libavfilter/vf_settb.c b/libavfilter/vf_settb.c
index 00b735cdf7..9f4c1b2d16 100644
--- a/libavfilter/vf_settb.c
+++ b/libavfilter/vf_settb.c
@@ -110,7 +110,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
         avfilter_unref_buffer(picref);
     }
 
-    avfilter_start_frame(outlink, picref2);
+    ff_start_frame(outlink, picref2);
 }
 
 AVFilter avfilter_vf_settb = {
diff --git a/libavfilter/vf_showinfo.c b/libavfilter/vf_showinfo.c
index d14d99b1f1..9f3eb78ca4 100644
--- a/libavfilter/vf_showinfo.c
+++ b/libavfilter/vf_showinfo.c
@@ -82,7 +82,7 @@ static void end_frame(AVFilterLink *inlink)
 
     showinfo->frame++;
     avfilter_unref_buffer(picref);
-    avfilter_end_frame(inlink->dst->outputs[0]);
+    ff_end_frame(inlink->dst->outputs[0]);
 }
 
 AVFilter avfilter_vf_showinfo = {
diff --git a/libavfilter/vf_slicify.c b/libavfilter/vf_slicify.c
index f496bfd9b6..76d2b237bd 100644
--- a/libavfilter/vf_slicify.c
+++ b/libavfilter/vf_slicify.c
@@ -73,7 +73,7 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
 
     av_log(link->dst, AV_LOG_DEBUG, "h:%d\n", slice->h);
 
-    avfilter_start_frame(link->dst->outputs[0], picref);
+    ff_start_frame(link->dst->outputs[0], picref);
 }
 
 static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
@@ -83,16 +83,16 @@ static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
 
     if (slice_dir == 1) {
         for (y2 = y; y2 + slice->h <= y + h; y2 += slice->h)
-            avfilter_draw_slice(link->dst->outputs[0], y2, slice->h, slice_dir);
+            ff_draw_slice(link->dst->outputs[0], y2, slice->h, slice_dir);
 
         if (y2 < y + h)
-            avfilter_draw_slice(link->dst->outputs[0], y2, y + h - y2, slice_dir);
+            ff_draw_slice(link->dst->outputs[0], y2, y + h - y2, slice_dir);
     } else if (slice_dir == -1) {
         for (y2 = y + h; y2 - slice->h >= y; y2 -= slice->h)
-            avfilter_draw_slice(link->dst->outputs[0], y2 - slice->h, slice->h, slice_dir);
+            ff_draw_slice(link->dst->outputs[0], y2 - slice->h, slice->h, slice_dir);
 
         if (y2 > y)
-            avfilter_draw_slice(link->dst->outputs[0], y, y2 - y, slice_dir);
+            ff_draw_slice(link->dst->outputs[0], y, y2 - y, slice_dir);
     }
 }
 
diff --git a/libavfilter/vf_transpose.c b/libavfilter/vf_transpose.c
index 596f3cb28d..3ac07f5870 100644
--- a/libavfilter/vf_transpose.c
+++ b/libavfilter/vf_transpose.c
@@ -29,6 +29,8 @@
 #include "libavutil/pixdesc.h"
 #include "libavutil/imgutils.h"
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 
 typedef struct {
     int hsub, vsub;
@@ -80,7 +82,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -126,7 +128,7 @@ static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
         outlink->out_buf->video->sample_aspect_ratio.den = picref->video->sample_aspect_ratio.num;
     }
 
-    avfilter_start_frame(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
+    ff_start_frame(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
 }
 
 static void end_frame(AVFilterLink *inlink)
@@ -187,8 +189,8 @@ static void end_frame(AVFilterLink *inlink)
     }
 
     avfilter_unref_buffer(inpic);
-    avfilter_draw_slice(outlink, 0, outpic->video->h, 1);
-    avfilter_end_frame(outlink);
+    ff_draw_slice(outlink, 0, outpic->video->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(outpic);
 }
 
diff --git a/libavfilter/vf_unsharp.c b/libavfilter/vf_unsharp.c
index 8535d73f3a..a280a0df7f 100644
--- a/libavfilter/vf_unsharp.c
+++ b/libavfilter/vf_unsharp.c
@@ -37,6 +37,8 @@
  */
 
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 #include "libavutil/common.h"
 #include "libavutil/mem.h"
 #include "libavutil/pixdesc.h"
@@ -162,7 +164,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_YUVJ444P, PIX_FMT_YUVJ440P, PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 
     return 0;
 }
@@ -223,8 +225,8 @@ static void end_frame(AVFilterLink *link)
     apply_unsharp(out->data[2], out->linesize[2], in->data[2], in->linesize[2], cw,      ch,      &unsharp->chroma);
 
     avfilter_unref_buffer(in);
-    avfilter_draw_slice(link->dst->outputs[0], 0, link->h, 1);
-    avfilter_end_frame(link->dst->outputs[0]);
+    ff_draw_slice(link->dst->outputs[0], 0, link->h, 1);
+    ff_end_frame(link->dst->outputs[0]);
     avfilter_unref_buffer(out);
 }
 
diff --git a/libavfilter/vf_vflip.c b/libavfilter/vf_vflip.c
index 24288e6966..2c8436ff20 100644
--- a/libavfilter/vf_vflip.c
+++ b/libavfilter/vf_vflip.c
@@ -78,14 +78,14 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *inpicref)
         }
     }
 
-    avfilter_start_frame(link->dst->outputs[0], outpicref);
+    ff_start_frame(link->dst->outputs[0], outpicref);
 }
 
 static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
 {
     AVFilterContext *ctx = link->dst;
 
-    avfilter_draw_slice(ctx->outputs[0], link->h - (y+h), h, -1 * slice_dir);
+    ff_draw_slice(ctx->outputs[0], link->h - (y+h), h, -1 * slice_dir);
 }
 
 AVFilter avfilter_vf_vflip = {
diff --git a/libavfilter/vf_yadif.c b/libavfilter/vf_yadif.c
index 19b699b584..a0a5e05526 100644
--- a/libavfilter/vf_yadif.c
+++ b/libavfilter/vf_yadif.c
@@ -22,6 +22,8 @@
 #include "libavutil/common.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
 #include "video.h"
 #include "yadif.h"
 
@@ -227,10 +229,10 @@ static void return_frame(AVFilterContext *ctx, int is_second)
         } else {
             yadif->out->pts = AV_NOPTS_VALUE;
         }
-        avfilter_start_frame(ctx->outputs[0], yadif->out);
+        ff_start_frame(ctx->outputs[0], yadif->out);
     }
-    avfilter_draw_slice(ctx->outputs[0], 0, link->h, 1);
-    avfilter_end_frame(ctx->outputs[0]);
+    ff_draw_slice(ctx->outputs[0], 0, link->h, 1);
+    ff_end_frame(ctx->outputs[0]);
 
     yadif->frame_pending = (yadif->mode&1) && !is_second;
 }
@@ -260,7 +262,7 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
         yadif->prev = NULL;
         if (yadif->out->pts != AV_NOPTS_VALUE)
             yadif->out->pts *= 2;
-        avfilter_start_frame(ctx->outputs[0], yadif->out);
+        ff_start_frame(ctx->outputs[0], yadif->out);
         return;
     }
 
@@ -274,7 +276,7 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
     yadif->out->video->interlaced = 0;
     if (yadif->out->pts != AV_NOPTS_VALUE)
         yadif->out->pts *= 2;
-    avfilter_start_frame(ctx->outputs[0], yadif->out);
+    ff_start_frame(ctx->outputs[0], yadif->out);
 }
 
 static void end_frame(AVFilterLink *link)
@@ -286,8 +288,8 @@ static void end_frame(AVFilterLink *link)
         return;
 
     if (yadif->auto_enable && !yadif->cur->video->interlaced) {
-        avfilter_draw_slice(ctx->outputs[0], 0, link->h, 1);
-        avfilter_end_frame(ctx->outputs[0]);
+        ff_draw_slice(ctx->outputs[0], 0, link->h, 1);
+        ff_end_frame(ctx->outputs[0]);
         return;
     }
 
@@ -310,7 +312,7 @@ static int request_frame(AVFilterLink *link)
         if (yadif->eof)
             return AVERROR_EOF;
 
-        ret  = avfilter_request_frame(link->src->inputs[0]);
+        ret  = ff_request_frame(link->src->inputs[0]);
 
         if (ret == AVERROR_EOF && yadif->cur) {
             AVFilterBufferRef *next = avfilter_ref_buffer(yadif->next, AV_PERM_READ);
@@ -335,14 +337,14 @@ static int poll_frame(AVFilterLink *link)
     if (yadif->frame_pending)
         return 1;
 
-    val = avfilter_poll_frame(link->src->inputs[0]);
+    val = ff_poll_frame(link->src->inputs[0]);
     if (val <= 0)
         return val;
 
     if (val >= 1 && !yadif->next) { //FIXME change API to not requre this red tape
-        if ((ret = avfilter_request_frame(link->src->inputs[0])) < 0)
+        if ((ret = ff_request_frame(link->src->inputs[0])) < 0)
             return ret;
-        val = avfilter_poll_frame(link->src->inputs[0]);
+        val = ff_poll_frame(link->src->inputs[0]);
         if (val <= 0)
             return val;
     }
@@ -390,7 +392,7 @@ static int query_formats(AVFilterContext *ctx)
         PIX_FMT_NONE
     };
 
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 
     return 0;
 }
diff --git a/libavfilter/video.c b/libavfilter/video.c
index c26c7b7327..d443885df2 100644
--- a/libavfilter/video.c
+++ b/libavfilter/video.c
@@ -151,7 +151,7 @@ AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int
 
 void ff_null_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
 {
-    avfilter_start_frame(link->dst->outputs[0], picref);
+    ff_start_frame(link->dst->outputs[0], picref);
 }
 
 static void default_start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
@@ -164,13 +164,13 @@ static void default_start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
     if (outlink) {
         outlink->out_buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
         avfilter_copy_buffer_ref_props(outlink->out_buf, picref);
-        avfilter_start_frame(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
+        ff_start_frame(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
     }
 }
 
 /* XXX: should we do the duplicating of the picture ref here, instead of
  * forcing the source filter to do it? */
-void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
+void ff_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
 {
     void (*start_frame)(AVFilterLink *, AVFilterBufferRef *);
     AVFilterPad *dst = link->dstpad;
@@ -217,7 +217,7 @@ void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
 
 void ff_null_end_frame(AVFilterLink *link)
 {
-    avfilter_end_frame(link->dst->outputs[0]);
+    ff_end_frame(link->dst->outputs[0]);
 }
 
 static void default_end_frame(AVFilterLink *inlink)
@@ -235,11 +235,11 @@ static void default_end_frame(AVFilterLink *inlink)
             avfilter_unref_buffer(outlink->out_buf);
             outlink->out_buf = NULL;
         }
-        avfilter_end_frame(outlink);
+        ff_end_frame(outlink);
     }
 }
 
-void avfilter_end_frame(AVFilterLink *link)
+void ff_end_frame(AVFilterLink *link)
 {
     void (*end_frame)(AVFilterLink *);
 
@@ -258,7 +258,7 @@ void avfilter_end_frame(AVFilterLink *link)
 
 void ff_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
 {
-    avfilter_draw_slice(link->dst->outputs[0], y, h, slice_dir);
+    ff_draw_slice(link->dst->outputs[0], y, h, slice_dir);
 }
 
 static void default_draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
@@ -269,10 +269,10 @@ static void default_draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir
         outlink = inlink->dst->outputs[0];
 
     if (outlink)
-        avfilter_draw_slice(outlink, y, h, slice_dir);
+        ff_draw_slice(outlink, y, h, slice_dir);
 }
 
-void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
+void ff_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
 {
     uint8_t *src[4], *dst[4];
     int i, j, vsub;
@@ -346,4 +346,16 @@ void avfilter_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
 {
     ff_null_draw_slice(link, y, h, slice_dir);
 }
+void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
+{
+    ff_start_frame(link, picref);
+}
+void avfilter_end_frame(AVFilterLink *link)
+{
+    ff_end_frame(link);
+}
+void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
+{
+    ff_draw_slice(link, y, h, slice_dir);
+}
 #endif
diff --git a/libavfilter/video.h b/libavfilter/video.h
index e24dd9a38e..1fed45f925 100644
--- a/libavfilter/video.h
+++ b/libavfilter/video.h
@@ -33,4 +33,39 @@ void ff_null_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
 void ff_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
 void ff_null_end_frame(AVFilterLink *link);
 
+/**
+ * Notify the next filter of the start of a frame.
+ *
+ * @param link   the output link the frame will be sent over
+ * @param picref A reference to the frame about to be sent. The data for this
+ *               frame need only be valid once draw_slice() is called for that
+ *               portion. The receiving filter will free this reference when
+ *               it no longer needs it.
+ */
+void ff_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
+
+/**
+ * Notify the next filter that the current frame has finished.
+ *
+ * @param link the output link the frame was sent over
+ */
+void ff_end_frame(AVFilterLink *link);
+
+/**
+ * Send a slice to the next filter.
+ *
+ * Slices have to be provided in sequential order, either in
+ * top-bottom or bottom-top order. If slices are provided in
+ * non-sequential order the behavior of the function is undefined.
+ *
+ * @param link the output link over which the frame is being sent
+ * @param y    offset in pixels from the top of the image for this slice
+ * @param h    height of this slice in pixels
+ * @param slice_dir the assumed direction for sending slices,
+ *             from the top slice to the bottom slice if the value is 1,
+ *             from the bottom slice to the top slice if the value is -1,
+ *             for other values the behavior of the function is undefined.
+ */
+void ff_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
+
 #endif /* AVFILTER_VIDEO_H */
diff --git a/libavfilter/vsrc_color.c b/libavfilter/vsrc_color.c
index 69ba8e0a6f..cde971450c 100644
--- a/libavfilter/vsrc_color.c
+++ b/libavfilter/vsrc_color.c
@@ -24,6 +24,8 @@
  */
 
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/colorspace.h"
 #include "libavutil/imgutils.h"
@@ -73,7 +75,7 @@ static av_cold int color_init(AVFilterContext *ctx, const char *args, void *opaq
 
 static int query_formats(AVFilterContext *ctx)
 {
-    avfilter_set_common_pixel_formats(ctx, ff_draw_supported_pixel_formats(0));
+    ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
     return 0;
 }
 
@@ -108,11 +110,11 @@ static int color_request_frame(AVFilterLink *link)
     picref->pts = color->pts++;
     picref->pos = -1;
 
-    avfilter_start_frame(link, avfilter_ref_buffer(picref, ~0));
+    ff_start_frame(link, avfilter_ref_buffer(picref, ~0));
     ff_fill_rectangle(&color->draw, &color->color, picref->data, picref->linesize,
                       0, 0, color->w, color->h);
-    avfilter_draw_slice(link, 0, color->h, 1);
-    avfilter_end_frame(link);
+    ff_draw_slice(link, 0, color->h, 1);
+    ff_end_frame(link);
     avfilter_unref_buffer(picref);
 
     return 0;
diff --git a/libavfilter/vsrc_testsrc.c b/libavfilter/vsrc_testsrc.c
index 7d7d5ce9d4..5de7abf51f 100644
--- a/libavfilter/vsrc_testsrc.c
+++ b/libavfilter/vsrc_testsrc.c
@@ -36,6 +36,8 @@
 #include "libavutil/intreadwrite.h"
 #include "libavutil/parseutils.h"
 #include "avfilter.h"
+#include "formats.h"
+#include "video.h"
 
 typedef struct {
     const AVClass *class;
@@ -146,9 +148,9 @@ static int request_frame(AVFilterLink *outlink)
     test->fill_picture_fn(outlink->src, picref);
     test->nb_frame++;
 
-    avfilter_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
-    avfilter_draw_slice(outlink, 0, picref->video->h, 1);
-    avfilter_end_frame(outlink);
+    ff_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
+    ff_draw_slice(outlink, 0, picref->video->h, 1);
+    ff_end_frame(outlink);
     avfilter_unref_buffer(picref);
 
     return 0;
@@ -388,7 +390,7 @@ static int test_query_formats(AVFilterContext *ctx)
     static const enum PixelFormat pix_fmts[] = {
         PIX_FMT_RGB24, PIX_FMT_NONE
     };
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }
 
@@ -494,7 +496,7 @@ static int rgbtest_query_formats(AVFilterContext *ctx)
         PIX_FMT_RGB555, PIX_FMT_BGR555,
         PIX_FMT_NONE
     };
-    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
+    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
     return 0;
 }