avfilter: Deduplicate default video inputs/outputs

Lots of video filters use a very simple input or output:
An array with a single AVFilterPad whose name is "default"
and whose type is AVMEDIA_TYPE_VIDEO; everything else is unset.

Given that we never use pointer equality for inputs or outputs*,
we can simply use a single AVFilterPad instead of dozens; this
even saves .data.rel.ro (8312B here) as well as relocations.

*: In fact, several filters (like the filters in vf_lut.c)
already use the same outputs; furthermore, ff_filter_alloc()
duplicates the input and output pads so that we do not even
work with the pads directly.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>

147 files changed, 207 insertions, 1247 deletions

diff --git a/libavfilter/buffersink.c b/libavfilter/buffersink.c
index af9a638e4c..6d83a9310c 100644
--- a/libavfilter/buffersink.c
+++ b/libavfilter/buffersink.c
@@ -38,6 +38,7 @@
 #include "buffersink.h"
 #include "filters.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct BufferSinkContext {
     const AVClass *class;
@@ -377,13 +378,6 @@ static const AVOption abuffersink_options[] = {
 AVFILTER_DEFINE_CLASS(buffersink);
 AVFILTER_DEFINE_CLASS(abuffersink);
 
-static const AVFilterPad avfilter_vsink_buffer_inputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vsink_buffer = {
     .name          = "buffersink",
     .description   = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them available to the end of the filter graph."),
@@ -391,7 +385,7 @@ const AVFilter ff_vsink_buffer = {
     .priv_class    = &buffersink_class,
     .init          = common_init,
     .activate      = activate,
-    FILTER_INPUTS(avfilter_vsink_buffer_inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     .outputs       = NULL,
     FILTER_QUERY_FUNC(vsink_query_formats),
 };
diff --git a/libavfilter/f_bench.c b/libavfilter/f_bench.c
index 7938583d0e..8b840b4b41 100644
--- a/libavfilter/f_bench.c
+++ b/libavfilter/f_bench.c
@@ -24,6 +24,7 @@
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
+#include "video.h"
 
 enum BenchAction {
     ACTION_START,
@@ -101,20 +102,13 @@ static const AVFilterPad bench_inputs[] = {
     },
 };
 
-static const AVFilterPad bench_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_bench = {
     .name          = "bench",
     .description   = NULL_IF_CONFIG_SMALL("Benchmark part of a filtergraph."),
     .priv_size     = sizeof(BenchContext),
     .init          = init,
     FILTER_INPUTS(bench_inputs),
-    FILTER_OUTPUTS(bench_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .priv_class    = &bench_class,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
 };
diff --git a/libavfilter/f_cue.c b/libavfilter/f_cue.c
index 290a828d99..7748e8f1fd 100644
--- a/libavfilter/f_cue.c
+++ b/libavfilter/f_cue.c
@@ -26,6 +26,7 @@
 #include "avfilter.h"
 #include "filters.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct CueContext {
     const AVClass *class;
@@ -100,27 +101,13 @@ static const AVOption options[] = {
 AVFILTER_DEFINE_CLASS_EXT(cue_acue, "(a)cue", options);
 
 #if CONFIG_CUE_FILTER
-static const AVFilterPad cue_inputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
-static const AVFilterPad cue_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_cue = {
     .name        = "cue",
     .description = NULL_IF_CONFIG_SMALL("Delay filtering to match a cue."),
     .priv_class  = &cue_acue_class,
     .priv_size   = sizeof(CueContext),
-    FILTER_INPUTS(cue_inputs),
-    FILTER_OUTPUTS(cue_outputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .activate    = activate,
 };
 #endif /* CONFIG_CUE_FILTER */
diff --git a/libavfilter/f_graphmonitor.c b/libavfilter/f_graphmonitor.c
index e75cc52fbe..ce4153fc79 100644
--- a/libavfilter/f_graphmonitor.c
+++ b/libavfilter/f_graphmonitor.c
@@ -570,13 +570,6 @@ AVFILTER_DEFINE_CLASS_EXT(graphmonitor, "(a)graphmonitor", graphmonitor_options)
 
 #if CONFIG_GRAPHMONITOR_FILTER
 
-static const AVFilterPad graphmonitor_inputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static const AVFilterPad graphmonitor_outputs[] = {
     {
         .name         = "default",
@@ -593,7 +586,7 @@ const AVFilter ff_vf_graphmonitor = {
     .init          = init,
     .uninit        = uninit,
     .activate      = activate,
-    FILTER_INPUTS(graphmonitor_inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     FILTER_OUTPUTS(graphmonitor_outputs),
     FILTER_QUERY_FUNC(query_formats),
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/f_latency.c b/libavfilter/f_latency.c
index a497e0c71a..7c97363853 100644
--- a/libavfilter/f_latency.c
+++ b/libavfilter/f_latency.c
@@ -26,6 +26,7 @@
 #include "filters.h"
 #include "formats.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct LatencyContext {
     int64_t min_latency;
@@ -100,20 +101,6 @@ static av_cold void uninit(AVFilterContext *ctx)
 
 #if CONFIG_LATENCY_FILTER
 
-static const AVFilterPad latency_inputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
-static const AVFilterPad latency_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_latency = {
     .name          = "latency",
     .description   = NULL_IF_CONFIG_SMALL("Report video filtering latency."),
@@ -123,8 +110,8 @@ const AVFilter ff_vf_latency = {
     .activate      = activate,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_METADATA_ONLY,
-    FILTER_INPUTS(latency_inputs),
-    FILTER_OUTPUTS(latency_outputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
 
 #endif // CONFIG_LATENCY_FILTER
diff --git a/libavfilter/f_loop.c b/libavfilter/f_loop.c
index 6a654c2109..23bdfba57e 100644
--- a/libavfilter/f_loop.c
+++ b/libavfilter/f_loop.c
@@ -470,20 +470,6 @@ static const AVOption loop_options[] = {
 
 AVFILTER_DEFINE_CLASS(loop);
 
-static const AVFilterPad inputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_loop = {
     .name        = "loop",
     .description = NULL_IF_CONFIG_SMALL("Loop video frames."),
@@ -492,7 +478,7 @@ const AVFilter ff_vf_loop = {
     .init        = init,
     .uninit      = uninit,
     .activate    = activate,
-    FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
 #endif /* CONFIG_LOOP_FILTER */
diff --git a/libavfilter/f_metadata.c b/libavfilter/f_metadata.c
index 5679dfb203..86500cd353 100644
--- a/libavfilter/f_metadata.c
+++ b/libavfilter/f_metadata.c
@@ -404,13 +404,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_metadata = {
     .name        = "metadata",
     .description = NULL_IF_CONFIG_SMALL("Manipulate video frame metadata."),
@@ -419,7 +412,7 @@ const AVFilter ff_vf_metadata = {
     .init        = init,
     .uninit      = uninit,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                    AVFILTER_FLAG_METADATA_ONLY,
 };
diff --git a/libavfilter/f_perms.c b/libavfilter/f_perms.c
index 1c8cc5f68b..16b8e5c12f 100644
--- a/libavfilter/f_perms.c
+++ b/libavfilter/f_perms.c
@@ -149,20 +149,13 @@ static const AVFilterPad perms_inputs[] = {
     },
 };
 
-static const AVFilterPad perms_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_perms = {
     .name        = "perms",
     .description = NULL_IF_CONFIG_SMALL("Set permissions for the output video frame."),
     .init        = init,
     .priv_size   = sizeof(PermsContext),
     FILTER_INPUTS(perms_inputs),
-    FILTER_OUTPUTS(perms_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .priv_class  = &perms_class,
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                    AVFILTER_FLAG_METADATA_ONLY,
diff --git a/libavfilter/f_realtime.c b/libavfilter/f_realtime.c
index 278ee18f36..83793bbe15 100644
--- a/libavfilter/f_realtime.c
+++ b/libavfilter/f_realtime.c
@@ -25,6 +25,7 @@
 #include "audio.h"
 #include "avfilter.h"
 #include "internal.h"
+#include "video.h"
 #include <float.h>
 
 typedef struct RealtimeContext {
@@ -86,13 +87,6 @@ static const AVFilterPad avfilter_vf_realtime_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_realtime_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_realtime = {
     .name        = "realtime",
     .description = NULL_IF_CONFIG_SMALL("Slow down filtering to match realtime."),
@@ -100,7 +94,7 @@ const AVFilter ff_vf_realtime = {
     .priv_class  = &realtime_class,
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(avfilter_vf_realtime_inputs),
-    FILTER_OUTPUTS(avfilter_vf_realtime_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .process_command = ff_filter_process_command,
 };
 #endif /* CONFIG_REALTIME_FILTER */
diff --git a/libavfilter/f_sendcmd.c b/libavfilter/f_sendcmd.c
index 9f27fbde14..922ce78287 100644
--- a/libavfilter/f_sendcmd.c
+++ b/libavfilter/f_sendcmd.c
@@ -600,13 +600,6 @@ static const AVFilterPad sendcmd_inputs[] = {
     },
 };
 
-static const AVFilterPad sendcmd_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_sendcmd = {
     .name        = "sendcmd",
     .description = NULL_IF_CONFIG_SMALL("Send commands to filters."),
@@ -615,7 +608,7 @@ const AVFilter ff_vf_sendcmd = {
     .priv_size   = sizeof(SendCmdContext),
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(sendcmd_inputs),
-    FILTER_OUTPUTS(sendcmd_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .priv_class  = &sendcmd_class,
 };
 
diff --git a/libavfilter/f_sidedata.c b/libavfilter/f_sidedata.c
index 23e95d0b8a..208b457804 100644
--- a/libavfilter/f_sidedata.c
+++ b/libavfilter/f_sidedata.c
@@ -31,6 +31,7 @@
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
+#include "video.h"
 
 enum SideDataMode {
     SIDEDATA_SELECT,
@@ -161,13 +162,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_sidedata = {
     .name        = "sidedata",
     .description = NULL_IF_CONFIG_SMALL("Manipulate video frame side data."),
@@ -175,7 +169,7 @@ const AVFilter ff_vf_sidedata = {
     .priv_class  = &sidedata_class,
     .init        = init,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                    AVFILTER_FLAG_METADATA_ONLY,
 };
diff --git a/libavfilter/f_zmq.c b/libavfilter/f_zmq.c
index d368482a68..3829b55224 100644
--- a/libavfilter/f_zmq.c
+++ b/libavfilter/f_zmq.c
@@ -217,13 +217,6 @@ static const AVFilterPad zmq_inputs[] = {
     },
 };
 
-static const AVFilterPad zmq_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_zmq = {
     .name        = "zmq",
     .description = NULL_IF_CONFIG_SMALL("Receive commands through ZMQ and broker them to filters."),
@@ -231,7 +224,7 @@ const AVFilter ff_vf_zmq = {
     .uninit      = uninit,
     .priv_size   = sizeof(ZMQContext),
     FILTER_INPUTS(zmq_inputs),
-    FILTER_OUTPUTS(zmq_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .priv_class  = &zmq_class,
 };
 
diff --git a/libavfilter/setpts.c b/libavfilter/setpts.c
index e5150b7e03..d057fc91c4 100644
--- a/libavfilter/setpts.c
+++ b/libavfilter/setpts.c
@@ -326,13 +326,6 @@ static const AVFilterPad avfilter_vf_setpts_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_setpts_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_setpts = {
     .name            = "setpts",
     .description     = NULL_IF_CONFIG_SMALL("Set PTS for the output video frame."),
@@ -346,7 +339,7 @@ const AVFilter ff_vf_setpts = {
     .priv_class = &setpts_class,
 
     FILTER_INPUTS(avfilter_vf_setpts_inputs),
-    FILTER_OUTPUTS(avfilter_vf_setpts_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
 #endif /* CONFIG_SETPTS_FILTER */
 
diff --git a/libavfilter/settb.c b/libavfilter/settb.c
index c7523436d3..ba58abd9e9 100644
--- a/libavfilter/settb.c
+++ b/libavfilter/settb.c
@@ -165,13 +165,6 @@ static int activate(AVFilterContext *ctx)
 DEFINE_OPTIONS(settb, VIDEO);
 AVFILTER_DEFINE_CLASS(settb);
 
-static const AVFilterPad avfilter_vf_settb_inputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static const AVFilterPad avfilter_vf_settb_outputs[] = {
     {
         .name         = "default",
@@ -185,7 +178,7 @@ const AVFilter ff_vf_settb = {
     .description = NULL_IF_CONFIG_SMALL("Set timebase for the video output link."),
     .priv_size   = sizeof(SetTBContext),
     .priv_class  = &settb_class,
-    FILTER_INPUTS(avfilter_vf_settb_inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     FILTER_OUTPUTS(avfilter_vf_settb_outputs),
     .activate    = activate,
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
diff --git a/libavfilter/split.c b/libavfilter/split.c
index 6f24af3f02..290537aba5 100644
--- a/libavfilter/split.c
+++ b/libavfilter/split.c
@@ -134,13 +134,6 @@ static const AVOption options[] = {
 
 AVFILTER_DEFINE_CLASS_EXT(split, "(a)split", options);
 
-static const AVFilterPad avfilter_vf_split_inputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_split = {
     .name        = "split",
     .description = NULL_IF_CONFIG_SMALL("Pass on the input to N video outputs."),
@@ -148,7 +141,7 @@ const AVFilter ff_vf_split = {
     .priv_class  = &split_class,
     .init        = split_init,
     .activate    = activate,
-    FILTER_INPUTS(avfilter_vf_split_inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     .outputs     = NULL,
     .flags       = AVFILTER_FLAG_DYNAMIC_OUTPUTS | AVFILTER_FLAG_METADATA_ONLY,
 };
diff --git a/libavfilter/trim.c b/libavfilter/trim.c
index 91a68716c9..4c1a2b4f48 100644
--- a/libavfilter/trim.c
+++ b/libavfilter/trim.c
@@ -32,6 +32,7 @@
 #include "avfilter.h"
 #include "internal.h"
 #include "filters.h"
+#include "video.h"
 
 typedef struct TrimContext {
     const AVClass *class;
@@ -356,13 +357,6 @@ static const AVFilterPad trim_inputs[] = {
     },
 };
 
-static const AVFilterPad trim_outputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_trim = {
     .name        = "trim",
     .description = NULL_IF_CONFIG_SMALL("Pick one continuous section from the input, drop the rest."),
@@ -371,7 +365,7 @@ const AVFilter ff_vf_trim = {
     .priv_size   = sizeof(TrimContext),
     .priv_class  = &trim_class,
     FILTER_INPUTS(trim_inputs),
-    FILTER_OUTPUTS(trim_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
 #endif // CONFIG_TRIM_FILTER
 
diff --git a/libavfilter/vf_addroi.c b/libavfilter/vf_addroi.c
index dd3daeda81..e7ad916214 100644
--- a/libavfilter/vf_addroi.c
+++ b/libavfilter/vf_addroi.c
@@ -21,6 +21,7 @@
 #include "libavutil/opt.h"
 #include "avfilter.h"
 #include "internal.h"
+#include "video.h"
 
 enum {
     X, Y, W, H,
@@ -246,13 +247,6 @@ static const AVFilterPad addroi_inputs[] = {
     },
 };
 
-static const AVFilterPad addroi_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_addroi = {
     .name        = "addroi",
     .description = NULL_IF_CONFIG_SMALL("Add region of interest to frame."),
@@ -265,5 +259,5 @@ const AVFilter ff_vf_addroi = {
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
 
     FILTER_INPUTS(addroi_inputs),
-    FILTER_OUTPUTS(addroi_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
diff --git a/libavfilter/vf_avgblur.c b/libavfilter/vf_avgblur.c
index bd4471cb8e..bbb85bab17 100644
--- a/libavfilter/vf_avgblur.c
+++ b/libavfilter/vf_avgblur.c
@@ -334,13 +334,6 @@ static const AVFilterPad avgblur_inputs[] = {
     },
 };
 
-static const AVFilterPad avgblur_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_avgblur = {
     .name          = "avgblur",
     .description   = NULL_IF_CONFIG_SMALL("Apply Average Blur filter."),
@@ -348,7 +341,7 @@ const AVFilter ff_vf_avgblur = {
     .priv_class    = &avgblur_class,
     .uninit        = uninit,
     FILTER_INPUTS(avgblur_inputs),
-    FILTER_OUTPUTS(avgblur_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,
diff --git a/libavfilter/vf_bilateral.c b/libavfilter/vf_bilateral.c
index 41dc38d6f2..4d3dfa3511 100644
--- a/libavfilter/vf_bilateral.c
+++ b/libavfilter/vf_bilateral.c
@@ -498,13 +498,6 @@ static const AVFilterPad bilateral_inputs[] = {
     },
 };
 
-static const AVFilterPad bilateral_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_bilateral = {
     .name          = "bilateral",
     .description   = NULL_IF_CONFIG_SMALL("Apply Bilateral filter."),
@@ -512,7 +505,7 @@ const AVFilter ff_vf_bilateral = {
     .priv_class    = &bilateral_class,
     .uninit        = uninit,
     FILTER_INPUTS(bilateral_inputs),
-    FILTER_OUTPUTS(bilateral_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                      AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_bitplanenoise.c b/libavfilter/vf_bitplanenoise.c
index 5b5c429369..ebd8c4deaf 100644
--- a/libavfilter/vf_bitplanenoise.c
+++ b/libavfilter/vf_bitplanenoise.c
@@ -197,19 +197,12 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_bitplanenoise = {
     .name           = "bitplanenoise",
     .description    = NULL_IF_CONFIG_SMALL("Measure bit plane noise."),
     .priv_size      = sizeof(BPNContext),
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixfmts),
     .priv_class     = &bitplanenoise_class,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_blackdetect.c b/libavfilter/vf_blackdetect.c
index c937248169..55033ba5ea 100644
--- a/libavfilter/vf_blackdetect.c
+++ b/libavfilter/vf_blackdetect.c
@@ -30,6 +30,7 @@
 #include "libavutil/timestamp.h"
 #include "avfilter.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct BlackDetectContext {
     const AVClass *class;
@@ -241,19 +242,12 @@ static const AVFilterPad blackdetect_inputs[] = {
     },
 };
 
-static const AVFilterPad blackdetect_outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_blackdetect = {
     .name          = "blackdetect",
     .description   = NULL_IF_CONFIG_SMALL("Detect video intervals that are (almost) black."),
     .priv_size     = sizeof(BlackDetectContext),
     FILTER_INPUTS(blackdetect_inputs),
-    FILTER_OUTPUTS(blackdetect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .uninit        = uninit,
     .priv_class    = &blackdetect_class,
diff --git a/libavfilter/vf_blackframe.c b/libavfilter/vf_blackframe.c
index 4bcec86688..27198b318c 100644
--- a/libavfilter/vf_blackframe.c
+++ b/libavfilter/vf_blackframe.c
@@ -115,13 +115,6 @@ static const AVFilterPad avfilter_vf_blackframe_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_blackframe_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO
-    },
-};
-
 const AVFilter ff_vf_blackframe = {
     .name          = "blackframe",
     .description   = NULL_IF_CONFIG_SMALL("Detect frames that are (almost) black."),
@@ -129,6 +122,6 @@ const AVFilter ff_vf_blackframe = {
     .priv_class    = &blackframe_class,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(avfilter_vf_blackframe_inputs),
-    FILTER_OUTPUTS(avfilter_vf_blackframe_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
 };
diff --git a/libavfilter/vf_blockdetect.c b/libavfilter/vf_blockdetect.c
index 27283590be..d787aff5e4 100644
--- a/libavfilter/vf_blockdetect.c
+++ b/libavfilter/vf_blockdetect.c
@@ -32,6 +32,7 @@
 #include "libavutil/imgutils.h"
 #include "libavutil/opt.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct BLKContext {
     const AVClass *class;
@@ -272,13 +273,6 @@ static const AVFilterPad blockdetect_inputs[] = {
     },
 };
 
-static const AVFilterPad blockdetect_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_blockdetect = {
     .name          = "blockdetect",
     .description   = NULL_IF_CONFIG_SMALL("Blockdetect filter."),
@@ -286,7 +280,7 @@ const AVFilter ff_vf_blockdetect = {
     .uninit        = blockdetect_uninit,
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     FILTER_INPUTS(blockdetect_inputs),
-    FILTER_OUTPUTS(blockdetect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .priv_class    = &blockdetect_class,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
 };
diff --git a/libavfilter/vf_blurdetect.c b/libavfilter/vf_blurdetect.c
index db06efcce7..354a6b6100 100644
--- a/libavfilter/vf_blurdetect.c
+++ b/libavfilter/vf_blurdetect.c
@@ -35,6 +35,7 @@
 #include "libavutil/qsort.h"
 #include "internal.h"
 #include "edge_common.h"
+#include "video.h"
 
 static int comp(const float *a,const float *b)
 {
@@ -356,13 +357,6 @@ static const AVFilterPad blurdetect_inputs[] = {
     },
 };
 
-static const AVFilterPad blurdetect_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_blurdetect = {
     .name          = "blurdetect",
     .description   = NULL_IF_CONFIG_SMALL("Blurdetect filter."),
@@ -371,7 +365,7 @@ const AVFilter ff_vf_blurdetect = {
     .uninit        = blurdetect_uninit,
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     FILTER_INPUTS(blurdetect_inputs),
-    FILTER_OUTPUTS(blurdetect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .priv_class    = &blurdetect_class,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
 };
diff --git a/libavfilter/vf_boxblur.c b/libavfilter/vf_boxblur.c
index e13c2472b3..60375463a6 100644
--- a/libavfilter/vf_boxblur.c
+++ b/libavfilter/vf_boxblur.c
@@ -295,13 +295,6 @@ static const AVFilterPad avfilter_vf_boxblur_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_boxblur_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_boxblur = {
     .name          = "boxblur",
     .description   = NULL_IF_CONFIG_SMALL("Blur the input."),
@@ -309,7 +302,7 @@ const AVFilter ff_vf_boxblur = {
     .priv_class    = &boxblur_class,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_boxblur_inputs),
-    FILTER_OUTPUTS(avfilter_vf_boxblur_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_cas.c b/libavfilter/vf_cas.c
index c45529cef7..545a0dd70a 100644
--- a/libavfilter/vf_cas.c
+++ b/libavfilter/vf_cas.c
@@ -255,13 +255,6 @@ static const AVFilterPad cas_inputs[] = {
     },
 };
 
-static const AVFilterPad cas_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(CASContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -279,7 +272,7 @@ const AVFilter ff_vf_cas = {
     .priv_size     = sizeof(CASContext),
     .priv_class    = &cas_class,
     FILTER_INPUTS(cas_inputs),
-    FILTER_OUTPUTS(cas_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_ccrepack.c b/libavfilter/vf_ccrepack.c
index 950bb7b528..5213eab82b 100644
--- a/libavfilter/vf_ccrepack.c
+++ b/libavfilter/vf_ccrepack.c
@@ -32,6 +32,7 @@
 #include "avfilter.h"
 #include "internal.h"
 #include "ccfifo.h"
+#include "video.h"
 #include "libavutil/opt.h"
 
 typedef struct CCRepackContext
@@ -85,13 +86,6 @@ static const AVFilterPad avfilter_vf_ccrepack_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_ccrepack_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_ccrepack = {
     .name        = "ccrepack",
     .description = NULL_IF_CONFIG_SMALL("Repack CEA-708 closed caption metadata"),
@@ -99,5 +93,5 @@ const AVFilter ff_vf_ccrepack = {
     .priv_size   = sizeof(CCRepackContext),
     .priv_class  = &ccrepack_class,
     FILTER_INPUTS(avfilter_vf_ccrepack_inputs),
-    FILTER_OUTPUTS(avfilter_vf_ccrepack_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
diff --git a/libavfilter/vf_chromanr.c b/libavfilter/vf_chromanr.c
index 36c29ed8cf..8a16460c06 100644
--- a/libavfilter/vf_chromanr.c
+++ b/libavfilter/vf_chromanr.c
@@ -289,13 +289,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 AVFILTER_DEFINE_CLASS(chromanr);
 
 const AVFilter ff_vf_chromanr = {
@@ -303,7 +296,7 @@ const AVFilter ff_vf_chromanr = {
     .description   = NULL_IF_CONFIG_SMALL("Reduce chrominance noise."),
     .priv_size     = sizeof(ChromaNRContext),
     .priv_class    = &chromanr_class,
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_INPUTS(inputs),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_chromashift.c b/libavfilter/vf_chromashift.c
index 2ddfa61726..92869113a9 100644
--- a/libavfilter/vf_chromashift.c
+++ b/libavfilter/vf_chromashift.c
@@ -382,13 +382,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static const enum AVPixelFormat yuv_pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P,AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
@@ -411,7 +404,7 @@ const AVFilter ff_vf_chromashift = {
     .description   = NULL_IF_CONFIG_SMALL("Shift chroma."),
     .priv_size     = sizeof(ChromaShiftContext),
     .priv_class    = &chromashift_class,
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_INPUTS(inputs),
     FILTER_PIXFMTS_ARRAY(yuv_pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
@@ -448,7 +441,7 @@ const AVFilter ff_vf_rgbashift = {
     .description   = NULL_IF_CONFIG_SMALL("Shift RGBA."),
     .priv_size     = sizeof(ChromaShiftContext),
     .priv_class    = &rgbashift_class,
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_INPUTS(inputs),
     FILTER_PIXFMTS_ARRAY(rgb_pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_codecview.c b/libavfilter/vf_codecview.c
index cddb3e5368..0c1ef21e28 100644
--- a/libavfilter/vf_codecview.c
+++ b/libavfilter/vf_codecview.c
@@ -36,6 +36,7 @@
 #include "avfilter.h"
 #include "qp_table.h"
 #include "internal.h"
+#include "video.h"
 
 #define MV_P_FOR  (1<<0)
 #define MV_B_FOR  (1<<1)
@@ -334,19 +335,12 @@ static const AVFilterPad codecview_inputs[] = {
     },
 };
 
-static const AVFilterPad codecview_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_codecview = {
     .name          = "codecview",
     .description   = NULL_IF_CONFIG_SMALL("Visualize information about some codecs."),
     .priv_size     = sizeof(CodecViewContext),
     FILTER_INPUTS(codecview_inputs),
-    FILTER_OUTPUTS(codecview_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     // TODO: we can probably add way more pixel formats without any other
     // changes; anything with 8-bit luma in first plane should be working
     FILTER_SINGLE_PIXFMT(AV_PIX_FMT_YUV420P),
diff --git a/libavfilter/vf_colorconstancy.c b/libavfilter/vf_colorconstancy.c
index db7e20df53..af0356767f 100644
--- a/libavfilter/vf_colorconstancy.c
+++ b/libavfilter/vf_colorconstancy.c
@@ -719,13 +719,6 @@ static const AVFilterPad colorconstancy_inputs[] = {
     },
 };
 
-static const AVFilterPad colorconstancy_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #if CONFIG_GREYEDGE_FILTER
 
 static const AVOption greyedge_options[] = {
@@ -744,7 +737,7 @@ const AVFilter ff_vf_greyedge = {
     .priv_class    = &greyedge_class,
     .uninit        = uninit,
     FILTER_INPUTS(colorconstancy_inputs),
-    FILTER_OUTPUTS(colorconstancy_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     // TODO: support more formats
     // FIXME: error when saving to .jpg
     FILTER_SINGLE_PIXFMT(AV_PIX_FMT_GBRP),
diff --git a/libavfilter/vf_colorcontrast.c b/libavfilter/vf_colorcontrast.c
index 7561d21259..2cb46cc35a 100644
--- a/libavfilter/vf_colorcontrast.c
+++ b/libavfilter/vf_colorcontrast.c
@@ -359,13 +359,6 @@ static const AVFilterPad colorcontrast_inputs[] = {
     },
 };
 
-static const AVFilterPad colorcontrast_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(ColorContrastContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -388,7 +381,7 @@ const AVFilter ff_vf_colorcontrast = {
     .priv_size     = sizeof(ColorContrastContext),
     .priv_class    = &colorcontrast_class,
     FILTER_INPUTS(colorcontrast_inputs),
-    FILTER_OUTPUTS(colorcontrast_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_colorcorrect.c b/libavfilter/vf_colorcorrect.c
index ee97b62b0e..55df67404a 100644
--- a/libavfilter/vf_colorcorrect.c
+++ b/libavfilter/vf_colorcorrect.c
@@ -510,13 +510,6 @@ static const AVFilterPad colorcorrect_inputs[] = {
     },
 };
 
-static const AVFilterPad colorcorrect_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(ColorCorrectContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -543,7 +536,7 @@ const AVFilter ff_vf_colorcorrect = {
     .priv_class    = &colorcorrect_class,
     .uninit        = uninit,
     FILTER_INPUTS(colorcorrect_inputs),
-    FILTER_OUTPUTS(colorcorrect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_colorize.c b/libavfilter/vf_colorize.c
index ba7b80dae7..03681a788f 100644
--- a/libavfilter/vf_colorize.c
+++ b/libavfilter/vf_colorize.c
@@ -260,13 +260,6 @@ static const AVFilterPad colorize_inputs[] = {
     },
 };
 
-static const AVFilterPad colorize_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(ColorizeContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -286,7 +279,7 @@ const AVFilter ff_vf_colorize = {
     .priv_size     = sizeof(ColorizeContext),
     .priv_class    = &colorize_class,
     FILTER_INPUTS(colorize_inputs),
-    FILTER_OUTPUTS(colorize_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_colorlevels.c b/libavfilter/vf_colorlevels.c
index 44ae6cffbf..b89f465d67 100644
--- a/libavfilter/vf_colorlevels.c
+++ b/libavfilter/vf_colorlevels.c
@@ -559,20 +559,13 @@ static const AVFilterPad colorlevels_inputs[] = {
     },
 };
 
-static const AVFilterPad colorlevels_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_colorlevels = {
     .name          = "colorlevels",
     .description   = NULL_IF_CONFIG_SMALL("Adjust the color levels."),
     .priv_size     = sizeof(ColorLevelsContext),
     .priv_class    = &colorlevels_class,
     FILTER_INPUTS(colorlevels_inputs),
-    FILTER_OUTPUTS(colorlevels_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,
                    AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,
                    AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,
diff --git a/libavfilter/vf_colormatrix.c b/libavfilter/vf_colormatrix.c
index bee80c69cc..aa00295250 100644
--- a/libavfilter/vf_colormatrix.c
+++ b/libavfilter/vf_colormatrix.c
@@ -483,20 +483,13 @@ static const AVFilterPad colormatrix_inputs[] = {
     },
 };
 
-static const AVFilterPad colormatrix_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_colormatrix = {
     .name          = "colormatrix",
     .description   = NULL_IF_CONFIG_SMALL("Convert color matrix."),
     .priv_size     = sizeof(ColorMatrixContext),
     .init          = init,
     FILTER_INPUTS(colormatrix_inputs),
-    FILTER_OUTPUTS(colormatrix_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_YUV444P,
                    AV_PIX_FMT_YUV422P,
                    AV_PIX_FMT_YUV420P,
diff --git a/libavfilter/vf_colortemperature.c b/libavfilter/vf_colortemperature.c
index e6ac5f95c7..e3f3005171 100644
--- a/libavfilter/vf_colortemperature.c
+++ b/libavfilter/vf_colortemperature.c
@@ -325,13 +325,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(ColorTemperatureContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -350,7 +343,7 @@ const AVFilter ff_vf_colortemperature = {
     .priv_size     = sizeof(ColorTemperatureContext),
     .priv_class    = &colortemperature_class,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_convolution.c b/libavfilter/vf_convolution.c
index 7762fa2a05..814203aeee 100644
--- a/libavfilter/vf_convolution.c
+++ b/libavfilter/vf_convolution.c
@@ -873,13 +873,6 @@ static const AVFilterPad convolution_inputs[] = {
     },
 };
 
-static const AVFilterPad convolution_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #if CONFIG_CONVOLUTION_FILTER
 
 const AVFilter ff_vf_convolution = {
@@ -888,7 +881,7 @@ const AVFilter ff_vf_convolution = {
     .priv_size     = sizeof(ConvolutionContext),
     .priv_class    = &convolution_class,
     FILTER_INPUTS(convolution_inputs),
-    FILTER_OUTPUTS(convolution_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
@@ -914,7 +907,7 @@ const AVFilter ff_vf_prewitt = {
     .priv_size     = sizeof(ConvolutionContext),
     .priv_class    = &common_class,
     FILTER_INPUTS(convolution_inputs),
-    FILTER_OUTPUTS(convolution_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
@@ -930,7 +923,7 @@ const AVFilter ff_vf_sobel = {
     .priv_size     = sizeof(ConvolutionContext),
     .priv_class    = &common_class,
     FILTER_INPUTS(convolution_inputs),
-    FILTER_OUTPUTS(convolution_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
@@ -946,7 +939,7 @@ const AVFilter ff_vf_roberts = {
     .priv_size     = sizeof(ConvolutionContext),
     .priv_class    = &common_class,
     FILTER_INPUTS(convolution_inputs),
-    FILTER_OUTPUTS(convolution_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
@@ -962,7 +955,7 @@ const AVFilter ff_vf_kirsch = {
     .priv_size     = sizeof(ConvolutionContext),
     .priv_class    = &common_class,
     FILTER_INPUTS(convolution_inputs),
-    FILTER_OUTPUTS(convolution_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
@@ -978,7 +971,7 @@ const AVFilter ff_vf_scharr = {
     .priv_size     = sizeof(ConvolutionContext),
     .priv_class    = &common_class,
     FILTER_INPUTS(convolution_inputs),
-    FILTER_OUTPUTS(convolution_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
diff --git a/libavfilter/vf_copy.c b/libavfilter/vf_copy.c
index 2fbced354f..057b851b4c 100644
--- a/libavfilter/vf_copy.c
+++ b/libavfilter/vf_copy.c
@@ -65,18 +65,11 @@ static const AVFilterPad avfilter_vf_copy_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_copy_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_copy = {
     .name        = "copy",
     .description = NULL_IF_CONFIG_SMALL("Copy the input video unchanged to the output."),
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(avfilter_vf_copy_inputs),
-    FILTER_OUTPUTS(avfilter_vf_copy_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
 };
diff --git a/libavfilter/vf_cover_rect.c b/libavfilter/vf_cover_rect.c
index 642747a351..7f34311589 100644
--- a/libavfilter/vf_cover_rect.c
+++ b/libavfilter/vf_cover_rect.c
@@ -26,6 +26,7 @@
 #include "libavutil/opt.h"
 #include "filters.h"
 #include "internal.h"
+#include "video.h"
 
 #include "lavfutils.h"
 
@@ -232,13 +233,6 @@ static const AVFilterPad cover_rect_inputs[] = {
     },
 };
 
-static const AVFilterPad cover_rect_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_cover_rect = {
     .name            = "cover_rect",
     .description     = NULL_IF_CONFIG_SMALL("Find and cover a user specified object."),
@@ -246,7 +240,7 @@ const AVFilter ff_vf_cover_rect = {
     .init            = init,
     .uninit          = uninit,
     FILTER_INPUTS(cover_rect_inputs),
-    FILTER_OUTPUTS(cover_rect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
     .priv_class      = &cover_rect_class,
 };
diff --git a/libavfilter/vf_cropdetect.c b/libavfilter/vf_cropdetect.c
index 588a38fed8..ff9bcc79f3 100644
--- a/libavfilter/vf_cropdetect.c
+++ b/libavfilter/vf_cropdetect.c
@@ -495,13 +495,6 @@ static const AVFilterPad avfilter_vf_cropdetect_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_cropdetect_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO
-    },
-};
-
 const AVFilter ff_vf_cropdetect = {
     .name          = "cropdetect",
     .description   = NULL_IF_CONFIG_SMALL("Auto-detect crop size."),
@@ -510,7 +503,7 @@ const AVFilter ff_vf_cropdetect = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_cropdetect_inputs),
-    FILTER_OUTPUTS(avfilter_vf_cropdetect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_METADATA_ONLY,
     .process_command = process_command,
diff --git a/libavfilter/vf_curves.c b/libavfilter/vf_curves.c
index 838942d745..f77fae7eae 100644
--- a/libavfilter/vf_curves.c
+++ b/libavfilter/vf_curves.c
@@ -1005,13 +1005,6 @@ static const AVFilterPad curves_inputs[] = {
     },
 };
 
-static const AVFilterPad curves_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_curves = {
     .name          = "curves",
     .description   = NULL_IF_CONFIG_SMALL("Adjust components curves."),
@@ -1019,7 +1012,7 @@ const AVFilter ff_vf_curves = {
     .init          = curves_init,
     .uninit        = curves_uninit,
     FILTER_INPUTS(curves_inputs),
-    FILTER_OUTPUTS(curves_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,
                    AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,
                    AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,
diff --git a/libavfilter/vf_datascope.c b/libavfilter/vf_datascope.c
index d4f441c0ab..89b59f2510 100644
--- a/libavfilter/vf_datascope.c
+++ b/libavfilter/vf_datascope.c
@@ -728,20 +728,13 @@ static const AVFilterPad pixscope_inputs[] = {
     },
 };
 
-static const AVFilterPad pixscope_outputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_pixscope = {
     .name          = "pixscope",
     .description   = NULL_IF_CONFIG_SMALL("Pixel data analysis."),
     .priv_size     = sizeof(PixscopeContext),
     .priv_class    = &pixscope_class,
     FILTER_INPUTS(pixscope_inputs),
-    FILTER_OUTPUTS(pixscope_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = pixscope_process_command,
@@ -1132,13 +1125,6 @@ static const AVFilterPad oscilloscope_inputs[] = {
     },
 };
 
-static const AVFilterPad oscilloscope_outputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_oscilloscope = {
     .name          = "oscilloscope",
     .description   = NULL_IF_CONFIG_SMALL("2D Video Oscilloscope."),
@@ -1146,7 +1132,7 @@ const AVFilter ff_vf_oscilloscope = {
     .priv_class    = &oscilloscope_class,
     .uninit        = oscilloscope_uninit,
     FILTER_INPUTS(oscilloscope_inputs),
-    FILTER_OUTPUTS(oscilloscope_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = oscilloscope_process_command,
diff --git a/libavfilter/vf_dblur.c b/libavfilter/vf_dblur.c
index 7dcb873ba8..43100805c4 100644
--- a/libavfilter/vf_dblur.c
+++ b/libavfilter/vf_dblur.c
@@ -299,13 +299,6 @@ static const AVFilterPad dblur_inputs[] = {
     },
 };
 
-static const AVFilterPad dblur_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_dblur = {
     .name          = "dblur",
     .description   = NULL_IF_CONFIG_SMALL("Apply Directional Blur filter."),
@@ -313,7 +306,7 @@ const AVFilter ff_vf_dblur = {
     .priv_class    = &dblur_class,
     .uninit        = uninit,
     FILTER_INPUTS(dblur_inputs),
-    FILTER_OUTPUTS(dblur_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_dctdnoiz.c b/libavfilter/vf_dctdnoiz.c
index 95f71bc731..ab96dbe15e 100644
--- a/libavfilter/vf_dctdnoiz.c
+++ b/libavfilter/vf_dctdnoiz.c
@@ -810,13 +810,6 @@ static const AVFilterPad dctdnoiz_inputs[] = {
     },
 };
 
-static const AVFilterPad dctdnoiz_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_dctdnoiz = {
     .name          = "dctdnoiz",
     .description   = NULL_IF_CONFIG_SMALL("Denoise frames using 2D DCT."),
@@ -824,7 +817,7 @@ const AVFilter ff_vf_dctdnoiz = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(dctdnoiz_inputs),
-    FILTER_OUTPUTS(dctdnoiz_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &dctdnoiz_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_deband.c b/libavfilter/vf_deband.c
index ec91cb1548..b3c36de8c3 100644
--- a/libavfilter/vf_deband.c
+++ b/libavfilter/vf_deband.c
@@ -458,13 +458,6 @@ static const AVFilterPad avfilter_vf_deband_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_deband_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_deband = {
     .name          = "deband",
     .description   = NULL_IF_CONFIG_SMALL("Debands video."),
@@ -472,7 +465,7 @@ const AVFilter ff_vf_deband = {
     .priv_class    = &deband_class,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_deband_inputs),
-    FILTER_OUTPUTS(avfilter_vf_deband_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
diff --git a/libavfilter/vf_dedot.c b/libavfilter/vf_dedot.c
index 6ca47c262a..fb62c183d7 100644
--- a/libavfilter/vf_dedot.c
+++ b/libavfilter/vf_dedot.c
@@ -375,13 +375,6 @@ static const AVOption dedot_options[] = {
     { NULL },
 };
 
-static const AVFilterPad inputs[] = {
-    {
-        .name           = "default",
-        .type           = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static const AVFilterPad outputs[] = {
     {
         .name          = "default",
@@ -399,7 +392,7 @@ const AVFilter ff_vf_dedot = {
     .priv_class    = &dedot_class,
     .activate      = activate,
     .uninit        = uninit,
-    FILTER_INPUTS(inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     FILTER_OUTPUTS(outputs),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_delogo.c b/libavfilter/vf_delogo.c
index cc71f25c59..4b835b65f1 100644
--- a/libavfilter/vf_delogo.c
+++ b/libavfilter/vf_delogo.c
@@ -381,13 +381,6 @@ static const AVFilterPad avfilter_vf_delogo_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_delogo_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_delogo = {
     .name          = "delogo",
     .description   = NULL_IF_CONFIG_SMALL("Remove logo from input video."),
@@ -396,7 +389,7 @@ const AVFilter ff_vf_delogo = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_delogo_inputs),
-    FILTER_OUTPUTS(avfilter_vf_delogo_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_derain.c b/libavfilter/vf_derain.c
index 3cb4364def..2a57035c83 100644
--- a/libavfilter/vf_derain.c
+++ b/libavfilter/vf_derain.c
@@ -111,13 +111,6 @@ static const AVFilterPad derain_inputs[] = {
     },
 };
 
-static const AVFilterPad derain_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_derain = {
     .name          = "derain",
     .description   = NULL_IF_CONFIG_SMALL("Apply derain filter to the input."),
@@ -125,7 +118,7 @@ const AVFilter ff_vf_derain = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(derain_inputs),
-    FILTER_OUTPUTS(derain_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_SINGLE_PIXFMT(AV_PIX_FMT_RGB24),
     .priv_class    = &derain_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_deshake.c b/libavfilter/vf_deshake.c
index 142f88541d..a10d59ad80 100644
--- a/libavfilter/vf_deshake.c
+++ b/libavfilter/vf_deshake.c
@@ -535,13 +535,6 @@ static const AVFilterPad deshake_inputs[] = {
     },
 };
 
-static const AVFilterPad deshake_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_deshake = {
     .name          = "deshake",
     .description   = NULL_IF_CONFIG_SMALL("Stabilize shaky video."),
@@ -549,7 +542,7 @@ const AVFilter ff_vf_deshake = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(deshake_inputs),
-    FILTER_OUTPUTS(deshake_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &deshake_class,
 };
diff --git a/libavfilter/vf_dnn_classify.c b/libavfilter/vf_dnn_classify.c
index c3f2762cf9..e88e59d09c 100644
--- a/libavfilter/vf_dnn_classify.c
+++ b/libavfilter/vf_dnn_classify.c
@@ -26,6 +26,7 @@
 #include "filters.h"
 #include "dnn_filter_common.h"
 #include "internal.h"
+#include "video.h"
 #include "libavutil/time.h"
 #include "libavutil/avstring.h"
 #include "libavutil/detection_bbox.h"
@@ -293,28 +294,14 @@ static av_cold void dnn_classify_uninit(AVFilterContext *context)
     free_classify_labels(ctx);
 }
 
-static const AVFilterPad dnn_classify_inputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
-static const AVFilterPad dnn_classify_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_dnn_classify = {
     .name          = "dnn_classify",
     .description   = NULL_IF_CONFIG_SMALL("Apply DNN classify filter to the input."),
     .priv_size     = sizeof(DnnClassifyContext),
     .init          = dnn_classify_init,
     .uninit        = dnn_classify_uninit,
-    FILTER_INPUTS(dnn_classify_inputs),
-    FILTER_OUTPUTS(dnn_classify_outputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &dnn_classify_class,
     .activate      = dnn_classify_activate,
diff --git a/libavfilter/vf_dnn_detect.c b/libavfilter/vf_dnn_detect.c
index 6ef04e0958..b5dae42c65 100644
--- a/libavfilter/vf_dnn_detect.c
+++ b/libavfilter/vf_dnn_detect.c
@@ -26,6 +26,7 @@
 #include "filters.h"
 #include "dnn_filter_common.h"
 #include "internal.h"
+#include "video.h"
 #include "libavutil/time.h"
 #include "libavutil/avstring.h"
 #include "libavutil/detection_bbox.h"
@@ -435,28 +436,14 @@ static av_cold void dnn_detect_uninit(AVFilterContext *context)
     free_detect_labels(ctx);
 }
 
-static const AVFilterPad dnn_detect_inputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
-static const AVFilterPad dnn_detect_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_dnn_detect = {
     .name          = "dnn_detect",
     .description   = NULL_IF_CONFIG_SMALL("Apply DNN detect filter to the input."),
     .priv_size     = sizeof(DnnDetectContext),
     .init          = dnn_detect_init,
     .uninit        = dnn_detect_uninit,
-    FILTER_INPUTS(dnn_detect_inputs),
-    FILTER_OUTPUTS(dnn_detect_outputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &dnn_detect_class,
     .activate      = dnn_detect_activate,
diff --git a/libavfilter/vf_drawbox.c b/libavfilter/vf_drawbox.c
index 64eeeece12..82266481ca 100644
--- a/libavfilter/vf_drawbox.c
+++ b/libavfilter/vf_drawbox.c
@@ -471,13 +471,6 @@ static const AVFilterPad drawbox_inputs[] = {
     },
 };
 
-static const AVFilterPad drawbox_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_drawbox = {
     .name          = "drawbox",
     .description   = NULL_IF_CONFIG_SMALL("Draw a colored box on the input video."),
@@ -485,7 +478,7 @@ const AVFilter ff_vf_drawbox = {
     .priv_class    = &drawbox_class,
     .init          = init,
     FILTER_INPUTS(drawbox_inputs),
-    FILTER_OUTPUTS(drawbox_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
@@ -553,13 +546,6 @@ static const AVFilterPad drawgrid_inputs[] = {
     },
 };
 
-static const AVFilterPad drawgrid_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_drawgrid = {
     .name          = "drawgrid",
     .description   = NULL_IF_CONFIG_SMALL("Draw a colored grid on the input video."),
@@ -567,7 +553,7 @@ const AVFilter ff_vf_drawgrid = {
     .priv_class    = &drawgrid_class,
     .init          = init,
     FILTER_INPUTS(drawgrid_inputs),
-    FILTER_OUTPUTS(drawgrid_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,
diff --git a/libavfilter/vf_drawtext.c b/libavfilter/vf_drawtext.c
index 7854362eab..ec8d215795 100644
--- a/libavfilter/vf_drawtext.c
+++ b/libavfilter/vf_drawtext.c
@@ -2181,13 +2181,6 @@ static const AVFilterPad avfilter_vf_drawtext_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_drawtext_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_drawtext = {
     .name          = "drawtext",
     .description   = NULL_IF_CONFIG_SMALL("Draw text on top of video frames using libfreetype library."),
@@ -2196,7 +2189,7 @@ const AVFilter ff_vf_drawtext = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_drawtext_inputs),
-    FILTER_OUTPUTS(avfilter_vf_drawtext_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .process_command = command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_edgedetect.c b/libavfilter/vf_edgedetect.c
index 603f06f141..1362f4f677 100644
--- a/libavfilter/vf_edgedetect.c
+++ b/libavfilter/vf_edgedetect.c
@@ -249,13 +249,6 @@ static const AVFilterPad edgedetect_inputs[] = {
     },
 };
 
-static const AVFilterPad edgedetect_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_edgedetect = {
     .name          = "edgedetect",
     .description   = NULL_IF_CONFIG_SMALL("Detect and draw edge."),
@@ -263,7 +256,7 @@ const AVFilter ff_vf_edgedetect = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(edgedetect_inputs),
-    FILTER_OUTPUTS(edgedetect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .priv_class    = &edgedetect_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_elbg.c b/libavfilter/vf_elbg.c
index d1166714fc..cc49b8e240 100644
--- a/libavfilter/vf_elbg.c
+++ b/libavfilter/vf_elbg.c
@@ -253,13 +253,6 @@ static const AVFilterPad elbg_inputs[] = {
     },
 };
 
-static const AVFilterPad elbg_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_elbg = {
     .name          = "elbg",
     .description   = NULL_IF_CONFIG_SMALL("Apply posterize effect, using the ELBG algorithm."),
@@ -268,6 +261,6 @@ const AVFilter ff_vf_elbg = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(elbg_inputs),
-    FILTER_OUTPUTS(elbg_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
 };
diff --git a/libavfilter/vf_entropy.c b/libavfilter/vf_entropy.c
index 893d07d8e6..c96cbaaecd 100644
--- a/libavfilter/vf_entropy.c
+++ b/libavfilter/vf_entropy.c
@@ -176,20 +176,13 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_entropy = {
     .name           = "entropy",
     .description    = NULL_IF_CONFIG_SMALL("Measure video frames entropy."),
     .priv_size      = sizeof(EntropyContext),
     .uninit         = uninit,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixfmts),
     .priv_class     = &entropy_class,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_METADATA_ONLY,
diff --git a/libavfilter/vf_eq.c b/libavfilter/vf_eq.c
index 3c686abe24..00fd840dec 100644
--- a/libavfilter/vf_eq.c
+++ b/libavfilter/vf_eq.c
@@ -314,13 +314,6 @@ static const AVFilterPad eq_inputs[] = {
     },
 };
 
-static const AVFilterPad eq_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(EQContext, x)
 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@@ -355,7 +348,7 @@ const AVFilter ff_vf_eq = {
     .priv_size       = sizeof(EQContext),
     .priv_class      = &eq_class,
     FILTER_INPUTS(eq_inputs),
-    FILTER_OUTPUTS(eq_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts_eq),
     .process_command = process_command,
     .init            = initialize,
diff --git a/libavfilter/vf_exposure.c b/libavfilter/vf_exposure.c
index ff2f156534..12434cdd9d 100644
--- a/libavfilter/vf_exposure.c
+++ b/libavfilter/vf_exposure.c
@@ -133,13 +133,6 @@ static const AVFilterPad exposure_inputs[] = {
     },
 };
 
-static const AVFilterPad exposure_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(ExposureContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -157,7 +150,7 @@ const AVFilter ff_vf_exposure = {
     .priv_size     = sizeof(ExposureContext),
     .priv_class    = &exposure_class,
     FILTER_INPUTS(exposure_inputs),
-    FILTER_OUTPUTS(exposure_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_fade.c b/libavfilter/vf_fade.c
index 868e7cc16a..f903db0415 100644
--- a/libavfilter/vf_fade.c
+++ b/libavfilter/vf_fade.c
@@ -557,13 +557,6 @@ static const AVFilterPad avfilter_vf_fade_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_fade_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_fade = {
     .name          = "fade",
     .description   = NULL_IF_CONFIG_SMALL("Fade in/out input video."),
@@ -571,7 +564,7 @@ const AVFilter ff_vf_fade = {
     .priv_size     = sizeof(FadeContext),
     .priv_class    = &fade_class,
     FILTER_INPUTS(avfilter_vf_fade_inputs),
-    FILTER_OUTPUTS(avfilter_vf_fade_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SLICE_THREADS |
                      AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_fftfilt.c b/libavfilter/vf_fftfilt.c
index 2b2408f15c..aea83dc19c 100644
--- a/libavfilter/vf_fftfilt.c
+++ b/libavfilter/vf_fftfilt.c
@@ -593,20 +593,13 @@ static const AVFilterPad fftfilt_inputs[] = {
     },
 };
 
-static const AVFilterPad fftfilt_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_fftfilt = {
     .name            = "fftfilt",
     .description     = NULL_IF_CONFIG_SMALL("Apply arbitrary expressions to pixels in frequency domain."),
     .priv_size       = sizeof(FFTFILTContext),
     .priv_class      = &fftfilt_class,
     FILTER_INPUTS(fftfilt_inputs),
-    FILTER_OUTPUTS(fftfilt_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts_fftfilt),
     .init            = initialize,
     .uninit          = uninit,
diff --git a/libavfilter/vf_fieldorder.c b/libavfilter/vf_fieldorder.c
index cf6efa6e54..165b359024 100644
--- a/libavfilter/vf_fieldorder.c
+++ b/libavfilter/vf_fieldorder.c
@@ -176,20 +176,13 @@ static const AVFilterPad avfilter_vf_fieldorder_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_fieldorder_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_fieldorder = {
     .name          = "fieldorder",
     .description   = NULL_IF_CONFIG_SMALL("Set the field order."),
     .priv_size     = sizeof(FieldOrderContext),
     .priv_class    = &fieldorder_class,
     FILTER_INPUTS(avfilter_vf_fieldorder_inputs),
-    FILTER_OUTPUTS(avfilter_vf_fieldorder_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_fillborders.c b/libavfilter/vf_fillborders.c
index 83f206aeb1..e4aa7cd5ca 100644
--- a/libavfilter/vf_fillborders.c
+++ b/libavfilter/vf_fillborders.c
@@ -707,20 +707,13 @@ static const AVFilterPad fillborders_inputs[] = {
     },
 };
 
-static const AVFilterPad fillborders_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_fillborders = {
     .name          = "fillborders",
     .description   = NULL_IF_CONFIG_SMALL("Fill borders of the input video."),
     .priv_size     = sizeof(FillBordersContext),
     .priv_class    = &fillborders_class,
     FILTER_INPUTS(fillborders_inputs),
-    FILTER_OUTPUTS(fillborders_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,
diff --git a/libavfilter/vf_find_rect.c b/libavfilter/vf_find_rect.c
index a536d669d1..9f4ee1e32f 100644
--- a/libavfilter/vf_find_rect.c
+++ b/libavfilter/vf_find_rect.c
@@ -25,6 +25,7 @@
 #include "libavutil/imgutils.h"
 #include "libavutil/opt.h"
 #include "internal.h"
+#include "video.h"
 
 #include "lavfutils.h"
 
@@ -281,13 +282,6 @@ static const AVFilterPad foc_inputs[] = {
     },
 };
 
-static const AVFilterPad foc_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_find_rect = {
     .name            = "find_rect",
     .description     = NULL_IF_CONFIG_SMALL("Find a user specified object."),
@@ -296,7 +290,7 @@ const AVFilter ff_vf_find_rect = {
     .uninit          = uninit,
     .flags           = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(foc_inputs),
-    FILTER_OUTPUTS(foc_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
     .priv_class      = &find_rect_class,
 };
diff --git a/libavfilter/vf_floodfill.c b/libavfilter/vf_floodfill.c
index 212255a784..675e0f084f 100644
--- a/libavfilter/vf_floodfill.c
+++ b/libavfilter/vf_floodfill.c
@@ -385,13 +385,6 @@ static const AVFilterPad floodfill_inputs[] = {
     },
 };
 
-static const AVFilterPad floodfill_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(FloodfillContext, x)
 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
 
@@ -418,7 +411,7 @@ const AVFilter ff_vf_floodfill = {
     .priv_class    = &floodfill_class,
     .uninit        = uninit,
     FILTER_INPUTS(floodfill_inputs),
-    FILTER_OUTPUTS(floodfill_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_format.c b/libavfilter/vf_format.c
index 24b1c9ca61..04c265f59f 100644
--- a/libavfilter/vf_format.c
+++ b/libavfilter/vf_format.c
@@ -154,13 +154,6 @@ static const AVFilterPad avfilter_vf_format_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_format_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO
-    },
-};
-
 const AVFilter ff_vf_format = {
     .name          = "format",
     .description   = NULL_IF_CONFIG_SMALL("Convert the input video to one of the specified pixel formats."),
@@ -174,7 +167,7 @@ const AVFilter ff_vf_format = {
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
 
     FILTER_INPUTS(avfilter_vf_format_inputs),
-    FILTER_OUTPUTS(avfilter_vf_format_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 
     FILTER_QUERY_FUNC(query_formats),
 };
@@ -190,13 +183,6 @@ static const AVFilterPad avfilter_vf_noformat_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_noformat_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO
-    },
-};
-
 const AVFilter ff_vf_noformat = {
     .name          = "noformat",
     .description   = NULL_IF_CONFIG_SMALL("Force libavfilter not to use any of the specified pixel formats for the input to the next filter."),
@@ -210,7 +196,7 @@ const AVFilter ff_vf_noformat = {
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
 
     FILTER_INPUTS(avfilter_vf_noformat_inputs),
-    FILTER_OUTPUTS(avfilter_vf_noformat_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 
     FILTER_QUERY_FUNC(query_formats),
 };
diff --git a/libavfilter/vf_fps.c b/libavfilter/vf_fps.c
index 2bfb6d29e7..089f7f2021 100644
--- a/libavfilter/vf_fps.c
+++ b/libavfilter/vf_fps.c
@@ -37,6 +37,7 @@
 #include "ccfifo.h"
 #include "filters.h"
 #include "internal.h"
+#include "video.h"
 
 enum EOFAction {
     EOF_ACTION_ROUND,
@@ -376,13 +377,6 @@ static int activate(AVFilterContext *ctx)
     return FFERROR_NOT_READY;
 }
 
-static const AVFilterPad avfilter_vf_fps_inputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static const AVFilterPad avfilter_vf_fps_outputs[] = {
     {
         .name          = "default",
@@ -400,6 +394,6 @@ const AVFilter ff_vf_fps = {
     .priv_class  = &fps_class,
     .activate    = activate,
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
-    FILTER_INPUTS(avfilter_vf_fps_inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     FILTER_OUTPUTS(avfilter_vf_fps_outputs),
 };
diff --git a/libavfilter/vf_freezedetect.c b/libavfilter/vf_freezedetect.c
index 31a80a6dc0..fb4e59b127 100644
--- a/libavfilter/vf_freezedetect.c
+++ b/libavfilter/vf_freezedetect.c
@@ -29,6 +29,7 @@
 #include "avfilter.h"
 #include "filters.h"
 #include "scene_sad.h"
+#include "video.h"
 
 typedef struct FreezeDetectContext {
     const AVClass *class;
@@ -204,13 +205,6 @@ static const AVFilterPad freezedetect_inputs[] = {
     },
 };
 
-static const AVFilterPad freezedetect_outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_freezedetect = {
     .name          = "freezedetect",
     .description   = NULL_IF_CONFIG_SMALL("Detects frozen video input."),
@@ -219,7 +213,7 @@ const AVFilter ff_vf_freezedetect = {
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(freezedetect_inputs),
-    FILTER_OUTPUTS(freezedetect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .activate      = activate,
 };
diff --git a/libavfilter/vf_frei0r.c b/libavfilter/vf_frei0r.c
index 59873dc502..7dccd5946f 100644
--- a/libavfilter/vf_frei0r.c
+++ b/libavfilter/vf_frei0r.c
@@ -423,13 +423,6 @@ static const AVFilterPad avfilter_vf_frei0r_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_frei0r_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_frei0r = {
     .name          = "frei0r",
     .description   = NULL_IF_CONFIG_SMALL("Apply a frei0r effect."),
@@ -438,7 +431,7 @@ const AVFilter ff_vf_frei0r = {
     .priv_size     = sizeof(Frei0rContext),
     .priv_class    = &frei0r_class,
     FILTER_INPUTS(avfilter_vf_frei0r_inputs),
-    FILTER_OUTPUTS(avfilter_vf_frei0r_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_fspp.c b/libavfilter/vf_fspp.c
index b110c5a7d2..88e887897e 100644
--- a/libavfilter/vf_fspp.c
+++ b/libavfilter/vf_fspp.c
@@ -652,20 +652,13 @@ static const AVFilterPad fspp_inputs[] = {
     },
 };
 
-static const AVFilterPad fspp_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_fspp = {
     .name            = "fspp",
     .description     = NULL_IF_CONFIG_SMALL("Apply Fast Simple Post-processing filter."),
     .priv_size       = sizeof(FSPPContext),
     .uninit          = uninit,
     FILTER_INPUTS(fspp_inputs),
-    FILTER_OUTPUTS(fspp_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class      = &fspp_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
diff --git a/libavfilter/vf_gblur.c b/libavfilter/vf_gblur.c
index ca1dcb3dab..509ae3dece 100644
--- a/libavfilter/vf_gblur.c
+++ b/libavfilter/vf_gblur.c
@@ -315,13 +315,6 @@ static const AVFilterPad gblur_inputs[] = {
     },
 };
 
-static const AVFilterPad gblur_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_gblur = {
     .name          = "gblur",
     .description   = NULL_IF_CONFIG_SMALL("Apply Gaussian Blur filter."),
@@ -329,7 +322,7 @@ const AVFilter ff_vf_gblur = {
     .priv_class    = &gblur_class,
     .uninit        = uninit,
     FILTER_INPUTS(gblur_inputs),
-    FILTER_OUTPUTS(gblur_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_geq.c b/libavfilter/vf_geq.c
index e90b49366f..092124669f 100644
--- a/libavfilter/vf_geq.c
+++ b/libavfilter/vf_geq.c
@@ -516,13 +516,6 @@ static const AVFilterPad geq_inputs[] = {
     },
 };
 
-static const AVFilterPad geq_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_geq = {
     .name          = "geq",
     .description   = NULL_IF_CONFIG_SMALL("Apply generic equation to each pixel."),
@@ -530,7 +523,7 @@ const AVFilter ff_vf_geq = {
     .init          = geq_init,
     .uninit        = geq_uninit,
     FILTER_INPUTS(geq_inputs),
-    FILTER_OUTPUTS(geq_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(geq_query_formats),
     .priv_class    = &geq_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_gradfun.c b/libavfilter/vf_gradfun.c
index 71a5f9c787..e8566918a4 100644
--- a/libavfilter/vf_gradfun.c
+++ b/libavfilter/vf_gradfun.c
@@ -236,13 +236,6 @@ static const AVFilterPad avfilter_vf_gradfun_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_gradfun_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_gradfun = {
     .name          = "gradfun",
     .description   = NULL_IF_CONFIG_SMALL("Debands video quickly using gradients."),
@@ -251,7 +244,7 @@ const AVFilter ff_vf_gradfun = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_gradfun_inputs),
-    FILTER_OUTPUTS(avfilter_vf_gradfun_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_grayworld.c b/libavfilter/vf_grayworld.c
index f20412cb10..6fa758199c 100644
--- a/libavfilter/vf_grayworld.c
+++ b/libavfilter/vf_grayworld.c
@@ -308,20 +308,13 @@ static const AVFilterPad grayworld_inputs[] = {
     }
 };
 
-static const AVFilterPad grayworld_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    }
-};
-
 const AVFilter ff_vf_grayworld = {
     .name          = "grayworld",
     .description   = NULL_IF_CONFIG_SMALL("Adjust white balance using LAB gray world algorithm"),
     .priv_size     = sizeof(GrayWorldContext),
     .priv_class    = &grayworld_class,
     FILTER_INPUTS(grayworld_inputs),
-    FILTER_OUTPUTS(grayworld_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .uninit        = uninit,
diff --git a/libavfilter/vf_hflip.c b/libavfilter/vf_hflip.c
index 8517b87889..09f4e08ea3 100644
--- a/libavfilter/vf_hflip.c
+++ b/libavfilter/vf_hflip.c
@@ -151,20 +151,13 @@ static const AVFilterPad avfilter_vf_hflip_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_hflip_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_hflip = {
     .name          = "hflip",
     .description   = NULL_IF_CONFIG_SMALL("Horizontally flip the input video."),
     .priv_size     = sizeof(FlipContext),
     .priv_class    = &hflip_class,
     FILTER_INPUTS(avfilter_vf_hflip_inputs),
-    FILTER_OUTPUTS(avfilter_vf_hflip_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_histeq.c b/libavfilter/vf_histeq.c
index 3fee4c9480..87ed6d79e8 100644
--- a/libavfilter/vf_histeq.c
+++ b/libavfilter/vf_histeq.c
@@ -254,20 +254,13 @@ static const AVFilterPad histeq_inputs[] = {
     },
 };
 
-static const AVFilterPad histeq_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_histeq = {
     .name          = "histeq",
     .description   = NULL_IF_CONFIG_SMALL("Apply global color histogram equalization."),
     .priv_size     = sizeof(HisteqContext),
     .init          = init,
     FILTER_INPUTS(histeq_inputs),
-    FILTER_OUTPUTS(histeq_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &histeq_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_hqdn3d.c b/libavfilter/vf_hqdn3d.c
index c796ea9ab4..f6d49675a1 100644
--- a/libavfilter/vf_hqdn3d.c
+++ b/libavfilter/vf_hqdn3d.c
@@ -383,13 +383,6 @@ static const AVFilterPad avfilter_vf_hqdn3d_inputs[] = {
 };
 
 
-static const AVFilterPad avfilter_vf_hqdn3d_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO
-    },
-};
-
 const AVFilter ff_vf_hqdn3d = {
     .name          = "hqdn3d",
     .description   = NULL_IF_CONFIG_SMALL("Apply a High Quality 3D Denoiser."),
@@ -398,7 +391,7 @@ const AVFilter ff_vf_hqdn3d = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_hqdn3d_inputs),
-    FILTER_OUTPUTS(avfilter_vf_hqdn3d_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
diff --git a/libavfilter/vf_hue.c b/libavfilter/vf_hue.c
index 644c99b1b1..8f3b73e840 100644
--- a/libavfilter/vf_hue.c
+++ b/libavfilter/vf_hue.c
@@ -500,13 +500,6 @@ static const AVFilterPad hue_inputs[] = {
     },
 };
 
-static const AVFilterPad hue_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_hue = {
     .name            = "hue",
     .description     = NULL_IF_CONFIG_SMALL("Adjust the hue and saturation of the input video."),
@@ -515,7 +508,7 @@ const AVFilter ff_vf_hue = {
     .uninit          = uninit,
     .process_command = process_command,
     FILTER_INPUTS(hue_inputs),
-    FILTER_OUTPUTS(hue_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class      = &hue_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_huesaturation.c b/libavfilter/vf_huesaturation.c
index d4e3fea1c5..4b427e6bf6 100644
--- a/libavfilter/vf_huesaturation.c
+++ b/libavfilter/vf_huesaturation.c
@@ -434,13 +434,6 @@ static const AVFilterPad huesaturation_inputs[] = {
     },
 };
 
-static const AVFilterPad huesaturation_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(HueSaturationContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -472,7 +465,7 @@ const AVFilter ff_vf_huesaturation = {
     .priv_size       = sizeof(HueSaturationContext),
     .priv_class      = &huesaturation_class,
     FILTER_INPUTS(huesaturation_inputs),
-    FILTER_OUTPUTS(huesaturation_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_iccdetect.c b/libavfilter/vf_iccdetect.c
index 7c08a2baaa..5288b0320d 100644
--- a/libavfilter/vf_iccdetect.c
+++ b/libavfilter/vf_iccdetect.c
@@ -31,6 +31,7 @@
 #include "avfilter.h"
 #include "fflcms2.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct IccDetectContext {
     const AVClass *class;
@@ -123,13 +124,6 @@ static const AVFilterPad iccdetect_inputs[] = {
     },
 };
 
-static const AVFilterPad iccdetect_outputs[] = {
-    {
-        .name           = "default",
-        .type           = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_iccdetect = {
     .name        = "iccdetect",
     .description = NULL_IF_CONFIG_SMALL("Detect and parse ICC profiles."),
@@ -139,5 +133,5 @@ const AVFilter ff_vf_iccdetect = {
     .init        = &iccdetect_init,
     .uninit      = &iccdetect_uninit,
     FILTER_INPUTS(iccdetect_inputs),
-    FILTER_OUTPUTS(iccdetect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
diff --git a/libavfilter/vf_iccgen.c b/libavfilter/vf_iccgen.c
index 67d02f5bc2..80771edf9e 100644
--- a/libavfilter/vf_iccgen.c
+++ b/libavfilter/vf_iccgen.c
@@ -30,6 +30,7 @@
 #include "avfilter.h"
 #include "fflcms2.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct IccGenContext {
     const AVClass *class;
@@ -161,13 +162,6 @@ static const AVFilterPad iccgen_inputs[] = {
     },
 };
 
-static const AVFilterPad iccgen_outputs[] = {
-    {
-        .name           = "default",
-        .type           = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_iccgen = {
     .name        = "iccgen",
     .description = NULL_IF_CONFIG_SMALL("Generate and attach ICC profiles."),
@@ -177,5 +171,5 @@ const AVFilter ff_vf_iccgen = {
     .init        = &iccgen_init,
     .uninit      = &iccgen_uninit,
     FILTER_INPUTS(iccgen_inputs),
-    FILTER_OUTPUTS(iccgen_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
diff --git a/libavfilter/vf_il.c b/libavfilter/vf_il.c
index 210ce8e821..05c393d914 100644
--- a/libavfilter/vf_il.c
+++ b/libavfilter/vf_il.c
@@ -184,19 +184,12 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_il = {
     .name          = "il",
     .description   = NULL_IF_CONFIG_SMALL("Deinterleave or interleave fields."),
     .priv_size     = sizeof(IlContext),
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .priv_class    = &il_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_kerndeint.c b/libavfilter/vf_kerndeint.c
index 260a99bcc4..5267c3b3ae 100644
--- a/libavfilter/vf_kerndeint.c
+++ b/libavfilter/vf_kerndeint.c
@@ -295,13 +295,6 @@ static const AVFilterPad kerndeint_inputs[] = {
     },
 };
 
-static const AVFilterPad kerndeint_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 
 const AVFilter ff_vf_kerndeint = {
     .name          = "kerndeint",
@@ -310,6 +303,6 @@ const AVFilter ff_vf_kerndeint = {
     .priv_class    = &kerndeint_class,
     .uninit        = uninit,
     FILTER_INPUTS(kerndeint_inputs),
-    FILTER_OUTPUTS(kerndeint_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
 };
diff --git a/libavfilter/vf_lensfun.c b/libavfilter/vf_lensfun.c
index f544af773e..05881b0651 100644
--- a/libavfilter/vf_lensfun.c
+++ b/libavfilter/vf_lensfun.c
@@ -522,13 +522,6 @@ static const AVFilterPad lensfun_inputs[] = {
     },
 };
 
-static const AVFilterPad lensfun_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_lensfun = {
     .name          = "lensfun",
     .description   = NULL_IF_CONFIG_SMALL("Apply correction to an image based on info derived from the lensfun database."),
@@ -536,7 +529,7 @@ const AVFilter ff_vf_lensfun = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(lensfun_inputs),
-    FILTER_OUTPUTS(lensfun_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_SINGLE_PIXFMT(AV_PIX_FMT_RGB24),
     .priv_class    = &lensfun_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_limiter.c b/libavfilter/vf_limiter.c
index 67b734229f..b602ce384b 100644
--- a/libavfilter/vf_limiter.c
+++ b/libavfilter/vf_limiter.c
@@ -231,13 +231,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_limiter = {
     .name          = "limiter",
     .description   = NULL_IF_CONFIG_SMALL("Limit pixels components to the specified range."),
@@ -245,7 +238,7 @@ const AVFilter ff_vf_limiter = {
     .priv_class    = &limiter_class,
     .init          = init,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
diff --git a/libavfilter/vf_lumakey.c b/libavfilter/vf_lumakey.c
index af1d85ec54..448b43dda0 100644
--- a/libavfilter/vf_lumakey.c
+++ b/libavfilter/vf_lumakey.c
@@ -173,13 +173,6 @@ static const AVFilterPad lumakey_inputs[] = {
     },
 };
 
-static const AVFilterPad lumakey_outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(LumakeyContext, x)
 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -198,7 +191,7 @@ const AVFilter ff_vf_lumakey = {
     .priv_size     = sizeof(LumakeyContext),
     .priv_class    = &lumakey_class,
     FILTER_INPUTS(lumakey_inputs),
-    FILTER_OUTPUTS(lumakey_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
diff --git a/libavfilter/vf_lut.c b/libavfilter/vf_lut.c
index 621291cdad..1a6ca06546 100644
--- a/libavfilter/vf_lut.c
+++ b/libavfilter/vf_lut.c
@@ -582,11 +582,6 @@ static const AVFilterPad inputs[] = {
       .config_props = config_props,
     },
 };
-static const AVFilterPad outputs[] = {
-    { .name = "default",
-      .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
 
 #define DEFINE_LUT_FILTER(name_, description_, priv_class_)             \
     const AVFilter ff_vf_##name_ = {                                    \
@@ -597,7 +592,7 @@ static const AVFilterPad outputs[] = {
         .init          = name_##_init,                                  \
         .uninit        = uninit,                                        \
         FILTER_INPUTS(inputs),                                          \
-        FILTER_OUTPUTS(outputs),                                        \
+        FILTER_OUTPUTS(ff_video_default_filterpad),                     \
         FILTER_QUERY_FUNC(query_formats),                               \
         .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |       \
                          AVFILTER_FLAG_SLICE_THREADS,                   \
diff --git a/libavfilter/vf_lut3d.c b/libavfilter/vf_lut3d.c
index 1ca448fcb3..db38d41932 100644
--- a/libavfilter/vf_lut3d.c
+++ b/libavfilter/vf_lut3d.c
@@ -1301,13 +1301,6 @@ static const AVFilterPad lut3d_inputs[] = {
     },
 };
 
-static const AVFilterPad lut3d_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_lut3d = {
     .name          = "lut3d",
     .description   = NULL_IF_CONFIG_SMALL("Adjust colors using a 3D LUT."),
@@ -1315,7 +1308,7 @@ const AVFilter ff_vf_lut3d = {
     .init          = lut3d_init,
     .uninit        = lut3d_uninit,
     FILTER_INPUTS(lut3d_inputs),
-    FILTER_OUTPUTS(lut3d_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &lut3d_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
@@ -2232,20 +2225,13 @@ static const AVFilterPad lut1d_inputs[] = {
     },
 };
 
-static const AVFilterPad lut1d_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_lut1d = {
     .name          = "lut1d",
     .description   = NULL_IF_CONFIG_SMALL("Adjust colors using a 1D LUT."),
     .priv_size     = sizeof(LUT1DContext),
     .init          = lut1d_init,
     FILTER_INPUTS(lut1d_inputs),
-    FILTER_OUTPUTS(lut1d_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &lut1d_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_maskfun.c b/libavfilter/vf_maskfun.c
index 253e5e40f7..44499d34ae 100644
--- a/libavfilter/vf_maskfun.c
+++ b/libavfilter/vf_maskfun.c
@@ -317,20 +317,13 @@ static const AVFilterPad maskfun_inputs[] = {
     },
 };
 
-static const AVFilterPad maskfun_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_maskfun = {
     .name          = "maskfun",
     .description   = NULL_IF_CONFIG_SMALL("Create Mask."),
     .priv_size     = sizeof(MaskFunContext),
     .uninit        = uninit,
     FILTER_INPUTS(maskfun_inputs),
-    FILTER_OUTPUTS(maskfun_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &maskfun_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_mcdeint.c b/libavfilter/vf_mcdeint.c
index a33f6feebf..e1b0a082f3 100644
--- a/libavfilter/vf_mcdeint.c
+++ b/libavfilter/vf_mcdeint.c
@@ -301,20 +301,13 @@ static const AVFilterPad mcdeint_inputs[] = {
     },
 };
 
-static const AVFilterPad mcdeint_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_mcdeint = {
     .name          = "mcdeint",
     .description   = NULL_IF_CONFIG_SMALL("Apply motion compensating deinterlacing."),
     .priv_size     = sizeof(MCDeintContext),
     .uninit        = uninit,
     FILTER_INPUTS(mcdeint_inputs),
-    FILTER_OUTPUTS(mcdeint_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_SINGLE_PIXFMT(AV_PIX_FMT_YUV420P),
     .priv_class    = &mcdeint_class,
 };
diff --git a/libavfilter/vf_median.c b/libavfilter/vf_median.c
index 11eccf608c..bc070105cd 100644
--- a/libavfilter/vf_median.c
+++ b/libavfilter/vf_median.c
@@ -270,13 +270,6 @@ static const AVFilterPad median_inputs[] = {
     },
 };
 
-static const AVFilterPad median_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_median = {
     .name          = "median",
     .description   = NULL_IF_CONFIG_SMALL("Apply Median filter."),
@@ -284,7 +277,7 @@ const AVFilter ff_vf_median = {
     .priv_class    = &median_class,
     .uninit        = uninit,
     FILTER_INPUTS(median_inputs),
-    FILTER_OUTPUTS(median_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
diff --git a/libavfilter/vf_mestimate.c b/libavfilter/vf_mestimate.c
index eff58f612e..001e6b0e8d 100644
--- a/libavfilter/vf_mestimate.c
+++ b/libavfilter/vf_mestimate.c
@@ -350,13 +350,6 @@ static const AVFilterPad mestimate_inputs[] = {
     },
 };
 
-static const AVFilterPad mestimate_outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_mestimate = {
     .name          = "mestimate",
     .description   = NULL_IF_CONFIG_SMALL("Generate motion vectors."),
@@ -365,6 +358,6 @@ const AVFilter ff_vf_mestimate = {
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(mestimate_inputs),
-    FILTER_OUTPUTS(mestimate_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
 };
diff --git a/libavfilter/vf_monochrome.c b/libavfilter/vf_monochrome.c
index c77c3b8f19..92ea651db2 100644
--- a/libavfilter/vf_monochrome.c
+++ b/libavfilter/vf_monochrome.c
@@ -268,13 +268,6 @@ static const AVFilterPad monochrome_inputs[] = {
     },
 };
 
-static const AVFilterPad monochrome_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(MonochromeContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -294,7 +287,7 @@ const AVFilter ff_vf_monochrome = {
     .priv_size     = sizeof(MonochromeContext),
     .priv_class    = &monochrome_class,
     FILTER_INPUTS(monochrome_inputs),
-    FILTER_OUTPUTS(monochrome_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_mpdecimate.c b/libavfilter/vf_mpdecimate.c
index a7b50d3973..d677a6e385 100644
--- a/libavfilter/vf_mpdecimate.c
+++ b/libavfilter/vf_mpdecimate.c
@@ -241,13 +241,6 @@ static const AVFilterPad mpdecimate_inputs[] = {
     },
 };
 
-static const AVFilterPad mpdecimate_outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_mpdecimate = {
     .name          = "mpdecimate",
     .description   = NULL_IF_CONFIG_SMALL("Remove near-duplicate frames."),
@@ -256,6 +249,6 @@ const AVFilter ff_vf_mpdecimate = {
     .priv_size     = sizeof(DecimateContext),
     .priv_class    = &mpdecimate_class,
     FILTER_INPUTS(mpdecimate_inputs),
-    FILTER_OUTPUTS(mpdecimate_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
 };
diff --git a/libavfilter/vf_negate.c b/libavfilter/vf_negate.c
index d782e63d3a..87cf908fd5 100644
--- a/libavfilter/vf_negate.c
+++ b/libavfilter/vf_negate.c
@@ -355,20 +355,13 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_negate = {
     .name          = "negate",
     .description   = NULL_IF_CONFIG_SMALL("Negate input video."),
     .priv_size     = sizeof(NegateContext),
     .priv_class    = &negate_class,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
diff --git a/libavfilter/vf_neighbor.c b/libavfilter/vf_neighbor.c
index d6638779e5..796f33c157 100644
--- a/libavfilter/vf_neighbor.c
+++ b/libavfilter/vf_neighbor.c
@@ -341,13 +341,6 @@ static const AVFilterPad neighbor_inputs[] = {
     },
 };
 
-static const AVFilterPad neighbor_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(NContext, x)
 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -358,7 +351,7 @@ const AVFilter ff_vf_##name_ = {                                   \
     .priv_class    = &priv_class_##_class,                   \
     .priv_size     = sizeof(NContext),                       \
     FILTER_INPUTS(neighbor_inputs),                          \
-    FILTER_OUTPUTS(neighbor_outputs),                        \
+    FILTER_OUTPUTS(ff_video_default_filterpad),              \
     FILTER_PIXFMTS_ARRAY(pix_fmts),                          \
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC| \
                      AVFILTER_FLAG_SLICE_THREADS,            \
diff --git a/libavfilter/vf_nlmeans.c b/libavfilter/vf_nlmeans.c
index 2fc3adacca..283865f3db 100644
--- a/libavfilter/vf_nlmeans.c
+++ b/libavfilter/vf_nlmeans.c
@@ -472,13 +472,6 @@ static const AVFilterPad nlmeans_inputs[] = {
     },
 };
 
-static const AVFilterPad nlmeans_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_nlmeans = {
     .name          = "nlmeans",
     .description   = NULL_IF_CONFIG_SMALL("Non-local means denoiser."),
@@ -486,7 +479,7 @@ const AVFilter ff_vf_nlmeans = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(nlmeans_inputs),
-    FILTER_OUTPUTS(nlmeans_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &nlmeans_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_noise.c b/libavfilter/vf_noise.c
index 8ed12f7409..ba843eed4e 100644
--- a/libavfilter/vf_noise.c
+++ b/libavfilter/vf_noise.c
@@ -330,13 +330,6 @@ static const AVFilterPad noise_inputs[] = {
     },
 };
 
-static const AVFilterPad noise_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_noise = {
     .name          = "noise",
     .description   = NULL_IF_CONFIG_SMALL("Add noise."),
@@ -344,7 +337,7 @@ const AVFilter ff_vf_noise = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(noise_inputs),
-    FILTER_OUTPUTS(noise_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .priv_class    = &noise_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_normalize.c b/libavfilter/vf_normalize.c
index 43ed3c67b3..146e36f5fd 100644
--- a/libavfilter/vf_normalize.c
+++ b/libavfilter/vf_normalize.c
@@ -511,13 +511,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_normalize = {
     .name          = "normalize",
     .description   = NULL_IF_CONFIG_SMALL("Normalize RGB video."),
@@ -525,7 +518,7 @@ const AVFilter ff_vf_normalize = {
     .priv_class    = &normalize_class,
     .uninit        = uninit,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_null.c b/libavfilter/vf_null.c
index fa80e2a102..1502774f98 100644
--- a/libavfilter/vf_null.c
+++ b/libavfilter/vf_null.c
@@ -26,24 +26,10 @@
 #include "internal.h"
 #include "video.h"
 
-static const AVFilterPad avfilter_vf_null_inputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
-static const AVFilterPad avfilter_vf_null_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_null = {
     .name        = "null",
     .description = NULL_IF_CONFIG_SMALL("Pass the source unchanged to the output."),
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
-    FILTER_INPUTS(avfilter_vf_null_inputs),
-    FILTER_OUTPUTS(avfilter_vf_null_outputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
diff --git a/libavfilter/vf_ocr.c b/libavfilter/vf_ocr.c
index 1648afa0f9..c7f7b69df7 100644
--- a/libavfilter/vf_ocr.c
+++ b/libavfilter/vf_ocr.c
@@ -129,13 +129,6 @@ static const AVFilterPad ocr_inputs[] = {
     },
 };
 
-static const AVFilterPad ocr_outputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_ocr = {
     .name          = "ocr",
     .description   = NULL_IF_CONFIG_SMALL("Optical Character Recognition."),
@@ -145,6 +138,6 @@ const AVFilter ff_vf_ocr = {
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(ocr_inputs),
-    FILTER_OUTPUTS(ocr_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
 };
diff --git a/libavfilter/vf_owdenoise.c b/libavfilter/vf_owdenoise.c
index a728d2ba75..fad85bfa8e 100644
--- a/libavfilter/vf_owdenoise.c
+++ b/libavfilter/vf_owdenoise.c
@@ -355,20 +355,13 @@ static const AVFilterPad owdenoise_inputs[] = {
     },
 };
 
-static const AVFilterPad owdenoise_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_owdenoise = {
     .name          = "owdenoise",
     .description   = NULL_IF_CONFIG_SMALL("Denoise using wavelets."),
     .priv_size     = sizeof(OWDenoiseContext),
     .uninit        = uninit,
     FILTER_INPUTS(owdenoise_inputs),
-    FILTER_OUTPUTS(owdenoise_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &owdenoise_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_perspective.c b/libavfilter/vf_perspective.c
index da720dcb54..97ed938034 100644
--- a/libavfilter/vf_perspective.c
+++ b/libavfilter/vf_perspective.c
@@ -495,13 +495,6 @@ static const AVFilterPad perspective_inputs[] = {
     },
 };
 
-static const AVFilterPad perspective_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_perspective = {
     .name          = "perspective",
     .description   = NULL_IF_CONFIG_SMALL("Correct the perspective of video."),
@@ -509,7 +502,7 @@ const AVFilter ff_vf_perspective = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(perspective_inputs),
-    FILTER_OUTPUTS(perspective_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &perspective_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_phase.c b/libavfilter/vf_phase.c
index 1cb71e0e43..ba1223cc8f 100644
--- a/libavfilter/vf_phase.c
+++ b/libavfilter/vf_phase.c
@@ -218,13 +218,6 @@ static const AVFilterPad phase_inputs[] = {
     },
 };
 
-static const AVFilterPad phase_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_phase = {
     .name          = "phase",
     .description   = NULL_IF_CONFIG_SMALL("Phase shift fields."),
@@ -232,7 +225,7 @@ const AVFilter ff_vf_phase = {
     .priv_class    = &phase_class,
     .uninit        = uninit,
     FILTER_INPUTS(phase_inputs),
-    FILTER_OUTPUTS(phase_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_photosensitivity.c b/libavfilter/vf_photosensitivity.c
index e05d4d0262..8c8bbb8662 100644
--- a/libavfilter/vf_photosensitivity.c
+++ b/libavfilter/vf_photosensitivity.c
@@ -310,13 +310,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_photosensitivity = {
     .name          = "photosensitivity",
     .description   = NULL_IF_CONFIG_SMALL("Filter out photosensitive epilepsy seizure-inducing flashes."),
@@ -324,6 +317,6 @@ const AVFilter ff_vf_photosensitivity = {
     .priv_class    = &photosensitivity_class,
     .uninit        = uninit,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24),
 };
diff --git a/libavfilter/vf_pixdesctest.c b/libavfilter/vf_pixdesctest.c
index 12815aea9c..c2638d058f 100644
--- a/libavfilter/vf_pixdesctest.c
+++ b/libavfilter/vf_pixdesctest.c
@@ -115,18 +115,11 @@ static const AVFilterPad avfilter_vf_pixdesctest_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_pixdesctest_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_pixdesctest = {
     .name        = "pixdesctest",
     .description = NULL_IF_CONFIG_SMALL("Test pixel format definitions."),
     .priv_size   = sizeof(PixdescTestContext),
     .uninit      = uninit,
     FILTER_INPUTS(avfilter_vf_pixdesctest_inputs),
-    FILTER_OUTPUTS(avfilter_vf_pixdesctest_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
diff --git a/libavfilter/vf_pp.c b/libavfilter/vf_pp.c
index 2d563f7d8a..aa37325a24 100644
--- a/libavfilter/vf_pp.c
+++ b/libavfilter/vf_pp.c
@@ -175,13 +175,6 @@ static const AVFilterPad pp_inputs[] = {
     },
 };
 
-static const AVFilterPad pp_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_pp = {
     .name            = "pp",
     .description     = NULL_IF_CONFIG_SMALL("Filter video using libpostproc."),
@@ -189,7 +182,7 @@ const AVFilter ff_vf_pp = {
     .init            = pp_init,
     .uninit          = pp_uninit,
     FILTER_INPUTS(pp_inputs),
-    FILTER_OUTPUTS(pp_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .process_command = pp_process_command,
     .priv_class      = &pp_class,
diff --git a/libavfilter/vf_pp7.c b/libavfilter/vf_pp7.c
index 4f0e60c2e2..f44a5396ea 100644
--- a/libavfilter/vf_pp7.c
+++ b/libavfilter/vf_pp7.c
@@ -386,20 +386,13 @@ static const AVFilterPad pp7_inputs[] = {
     },
 };
 
-static const AVFilterPad pp7_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_pp7 = {
     .name            = "pp7",
     .description     = NULL_IF_CONFIG_SMALL("Apply Postprocessing 7 filter."),
     .priv_size       = sizeof(PP7Context),
     .uninit          = uninit,
     FILTER_INPUTS(pp7_inputs),
-    FILTER_OUTPUTS(pp7_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class      = &pp7_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
diff --git a/libavfilter/vf_pseudocolor.c b/libavfilter/vf_pseudocolor.c
index 31532e2824..427eb1b5b4 100644
--- a/libavfilter/vf_pseudocolor.c
+++ b/libavfilter/vf_pseudocolor.c
@@ -1040,13 +1040,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static av_cold void uninit(AVFilterContext *ctx)
 {
     PseudoColorContext *s = ctx->priv;
@@ -1067,7 +1060,7 @@ const AVFilter ff_vf_pseudocolor = {
     .priv_class    = &pseudocolor_class,
     .uninit        = uninit,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
diff --git a/libavfilter/vf_pullup.c b/libavfilter/vf_pullup.c
index fcdcfc44af..80105ec1c0 100644
--- a/libavfilter/vf_pullup.c
+++ b/libavfilter/vf_pullup.c
@@ -749,13 +749,6 @@ static const AVFilterPad pullup_inputs[] = {
     },
 };
 
-static const AVFilterPad pullup_outputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_pullup = {
     .name          = "pullup",
     .description   = NULL_IF_CONFIG_SMALL("Pullup from field sequence to frames."),
@@ -763,6 +756,6 @@ const AVFilter ff_vf_pullup = {
     .priv_class    = &pullup_class,
     .uninit        = uninit,
     FILTER_INPUTS(pullup_inputs),
-    FILTER_OUTPUTS(pullup_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
 };
diff --git a/libavfilter/vf_qp.c b/libavfilter/vf_qp.c
index a771b51ae1..3019e77052 100644
--- a/libavfilter/vf_qp.c
+++ b/libavfilter/vf_qp.c
@@ -184,19 +184,12 @@ static const AVFilterPad qp_inputs[] = {
     },
 };
 
-static const AVFilterPad qp_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_qp = {
     .name          = "qp",
     .description   = NULL_IF_CONFIG_SMALL("Change video quantization parameters."),
     .priv_size     = sizeof(QPContext),
     FILTER_INPUTS(qp_inputs),
-    FILTER_OUTPUTS(qp_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .priv_class    = &qp_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_METADATA_ONLY,
diff --git a/libavfilter/vf_readeia608.c b/libavfilter/vf_readeia608.c
index d85012564f..8f3c44e8d8 100644
--- a/libavfilter/vf_readeia608.c
+++ b/libavfilter/vf_readeia608.c
@@ -539,20 +539,13 @@ static const AVFilterPad readeia608_inputs[] = {
     },
 };
 
-static const AVFilterPad readeia608_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_readeia608 = {
     .name          = "readeia608",
     .description   = NULL_IF_CONFIG_SMALL("Read EIA-608 Closed Caption codes from input video and write them to frame metadata."),
     .priv_size     = sizeof(ReadEIA608Context),
     .priv_class    = &readeia608_class,
     FILTER_INPUTS(readeia608_inputs),
-    FILTER_OUTPUTS(readeia608_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
diff --git a/libavfilter/vf_readvitc.c b/libavfilter/vf_readvitc.c
index d0fba234f7..011063a29b 100644
--- a/libavfilter/vf_readvitc.c
+++ b/libavfilter/vf_readvitc.c
@@ -32,6 +32,7 @@
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
+#include "video.h"
 
 #define LINE_DATA_SIZE 9
 
@@ -230,13 +231,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_readvitc = {
     .name          = "readvitc",
     .description   = NULL_IF_CONFIG_SMALL("Read vertical interval timecode and write it to frame metadata."),
@@ -244,7 +238,7 @@ const AVFilter ff_vf_readvitc = {
     .priv_class    = &readvitc_class,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .init          = init,
 };
diff --git a/libavfilter/vf_removegrain.c b/libavfilter/vf_removegrain.c
index 0d4b070cd5..a3a801f8d7 100644
--- a/libavfilter/vf_removegrain.c
+++ b/libavfilter/vf_removegrain.c
@@ -632,19 +632,12 @@ static const AVFilterPad removegrain_inputs[] = {
     },
 };
 
-static const AVFilterPad removegrain_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_removegrain = {
     .name          = "removegrain",
     .description   = NULL_IF_CONFIG_SMALL("Remove grain."),
     .priv_size     = sizeof(RemoveGrainContext),
     FILTER_INPUTS(removegrain_inputs),
-    FILTER_OUTPUTS(removegrain_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &removegrain_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_removelogo.c b/libavfilter/vf_removelogo.c
index c323b5eff3..346a746fe9 100644
--- a/libavfilter/vf_removelogo.c
+++ b/libavfilter/vf_removelogo.c
@@ -555,13 +555,6 @@ static const AVFilterPad removelogo_inputs[] = {
     },
 };
 
-static const AVFilterPad removelogo_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_removelogo = {
     .name          = "removelogo",
     .description   = NULL_IF_CONFIG_SMALL("Remove a TV logo based on a mask image."),
@@ -569,7 +562,7 @@ const AVFilter ff_vf_removelogo = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(removelogo_inputs),
-    FILTER_OUTPUTS(removelogo_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_SINGLE_PIXFMT(AV_PIX_FMT_YUV420P),
     .priv_class    = &removelogo_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_repeatfields.c b/libavfilter/vf_repeatfields.c
index 782b1e543f..bf0edb5440 100644
--- a/libavfilter/vf_repeatfields.c
+++ b/libavfilter/vf_repeatfields.c
@@ -22,6 +22,7 @@
 #include "avfilter.h"
 #include "filters.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct RepeatFieldsContext {
     const AVClass *class;
@@ -182,19 +183,12 @@ static const AVFilterPad repeatfields_inputs[] = {
     },
 };
 
-static const AVFilterPad repeatfields_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_repeatfields = {
     .name          = "repeatfields",
     .description   = NULL_IF_CONFIG_SMALL("Hard repeat fields based on MPEG repeat field flag."),
     .priv_size     = sizeof(RepeatFieldsContext),
     .uninit        = uninit,
     FILTER_INPUTS(repeatfields_inputs),
-    FILTER_OUTPUTS(repeatfields_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts_eq),
 };
diff --git a/libavfilter/vf_sab.c b/libavfilter/vf_sab.c
index ee6edd5a48..43cecea547 100644
--- a/libavfilter/vf_sab.c
+++ b/libavfilter/vf_sab.c
@@ -308,13 +308,6 @@ static const AVFilterPad sab_inputs[] = {
     },
 };
 
-static const AVFilterPad sab_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_sab = {
     .name          = "sab",
     .description   = NULL_IF_CONFIG_SMALL("Apply shape adaptive blur."),
@@ -322,7 +315,7 @@ const AVFilter ff_vf_sab = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(sab_inputs),
-    FILTER_OUTPUTS(sab_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &sab_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_scdet.c b/libavfilter/vf_scdet.c
index 8dcce5ada6..6de84a43a0 100644
--- a/libavfilter/vf_scdet.c
+++ b/libavfilter/vf_scdet.c
@@ -29,6 +29,7 @@
 #include "avfilter.h"
 #include "filters.h"
 #include "scene_sad.h"
+#include "video.h"
 
 typedef struct SCDetContext {
     const AVClass *class;
@@ -193,13 +194,6 @@ static const AVFilterPad scdet_inputs[] = {
     },
 };
 
-static const AVFilterPad scdet_outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_scdet = {
     .name          = "scdet",
     .description   = NULL_IF_CONFIG_SMALL("Detect video scene change"),
@@ -208,7 +202,7 @@ const AVFilter ff_vf_scdet = {
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(scdet_inputs),
-    FILTER_OUTPUTS(scdet_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .activate      = activate,
 };
diff --git a/libavfilter/vf_scroll.c b/libavfilter/vf_scroll.c
index 5b7d0ad11c..5e35958fcd 100644
--- a/libavfilter/vf_scroll.c
+++ b/libavfilter/vf_scroll.c
@@ -195,20 +195,13 @@ static const AVFilterPad scroll_inputs[] = {
     },
 };
 
-static const AVFilterPad scroll_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_scroll = {
     .name          = "scroll",
     .description   = NULL_IF_CONFIG_SMALL("Scroll input video."),
     .priv_size     = sizeof(ScrollContext),
     .priv_class    = &scroll_class,
     FILTER_INPUTS(scroll_inputs),
-    FILTER_OUTPUTS(scroll_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_selectivecolor.c b/libavfilter/vf_selectivecolor.c
index ea4b5dfee2..ab980479a8 100644
--- a/libavfilter/vf_selectivecolor.c
+++ b/libavfilter/vf_selectivecolor.c
@@ -474,19 +474,12 @@ static const AVFilterPad selectivecolor_inputs[] = {
     },
 };
 
-static const AVFilterPad selectivecolor_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_selectivecolor = {
     .name          = "selectivecolor",
     .description   = NULL_IF_CONFIG_SMALL("Apply CMYK adjustments to specific color ranges."),
     .priv_size     = sizeof(SelectiveColorContext),
     FILTER_INPUTS(selectivecolor_inputs),
-    FILTER_OUTPUTS(selectivecolor_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &selectivecolor_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_separatefields.c b/libavfilter/vf_separatefields.c
index 723974afaa..b7ddb26377 100644
--- a/libavfilter/vf_separatefields.c
+++ b/libavfilter/vf_separatefields.c
@@ -22,6 +22,7 @@
 #include "avfilter.h"
 #include "filters.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct SeparateFieldsContext {
     int nb_planes;
@@ -161,13 +162,6 @@ static av_cold void uninit(AVFilterContext *ctx)
     av_frame_free(&s->second);
 }
 
-static const AVFilterPad separatefields_inputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static const AVFilterPad separatefields_outputs[] = {
     {
         .name          = "default",
@@ -182,6 +176,6 @@ const AVFilter ff_vf_separatefields = {
     .priv_size   = sizeof(SeparateFieldsContext),
     .activate    = activate,
     .uninit      = uninit,
-    FILTER_INPUTS(separatefields_inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     FILTER_OUTPUTS(separatefields_outputs),
 };
diff --git a/libavfilter/vf_setparams.c b/libavfilter/vf_setparams.c
index 321a64a14e..ae4c937518 100644
--- a/libavfilter/vf_setparams.c
+++ b/libavfilter/vf_setparams.c
@@ -169,13 +169,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_setparams = {
     .name        = "setparams",
     .description = NULL_IF_CONFIG_SMALL("Force field, or color property for the output video frame."),
@@ -183,7 +176,7 @@ const AVFilter ff_vf_setparams = {
     .priv_class  = &setparams_class,
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
 
 #if CONFIG_SETRANGE_FILTER
@@ -223,7 +216,7 @@ const AVFilter ff_vf_setrange = {
     .priv_class  = &setrange_class,
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
 #endif /* CONFIG_SETRANGE_FILTER */
 
@@ -258,6 +251,6 @@ const AVFilter ff_vf_setfield = {
     .priv_class  = &setfield_class,
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
 #endif /* CONFIG_SETFIELD_FILTER */
diff --git a/libavfilter/vf_shuffleframes.c b/libavfilter/vf_shuffleframes.c
index 14b90e6446..cf8f197e27 100644
--- a/libavfilter/vf_shuffleframes.c
+++ b/libavfilter/vf_shuffleframes.c
@@ -146,13 +146,6 @@ static const AVFilterPad shuffleframes_inputs[] = {
     },
 };
 
-static const AVFilterPad shuffleframes_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_shuffleframes = {
     .name          = "shuffleframes",
     .description   = NULL_IF_CONFIG_SMALL("Shuffle video frames."),
@@ -161,6 +154,6 @@ const AVFilter ff_vf_shuffleframes = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(shuffleframes_inputs),
-    FILTER_OUTPUTS(shuffleframes_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_shuffleplanes.c b/libavfilter/vf_shuffleplanes.c
index b2f64ad076..1540eaad0e 100644
--- a/libavfilter/vf_shuffleplanes.c
+++ b/libavfilter/vf_shuffleplanes.c
@@ -153,20 +153,13 @@ static const AVFilterPad shuffleplanes_inputs[] = {
     },
 };
 
-static const AVFilterPad shuffleplanes_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_shuffleplanes = {
     .name         = "shuffleplanes",
     .description  = NULL_IF_CONFIG_SMALL("Shuffle video planes."),
     .priv_size    = sizeof(ShufflePlanesContext),
     .priv_class   = &shuffleplanes_class,
     FILTER_INPUTS(shuffleplanes_inputs),
-    FILTER_OUTPUTS(shuffleplanes_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags        = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_siti.c b/libavfilter/vf_siti.c
index 738affa5e8..ae9278c47c 100644
--- a/libavfilter/vf_siti.c
+++ b/libavfilter/vf_siti.c
@@ -328,13 +328,6 @@ static const AVFilterPad avfilter_vf_siti_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_siti_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO
-    },
-};
-
 const AVFilter ff_vf_siti = {
     .name          = "siti",
     .description   = NULL_IF_CONFIG_SMALL("Calculate spatial information (SI) and temporal information (TI)."),
@@ -345,5 +338,5 @@ const AVFilter ff_vf_siti = {
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     FILTER_INPUTS(avfilter_vf_siti_inputs),
-    FILTER_OUTPUTS(avfilter_vf_siti_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
diff --git a/libavfilter/vf_smartblur.c b/libavfilter/vf_smartblur.c
index 6c4719eab5..e9f56d5330 100644
--- a/libavfilter/vf_smartblur.c
+++ b/libavfilter/vf_smartblur.c
@@ -275,13 +275,6 @@ static const AVFilterPad smartblur_inputs[] = {
     },
 };
 
-static const AVFilterPad smartblur_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_smartblur = {
     .name          = "smartblur",
     .description   = NULL_IF_CONFIG_SMALL("Blur the input video without impacting the outlines."),
@@ -289,7 +282,7 @@ const AVFilter ff_vf_smartblur = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(smartblur_inputs),
-    FILTER_OUTPUTS(smartblur_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &smartblur_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_spp.c b/libavfilter/vf_spp.c
index efabe4dbae..83f062b3bf 100644
--- a/libavfilter/vf_spp.c
+++ b/libavfilter/vf_spp.c
@@ -485,13 +485,6 @@ static const AVFilterPad spp_inputs[] = {
     },
 };
 
-static const AVFilterPad spp_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_spp = {
     .name            = "spp",
     .description     = NULL_IF_CONFIG_SMALL("Apply a simple post processing filter."),
@@ -499,7 +492,7 @@ const AVFilter ff_vf_spp = {
     .preinit         = preinit,
     .uninit          = uninit,
     FILTER_INPUTS(spp_inputs),
-    FILTER_OUTPUTS(spp_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .process_command = process_command,
     .priv_class      = &spp_class,
diff --git a/libavfilter/vf_subtitles.c b/libavfilter/vf_subtitles.c
index 3e5a19e715..e2857e90c0 100644
--- a/libavfilter/vf_subtitles.c
+++ b/libavfilter/vf_subtitles.c
@@ -212,13 +212,6 @@ static const AVFilterPad ass_inputs[] = {
     },
 };
 
-static const AVFilterPad ass_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #if CONFIG_ASS_FILTER
 
 static const AVOption ass_options[] = {
@@ -260,7 +253,7 @@ const AVFilter ff_vf_ass = {
     .init          = init_ass,
     .uninit        = uninit,
     FILTER_INPUTS(ass_inputs),
-    FILTER_OUTPUTS(ass_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .priv_class    = &ass_class,
 };
@@ -515,7 +508,7 @@ const AVFilter ff_vf_subtitles = {
     .init          = init_subtitles,
     .uninit        = uninit,
     FILTER_INPUTS(ass_inputs),
-    FILTER_OUTPUTS(ass_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .priv_class    = &subtitles_class,
 };
diff --git a/libavfilter/vf_swaprect.c b/libavfilter/vf_swaprect.c
index fad650151f..13ae149afd 100644
--- a/libavfilter/vf_swaprect.c
+++ b/libavfilter/vf_swaprect.c
@@ -237,13 +237,6 @@ static const AVFilterPad inputs[] = {
     },
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_swaprect = {
     .name          = "swaprect",
     .description   = NULL_IF_CONFIG_SMALL("Swap 2 rectangular objects in video."),
@@ -251,7 +244,7 @@ const AVFilter ff_vf_swaprect = {
     .priv_class    = &swaprect_class,
     .uninit        = uninit,
     FILTER_INPUTS(inputs),
-    FILTER_OUTPUTS(outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_swapuv.c b/libavfilter/vf_swapuv.c
index 4452028262..df04631d20 100644
--- a/libavfilter/vf_swapuv.c
+++ b/libavfilter/vf_swapuv.c
@@ -101,20 +101,13 @@ static const AVFilterPad swapuv_inputs[] = {
     },
 };
 
-static const AVFilterPad swapuv_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_swapuv = {
     .name          = "swapuv",
     .description   = NULL_IF_CONFIG_SMALL("Swap U and V components."),
     .priv_size     = sizeof(SwapUVContext),
     .priv_class    = &swapuv_class,
     FILTER_INPUTS(swapuv_inputs),
-    FILTER_OUTPUTS(swapuv_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_tonemap.c b/libavfilter/vf_tonemap.c
index d1087e6bd9..f34448d0e9 100644
--- a/libavfilter/vf_tonemap.c
+++ b/libavfilter/vf_tonemap.c
@@ -307,13 +307,6 @@ static const AVFilterPad tonemap_inputs[] = {
     },
 };
 
-static const AVFilterPad tonemap_outputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_tonemap = {
     .name            = "tonemap",
     .description     = NULL_IF_CONFIG_SMALL("Conversion to/from different dynamic ranges."),
@@ -321,7 +314,7 @@ const AVFilter ff_vf_tonemap = {
     .priv_size       = sizeof(TonemapContext),
     .priv_class      = &tonemap_class,
     FILTER_INPUTS(tonemap_inputs),
-    FILTER_OUTPUTS(tonemap_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS(AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32),
     .flags           = AVFILTER_FLAG_SLICE_THREADS,
 };
diff --git a/libavfilter/vf_tpad.c b/libavfilter/vf_tpad.c
index 19c4f9b0b5..7990403e81 100644
--- a/libavfilter/vf_tpad.c
+++ b/libavfilter/vf_tpad.c
@@ -225,13 +225,6 @@ static const AVFilterPad tpad_inputs[] = {
     },
 };
 
-static const AVFilterPad tpad_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_tpad = {
     .name          = "tpad",
     .description   = NULL_IF_CONFIG_SMALL("Temporarily pad video frames."),
@@ -240,6 +233,6 @@ const AVFilter ff_vf_tpad = {
     .activate      = activate,
     .uninit        = uninit,
     FILTER_INPUTS(tpad_inputs),
-    FILTER_OUTPUTS(tpad_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
 };
diff --git a/libavfilter/vf_unsharp.c b/libavfilter/vf_unsharp.c
index 5e17ebce1e..73dd2f2a28 100644
--- a/libavfilter/vf_unsharp.c
+++ b/libavfilter/vf_unsharp.c
@@ -366,13 +366,6 @@ static const AVFilterPad avfilter_vf_unsharp_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_unsharp_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_unsharp = {
     .name          = "unsharp",
     .description   = NULL_IF_CONFIG_SMALL("Sharpen or blur the input video."),
@@ -381,7 +374,7 @@ const AVFilter ff_vf_unsharp = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_unsharp_inputs),
-    FILTER_OUTPUTS(avfilter_vf_unsharp_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };
diff --git a/libavfilter/vf_untile.c b/libavfilter/vf_untile.c
index c8dafd1e60..f32f3e186b 100644
--- a/libavfilter/vf_untile.c
+++ b/libavfilter/vf_untile.c
@@ -24,6 +24,7 @@
 #include "avfilter.h"
 #include "formats.h"
 #include "filters.h"
+#include "video.h"
 
 typedef struct UntileContext {
     const AVClass *class;
@@ -162,13 +163,6 @@ static av_cold void uninit(AVFilterContext *ctx)
     av_frame_free(&s->frame);
 }
 
-static const AVFilterPad untile_inputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static const AVFilterPad untile_outputs[] = {
     {
         .name          = "default",
@@ -184,7 +178,7 @@ const AVFilter ff_vf_untile = {
     .uninit        = uninit,
     .activate      = activate,
     .priv_size     = sizeof(UntileContext),
-    FILTER_INPUTS(untile_inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     FILTER_OUTPUTS(untile_outputs),
     FILTER_QUERY_FUNC(query_formats),
     .priv_class    = &untile_class,
diff --git a/libavfilter/vf_uspp.c b/libavfilter/vf_uspp.c
index 5f410b98a5..10c8aaeb6c 100644
--- a/libavfilter/vf_uspp.c
+++ b/libavfilter/vf_uspp.c
@@ -547,20 +547,13 @@ static const AVFilterPad uspp_inputs[] = {
     },
 };
 
-static const AVFilterPad uspp_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_uspp = {
     .name            = "uspp",
     .description     = NULL_IF_CONFIG_SMALL("Apply Ultra Simple / Slow Post-processing filter."),
     .priv_size       = sizeof(USPPContext),
     .uninit          = uninit,
     FILTER_INPUTS(uspp_inputs),
-    FILTER_OUTPUTS(uspp_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class      = &uspp_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
diff --git a/libavfilter/vf_vaguedenoiser.c b/libavfilter/vf_vaguedenoiser.c
index fb66f0dea1..81cc4b26e1 100644
--- a/libavfilter/vf_vaguedenoiser.c
+++ b/libavfilter/vf_vaguedenoiser.c
@@ -594,13 +594,6 @@ static const AVFilterPad vaguedenoiser_inputs[] = {
 };
 
 
-static const AVFilterPad vaguedenoiser_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO
-    },
-};
-
 const AVFilter ff_vf_vaguedenoiser = {
     .name          = "vaguedenoiser",
     .description   = NULL_IF_CONFIG_SMALL("Apply a Wavelet based Denoiser."),
@@ -609,7 +602,7 @@ const AVFilter ff_vf_vaguedenoiser = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(vaguedenoiser_inputs),
-    FILTER_OUTPUTS(vaguedenoiser_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_vflip.c b/libavfilter/vf_vflip.c
index 0d624512f9..8d6724ed37 100644
--- a/libavfilter/vf_vflip.c
+++ b/libavfilter/vf_vflip.c
@@ -135,19 +135,12 @@ static const AVFilterPad avfilter_vf_vflip_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_vflip_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_vflip = {
     .name        = "vflip",
     .description = NULL_IF_CONFIG_SMALL("Flip the input video vertically."),
     .priv_size   = sizeof(FlipContext),
     .priv_class  = &vflip_class,
     FILTER_INPUTS(avfilter_vf_vflip_inputs),
-    FILTER_OUTPUTS(avfilter_vf_vflip_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/libavfilter/vf_vfrdet.c b/libavfilter/vf_vfrdet.c
index 0ca221b5b8..8d641dd368 100644
--- a/libavfilter/vf_vfrdet.c
+++ b/libavfilter/vf_vfrdet.c
@@ -21,6 +21,7 @@
 #include "libavutil/common.h"
 #include "libavutil/opt.h"
 #include "internal.h"
+#include "video.h"
 
 typedef struct VFRDETContext {
     const AVClass *class;
@@ -95,13 +96,6 @@ static const AVFilterPad vfrdet_inputs[] = {
     },
 };
 
-static const AVFilterPad vfrdet_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_vfrdet = {
     .name        = "vfrdet",
     .description = NULL_IF_CONFIG_SMALL("Variable frame rate detect filter."),
@@ -110,5 +104,5 @@ const AVFilter ff_vf_vfrdet = {
     .uninit      = uninit,
     .flags       = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(vfrdet_inputs),
-    FILTER_OUTPUTS(vfrdet_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
 };
diff --git a/libavfilter/vf_vibrance.c b/libavfilter/vf_vibrance.c
index 329b37bdc6..e5ab3d24bf 100644
--- a/libavfilter/vf_vibrance.c
+++ b/libavfilter/vf_vibrance.c
@@ -416,13 +416,6 @@ static const AVFilterPad vibrance_inputs[] = {
     },
 };
 
-static const AVFilterPad vibrance_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(VibranceContext, x)
 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -446,7 +439,7 @@ const AVFilter ff_vf_vibrance = {
     .priv_size     = sizeof(VibranceContext),
     .priv_class    = &vibrance_class,
     FILTER_INPUTS(vibrance_inputs),
-    FILTER_OUTPUTS(vibrance_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pixel_fmts),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_vidstabdetect.c b/libavfilter/vf_vidstabdetect.c
index b27b1e40a6..a2c6d89503 100644
--- a/libavfilter/vf_vidstabdetect.c
+++ b/libavfilter/vf_vidstabdetect.c
@@ -29,6 +29,7 @@
 #include "avfilter.h"
 #include "filters.h"
 #include "internal.h"
+#include "video.h"
 
 #include "vidstabutils.h"
 
@@ -188,13 +189,6 @@ static const AVFilterPad avfilter_vf_vidstabdetect_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_vidstabdetect_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_vidstabdetect = {
     .name          = "vidstabdetect",
     .description   = NULL_IF_CONFIG_SMALL("Extract relative transformations, "
@@ -205,7 +199,7 @@ const AVFilter ff_vf_vidstabdetect = {
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(avfilter_vf_vidstabdetect_inputs),
-    FILTER_OUTPUTS(avfilter_vf_vidstabdetect_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(ff_vidstab_pix_fmts),
     .priv_class    = &vidstabdetect_class,
 };
diff --git a/libavfilter/vf_vidstabtransform.c b/libavfilter/vf_vidstabtransform.c
index 9efc8ef5a0..8a66a463b4 100644
--- a/libavfilter/vf_vidstabtransform.c
+++ b/libavfilter/vf_vidstabtransform.c
@@ -283,13 +283,6 @@ static const AVFilterPad avfilter_vf_vidstabtransform_inputs[] = {
     },
 };
 
-static const AVFilterPad avfilter_vf_vidstabtransform_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_vidstabtransform = {
     .name          = "vidstabtransform",
     .description   = NULL_IF_CONFIG_SMALL("Transform the frames, "
@@ -299,7 +292,7 @@ const AVFilter ff_vf_vidstabtransform = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(avfilter_vf_vidstabtransform_inputs),
-    FILTER_OUTPUTS(avfilter_vf_vidstabtransform_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(ff_vidstab_pix_fmts),
     .priv_class    = &vidstabtransform_class,
 };
diff --git a/libavfilter/vf_vignette.c b/libavfilter/vf_vignette.c
index 56764b49d1..177d51e276 100644
--- a/libavfilter/vf_vignette.c
+++ b/libavfilter/vf_vignette.c
@@ -325,13 +325,6 @@ static const AVFilterPad vignette_inputs[] = {
     },
 };
 
-static const AVFilterPad vignette_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_vignette = {
     .name          = "vignette",
     .description   = NULL_IF_CONFIG_SMALL("Make or reverse a vignette effect."),
@@ -339,7 +332,7 @@ const AVFilter ff_vf_vignette = {
     .init          = init,
     .uninit        = uninit,
     FILTER_INPUTS(vignette_inputs),
-    FILTER_OUTPUTS(vignette_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .priv_class    = &vignette_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/libavfilter/vf_vmafmotion.c b/libavfilter/vf_vmafmotion.c
index 137afd9245..022816e896 100644
--- a/libavfilter/vf_vmafmotion.c
+++ b/libavfilter/vf_vmafmotion.c
@@ -30,6 +30,7 @@
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
+#include "video.h"
 #include "vmaf_motion.h"
 
 #define BIT_SHIFT 15
@@ -350,13 +351,6 @@ static const AVFilterPad vmafmotion_inputs[] = {
     },
 };
 
-static const AVFilterPad vmafmotion_outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 const AVFilter ff_vf_vmafmotion = {
     .name          = "vmafmotion",
     .description   = NULL_IF_CONFIG_SMALL("Calculate the VMAF Motion score."),
@@ -366,6 +360,6 @@ const AVFilter ff_vf_vmafmotion = {
     .priv_class    = &vmafmotion_class,
     .flags         = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(vmafmotion_inputs),
-    FILTER_OUTPUTS(vmafmotion_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_QUERY_FUNC(query_formats),
 };
diff --git a/libavfilter/vf_yaepblur.c b/libavfilter/vf_yaepblur.c
index 473a444498..b39738b577 100644
--- a/libavfilter/vf_yaepblur.c
+++ b/libavfilter/vf_yaepblur.c
@@ -310,13 +310,6 @@ static const AVFilterPad yaep_inputs[] = {
     },
 };
 
-static const AVFilterPad yaep_outputs[] = {
-    {
-        .name = "default",
-        .type = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 #define OFFSET(x) offsetof(YAEPContext, x)
 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
 
@@ -339,7 +332,7 @@ const AVFilter ff_vf_yaepblur = {
     .priv_class      = &yaepblur_class,
     .uninit          = uninit,
     FILTER_INPUTS(yaep_inputs),
-    FILTER_OUTPUTS(yaep_outputs),
+    FILTER_OUTPUTS(ff_video_default_filterpad),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
diff --git a/libavfilter/vf_zoompan.c b/libavfilter/vf_zoompan.c
index cca979e01a..2e8bc18f3a 100644
--- a/libavfilter/vf_zoompan.c
+++ b/libavfilter/vf_zoompan.c
@@ -351,13 +351,6 @@ static av_cold void uninit(AVFilterContext *ctx)
     av_frame_free(&s->in);
 }
 
-static const AVFilterPad inputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-    },
-};
-
 static const AVFilterPad outputs[] = {
     {
         .name          = "default",
@@ -374,7 +367,7 @@ const AVFilter ff_vf_zoompan = {
     .init          = init,
     .uninit        = uninit,
     .activate      = activate,
-    FILTER_INPUTS(inputs),
+    FILTER_INPUTS(ff_video_default_filterpad),
     FILTER_OUTPUTS(outputs),
     FILTER_PIXFMTS_ARRAY(pix_fmts),
 };
diff --git a/libavfilter/video.c b/libavfilter/video.c
index 7683ef6fd4..42eeb98c28 100644
--- a/libavfilter/video.c
+++ b/libavfilter/video.c
@@ -33,6 +33,13 @@
 #include "internal.h"
 #include "video.h"
 
+const AVFilterPad ff_video_default_filterpad[1] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+    }
+};
+
 AVFrame *ff_null_get_video_buffer(AVFilterLink *link, int w, int h)
 {
     return ff_get_video_buffer(link->dst->outputs[0], w, h);
diff --git a/libavfilter/video.h b/libavfilter/video.h
index f37bab9d03..81331c3199 100644
--- a/libavfilter/video.h
+++ b/libavfilter/video.h
@@ -22,6 +22,13 @@
 #define AVFILTER_VIDEO_H
 
 #include "avfilter.h"
+#include "internal.h"
+
+/**
+ * An AVFilterPad array whose only entry has name "default"
+ * and is of type AVMEDIA_TYPE_VIDEO.
+ */
+extern const AVFilterPad ff_video_default_filterpad[1];
 
 AVFrame *ff_default_get_video_buffer(AVFilterLink *link, int w, int h);
 AVFrame *ff_default_get_video_buffer2(AVFilterLink *link, int w, int h, int align);