sigrid/ffmpeg

libavfilter/aeval.c+3−6

         .config_props  = config_props,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_asrc_aevalsrc = {
     .uninit        = uninit,
     .priv_size     = sizeof(EvalContext),
     .inputs        = NULL,
-    .outputs       = aevalsrc_outputs,
+    FILTER_OUTPUTS(aevalsrc_outputs),
     .priv_class    = &aevalsrc_class,
 };
         .type           = AVMEDIA_TYPE_AUDIO,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad aeval_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = aeval_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_aeval = {
     .init          = init,
     .uninit        = uninit,
     .priv_size     = sizeof(EvalContext),
-    .inputs        = aeval_inputs,
+    FILTER_INPUTS(aeval_inputs),
-    .outputs       = aeval_outputs,
+    FILTER_OUTPUTS(aeval_outputs),
     .priv_class    = &aeval_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/af_acontrast.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_acontrast = {
     .query_formats  = query_formats,
     .priv_size      = sizeof(AudioContrastContext),
     .priv_class     = &acontrast_class,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/af_acopy.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad acopy_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_acopy = {
     .name          = "acopy",
     .description   = NULL_IF_CONFIG_SMALL("Copy the input audio unchanged to the output."),
-    .inputs        = acopy_inputs,
+    FILTER_INPUTS(acopy_inputs),
-    .outputs       = acopy_outputs,
+    FILTER_OUTPUTS(acopy_outputs),
 };

libavfilter/af_acrossover.c+1−2

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 const AVFilter ff_af_acrossover = {
     .init           = init,
     .uninit         = uninit,
     .query_formats  = query_formats,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
     .outputs        = NULL,
     .flags          = AVFILTER_FLAG_DYNAMIC_OUTPUTS |
                       AVFILTER_FLAG_SLICE_THREADS,

libavfilter/af_acrusher.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_acrusher_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_acrusher = {
     .priv_class    = &acrusher_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_af_acrusher_inputs,
+    FILTER_INPUTS(avfilter_af_acrusher_inputs),
-    .outputs       = avfilter_af_acrusher_outputs,
+    FILTER_OUTPUTS(avfilter_af_acrusher_outputs),
     .process_command = process_command,
 };

libavfilter/af_adeclick.c+4−6

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_adeclick = {
     .init          = init,
     .activate      = activate,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };
     .init          = init,
     .activate      = activate,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/af_adelay.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad adelay_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_adelay = {
     .priv_class    = &adelay_class,
     .activate      = activate,
     .uninit        = uninit,
-    .inputs        = adelay_inputs,
+    FILTER_INPUTS(adelay_inputs),
-    .outputs       = adelay_outputs,
+    FILTER_OUTPUTS(adelay_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/af_adenorm.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad adenorm_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ADenormContext, x)
     .description     = NULL_IF_CONFIG_SMALL("Remedy denormals by adding extremely low-level noise."),
     .query_formats   = query_formats,
     .priv_size       = sizeof(ADenormContext),
-    .inputs          = adenorm_inputs,
+    FILTER_INPUTS(adenorm_inputs),
-    .outputs         = adenorm_outputs,
+    FILTER_OUTPUTS(adenorm_outputs),
     .priv_class      = &adenorm_class,
     .process_command = process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |

libavfilter/af_aderivative.c+4−6

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad aderivative_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_aderivative = {
     .query_formats = query_formats,
     .priv_size     = sizeof(ADerivativeContext),
     .uninit        = uninit,
-    .inputs        = aderivative_inputs,
+    FILTER_INPUTS(aderivative_inputs),
-    .outputs       = aderivative_outputs,
+    FILTER_OUTPUTS(aderivative_outputs),
 };
 const AVFilter ff_af_aintegral = {
     .query_formats = query_formats,
     .priv_size     = sizeof(ADerivativeContext),
     .uninit        = uninit,
-    .inputs        = aderivative_inputs,
+    FILTER_INPUTS(aderivative_inputs),
-    .outputs       = aderivative_outputs,
+    FILTER_OUTPUTS(aderivative_outputs),
 };

libavfilter/af_aecho.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad aecho_outputs[] = {
         .config_props  = config_output,
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_aecho = {
     .init          = init,
     .activate      = activate,
     .uninit        = uninit,
-    .inputs        = aecho_inputs,
+    FILTER_INPUTS(aecho_inputs),
-    .outputs       = aecho_outputs,
+    FILTER_OUTPUTS(aecho_outputs),
 };

libavfilter/af_aemphasis.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_aemphasis_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_aemphasis = {
     .priv_class    = &aemphasis_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_af_aemphasis_inputs,
+    FILTER_INPUTS(avfilter_af_aemphasis_inputs),
-    .outputs       = avfilter_af_aemphasis_outputs,
+    FILTER_OUTPUTS(avfilter_af_aemphasis_outputs),
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                      AVFILTER_FLAG_SLICE_THREADS,

libavfilter/af_aexciter.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_aexciter_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_aexciter = {
     .priv_class    = &aexciter_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_af_aexciter_inputs,
+    FILTER_INPUTS(avfilter_af_aexciter_inputs),
-    .outputs       = avfilter_af_aexciter_outputs,
+    FILTER_OUTPUTS(avfilter_af_aexciter_outputs),
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/af_afade.c+4−8

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_afade_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_afade = {
     .query_formats = query_formats,
     .priv_size     = sizeof(AudioFadeContext),
     .init          = init,
-    .inputs        = avfilter_af_afade_inputs,
+    FILTER_INPUTS(avfilter_af_afade_inputs),
-    .outputs       = avfilter_af_afade_outputs,
+    FILTER_OUTPUTS(avfilter_af_afade_outputs),
     .priv_class    = &afade_class,
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
         .name         = "crossfade1",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_acrossfade_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = acrossfade_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_acrossfade = {
     .priv_size     = sizeof(AudioFadeContext),
     .activate      = activate,
     .priv_class    = &acrossfade_class,
-    .inputs        = avfilter_af_acrossfade_inputs,
+    FILTER_INPUTS(avfilter_af_acrossfade_inputs),
-    .outputs       = avfilter_af_acrossfade_outputs,
+    FILTER_OUTPUTS(avfilter_af_acrossfade_outputs),
 };
 #endif /* CONFIG_ACROSSFADE_FILTER */

libavfilter/af_afftdn.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_afftdn = {
     .priv_class      = &afftdn_class,
     .activate        = activate,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                        AVFILTER_FLAG_SLICE_THREADS,

libavfilter/af_afftfilt.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_afftfilt = {
     .description     = NULL_IF_CONFIG_SMALL("Apply arbitrary expressions to samples in frequency domain."),
     .priv_size       = sizeof(AFFTFiltContext),
     .priv_class      = &afftfilt_class,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .activate        = activate,
     .query_formats   = query_formats,
     .uninit          = uninit,

libavfilter/af_aformat.c+2−4

         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_aformat_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO
     },
-    { NULL }
 };
 const AVFilter ff_af_aformat = {
     .query_formats = query_formats,
     .priv_size     = sizeof(AFormatContext),
     .priv_class    = &aformat_class,
-    .inputs        = avfilter_af_aformat_inputs,
+    FILTER_INPUTS(avfilter_af_aformat_inputs),
-    .outputs       = avfilter_af_aformat_outputs,
+    FILTER_OUTPUTS(avfilter_af_aformat_outputs),
 };

libavfilter/af_afreqshift.c+4−6

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_afreqshift = {
     .priv_size       = sizeof(AFreqShift),
     .priv_class      = &afreqshift_class,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = ff_filter_process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                        AVFILTER_FLAG_SLICE_THREADS,
     .priv_size       = sizeof(AFreqShift),
     .priv_class      = &aphaseshift_class,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = ff_filter_process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                        AVFILTER_FLAG_SLICE_THREADS,

libavfilter/af_afwtdn.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_afwtdn = {
     .priv_class      = &afwtdn_class,
     .activate        = activate,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags           = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/af_agate.c+4−8

         .filter_frame = filter_frame,
         .config_props = agate_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_agate = {
     .query_formats  = query_formats,
     .priv_size      = sizeof(AudioGateContext),
     .priv_class     = &agate_class,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = ff_filter_process_command,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
         .name           = "sidechain",
         .type           = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad sidechaingate_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = scconfig_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_sidechaingate = {
     .query_formats  = scquery_formats,
     .activate       = activate,
     .uninit         = uninit,
-    .inputs         = sidechaingate_inputs,
+    FILTER_INPUTS(sidechaingate_inputs),
-    .outputs        = sidechaingate_outputs,
+    FILTER_OUTPUTS(sidechaingate_outputs),
     .process_command = ff_filter_process_command,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/af_aiir.c+1−2

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(AudioIIRContext, x)
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS |
                      AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/af_alimiter.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad alimiter_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_alimiter = {
     .init           = init,
     .uninit         = uninit,
     .query_formats  = query_formats,
-    .inputs         = alimiter_inputs,
+    FILTER_INPUTS(alimiter_inputs),
-    .outputs        = alimiter_outputs,
+    FILTER_OUTPUTS(alimiter_outputs),
 };

libavfilter/af_amerge.c+1−2

         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_amerge = {
     .query_formats = query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = amerge_outputs,
+    FILTER_OUTPUTS(amerge_outputs),
     .priv_class    = &amerge_class,
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/af_amix.c+1−2

         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_amix = {
     .activate       = activate,
     .query_formats  = query_formats,
     .inputs         = NULL,
-    .outputs        = avfilter_af_amix_outputs,
+    FILTER_OUTPUTS(avfilter_af_amix_outputs),
     .process_command = process_command,
     .flags          = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/af_amultiply.c+2−4

         .name = "multiply1",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_amultiply = {
     .uninit         = uninit,
     .activate       = activate,
     .query_formats  = query_formats,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/af_anequalizer.c+1−2

         .config_props   = config_input,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_anequalizer = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .outputs       = NULL,
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS |

libavfilter/af_anlmdn.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_anlmdn = {
     .priv_size     = sizeof(AudioNLMeansContext),
     .priv_class    = &anlmdn_class,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_SLICE_THREADS,

libavfilter/af_anlms.c+2−4

         .name = "desired",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_anlms = {
     .uninit         = uninit,
     .activate       = activate,
     .query_formats  = query_formats,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags          = AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/af_anull.c+2−4

         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_anull_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_anull = {
     .name          = "anull",
     .description   = NULL_IF_CONFIG_SMALL("Pass the source unchanged to the output."),
-    .inputs        = avfilter_af_anull_inputs,
+    FILTER_INPUTS(avfilter_af_anull_inputs),
-    .outputs       = avfilter_af_anull_outputs,
+    FILTER_OUTPUTS(avfilter_af_anull_outputs),
 };

libavfilter/af_apad.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad apad_outputs[] = {
         .config_props  = config_output,
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_apad = {
     .description   = NULL_IF_CONFIG_SMALL("Pad audio with silence."),
     .init          = init,
     .priv_size     = sizeof(APadContext),
-    .inputs        = apad_inputs,
+    FILTER_INPUTS(apad_inputs),
-    .outputs       = apad_outputs,
+    FILTER_OUTPUTS(apad_outputs),
     .priv_class    = &apad_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/af_aphaser.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad aphaser_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_aphaser = {
     .priv_size     = sizeof(AudioPhaserContext),
     .init          = init,
     .uninit        = uninit,
-    .inputs        = aphaser_inputs,
+    FILTER_INPUTS(aphaser_inputs),
-    .outputs       = aphaser_outputs,
+    FILTER_OUTPUTS(aphaser_outputs),
     .priv_class    = &aphaser_class,
 };

libavfilter/af_apulsator.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_apulsator = {
     .priv_size     = sizeof(AudioPulsatorContext),
     .priv_class    = &apulsator_class,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/af_aresample.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad aresample_outputs[] = {
         .request_frame = request_frame,
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_aresample = {
     .query_formats = query_formats,
     .priv_size     = sizeof(AResampleContext),
     .priv_class    = &aresample_class,
-    .inputs        = aresample_inputs,
+    FILTER_INPUTS(aresample_inputs),
-    .outputs       = aresample_outputs,
+    FILTER_OUTPUTS(aresample_outputs),
 };

libavfilter/af_arnndn.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(AudioRNNContext, x)
     .activate      = activate,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,

libavfilter/af_asetnsamples.c+2−4

         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad asetnsamples_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_asetnsamples = {
     .description = NULL_IF_CONFIG_SMALL("Set the number of samples for each output audio frames."),
     .priv_size   = sizeof(ASNSContext),
     .priv_class  = &asetnsamples_class,
-    .inputs      = asetnsamples_inputs,
+    FILTER_INPUTS(asetnsamples_inputs),
-    .outputs     = asetnsamples_outputs,
+    FILTER_OUTPUTS(asetnsamples_outputs),
     .activate    = activate,
 };

libavfilter/af_asetrate.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad asetrate_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_af_asetrate = {
                                           "altering the data."),
     .query_formats = query_formats,
     .priv_size     = sizeof(ASetRateContext),
-    .inputs        = asetrate_inputs,
+    FILTER_INPUTS(asetrate_inputs),
-    .outputs       = asetrate_outputs,
+    FILTER_OUTPUTS(asetrate_outputs),
     .priv_class    = &asetrate_class,
 };

libavfilter/af_ashowinfo.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_ashowinfo = {
     .description = NULL_IF_CONFIG_SMALL("Show textual information for each audio frame."),
     .priv_size   = sizeof(AShowInfoContext),
     .uninit      = uninit,
-    .inputs      = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs     = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/af_asoftclip.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_asoftclip = {
     .query_formats  = query_formats,
     .priv_size      = sizeof(ASoftClipContext),
     .priv_class     = &asoftclip_class,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .uninit         = uninit,
     .process_command = ff_filter_process_command,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |

libavfilter/af_asr.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad asr_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_asr = {
     .init          = asr_init,
     .uninit        = asr_uninit,
     .query_formats = query_formats,
-    .inputs        = asr_inputs,
+    FILTER_INPUTS(asr_inputs),
-    .outputs       = asr_outputs,
+    FILTER_OUTPUTS(asr_outputs),
 };

libavfilter/af_astats.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad astats_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_astats = {
     .priv_size     = sizeof(AudioStatsContext),
     .priv_class    = &astats_class,
     .uninit        = uninit,
-    .inputs        = astats_inputs,
+    FILTER_INPUTS(astats_inputs),
-    .outputs       = astats_outputs,
+    FILTER_OUTPUTS(astats_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/af_asubboost.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_asubboost = {
     .priv_size      = sizeof(ASubBoostContext),
     .priv_class     = &asubboost_class,
     .uninit         = uninit,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                        AVFILTER_FLAG_SLICE_THREADS,

libavfilter/af_asupercut.c+8−10

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_asupercut = {
     .priv_size       = sizeof(ASuperCutContext),
     .priv_class      = &asupercut_class,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                        AVFILTER_FLAG_SLICE_THREADS,
     .priv_size       = sizeof(ASuperCutContext),
     .priv_class      = &asubcut_class,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                        AVFILTER_FLAG_SLICE_THREADS,
     .priv_size       = sizeof(ASuperCutContext),
     .priv_class      = &asuperpass_class,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                        AVFILTER_FLAG_SLICE_THREADS,
     .priv_size       = sizeof(ASuperCutContext),
     .priv_class      = &asuperstop_class,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
                        AVFILTER_FLAG_SLICE_THREADS,

libavfilter/af_atempo.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad atempo_outputs[] = {
         .request_frame = request_frame,
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_atempo = {
     .process_command = process_command,
     .priv_size       = sizeof(ATempoContext),
     .priv_class      = &atempo_class,
-    .inputs          = atempo_inputs,
+    FILTER_INPUTS(atempo_inputs),
-    .outputs         = atempo_outputs,
+    FILTER_OUTPUTS(atempo_outputs),
 };

libavfilter/af_axcorrelate.c+2−4

         .name = "axcorrelate1",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
     .query_formats  = query_formats,
     .activate       = activate,
     .uninit         = uninit,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/af_biquads.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(BiquadsContext, x)
     .init          = name_##_init,                       \
     .uninit        = uninit,                             \
     .query_formats = query_formats,                      \
-    .inputs        = inputs,                             \
+    FILTER_INPUTS(inputs),                               \
-    .outputs       = outputs,                            \
+    FILTER_OUTPUTS(outputs),                             \
     .priv_class    = &name_##_class,                     \
     .process_command = process_command,                  \
     .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL, \

libavfilter/af_bs2b.c+2−4

         .type           = AVMEDIA_TYPE_AUDIO,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad bs2b_outputs[] = {
         .type           = AVMEDIA_TYPE_AUDIO,
         .config_props   = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_bs2b = {
     .priv_class     = &bs2b_class,
     .init           = init,
     .uninit         = uninit,
-    .inputs         = bs2b_inputs,
+    FILTER_INPUTS(bs2b_inputs),
-    .outputs        = bs2b_outputs,
+    FILTER_OUTPUTS(bs2b_outputs),
 };

libavfilter/af_channelmap.c+2−4

         .filter_frame   = channelmap_filter_frame,
         .config_props   = channelmap_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_channelmap_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO
     },
-    { NULL }
 };
 const AVFilter ff_af_channelmap = {
     .query_formats = channelmap_query_formats,
     .priv_size     = sizeof(ChannelMapContext),
     .priv_class    = &channelmap_class,
-    .inputs        = avfilter_af_channelmap_inputs,
+    FILTER_INPUTS(avfilter_af_channelmap_inputs),
-    .outputs       = avfilter_af_channelmap_outputs,
+    FILTER_OUTPUTS(avfilter_af_channelmap_outputs),
 };

libavfilter/af_channelsplit.c+1−2

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_channelsplit = {
     .priv_class     = &channelsplit_class,
     .init           = init,
     .query_formats  = query_formats,
-    .inputs         = avfilter_af_channelsplit_inputs,
+    FILTER_INPUTS(avfilter_af_channelsplit_inputs),
     .outputs        = NULL,
     .flags          = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };

libavfilter/af_chorus.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad chorus_outputs[] = {
         .request_frame = request_frame,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_chorus = {
     .priv_class    = &chorus_class,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = chorus_inputs,
+    FILTER_INPUTS(chorus_inputs),
-    .outputs       = chorus_outputs,
+    FILTER_OUTPUTS(chorus_outputs),
 };

libavfilter/af_compand.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad compand_outputs[] = {
         .config_props  = config_output,
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
     .priv_class     = &compand_class,
     .init           = init,
     .uninit         = uninit,
-    .inputs         = compand_inputs,
+    FILTER_INPUTS(compand_inputs),
-    .outputs        = compand_outputs,
+    FILTER_OUTPUTS(compand_outputs),
 };

libavfilter/af_compensationdelay.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad compensationdelay_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_compensationdelay = {
     .priv_size     = sizeof(CompensationDelayContext),
     .priv_class    = &compensationdelay_class,
     .uninit        = uninit,
-    .inputs        = compensationdelay_inputs,
+    FILTER_INPUTS(compensationdelay_inputs),
-    .outputs       = compensationdelay_outputs,
+    FILTER_OUTPUTS(compensationdelay_outputs),
 };

libavfilter/af_crossfeed.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_crossfeed = {
     .query_formats  = query_formats,
     .priv_size      = sizeof(CrossfeedContext),
     .priv_class     = &crossfeed_class,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .process_command = process_command,
 };

libavfilter/af_crystalizer.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_crystalizer = {
     .priv_size      = sizeof(CrystalizerContext),
     .priv_class     = &crystalizer_class,
     .uninit         = uninit,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                       AVFILTER_FLAG_SLICE_THREADS,

libavfilter/af_dcshift.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad dcshift_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_dcshift = {
     .priv_size      = sizeof(DCShiftContext),
     .priv_class     = &dcshift_class,
     .init           = init,
-    .inputs         = dcshift_inputs,
+    FILTER_INPUTS(dcshift_inputs),
-    .outputs        = dcshift_outputs,
+    FILTER_OUTPUTS(dcshift_outputs),
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/af_deesser.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_deesser = {
     .priv_size     = sizeof(DeesserContext),
     .priv_class    = &deesser_class,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/af_drmeter.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad drmeter_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_drmeter = {
     .priv_size     = sizeof(DRMeterContext),
     .priv_class    = &drmeter_class,
     .uninit        = uninit,
-    .inputs        = drmeter_inputs,
+    FILTER_INPUTS(drmeter_inputs),
-    .outputs       = drmeter_outputs,
+    FILTER_OUTPUTS(drmeter_outputs),
 };

libavfilter/af_dynaudnorm.c+2−4

         .type           = AVMEDIA_TYPE_AUDIO,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_dynaudnorm_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_dynaudnorm = {
     .init          = init,
     .uninit        = uninit,
     .activate      = activate,
-    .inputs        = avfilter_af_dynaudnorm_inputs,
+    FILTER_INPUTS(avfilter_af_dynaudnorm_inputs),
-    .outputs       = avfilter_af_dynaudnorm_outputs,
+    FILTER_OUTPUTS(avfilter_af_dynaudnorm_outputs),
     .priv_class    = &dynaudnorm_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .process_command = process_command,

libavfilter/af_earwax.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad earwax_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_earwax = {
     .query_formats  = query_formats,
     .priv_size      = sizeof(EarwaxContext),
     .uninit         = uninit,
-    .inputs         = earwax_inputs,
+    FILTER_INPUTS(earwax_inputs),
-    .outputs        = earwax_outputs,
+    FILTER_OUTPUTS(earwax_outputs),
 };

libavfilter/af_extrastereo.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_extrastereo = {
     .query_formats  = query_formats,
     .priv_size      = sizeof(ExtraStereoContext),
     .priv_class     = &extrastereo_class,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = ff_filter_process_command,
 };

libavfilter/af_firequalizer.c+2−4

         .filter_frame   = filter_frame,
         .type           = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad firequalizer_outputs[] = {
         .request_frame  = request_frame,
         .type           = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_firequalizer = {
     .query_formats      = query_formats,
     .process_command    = process_command,
     .priv_size          = sizeof(FIREqualizerContext),
-    .inputs             = firequalizer_inputs,
+    FILTER_INPUTS(firequalizer_inputs),
-    .outputs            = firequalizer_outputs,
+    FILTER_OUTPUTS(firequalizer_outputs),
     .priv_class         = &firequalizer_class,
 };

libavfilter/af_flanger.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad flanger_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_flanger = {
     .priv_class    = &flanger_class,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = flanger_inputs,
+    FILTER_INPUTS(flanger_inputs),
-    .outputs       = flanger_outputs,
+    FILTER_OUTPUTS(flanger_outputs),
 };

libavfilter/af_haas.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_haas = {
     .priv_size      = sizeof(HaasContext),
     .priv_class     = &haas_class,
     .uninit         = uninit,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/af_hdcd.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_hdcd_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_hdcd = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_af_hdcd_inputs,
+    FILTER_INPUTS(avfilter_af_hdcd_inputs),
-    .outputs       = avfilter_af_hdcd_outputs,
+    FILTER_OUTPUTS(avfilter_af_hdcd_outputs),
 };

libavfilter/af_headphone.c+1−2

         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_headphone = {
     .query_formats = query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/af_join.c+1−2

         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = join_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_join = {
     .activate       = activate,
     .query_formats  = join_query_formats,
     .inputs         = NULL,
-    .outputs        = avfilter_af_join_outputs,
+    FILTER_OUTPUTS(avfilter_af_join_outputs),
     .flags          = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/af_ladspa.c+1−2

         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_ladspa = {
     .query_formats = query_formats,
     .process_command = process_command,
     .inputs        = 0,
-    .outputs       = ladspa_outputs,
+    FILTER_OUTPUTS(ladspa_outputs),
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/af_loudnorm.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_loudnorm_outputs[] = {
         .request_frame = request_frame,
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_loudnorm = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = avfilter_af_loudnorm_inputs,
+    FILTER_INPUTS(avfilter_af_loudnorm_inputs),
-    .outputs       = avfilter_af_loudnorm_outputs,
+    FILTER_OUTPUTS(avfilter_af_loudnorm_outputs),
 };

libavfilter/af_lv2.c+1−2

         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_lv2 = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .inputs        = 0,
-    .outputs       = lv2_outputs,
+    FILTER_OUTPUTS(lv2_outputs),
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/af_mcompand.c+2−4

         .type           = AVMEDIA_TYPE_AUDIO,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad mcompand_outputs[] = {
         .request_frame = request_frame,
         .config_props  = config_output,
     },
-    { NULL }
 };
     .priv_size      = sizeof(MCompandContext),
     .priv_class     = &mcompand_class,
     .uninit         = uninit,
-    .inputs         = mcompand_inputs,
+    FILTER_INPUTS(mcompand_inputs),
-    .outputs        = mcompand_outputs,
+    FILTER_OUTPUTS(mcompand_outputs),
 };

libavfilter/af_pan.c+2−4

         .config_props = config_props,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad pan_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_pan = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = pan_inputs,
+    FILTER_INPUTS(pan_inputs),
-    .outputs       = pan_outputs,
+    FILTER_OUTPUTS(pan_outputs),
 };

libavfilter/af_replaygain.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad replaygain_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_replaygain = {
     .query_formats = query_formats,
     .uninit        = uninit,
     .priv_size     = sizeof(ReplayGainContext),
-    .inputs        = replaygain_inputs,
+    FILTER_INPUTS(replaygain_inputs),
-    .outputs       = replaygain_outputs,
+    FILTER_OUTPUTS(replaygain_outputs),
 };

libavfilter/af_rubberband.c+2−4

         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad rubberband_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_rubberband = {
     .priv_class    = &rubberband_class,
     .uninit        = uninit,
     .activate      = activate,
-    .inputs        = rubberband_inputs,
+    FILTER_INPUTS(rubberband_inputs),
-    .outputs       = rubberband_outputs,
+    FILTER_OUTPUTS(rubberband_outputs),
     .process_command = process_command,
 };

libavfilter/af_sidechaincompress.c+4−8

         .name           = "sidechain",
         .type           = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad sidechaincompress_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_sidechaincompress = {
     .query_formats  = query_formats,
     .activate       = activate,
     .uninit         = uninit,
-    .inputs         = sidechaincompress_inputs,
+    FILTER_INPUTS(sidechaincompress_inputs),
-    .outputs        = sidechaincompress_outputs,
+    FILTER_OUTPUTS(sidechaincompress_outputs),
     .process_command = process_command,
 };
 #endif  /* CONFIG_SIDECHAINCOMPRESS_FILTER */
         .type           = AVMEDIA_TYPE_AUDIO,
         .filter_frame   = acompressor_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad acompressor_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = compressor_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_acompressor = {
     .priv_size      = sizeof(SidechainCompressContext),
     .priv_class     = &acompressor_class,
     .query_formats  = acompressor_query_formats,
-    .inputs         = acompressor_inputs,
+    FILTER_INPUTS(acompressor_inputs),
-    .outputs        = acompressor_outputs,
+    FILTER_OUTPUTS(acompressor_outputs),
     .process_command = process_command,
 };
 #endif  /* CONFIG_ACOMPRESSOR_FILTER */

libavfilter/af_silencedetect.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad silencedetect_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_silencedetect = {
     .priv_size     = sizeof(SilenceDetectContext),
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = silencedetect_inputs,
+    FILTER_INPUTS(silencedetect_inputs),
-    .outputs       = silencedetect_outputs,
+    FILTER_OUTPUTS(silencedetect_outputs),
     .priv_class    = &silencedetect_class,
 };

libavfilter/af_silenceremove.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad silenceremove_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_silenceremove = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = silenceremove_inputs,
+    FILTER_INPUTS(silenceremove_inputs),
-    .outputs       = silenceremove_outputs,
+    FILTER_OUTPUTS(silenceremove_outputs),
 };

libavfilter/af_sofalizer.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_sofalizer = {
     .activate      = activate,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/af_speechnorm.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_speechnorm = {
     .priv_class      = &speechnorm_class,
     .activate        = activate,
     .uninit          = uninit,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
 };

libavfilter/af_stereotools.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_stereotools = {
     .priv_size      = sizeof(StereoToolsContext),
     .priv_class     = &stereotools_class,
     .uninit         = uninit,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .process_command = process_command,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/af_stereowiden.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_stereowiden = {
     .priv_size      = sizeof(StereoWidenContext),
     .priv_class     = &stereowiden_class,
     .uninit         = uninit,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .process_command = ff_filter_process_command,
 };

libavfilter/af_superequalizer.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad superequalizer_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
     .init          = init,
     .activate      = activate,
     .uninit        = uninit,
-    .inputs        = superequalizer_inputs,
+    FILTER_INPUTS(superequalizer_inputs),
-    .outputs       = superequalizer_outputs,
+    FILTER_OUTPUTS(superequalizer_outputs),
 };

libavfilter/af_surround.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_surround = {
     .init           = init,
     .uninit         = uninit,
     .activate       = activate,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags          = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/af_tremolo.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_tremolo_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_tremolo = {
     .priv_class    = &tremolo_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_af_tremolo_inputs,
+    FILTER_INPUTS(avfilter_af_tremolo_inputs),
-    .outputs       = avfilter_af_tremolo_outputs,
+    FILTER_OUTPUTS(avfilter_af_tremolo_outputs),
 };

libavfilter/af_vibrato.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_vibrato_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_vibrato = {
     .priv_class    = &vibrato_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_af_vibrato_inputs,
+    FILTER_INPUTS(avfilter_af_vibrato_inputs),
-    .outputs       = avfilter_af_vibrato_outputs,
+    FILTER_OUTPUTS(avfilter_af_vibrato_outputs),
 };

libavfilter/af_volume.c+2−4

         .type           = AVMEDIA_TYPE_AUDIO,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_volume_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_volume = {
     .priv_class     = &volume_class,
     .init           = init,
     .uninit         = uninit,
-    .inputs         = avfilter_af_volume_inputs,
+    FILTER_INPUTS(avfilter_af_volume_inputs),
-    .outputs        = avfilter_af_volume_outputs,
+    FILTER_OUTPUTS(avfilter_af_volume_outputs),
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,
 };

libavfilter/af_volumedetect.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad volumedetect_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_volumedetect = {
     .priv_size     = sizeof(VolDetectContext),
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = volumedetect_inputs,
+    FILTER_INPUTS(volumedetect_inputs),
-    .outputs       = volumedetect_outputs,
+    FILTER_OUTPUTS(volumedetect_outputs),
 };

libavfilter/asink_anullsink.c+1−2

         .type           = AVMEDIA_TYPE_AUDIO,
         .filter_frame   = null_filter_frame,
     },
-    { NULL },
 };
 const AVFilter ff_asink_anullsink = {
     .name        = "anullsink",
     .description = NULL_IF_CONFIG_SMALL("Do absolutely nothing with the input audio."),
     .priv_size   = 0,
-    .inputs      = avfilter_asink_anullsink_inputs,
+    FILTER_INPUTS(avfilter_asink_anullsink_inputs),
     .outputs     = NULL,
 };

libavfilter/asrc_afirsrc.c+1−2

         .request_frame = request_frame,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_asrc_afirsrc = {
     .uninit        = uninit,
     .priv_size     = sizeof(AudioFIRSourceContext),
     .inputs        = NULL,
-    .outputs       = afirsrc_outputs,
+    FILTER_OUTPUTS(afirsrc_outputs),
     .priv_class    = &afirsrc_class,
 };

libavfilter/asrc_anoisesrc.c+1−2

         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_asrc_anoisesrc = {
     .priv_size     = sizeof(ANoiseSrcContext),
     .inputs        = NULL,
     .activate      = activate,
-    .outputs       = anoisesrc_outputs,
+    FILTER_OUTPUTS(anoisesrc_outputs),
     .priv_class    = &anoisesrc_class,
 };

libavfilter/asrc_anullsrc.c+1−2

         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_asrc_anullsrc = {
     .query_formats = query_formats,
     .priv_size     = sizeof(ANullContext),
     .inputs        = NULL,
-    .outputs       = avfilter_asrc_anullsrc_outputs,
+    FILTER_OUTPUTS(avfilter_asrc_anullsrc_outputs),
     .activate      = activate,
     .priv_class    = &anullsrc_class,
 };

libavfilter/asrc_flite.c+1−2

         .config_props  = config_props,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_asrc_flite = {
     .uninit        = uninit,
     .priv_size     = sizeof(FliteContext),
     .inputs        = NULL,
-    .outputs       = flite_outputs,
+    FILTER_OUTPUTS(flite_outputs),
     .priv_class    = &flite_class,
 };

libavfilter/asrc_hilbert.c+1−2

         .request_frame = request_frame,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_asrc_hilbert = {
     .uninit        = uninit,
     .priv_size     = sizeof(HilbertContext),
     .inputs        = NULL,
-    .outputs       = hilbert_outputs,
+    FILTER_OUTPUTS(hilbert_outputs),
     .priv_class    = &hilbert_class,
 };

libavfilter/asrc_sinc.c+1−2

         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
     .query_formats = query_formats,
     .uninit        = uninit,
     .inputs        = NULL,
-    .outputs       = sinc_outputs,
+    FILTER_OUTPUTS(sinc_outputs),
 };

libavfilter/asrc_sine.c+1−2

         .request_frame = request_frame,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_asrc_sine = {
     .uninit        = uninit,
     .priv_size     = sizeof(SineContext),
     .inputs        = NULL,
-    .outputs       = sine_outputs,
+    FILTER_OUTPUTS(sine_outputs),
     .priv_class    = &sine_class,
 };

libavfilter/avf_abitscope.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_abitscope = {
     .description   = NULL_IF_CONFIG_SMALL("Convert input audio to audio bit scope video output."),
     .query_formats = query_formats,
     .priv_size     = sizeof(AudioBitScopeContext),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .activate      = activate,
     .priv_class    = &abitscope_class,
 };

libavfilter/avf_ahistogram.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad ahistogram_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_ahistogram = {
     .query_formats = query_formats,
     .priv_size     = sizeof(AudioHistogramContext),
     .activate      = activate,
-    .inputs        = ahistogram_inputs,
+    FILTER_INPUTS(ahistogram_inputs),
-    .outputs       = ahistogram_outputs,
+    FILTER_OUTPUTS(ahistogram_outputs),
     .priv_class    = &ahistogram_class,
 };

libavfilter/avf_aphasemeter.c+1−2

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 const AVFilter ff_avf_aphasemeter = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(AudioPhaseMeterContext),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .outputs       = NULL,
     .priv_class    = &aphasemeter_class,
     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS,

libavfilter/avf_avectorscope.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad audiovectorscope_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_avectorscope = {
     .query_formats = query_formats,
     .priv_size     = sizeof(AudioVectorScopeContext),
     .activate      = activate,
-    .inputs        = audiovectorscope_inputs,
+    FILTER_INPUTS(audiovectorscope_inputs),
-    .outputs       = audiovectorscope_outputs,
+    FILTER_OUTPUTS(audiovectorscope_outputs),
     .priv_class    = &avectorscope_class,
 };

libavfilter/avf_showcqt.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad showcqt_outputs[] = {
         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_avf_showcqt = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(ShowCQTContext),
-    .inputs        = showcqt_inputs,
+    FILTER_INPUTS(showcqt_inputs),
-    .outputs       = showcqt_outputs,
+    FILTER_OUTPUTS(showcqt_outputs),
     .priv_class    = &showcqt_class,
 };

libavfilter/avf_showfreqs.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad showfreqs_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_showfreqs = {
     .query_formats = query_formats,
     .priv_size     = sizeof(ShowFreqsContext),
     .activate      = activate,
-    .inputs        = showfreqs_inputs,
+    FILTER_INPUTS(showfreqs_inputs),
-    .outputs       = showfreqs_outputs,
+    FILTER_OUTPUTS(showfreqs_outputs),
     .priv_class    = &showfreqs_class,
 };

libavfilter/avf_showspatial.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad showspatial_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_showspatial = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(ShowSpatialContext),
-    .inputs        = showspatial_inputs,
+    FILTER_INPUTS(showspatial_inputs),
-    .outputs       = showspatial_outputs,
+    FILTER_OUTPUTS(showspatial_outputs),
     .activate      = spatial_activate,
     .priv_class    = &showspatial_class,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,

libavfilter/avf_showspectrum.c+4−8

         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad showspectrum_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_showspectrum = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(ShowSpectrumContext),
-    .inputs        = showspectrum_inputs,
+    FILTER_INPUTS(showspectrum_inputs),
-    .outputs       = showspectrum_outputs,
+    FILTER_OUTPUTS(showspectrum_outputs),
     .activate      = activate,
     .priv_class    = &showspectrum_class,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = showspectrumpic_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad showspectrumpic_outputs[] = {
         .config_props  = config_output,
         .request_frame = showspectrumpic_request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_avf_showspectrumpic = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(ShowSpectrumContext),
-    .inputs        = showspectrumpic_inputs,
+    FILTER_INPUTS(showspectrumpic_inputs),
-    .outputs       = showspectrumpic_outputs,
+    FILTER_OUTPUTS(showspectrumpic_outputs),
     .priv_class    = &showspectrumpic_class,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/avf_showvolume.c+2−4

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad showvolume_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_showvolume = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(ShowVolumeContext),
-    .inputs        = showvolume_inputs,
+    FILTER_INPUTS(showvolume_inputs),
-    .outputs       = showvolume_outputs,
+    FILTER_OUTPUTS(showvolume_outputs),
     .priv_class    = &showvolume_class,
 };

libavfilter/avf_showwaves.c+4−8

         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad showwaves_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_showwaves = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(ShowWavesContext),
-    .inputs        = showwaves_inputs,
+    FILTER_INPUTS(showwaves_inputs),
     .activate      = activate,
-    .outputs       = showwaves_outputs,
+    FILTER_OUTPUTS(showwaves_outputs),
     .priv_class    = &showwaves_class,
 };
         .config_props = showwavespic_config_input,
         .filter_frame = showwavespic_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad showwavespic_outputs[] = {
         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_avf_showwavespic = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(ShowWavesContext),
-    .inputs        = showwavespic_inputs,
+    FILTER_INPUTS(showwavespic_inputs),
-    .outputs       = showwavespic_outputs,
+    FILTER_OUTPUTS(showwavespic_outputs),
     .priv_class    = &showwavespic_class,
 };

libavfilter/avfilter.c+12−6

 int avfilter_pad_count(const AVFilterPad *pads)
 {
-    int count;
+    const AVFilter *filter;
+    void *opaque = NULL;
     if (!pads)
         return 0;
-    for (count = 0; pads->name; count++)
+    while (filter = av_filter_iterate(&opaque)) {
-        pads++;
+        if (pads == filter->inputs)
-    return count;
+            return filter->nb_inputs;
+        if (pads == filter->outputs)
+            return filter->nb_outputs;
+    }
+    av_assert0(!"AVFilterPad list not from a filter");
 }
 static const char *default_filter_name(void *filter_ctx)
         goto err;
     ret->internal->execute = default_execute;
-    ret->nb_inputs = avfilter_pad_count(filter->inputs);
+    ret->nb_inputs  = filter->nb_inputs;
     if (ret->nb_inputs ) {
         ret->input_pads   = av_memdup(filter->inputs,  ret->nb_inputs  * sizeof(*filter->inputs));
         if (!ret->input_pads)
             goto err;
     }
-    ret->nb_outputs = avfilter_pad_count(filter->outputs);
+    ret->nb_outputs = filter->nb_outputs;
     if (ret->nb_outputs) {
         ret->output_pads  = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
         if (!ret->output_pads)

libavfilter/avfilter.h+14−4

 typedef struct AVFilterChannelLayouts AVFilterChannelLayouts;
 /**
- * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
+ * Get the number of elements in an AVFilter's inputs or outputs array.
- * AVFilter.inputs/outputs).
  */
 int avfilter_pad_count(const AVFilterPad *pads);
     const char *description;
     /**
-     * List of inputs, terminated by a zeroed element.
+     * List of static inputs.
      *
      * NULL if there are no (static) inputs. Instances of filters with
      * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in
      * this list.
      */
     const AVFilterPad *inputs;
     /**
-     * List of outputs, terminated by a zeroed element.
+     * List of static outputs.
      *
      * NULL if there are no (static) outputs. Instances of filters with
      * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in
      *****************************************************************
      */
+    /**
+     * The number of entries in the list of inputs.
+     */
+    uint16_t nb_inputs;
+    /**
+     * The number of entries in the list of outputs.
+     */
+    uint16_t nb_outputs;
     /**
      * Filter pre-initialization function
      *

libavfilter/buffersink.c+2−4

         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vsink_buffer = {
     .init          = common_init,
     .query_formats = vsink_query_formats,
     .activate      = activate,
-    .inputs        = avfilter_vsink_buffer_inputs,
+    FILTER_INPUTS(avfilter_vsink_buffer_inputs),
     .outputs       = NULL,
 };
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_asink_abuffer = {
     .init          = common_init,
     .query_formats = asink_query_formats,
     .activate      = activate,
-    .inputs        = avfilter_asink_abuffer_inputs,
+    FILTER_INPUTS(avfilter_asink_abuffer_inputs),
     .outputs       = NULL,
 };

libavfilter/buffersrc.c+2−4

         .request_frame = request_frame,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_buffer = {
     .uninit    = uninit,
     .inputs    = NULL,
-    .outputs   = avfilter_vsrc_buffer_outputs,
+    FILTER_OUTPUTS(avfilter_vsrc_buffer_outputs),
     .priv_class = &buffer_class,
 };
         .request_frame = request_frame,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_asrc_abuffer = {
     .uninit    = uninit,
     .inputs    = NULL,
-    .outputs   = avfilter_asrc_abuffer_outputs,
+    FILTER_OUTPUTS(avfilter_asrc_abuffer_outputs),
     .priv_class = &abuffer_class,
 };

libavfilter/f_bench.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad bench_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_bench = {
     .description   = NULL_IF_CONFIG_SMALL("Benchmark part of a filtergraph."),
     .priv_size     = sizeof(BenchContext),
     .init          = init,
-    .inputs        = bench_inputs,
+    FILTER_INPUTS(bench_inputs),
-    .outputs       = bench_outputs,
+    FILTER_OUTPUTS(bench_outputs),
     .priv_class    = &bench_class,
 };
 #endif /* CONFIG_BENCH_FILTER */
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad abench_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_abench = {
     .description   = NULL_IF_CONFIG_SMALL("Benchmark part of a filtergraph."),
     .priv_size     = sizeof(BenchContext),
     .init          = init,
-    .inputs        = abench_inputs,
+    FILTER_INPUTS(abench_inputs),
-    .outputs       = abench_outputs,
+    FILTER_OUTPUTS(abench_outputs),
     .priv_class    = &abench_class,
 };
 #endif /* CONFIG_ABENCH_FILTER */

libavfilter/f_cue.c+4−8

         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad cue_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_cue = {
     .description = NULL_IF_CONFIG_SMALL("Delay filtering to match a cue."),
     .priv_size   = sizeof(CueContext),
     .priv_class  = &cue_class,
-    .inputs      = cue_inputs,
+    FILTER_INPUTS(cue_inputs),
-    .outputs     = cue_outputs,
+    FILTER_OUTPUTS(cue_outputs),
     .activate    = activate,
 };
 #endif /* CONFIG_CUE_FILTER */
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad acue_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_acue = {
     .description = NULL_IF_CONFIG_SMALL("Delay filtering to match a cue."),
     .priv_size   = sizeof(CueContext),
     .priv_class  = &acue_class,
-    .inputs      = acue_inputs,
+    FILTER_INPUTS(acue_inputs),
-    .outputs     = acue_outputs,
+    FILTER_OUTPUTS(acue_outputs),
     .activate    = activate,
 };
 #endif /* CONFIG_ACUE_FILTER */

libavfilter/f_drawgraph.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad drawgraph_outputs[] = {
         .config_props = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_drawgraph = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = drawgraph_inputs,
+    FILTER_INPUTS(drawgraph_inputs),
-    .outputs       = drawgraph_outputs,
+    FILTER_OUTPUTS(drawgraph_outputs),
 };
 #endif // CONFIG_DRAWGRAPH_FILTER
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad adrawgraph_outputs[] = {
         .config_props = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_avf_adrawgraph = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = adrawgraph_inputs,
+    FILTER_INPUTS(adrawgraph_inputs),
-    .outputs       = adrawgraph_outputs,
+    FILTER_OUTPUTS(adrawgraph_outputs),
 };
 #endif // CONFIG_ADRAWGRAPH_FILTER

libavfilter/f_ebur128.c+1−2

         .filter_frame = filter_frame,
         .config_props = config_audio_input,
     },
-    { NULL }
 };
 const AVFilter ff_af_ebur128 = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = ebur128_inputs,
+    FILTER_INPUTS(ebur128_inputs),
     .outputs       = NULL,
     .priv_class    = &ebur128_class,
     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS,

libavfilter/f_graphmonitor.c+4−8

         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad graphmonitor_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_graphmonitor = {
     .priv_class    = &graphmonitor_class,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = graphmonitor_inputs,
+    FILTER_INPUTS(graphmonitor_inputs),
-    .outputs       = graphmonitor_outputs,
+    FILTER_OUTPUTS(graphmonitor_outputs),
 };
 #endif // CONFIG_GRAPHMONITOR_FILTER
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad agraphmonitor_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_avf_agraphmonitor = {
     .priv_class    = &agraphmonitor_class,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = agraphmonitor_inputs,
+    FILTER_INPUTS(agraphmonitor_inputs),
-    .outputs       = agraphmonitor_outputs,
+    FILTER_OUTPUTS(agraphmonitor_outputs),
 };
 #endif // CONFIG_AGRAPHMONITOR_FILTER

libavfilter/f_interleave.c+2−4

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_interleave = {
     .init        = init,
     .uninit      = uninit,
     .activate    = activate,
-    .outputs     = interleave_outputs,
+    FILTER_OUTPUTS(interleave_outputs),
     .priv_class  = &interleave_class,
     .flags       = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_af_ainterleave = {
     .init        = init,
     .uninit      = uninit,
     .activate    = activate,
-    .outputs     = ainterleave_outputs,
+    FILTER_OUTPUTS(ainterleave_outputs),
     .priv_class  = &ainterleave_class,
     .flags       = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/f_loop.c+4−8

         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = aconfig_input,
     },
-    { NULL }
 };
 static const AVFilterPad aoutputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_aloop = {
     .priv_class    = &aloop_class,
     .activate      = aactivate,
     .uninit        = auninit,
-    .inputs        = ainputs,
+    FILTER_INPUTS(ainputs),
-    .outputs       = aoutputs,
+    FILTER_OUTPUTS(aoutputs),
 };
 #endif /* CONFIG_ALOOP_FILTER */
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_loop = {
     .init        = init,
     .uninit      = uninit,
     .activate    = activate,
-    .inputs      = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs     = outputs,
+    FILTER_OUTPUTS(outputs),
 };
 #endif /* CONFIG_LOOP_FILTER */

libavfilter/f_metadata.c+4−8

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad aoutputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_ametadata = {
     .priv_class    = &ametadata_class,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = ainputs,
+    FILTER_INPUTS(ainputs),
-    .outputs       = aoutputs,
+    FILTER_OUTPUTS(aoutputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
 #endif /* CONFIG_AMETADATA_FILTER */
         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_metadata = {
     .priv_class  = &metadata_class,
     .init        = init,
     .uninit      = uninit,
-    .inputs      = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs     = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
 #endif /* CONFIG_METADATA_FILTER */

libavfilter/f_perms.c+4−8

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad aperms_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_aperms = {
     .description = NULL_IF_CONFIG_SMALL("Set permissions for the output audio frame."),
     .init        = init,
     .priv_size   = sizeof(PermsContext),
-    .inputs      = aperms_inputs,
+    FILTER_INPUTS(aperms_inputs),
-    .outputs     = aperms_outputs,
+    FILTER_OUTPUTS(aperms_outputs),
     .priv_class  = &aperms_class,
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad perms_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_perms = {
     .description = NULL_IF_CONFIG_SMALL("Set permissions for the output video frame."),
     .init        = init,
     .priv_size   = sizeof(PermsContext),
-    .inputs      = perms_inputs,
+    FILTER_INPUTS(perms_inputs),
-    .outputs     = perms_outputs,
+    FILTER_OUTPUTS(perms_outputs),
     .priv_class  = &perms_class,
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/f_realtime.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_realtime_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_realtime = {
     .description = NULL_IF_CONFIG_SMALL("Slow down filtering to match realtime."),
     .priv_size   = sizeof(RealtimeContext),
     .priv_class  = &realtime_class,
-    .inputs      = avfilter_vf_realtime_inputs,
+    FILTER_INPUTS(avfilter_vf_realtime_inputs),
-    .outputs     = avfilter_vf_realtime_outputs,
+    FILTER_OUTPUTS(avfilter_vf_realtime_outputs),
 };
 #endif /* CONFIG_REALTIME_FILTER */
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad arealtime_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_arealtime = {
     .description = NULL_IF_CONFIG_SMALL("Slow down filtering to match realtime."),
     .priv_size   = sizeof(RealtimeContext),
     .priv_class  = &arealtime_class,
-    .inputs      = arealtime_inputs,
+    FILTER_INPUTS(arealtime_inputs),
-    .outputs     = arealtime_outputs,
+    FILTER_OUTPUTS(arealtime_outputs),
 };
 #endif /* CONFIG_AREALTIME_FILTER */

libavfilter/f_reverse.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad reverse_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_reverse = {
     .priv_size   = sizeof(ReverseContext),
     .init        = init,
     .uninit      = uninit,
-    .inputs      = reverse_inputs,
+    FILTER_INPUTS(reverse_inputs),
-    .outputs     = reverse_outputs,
+    FILTER_OUTPUTS(reverse_outputs),
 };
 #endif /* CONFIG_REVERSE_FILTER */
         .flags          = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad areverse_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .request_frame = areverse_request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_areverse = {
     .priv_size     = sizeof(ReverseContext),
     .init          = init,
     .uninit        = uninit,
-    .inputs        = areverse_inputs,
+    FILTER_INPUTS(areverse_inputs),
-    .outputs       = areverse_outputs,
+    FILTER_OUTPUTS(areverse_outputs),
 };
 #endif /* CONFIG_AREVERSE_FILTER */

libavfilter/f_segment.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input,
     },
-    { NULL }
 };
 const AVFilter ff_vf_segment = {
     .priv_size   = sizeof(SegmentContext),
     .priv_class  = &segment_class,
     .activate    = activate,
-    .inputs      = segment_inputs,
+    FILTER_INPUTS(segment_inputs),
     .outputs     = NULL,
     .flags       = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 const AVFilter ff_af_asegment = {
     .priv_size   = sizeof(SegmentContext),
     .priv_class  = &asegment_class,
     .activate    = activate,
-    .inputs      = asegment_inputs,
+    FILTER_INPUTS(asegment_inputs),
     .outputs     = NULL,
     .flags       = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };

libavfilter/f_select.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_aselect = {
     .init        = aselect_init,
     .uninit      = uninit,
     .priv_size   = sizeof(SelectContext),
-    .inputs      = avfilter_af_aselect_inputs,
+    FILTER_INPUTS(avfilter_af_aselect_inputs),
     .priv_class  = &aselect_class,
     .flags       = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };
         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_select = {
     .query_formats = query_formats,
     .priv_size     = sizeof(SelectContext),
     .priv_class    = &select_class,
-    .inputs        = avfilter_vf_select_inputs,
+    FILTER_INPUTS(avfilter_vf_select_inputs),
     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };
 #endif /* CONFIG_SELECT_FILTER */

libavfilter/f_sendcmd.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad sendcmd_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_sendcmd = {
     .init        = init,
     .uninit      = uninit,
     .priv_size   = sizeof(SendCmdContext),
-    .inputs      = sendcmd_inputs,
+    FILTER_INPUTS(sendcmd_inputs),
-    .outputs     = sendcmd_outputs,
+    FILTER_OUTPUTS(sendcmd_outputs),
     .priv_class  = &sendcmd_class,
 };
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad asendcmd_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_asendcmd = {
     .init        = init,
     .uninit      = uninit,
     .priv_size   = sizeof(SendCmdContext),
-    .inputs      = asendcmd_inputs,
+    FILTER_INPUTS(asendcmd_inputs),
-    .outputs     = asendcmd_outputs,
+    FILTER_OUTPUTS(asendcmd_outputs),
     .priv_class  = &asendcmd_class,
 };

libavfilter/f_sidedata.c+4−8

         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad aoutputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_asidedata = {
     .priv_size     = sizeof(SideDataContext),
     .priv_class    = &asidedata_class,
     .init          = init,
-    .inputs        = ainputs,
+    FILTER_INPUTS(ainputs),
-    .outputs       = aoutputs,
+    FILTER_OUTPUTS(aoutputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
 #endif /* CONFIG_ASIDEDATA_FILTER */
         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_sidedata = {
     .priv_size   = sizeof(SideDataContext),
     .priv_class  = &sidedata_class,
     .init        = init,
-    .inputs      = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs     = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
 #endif /* CONFIG_SIDEDATA_FILTER */

libavfilter/f_zmq.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad zmq_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_zmq = {
     .init        = init,
     .uninit      = uninit,
     .priv_size   = sizeof(ZMQContext),
-    .inputs      = zmq_inputs,
+    FILTER_INPUTS(zmq_inputs),
-    .outputs     = zmq_outputs,
+    FILTER_OUTPUTS(zmq_outputs),
     .priv_class  = &zmq_class,
 };
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad azmq_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_azmq = {
     .init        = init,
     .uninit      = uninit,
     .priv_size   = sizeof(ZMQContext),
-    .inputs      = azmq_inputs,
+    FILTER_INPUTS(azmq_inputs),
-    .outputs     = azmq_outputs,
+    FILTER_OUTPUTS(azmq_outputs),
     .priv_class  = &azmq_class,
 };

libavfilter/fifo.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = add_to_queue,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_fifo_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fifo = {
     .init        = init,
     .uninit      = uninit,
     .priv_size   = sizeof(FifoContext),
-    .inputs      = avfilter_vf_fifo_inputs,
+    FILTER_INPUTS(avfilter_vf_fifo_inputs),
-    .outputs     = avfilter_vf_fifo_outputs,
+    FILTER_OUTPUTS(avfilter_vf_fifo_outputs),
 };
 static const AVFilterPad avfilter_af_afifo_inputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = add_to_queue,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_afifo_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_afifo = {
     .init        = init,
     .uninit      = uninit,
     .priv_size   = sizeof(FifoContext),
-    .inputs      = avfilter_af_afifo_inputs,
+    FILTER_INPUTS(avfilter_af_afifo_inputs),
-    .outputs     = avfilter_af_afifo_outputs,
+    FILTER_OUTPUTS(avfilter_af_afifo_outputs),
 };

libavfilter/internal.h+6−0

     return ctx->internal->execute(ctx, func, arg, ret, nb_jobs);
 }
+#define FILTER_INOUTPADS(inout, array) \
+       .inout        = array, \
+       .nb_ ## inout = FF_ARRAY_ELEMS(array)
+#define FILTER_INPUTS(array) FILTER_INOUTPADS(inputs, (array))
+#define FILTER_OUTPUTS(array) FILTER_INOUTPADS(outputs, (array))
 /**
  * Tell if an integer is contained in the provided -1-terminated list of integers.
  * This is useful for determining (for instance) if an AVPixelFormat is in an

libavfilter/setpts.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_setpts_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_setpts = {
     .priv_size = sizeof(SetPTSContext),
     .priv_class = &setpts_class,
-    .inputs    = avfilter_vf_setpts_inputs,
+    FILTER_INPUTS(avfilter_vf_setpts_inputs),
-    .outputs   = avfilter_vf_setpts_outputs,
+    FILTER_OUTPUTS(avfilter_vf_setpts_outputs),
 };
 #endif /* CONFIG_SETPTS_FILTER */
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad asetpts_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_asetpts = {
     .uninit      = uninit,
     .priv_size   = sizeof(SetPTSContext),
     .priv_class  = &asetpts_class,
-    .inputs      = asetpts_inputs,
+    FILTER_INPUTS(asetpts_inputs),
-    .outputs     = asetpts_outputs,
+    FILTER_OUTPUTS(asetpts_outputs),
 };
 #endif /* CONFIG_ASETPTS_FILTER */

libavfilter/settb.c+4−8

         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_settb_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output_props,
     },
-    { NULL }
 };
 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,
-    .inputs      = avfilter_vf_settb_inputs,
+    FILTER_INPUTS(avfilter_vf_settb_inputs),
-    .outputs     = avfilter_vf_settb_outputs,
+    FILTER_OUTPUTS(avfilter_vf_settb_outputs),
     .activate    = activate,
 };
 #endif /* CONFIG_SETTB_FILTER */
         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_af_asettb_outputs[] = {
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_output_props,
     },
-    { NULL }
 };
 const AVFilter ff_af_asettb = {
     .name        = "asettb",
     .description = NULL_IF_CONFIG_SMALL("Set timebase for the audio output link."),
     .priv_size   = sizeof(SetTBContext),
-    .inputs      = avfilter_af_asettb_inputs,
+    FILTER_INPUTS(avfilter_af_asettb_inputs),
-    .outputs     = avfilter_af_asettb_outputs,
+    FILTER_OUTPUTS(avfilter_af_asettb_outputs),
     .priv_class  = &asettb_class,
     .activate    = activate,
 };

libavfilter/split.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_split = {
     .priv_class  = &split_class,
     .init        = split_init,
     .uninit      = split_uninit,
-    .inputs      = avfilter_vf_split_inputs,
+    FILTER_INPUTS(avfilter_vf_split_inputs),
     .outputs     = NULL,
     .flags       = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 const AVFilter ff_af_asplit = {
     .priv_class  = &asplit_class,
     .init        = split_init,
     .uninit      = split_uninit,
-    .inputs      = avfilter_af_asplit_inputs,
+    FILTER_INPUTS(avfilter_af_asplit_inputs),
     .outputs     = NULL,
     .flags       = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };

libavfilter/trim.c+4−8

         .filter_frame = trim_filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad trim_outputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_trim = {
     .init        = init,
     .priv_size   = sizeof(TrimContext),
     .priv_class  = &trim_class,
-    .inputs      = trim_inputs,
+    FILTER_INPUTS(trim_inputs),
-    .outputs     = trim_outputs,
+    FILTER_OUTPUTS(trim_outputs),
 };
 #endif // CONFIG_TRIM_FILTER
         .filter_frame = atrim_filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad atrim_outputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
     },
-    { NULL }
 };
 const AVFilter ff_af_atrim = {
     .init        = init,
     .priv_size   = sizeof(TrimContext),
     .priv_class  = &atrim_class,
-    .inputs      = atrim_inputs,
+    FILTER_INPUTS(atrim_inputs),
-    .outputs     = atrim_outputs,
+    FILTER_OUTPUTS(atrim_outputs),
 };
 #endif // CONFIG_ATRIM_FILTER

libavfilter/vaf_spectrumsynth.c+2−4

         .name         = "phase",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad spectrumsynth_outputs[] = {
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vaf_spectrumsynth = {
     .query_formats = query_formats,
     .activate      = activate,
     .priv_size     = sizeof(SpectrumSynthContext),
-    .inputs        = spectrumsynth_inputs,
+    FILTER_INPUTS(spectrumsynth_inputs),
-    .outputs       = spectrumsynth_outputs,
+    FILTER_OUTPUTS(spectrumsynth_outputs),
     .priv_class    = &spectrumsynth_class,
 };

libavfilter/vf_addroi.c+2−4

         .config_props = addroi_config_input,
         .filter_frame = addroi_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad addroi_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_addroi = {
     .priv_size   = sizeof(AddROIContext),
     .priv_class  = &addroi_class,
-    .inputs      = addroi_inputs,
+    FILTER_INPUTS(addroi_inputs),
-    .outputs     = addroi_outputs,
+    FILTER_OUTPUTS(addroi_outputs),
 };

libavfilter/vf_alphamerge.c+2−4

         .name             = "alpha",
         .type             = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad alphamerge_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 static const AVOption alphamerge_options[] = {
     .priv_class     = &alphamerge_class,
     .init           = init,
     .query_formats  = query_formats,
-    .inputs         = alphamerge_inputs,
+    FILTER_INPUTS(alphamerge_inputs),
-    .outputs        = alphamerge_outputs,
+    FILTER_OUTPUTS(alphamerge_outputs),
     .uninit         = uninit,
     .activate       = activate,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,

libavfilter/vf_amplify.c+2−4

         .type          = AVMEDIA_TYPE_VIDEO,
         .filter_frame  = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(amplify);
     .priv_size     = sizeof(AmplifyContext),
     .priv_class    = &amplify_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .init          = init,
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,

libavfilter/vf_aspect.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_setdar_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = setdar_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_setdar = {
     .description = NULL_IF_CONFIG_SMALL("Set the frame display aspect ratio."),
     .priv_size   = sizeof(AspectContext),
     .priv_class  = &setdar_class,
-    .inputs      = avfilter_vf_setdar_inputs,
+    FILTER_INPUTS(avfilter_vf_setdar_inputs),
-    .outputs     = avfilter_vf_setdar_outputs,
+    FILTER_OUTPUTS(avfilter_vf_setdar_outputs),
 };
 #endif /* CONFIG_SETDAR_FILTER */
         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_setsar_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = setsar_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_setsar = {
     .description = NULL_IF_CONFIG_SMALL("Set the pixel sample aspect ratio."),
     .priv_size   = sizeof(AspectContext),
     .priv_class  = &setsar_class,
-    .inputs      = avfilter_vf_setsar_inputs,
+    FILTER_INPUTS(avfilter_vf_setsar_inputs),
-    .outputs     = avfilter_vf_setsar_outputs,
+    FILTER_OUTPUTS(avfilter_vf_setsar_outputs),
 };
 #endif /* CONFIG_SETSAR_FILTER */

libavfilter/vf_atadenoise.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_atadenoise = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_avgblur.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avgblur_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_avgblur = {
     .priv_class    = &avgblur_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avgblur_inputs,
+    FILTER_INPUTS(avgblur_inputs),
-    .outputs       = avgblur_outputs,
+    FILTER_OUTPUTS(avgblur_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_avgblur_opencl.c+4−6

         .filter_frame = &avgblur_opencl_filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_output,
     },
-    { NULL }
 };
     .init           = &ff_opencl_filter_init,
     .uninit         = &avgblur_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = avgblur_opencl_inputs,
+    FILTER_INPUTS(avgblur_opencl_inputs),
-    .outputs        = avgblur_opencl_outputs,
+    FILTER_OUTPUTS(avgblur_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
     .init           = &ff_opencl_filter_init,
     .uninit         = &avgblur_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = avgblur_opencl_inputs,
+    FILTER_INPUTS(avgblur_opencl_inputs),
-    .outputs        = avgblur_opencl_outputs,
+    FILTER_OUTPUTS(avgblur_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_avgblur_vulkan.c+2−4

         .filter_frame = &avgblur_vulkan_filter_frame,
         .config_props = &ff_vk_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avgblur_vulkan_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_vk_filter_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_avgblur_vulkan = {
     .init           = &ff_vk_filter_init,
     .uninit         = &avgblur_vulkan_uninit,
     .query_formats  = &ff_vk_filter_query_formats,
-    .inputs         = avgblur_vulkan_inputs,
+    FILTER_INPUTS(avgblur_vulkan_inputs),
-    .outputs        = avgblur_vulkan_outputs,
+    FILTER_OUTPUTS(avgblur_vulkan_outputs),
     .priv_class     = &avgblur_vulkan_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_bbox.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad bbox_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_bbox = {
     .priv_size     = sizeof(BBoxContext),
     .priv_class    = &bbox_class,
     .query_formats = query_formats,
-    .inputs        = bbox_inputs,
+    FILTER_INPUTS(bbox_inputs),
-    .outputs       = bbox_outputs,
+    FILTER_OUTPUTS(bbox_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_bilateral.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad bilateral_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_bilateral = {
     .priv_class    = &bilateral_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = bilateral_inputs,
+    FILTER_INPUTS(bilateral_inputs),
-    .outputs       = bilateral_outputs,
+    FILTER_OUTPUTS(bilateral_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,
 };

libavfilter/vf_bitplanenoise.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_bitplanenoise = {
     .description    = NULL_IF_CONFIG_SMALL("Measure bit plane noise."),
     .priv_size      = sizeof(BPNContext),
     .query_formats  = query_formats,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .priv_class     = &bitplanenoise_class,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_blackdetect.c+2−4

         .config_props  = config_input,
         .filter_frame  = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad blackdetect_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_blackdetect = {
     .description   = NULL_IF_CONFIG_SMALL("Detect video intervals that are (almost) black."),
     .priv_size     = sizeof(BlackDetectContext),
     .query_formats = query_formats,
-    .inputs        = blackdetect_inputs,
+    FILTER_INPUTS(blackdetect_inputs),
-    .outputs       = blackdetect_outputs,
+    FILTER_OUTPUTS(blackdetect_outputs),
     .uninit        = uninit,
     .priv_class    = &blackdetect_class,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,

libavfilter/vf_blackframe.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_blackframe_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO
     },
-    { NULL }
 };
 const AVFilter ff_vf_blackframe = {
     .priv_size     = sizeof(BlackFrameContext),
     .priv_class    = &blackframe_class,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_blackframe_inputs,
+    FILTER_INPUTS(avfilter_vf_blackframe_inputs),
-    .outputs       = avfilter_vf_blackframe_outputs,
+    FILTER_OUTPUTS(avfilter_vf_blackframe_outputs),
 };

libavfilter/vf_blend.c+4−8

         .name          = "bottom",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad blend_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_blend = {
     .priv_size     = sizeof(BlendContext),
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = blend_inputs,
+    FILTER_INPUTS(blend_inputs),
-    .outputs       = blend_outputs,
+    FILTER_OUTPUTS(blend_outputs),
     .priv_class    = &blend_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
         .type          = AVMEDIA_TYPE_VIDEO,
         .filter_frame  = tblend_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad tblend_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tblend = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = tblend_inputs,
+    FILTER_INPUTS(tblend_inputs),
-    .outputs       = tblend_outputs,
+    FILTER_OUTPUTS(tblend_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_bm3d.c+1−2

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_bm3d = {
     .activate      = activate,
     .query_formats = query_formats,
     .inputs        = NULL,
-    .outputs       = bm3d_outputs,
+    FILTER_OUTPUTS(bm3d_outputs),
     .priv_class    = &bm3d_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_DYNAMIC_INPUTS |

libavfilter/vf_boxblur.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_boxblur_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_boxblur = {
     .priv_class    = &boxblur_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_boxblur_inputs,
+    FILTER_INPUTS(avfilter_vf_boxblur_inputs),
-    .outputs       = avfilter_vf_boxblur_outputs,
+    FILTER_OUTPUTS(avfilter_vf_boxblur_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_bwdif.c+2−4

         .type          = AVMEDIA_TYPE_VIDEO,
         .filter_frame  = ff_yadif_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_bwdif_outputs[] = {
         .request_frame = ff_yadif_request_frame,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_bwdif = {
     .priv_class    = &bwdif_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_bwdif_inputs,
+    FILTER_INPUTS(avfilter_vf_bwdif_inputs),
-    .outputs       = avfilter_vf_bwdif_outputs,
+    FILTER_OUTPUTS(avfilter_vf_bwdif_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_cas.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad cas_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(CASContext, x)
     .priv_size     = sizeof(CASContext),
     .priv_class    = &cas_class,
     .query_formats = query_formats,
-    .inputs        = cas_inputs,
+    FILTER_INPUTS(cas_inputs),
-    .outputs       = cas_outputs,
+    FILTER_OUTPUTS(cas_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_chromaber_vulkan.c+2−4

         .filter_frame = &chromaber_vulkan_filter_frame,
         .config_props = &ff_vk_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad chromaber_vulkan_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_vk_filter_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_chromaber_vulkan = {
     .init           = &ff_vk_filter_init,
     .uninit         = &chromaber_vulkan_uninit,
     .query_formats  = &ff_vk_filter_query_formats,
-    .inputs         = chromaber_vulkan_inputs,
+    FILTER_INPUTS(chromaber_vulkan_inputs),
-    .outputs        = chromaber_vulkan_outputs,
+    FILTER_OUTPUTS(chromaber_vulkan_outputs),
     .priv_class     = &chromaber_vulkan_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_chromakey.c+4−8

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad chromakey_outputs[] = {
         .type           = AVMEDIA_TYPE_VIDEO,
         .config_props   = config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ChromakeyContext, x)
     .priv_size     = sizeof(ChromakeyContext),
     .priv_class    = &chromakey_class,
     .query_formats = query_formats,
-    .inputs        = chromakey_inputs,
+    FILTER_INPUTS(chromakey_inputs),
-    .outputs       = chromakey_outputs,
+    FILTER_OUTPUTS(chromakey_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };
         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad chromahold_outputs[] = {
         .type           = AVMEDIA_TYPE_VIDEO,
         .config_props   = config_output,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(chromahold);
     .priv_size     = sizeof(ChromakeyContext),
     .priv_class    = &chromahold_class,
     .query_formats = query_formats,
-    .inputs        = chromahold_inputs,
+    FILTER_INPUTS(chromahold_inputs),
-    .outputs       = chromahold_outputs,
+    FILTER_OUTPUTS(chromahold_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_chromanr.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(chromanr);
     .priv_size     = sizeof(ChromaNRContext),
     .priv_class    = &chromanr_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_chromashift.c+4−6

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(chromashift);
     .priv_size     = sizeof(ChromaShiftContext),
     .priv_class    = &chromashift_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };
     .priv_size     = sizeof(ChromaShiftContext),
     .priv_class    = &rgbashift_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_ciescope.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_ciescope = {
     .priv_class    = &ciescope_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/vf_codecview.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad codecview_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_codecview = {
     .description   = NULL_IF_CONFIG_SMALL("Visualize information about some codecs."),
     .priv_size     = sizeof(CodecViewContext),
     .query_formats = query_formats,
-    .inputs        = codecview_inputs,
+    FILTER_INPUTS(codecview_inputs),
-    .outputs       = codecview_outputs,
+    FILTER_OUTPUTS(codecview_outputs),
     .priv_class    = &codecview_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_colorbalance.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad colorbalance_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_colorbalance = {
     .priv_size     = sizeof(ColorBalanceContext),
     .priv_class    = &colorbalance_class,
     .query_formats = query_formats,
-    .inputs        = colorbalance_inputs,
+    FILTER_INPUTS(colorbalance_inputs),
-    .outputs       = colorbalance_outputs,
+    FILTER_OUTPUTS(colorbalance_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_colorchannelmixer.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad colorchannelmixer_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_colorchannelmixer = {
     .priv_class    = &colorchannelmixer_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = colorchannelmixer_inputs,
+    FILTER_INPUTS(colorchannelmixer_inputs),
-    .outputs       = colorchannelmixer_outputs,
+    FILTER_OUTPUTS(colorchannelmixer_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_colorconstancy.c+2−4

         .config_props = config_props,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad colorconstancy_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #if CONFIG_GREYEDGE_FILTER
     .priv_class    = &greyedge_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = colorconstancy_inputs,
+    FILTER_INPUTS(colorconstancy_inputs),
-    .outputs       = colorconstancy_outputs,
+    FILTER_OUTPUTS(colorconstancy_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_colorcontrast.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad colorcontrast_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ColorContrastContext, x)
     .priv_size     = sizeof(ColorContrastContext),
     .priv_class    = &colorcontrast_class,
     .query_formats = query_formats,
-    .inputs        = colorcontrast_inputs,
+    FILTER_INPUTS(colorcontrast_inputs),
-    .outputs       = colorcontrast_outputs,
+    FILTER_OUTPUTS(colorcontrast_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_colorcorrect.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad colorcorrect_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ColorCorrectContext, x)
     .priv_class    = &colorcorrect_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = colorcorrect_inputs,
+    FILTER_INPUTS(colorcorrect_inputs),
-    .outputs       = colorcorrect_outputs,
+    FILTER_OUTPUTS(colorcorrect_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_colorize.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad colorize_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ColorizeContext, x)
     .priv_size     = sizeof(ColorizeContext),
     .priv_class    = &colorize_class,
     .query_formats = query_formats,
-    .inputs        = colorize_inputs,
+    FILTER_INPUTS(colorize_inputs),
-    .outputs       = colorize_outputs,
+    FILTER_OUTPUTS(colorize_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_colorkey.c+4−6

         .flags        = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad colorkey_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ColorkeyContext, x)
     .priv_class    = &colorkey_class,
     .query_formats = query_formats,
     .init          = init_filter,
-    .inputs        = colorkey_inputs,
+    FILTER_INPUTS(colorkey_inputs),
-    .outputs       = colorkey_outputs,
+    FILTER_OUTPUTS(colorkey_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };
     .priv_class    = &colorhold_class,
     .query_formats = query_formats,
     .init          = init_filter,
-    .inputs        = colorkey_inputs,
+    FILTER_INPUTS(colorkey_inputs),
-    .outputs       = colorkey_outputs,
+    FILTER_OUTPUTS(colorkey_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_colorkey_opencl.c+2−4

         .filter_frame = filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad colorkey_opencl_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ColorkeyOpenCLContext, x)
     .init           = &ff_opencl_filter_init,
     .uninit         = &colorkey_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = colorkey_opencl_inputs,
+    FILTER_INPUTS(colorkey_opencl_inputs),
-    .outputs        = colorkey_opencl_outputs,
+    FILTER_OUTPUTS(colorkey_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE
 };

libavfilter/vf_colorlevels.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad colorlevels_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_colorlevels = {
     .priv_size     = sizeof(ColorLevelsContext),
     .priv_class    = &colorlevels_class,
     .query_formats = query_formats,
-    .inputs        = colorlevels_inputs,
+    FILTER_INPUTS(colorlevels_inputs),
-    .outputs       = colorlevels_outputs,
+    FILTER_OUTPUTS(colorlevels_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_colormatrix.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad colormatrix_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_colormatrix = {
     .priv_size     = sizeof(ColorMatrixContext),
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = colormatrix_inputs,
+    FILTER_INPUTS(colormatrix_inputs),
-    .outputs       = colormatrix_outputs,
+    FILTER_OUTPUTS(colormatrix_outputs),
     .priv_class    = &colormatrix_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_colorspace.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_colorspace = {
     .query_formats   = query_formats,
     .priv_size       = sizeof(ColorSpaceContext),
     .priv_class      = &colorspace_class,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_colortemperature.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ColorTemperatureContext, x)
     .priv_size     = sizeof(ColorTemperatureContext),
     .priv_class    = &colortemperature_class,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_convolution.c+10−12

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad convolution_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #if CONFIG_CONVOLUTION_FILTER
     .priv_class    = &convolution_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = convolution_inputs,
+    FILTER_INPUTS(convolution_inputs),
-    .outputs       = convolution_outputs,
+    FILTER_OUTPUTS(convolution_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };
     .priv_class    = &prewitt_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = convolution_inputs,
+    FILTER_INPUTS(convolution_inputs),
-    .outputs       = convolution_outputs,
+    FILTER_OUTPUTS(convolution_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };
     .priv_class    = &sobel_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = convolution_inputs,
+    FILTER_INPUTS(convolution_inputs),
-    .outputs       = convolution_outputs,
+    FILTER_OUTPUTS(convolution_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };
     .priv_class    = &roberts_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = convolution_inputs,
+    FILTER_INPUTS(convolution_inputs),
-    .outputs       = convolution_outputs,
+    FILTER_OUTPUTS(convolution_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };
     .priv_class    = &kirsch_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = convolution_inputs,
+    FILTER_INPUTS(convolution_inputs),
-    .outputs       = convolution_outputs,
+    FILTER_OUTPUTS(convolution_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_convolution_opencl.c+8−10

         .filter_frame = &convolution_opencl_filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad convolution_opencl_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ConvolutionOpenCLContext, x)
     .init           = &ff_opencl_filter_init,
     .uninit         = &convolution_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = convolution_opencl_inputs,
+    FILTER_INPUTS(convolution_opencl_inputs),
-    .outputs        = convolution_opencl_outputs,
+    FILTER_OUTPUTS(convolution_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
     .init           = &ff_opencl_filter_init,
     .uninit         = &convolution_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = convolution_opencl_inputs,
+    FILTER_INPUTS(convolution_opencl_inputs),
-    .outputs        = convolution_opencl_outputs,
+    FILTER_OUTPUTS(convolution_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
     .init           = &ff_opencl_filter_init,
     .uninit         = &convolution_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = convolution_opencl_inputs,
+    FILTER_INPUTS(convolution_opencl_inputs),
-    .outputs        = convolution_opencl_outputs,
+    FILTER_OUTPUTS(convolution_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
     .init           = &ff_opencl_filter_init,
     .uninit         = &convolution_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = convolution_opencl_inputs,
+    FILTER_INPUTS(convolution_opencl_inputs),
-    .outputs        = convolution_opencl_outputs,
+    FILTER_OUTPUTS(convolution_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_convolve.c+4−6

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_input_impulse,
     },
-    { NULL }
 };
 static const AVFilterPad convolve_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 #if CONFIG_CONVOLVE_FILTER
     .activate      = activate,
     .priv_size     = sizeof(ConvolveContext),
     .priv_class    = &convolve_class,
-    .inputs        = convolve_inputs,
+    FILTER_INPUTS(convolve_inputs),
-    .outputs       = convolve_outputs,
+    FILTER_OUTPUTS(convolve_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };
     .activate      = activate,
     .priv_size     = sizeof(ConvolveContext),
     .priv_class    = &deconvolve_class,
-    .inputs        = convolve_inputs,
+    FILTER_INPUTS(convolve_inputs),
-    .outputs       = convolve_outputs,
+    FILTER_OUTPUTS(convolve_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_copy.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_copy_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_copy = {
     .name        = "copy",
     .description = NULL_IF_CONFIG_SMALL("Copy the input video unchanged to the output."),
-    .inputs      = avfilter_vf_copy_inputs,
+    FILTER_INPUTS(avfilter_vf_copy_inputs),
-    .outputs     = avfilter_vf_copy_outputs,
+    FILTER_OUTPUTS(avfilter_vf_copy_outputs),
     .query_formats = query_formats,
 };

libavfilter/vf_coreimage.m+3−6

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad vf_coreimage_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad vsrc_coreimagesrc_outputs[] = {
         .request_frame = request_frame,
         .config_props  = config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(CoreImageContext, x)
     .uninit        = uninit,
     .priv_size     = sizeof(CoreImageContext),
     .priv_class    = &coreimage_class,
-    .inputs        = vf_coreimage_inputs,
+    FILTER_INPUTS(vf_coreimage_inputs),
-    .outputs       = vf_coreimage_outputs,
+    FILTER_OUTPUTS(vf_coreimage_outputs),
     .query_formats = query_formats,
 };
     .priv_size     = sizeof(CoreImageContext),
     .priv_class    = &coreimagesrc_class,
     .inputs        = NULL,
-    .outputs       = vsrc_coreimagesrc_outputs,
+    FILTER_OUTPUTS(vsrc_coreimagesrc_outputs),
     .query_formats = query_formats_src,
 };

libavfilter/vf_cover_rect.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad cover_rect_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_cover_rect = {
     .init            = init,
     .uninit          = uninit,
     .query_formats   = query_formats,
-    .inputs          = cover_rect_inputs,
+    FILTER_INPUTS(cover_rect_inputs),
-    .outputs         = cover_rect_outputs,
+    FILTER_OUTPUTS(cover_rect_outputs),
     .priv_class      = &cover_rect_class,
 };

libavfilter/vf_crop.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_crop_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_crop = {
     .priv_class      = &crop_class,
     .query_formats   = query_formats,
     .uninit          = uninit,
-    .inputs          = avfilter_vf_crop_inputs,
+    FILTER_INPUTS(avfilter_vf_crop_inputs),
-    .outputs         = avfilter_vf_crop_outputs,
+    FILTER_OUTPUTS(avfilter_vf_crop_outputs),
     .process_command = process_command,
 };

libavfilter/vf_cropdetect.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_cropdetect_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO
     },
-    { NULL }
 };
 const AVFilter ff_vf_cropdetect = {
     .priv_class    = &cropdetect_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_cropdetect_inputs,
+    FILTER_INPUTS(avfilter_vf_cropdetect_inputs),
-    .outputs       = avfilter_vf_cropdetect_outputs,
+    FILTER_OUTPUTS(avfilter_vf_cropdetect_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_curves.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad curves_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_curves = {
     .init          = curves_init,
     .uninit        = curves_uninit,
     .query_formats = query_formats,
-    .inputs        = curves_inputs,
+    FILTER_INPUTS(curves_inputs),
-    .outputs       = curves_outputs,
+    FILTER_OUTPUTS(curves_outputs),
     .priv_class    = &curves_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,

libavfilter/vf_datascope.c+6−12

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_datascope = {
     .priv_size     = sizeof(DatascopeContext),
     .priv_class    = &datascope_class,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };
         .filter_frame   = pixscope_filter_frame,
         .config_props   = pixscope_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad pixscope_outputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_pixscope = {
     .priv_size     = sizeof(PixscopeContext),
     .priv_class    = &pixscope_class,
     .query_formats = query_formats,
-    .inputs        = pixscope_inputs,
+    FILTER_INPUTS(pixscope_inputs),
-    .outputs       = pixscope_outputs,
+    FILTER_OUTPUTS(pixscope_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = pixscope_process_command,
 };
         .filter_frame   = oscilloscope_filter_frame,
         .config_props   = oscilloscope_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad oscilloscope_outputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_oscilloscope = {
     .priv_class    = &oscilloscope_class,
     .query_formats = query_formats,
     .uninit        = oscilloscope_uninit,
-    .inputs        = oscilloscope_inputs,
+    FILTER_INPUTS(oscilloscope_inputs),
-    .outputs       = oscilloscope_outputs,
+    FILTER_OUTPUTS(oscilloscope_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = oscilloscope_process_command,
 };

libavfilter/vf_dblur.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad dblur_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_dblur = {
     .priv_class    = &dblur_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = dblur_inputs,
+    FILTER_INPUTS(dblur_inputs),
-    .outputs       = dblur_outputs,
+    FILTER_OUTPUTS(dblur_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_dctdnoiz.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad dctdnoiz_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_dctdnoiz = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = dctdnoiz_inputs,
+    FILTER_INPUTS(dctdnoiz_inputs),
-    .outputs       = dctdnoiz_outputs,
+    FILTER_OUTPUTS(dctdnoiz_outputs),
     .priv_class    = &dctdnoiz_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_deband.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_deband_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_deband = {
     .priv_class    = &deband_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_deband_inputs,
+    FILTER_INPUTS(avfilter_vf_deband_inputs),
-    .outputs       = avfilter_vf_deband_outputs,
+    FILTER_OUTPUTS(avfilter_vf_deband_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_deblock.c+2−4

         .type           = AVMEDIA_TYPE_VIDEO,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(deblock);
     .priv_size     = sizeof(DeblockContext),
     .priv_class    = &deblock_class,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,
 };

libavfilter/vf_decimate.c+1−2

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_decimate = {
     .uninit        = decimate_uninit,
     .priv_size     = sizeof(DecimateContext),
     .query_formats = query_formats,
-    .outputs       = decimate_outputs,
+    FILTER_OUTPUTS(decimate_outputs),
     .priv_class    = &decimate_class,
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/vf_dedot.c+2−4

         .name           = "default",
         .type           = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(dedot);
     .query_formats = query_formats,
     .activate      = activate,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_deflicker.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_deflicker = {
     .priv_class    = &deflicker_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/vf_deinterlace_qsv.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = qsvdeint_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad qsvdeint_outputs[] = {
         .config_props  = qsvdeint_config_props,
         .request_frame = qsvdeint_request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_deinterlace_qsv = {
     .priv_size = sizeof(QSVDeintContext),
     .priv_class = &qsvdeint_class,
-    .inputs    = qsvdeint_inputs,
+    FILTER_INPUTS(qsvdeint_inputs),
-    .outputs   = qsvdeint_outputs,
+    FILTER_OUTPUTS(qsvdeint_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_deinterlace_vaapi.c+2−4

         .filter_frame = &deint_vaapi_filter_frame,
         .config_props = &ff_vaapi_vpp_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad deint_vaapi_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &deint_vaapi_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_deinterlace_vaapi = {
     .init           = &deint_vaapi_init,
     .uninit         = &ff_vaapi_vpp_ctx_uninit,
     .query_formats  = &ff_vaapi_vpp_query_formats,
-    .inputs         = deint_vaapi_inputs,
+    FILTER_INPUTS(deint_vaapi_inputs),
-    .outputs        = deint_vaapi_outputs,
+    FILTER_OUTPUTS(deint_vaapi_outputs),
     .priv_class     = &deint_vaapi_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_dejudder.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad dejudder_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = config_out_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_dejudder = {
     .description = NULL_IF_CONFIG_SMALL("Remove judder produced by pullup."),
     .priv_size   = sizeof(DejudderContext),
     .priv_class  = &dejudder_class,
-    .inputs      = dejudder_inputs,
+    FILTER_INPUTS(dejudder_inputs),
-    .outputs     = dejudder_outputs,
+    FILTER_OUTPUTS(dejudder_outputs),
     .init        = dejudder_init,
     .uninit      = dejudder_uninit,
 };

libavfilter/vf_delogo.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_delogo_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_delogo = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_delogo_inputs,
+    FILTER_INPUTS(avfilter_vf_delogo_inputs),
-    .outputs       = avfilter_vf_delogo_outputs,
+    FILTER_OUTPUTS(avfilter_vf_delogo_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_derain.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad derain_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_derain = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = derain_inputs,
+    FILTER_INPUTS(derain_inputs),
-    .outputs       = derain_outputs,
+    FILTER_OUTPUTS(derain_outputs),
     .priv_class    = &derain_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_deshake.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad deshake_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_deshake = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = deshake_inputs,
+    FILTER_INPUTS(deshake_inputs),
-    .outputs       = deshake_outputs,
+    FILTER_OUTPUTS(deshake_outputs),
     .priv_class    = &deshake_class,
 };

libavfilter/vf_deshake_opencl.c+2−4

         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad deshake_opencl_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(DeshakeOpenCLContext, x)
     .uninit         = &deshake_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
     .activate       = activate,
-    .inputs         = deshake_opencl_inputs,
+    FILTER_INPUTS(deshake_opencl_inputs),
-    .outputs        = deshake_opencl_outputs,
+    FILTER_OUTPUTS(deshake_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE
 };

libavfilter/vf_despill.c+2−4

         .flags        = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad despill_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(DespillContext, x)
     .priv_size     = sizeof(DespillContext),
     .priv_class    = &despill_class,
     .query_formats = query_formats,
-    .inputs        = despill_inputs,
+    FILTER_INPUTS(despill_inputs),
-    .outputs       = despill_outputs,
+    FILTER_OUTPUTS(despill_outputs),
     .process_command = ff_filter_process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_detelecine.c+2−4

         .filter_frame  = filter_frame,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad detelecine_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_detelecine = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = detelecine_inputs,
+    FILTER_INPUTS(detelecine_inputs),
-    .outputs       = detelecine_outputs,
+    FILTER_OUTPUTS(detelecine_outputs),
 };

libavfilter/vf_displace.c+2−4

         .name         = "ymap",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad displace_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_displace = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = displace_inputs,
+    FILTER_INPUTS(displace_inputs),
-    .outputs       = displace_outputs,
+    FILTER_OUTPUTS(displace_outputs),
     .priv_class    = &displace_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_dnn_classify.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad dnn_classify_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_dnn_classify = {
     .init          = dnn_classify_init,
     .uninit        = dnn_classify_uninit,
     .query_formats = dnn_classify_query_formats,
-    .inputs        = dnn_classify_inputs,
+    FILTER_INPUTS(dnn_classify_inputs),
-    .outputs       = dnn_classify_outputs,
+    FILTER_OUTPUTS(dnn_classify_outputs),
     .priv_class    = &dnn_classify_class,
     .activate      = dnn_classify_activate,
 };

libavfilter/vf_dnn_detect.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad dnn_detect_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_dnn_detect = {
     .init          = dnn_detect_init,
     .uninit        = dnn_detect_uninit,
     .query_formats = dnn_detect_query_formats,
-    .inputs        = dnn_detect_inputs,
+    FILTER_INPUTS(dnn_detect_inputs),
-    .outputs       = dnn_detect_outputs,
+    FILTER_OUTPUTS(dnn_detect_outputs),
     .priv_class    = &dnn_detect_class,
     .activate      = dnn_detect_activate,
 };

libavfilter/vf_dnn_processing.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad dnn_processing_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_dnn_processing = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = dnn_processing_inputs,
+    FILTER_INPUTS(dnn_processing_inputs),
-    .outputs       = dnn_processing_outputs,
+    FILTER_OUTPUTS(dnn_processing_outputs),
     .priv_class    = &dnn_processing_class,
     .activate      = activate,
 };

libavfilter/vf_drawbox.c+4−8

         .config_props   = config_input,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad drawbox_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_drawbox = {
     .priv_class    = &drawbox_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = drawbox_inputs,
+    FILTER_INPUTS(drawbox_inputs),
-    .outputs       = drawbox_outputs,
+    FILTER_OUTPUTS(drawbox_outputs),
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
         .config_props   = config_input,
         .filter_frame   = drawgrid_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad drawgrid_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_drawgrid = {
     .priv_class    = &drawgrid_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = drawgrid_inputs,
+    FILTER_INPUTS(drawgrid_inputs),
-    .outputs       = drawgrid_outputs,
+    FILTER_OUTPUTS(drawgrid_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,
 };

libavfilter/vf_drawtext.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_drawtext_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_drawtext = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_drawtext_inputs,
+    FILTER_INPUTS(avfilter_vf_drawtext_inputs),
-    .outputs       = avfilter_vf_drawtext_outputs,
+    FILTER_OUTPUTS(avfilter_vf_drawtext_outputs),
     .process_command = command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_edgedetect.c+2−4

         .config_props = config_props,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad edgedetect_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_edgedetect = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = edgedetect_inputs,
+    FILTER_INPUTS(edgedetect_inputs),
-    .outputs       = edgedetect_outputs,
+    FILTER_OUTPUTS(edgedetect_outputs),
     .priv_class    = &edgedetect_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_elbg.c+2−4

         .config_props   = config_input,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad elbg_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_elbg = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = elbg_inputs,
+    FILTER_INPUTS(elbg_inputs),
-    .outputs       = elbg_outputs,
+    FILTER_OUTPUTS(elbg_outputs),
 };

libavfilter/vf_entropy.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_entropy = {
     .priv_size      = sizeof(EntropyContext),
     .uninit         = uninit,
     .query_formats  = query_formats,
-    .inputs         = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs        = outputs,
+    FILTER_OUTPUTS(outputs),
     .priv_class     = &entropy_class,
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_epx.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_epx = {
     .name          = "epx",
     .description   = NULL_IF_CONFIG_SMALL("Scale the input using EPX algorithm."),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .query_formats = query_formats,
     .priv_size     = sizeof(EPXContext),
     .priv_class    = &epx_class,

libavfilter/vf_eq.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad eq_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(EQContext, x)
     .description     = NULL_IF_CONFIG_SMALL("Adjust brightness, contrast, gamma, and saturation."),
     .priv_size       = sizeof(EQContext),
     .priv_class      = &eq_class,
-    .inputs          = eq_inputs,
+    FILTER_INPUTS(eq_inputs),
-    .outputs         = eq_outputs,
+    FILTER_OUTPUTS(eq_outputs),
     .process_command = process_command,
     .query_formats   = query_formats,
     .init            = initialize,

libavfilter/vf_estdif.c+2−4

         .filter_frame  = filter_frame,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad estdif_outputs[] = {
         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_estdif = {
     .priv_class    = &estdif_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = estdif_inputs,
+    FILTER_INPUTS(estdif_inputs),
-    .outputs       = estdif_outputs,
+    FILTER_OUTPUTS(estdif_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_exposure.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad exposure_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(ExposureContext, x)
     .priv_size     = sizeof(ExposureContext),
     .priv_class    = &exposure_class,
     .query_formats = query_formats,
-    .inputs        = exposure_inputs,
+    FILTER_INPUTS(exposure_inputs),
-    .outputs       = exposure_outputs,
+    FILTER_OUTPUTS(exposure_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_extractplanes.c+2−3

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 const AVFilter ff_vf_extractplanes = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = extractplanes_inputs,
+    FILTER_INPUTS(extractplanes_inputs),
     .outputs       = NULL,
     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };
     .init           = init_alphaextract,
     .uninit         = uninit,
     .query_formats  = query_formats,
-    .inputs         = extractplanes_inputs,
+    FILTER_INPUTS(extractplanes_inputs),
     .outputs        = NULL,
     .flags          = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };

libavfilter/vf_fade.c+2−4

         .config_props   = config_input,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_fade_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fade = {
     .priv_size     = sizeof(FadeContext),
     .priv_class    = &fade_class,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_fade_inputs,
+    FILTER_INPUTS(avfilter_vf_fade_inputs),
-    .outputs       = avfilter_vf_fade_outputs,
+    FILTER_OUTPUTS(avfilter_vf_fade_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS |
                      AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_fftdnoiz.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad fftdnoiz_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fftdnoiz = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = fftdnoiz_inputs,
+    FILTER_INPUTS(fftdnoiz_inputs),
-    .outputs       = fftdnoiz_outputs,
+    FILTER_OUTPUTS(fftdnoiz_outputs),
     .priv_class    = &fftdnoiz_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_fftfilt.c+2−4

         .config_props = config_props,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad fftfilt_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fftfilt = {
     .description     = NULL_IF_CONFIG_SMALL("Apply arbitrary expressions to pixels in frequency domain."),
     .priv_size       = sizeof(FFTFILTContext),
     .priv_class      = &fftfilt_class,
-    .inputs          = fftfilt_inputs,
+    FILTER_INPUTS(fftfilt_inputs),
-    .outputs         = fftfilt_outputs,
+    FILTER_OUTPUTS(fftfilt_outputs),
     .query_formats   = query_formats,
     .init            = initialize,
     .uninit          = uninit,

libavfilter/vf_field.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad field_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_props_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_field = {
     .name        = "field",
     .description = NULL_IF_CONFIG_SMALL("Extract a field from the input video."),
     .priv_size   = sizeof(FieldContext),
-    .inputs      = field_inputs,
+    FILTER_INPUTS(field_inputs),
-    .outputs     = field_outputs,
+    FILTER_OUTPUTS(field_outputs),
     .priv_class  = &field_class,
 };

libavfilter/vf_fieldhint.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fieldhint = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/vf_fieldmatch.c+1−2

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fieldmatch = {
     .activate       = activate,
     .uninit         = fieldmatch_uninit,
     .inputs         = NULL,
-    .outputs        = fieldmatch_outputs,
+    FILTER_OUTPUTS(fieldmatch_outputs),
     .priv_class     = &fieldmatch_class,
     .flags          = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/vf_fieldorder.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_fieldorder_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fieldorder = {
     .priv_size     = sizeof(FieldOrderContext),
     .priv_class    = &fieldorder_class,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_fieldorder_inputs,
+    FILTER_INPUTS(avfilter_vf_fieldorder_inputs),
-    .outputs       = avfilter_vf_fieldorder_outputs,
+    FILTER_OUTPUTS(avfilter_vf_fieldorder_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_fillborders.c+2−4

         .config_props   = config_input,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad fillborders_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fillborders = {
     .priv_size     = sizeof(FillBordersContext),
     .priv_class    = &fillborders_class,
     .query_formats = query_formats,
-    .inputs        = fillborders_inputs,
+    FILTER_INPUTS(fillborders_inputs),
-    .outputs       = fillborders_outputs,
+    FILTER_OUTPUTS(fillborders_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,
 };

libavfilter/vf_find_rect.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad foc_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_find_rect = {
     .init            = init,
     .uninit          = uninit,
     .query_formats   = query_formats,
-    .inputs          = foc_inputs,
+    FILTER_INPUTS(foc_inputs),
-    .outputs         = foc_outputs,
+    FILTER_OUTPUTS(foc_outputs),
     .priv_class      = &find_rect_class,
 };

libavfilter/vf_floodfill.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad floodfill_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(FloodfillContext, x)
     .priv_class    = &floodfill_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = floodfill_inputs,
+    FILTER_INPUTS(floodfill_inputs),
-    .outputs       = floodfill_outputs,
+    FILTER_OUTPUTS(floodfill_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_format.c+4−8

         .type             = AVMEDIA_TYPE_VIDEO,
         .get_buffer.video = ff_null_get_video_buffer,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_format_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO
     },
-    { NULL }
 };
 const AVFilter ff_vf_format = {
     .priv_size     = sizeof(FormatContext),
     .priv_class    = &format_class,
-    .inputs        = avfilter_vf_format_inputs,
+    FILTER_INPUTS(avfilter_vf_format_inputs),
-    .outputs       = avfilter_vf_format_outputs,
+    FILTER_OUTPUTS(avfilter_vf_format_outputs),
 };
 #endif /* CONFIG_FORMAT_FILTER */
         .type             = AVMEDIA_TYPE_VIDEO,
         .get_buffer.video = ff_null_get_video_buffer,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_noformat_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO
     },
-    { NULL }
 };
 const AVFilter ff_vf_noformat = {
     .priv_size     = sizeof(FormatContext),
     .priv_class    = &noformat_class,
-    .inputs        = avfilter_vf_noformat_inputs,
+    FILTER_INPUTS(avfilter_vf_noformat_inputs),
-    .outputs       = avfilter_vf_noformat_outputs,
+    FILTER_OUTPUTS(avfilter_vf_noformat_outputs),
 };
 #endif /* CONFIG_NOFORMAT_FILTER */

libavfilter/vf_fps.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_fps_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fps = {
     .priv_size   = sizeof(FPSContext),
     .priv_class  = &fps_class,
     .activate    = activate,
-    .inputs      = avfilter_vf_fps_inputs,
+    FILTER_INPUTS(avfilter_vf_fps_inputs),
-    .outputs     = avfilter_vf_fps_outputs,
+    FILTER_OUTPUTS(avfilter_vf_fps_outputs),
 };

libavfilter/vf_framepack.c+2−4

         .name         = "right",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad framepack_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_framepack = {
     .priv_size     = sizeof(FramepackContext),
     .priv_class    = &framepack_class,
     .query_formats = query_formats,
-    .inputs        = framepack_inputs,
+    FILTER_INPUTS(framepack_inputs),
-    .outputs       = framepack_outputs,
+    FILTER_OUTPUTS(framepack_outputs),
     .activate      = activate,
     .uninit        = framepack_uninit,
 };

libavfilter/vf_framerate.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad framerate_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_framerate = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = framerate_inputs,
+    FILTER_INPUTS(framerate_inputs),
-    .outputs       = framerate_outputs,
+    FILTER_OUTPUTS(framerate_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
     .activate      = activate,
 };

libavfilter/vf_framestep.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad framestep_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_framestep = {
     .description = NULL_IF_CONFIG_SMALL("Select one frame every N frames."),
     .priv_size   = sizeof(FrameStepContext),
     .priv_class  = &framestep_class,
-    .inputs      = framestep_inputs,
+    FILTER_INPUTS(framestep_inputs),
-    .outputs     = framestep_outputs,
+    FILTER_OUTPUTS(framestep_outputs),
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_freezedetect.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad freezedetect_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_freezedetect = {
     .priv_class    = &freezedetect_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = freezedetect_inputs,
+    FILTER_INPUTS(freezedetect_inputs),
-    .outputs       = freezedetect_outputs,
+    FILTER_OUTPUTS(freezedetect_outputs),
     .activate      = activate,
 };

libavfilter/vf_freezeframes.c+2−4

         .name = "replace",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL },
 };
 static const AVFilterPad freezeframes_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL },
 };
 const AVFilter ff_vf_freezeframes = {
     .description   = NULL_IF_CONFIG_SMALL("Freeze video frames."),
     .priv_size     = sizeof(FreezeFramesContext),
     .priv_class    = &freezeframes_class,
-    .inputs        = freezeframes_inputs,
+    FILTER_INPUTS(freezeframes_inputs),
-    .outputs       = freezeframes_outputs,
+    FILTER_OUTPUTS(freezeframes_outputs),
     .activate      = activate,
     .uninit        = uninit,
 };

libavfilter/vf_frei0r.c+3−6

         .config_props = config_input_props,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_frei0r_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_frei0r = {
     .uninit        = uninit,
     .priv_size     = sizeof(Frei0rContext),
     .priv_class    = &frei0r_class,
-    .inputs        = avfilter_vf_frei0r_inputs,
+    FILTER_INPUTS(avfilter_vf_frei0r_inputs),
-    .outputs       = avfilter_vf_frei0r_outputs,
+    FILTER_OUTPUTS(avfilter_vf_frei0r_outputs),
     .process_command = process_command,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
         .request_frame = source_request_frame,
         .config_props  = source_config_props
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_frei0r_src = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .inputs        = NULL,
-    .outputs       = avfilter_vsrc_frei0r_src_outputs,
+    FILTER_OUTPUTS(avfilter_vsrc_frei0r_src_outputs),
 };

libavfilter/vf_fspp.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad fspp_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_fspp = {
     .priv_size       = sizeof(FSPPContext),
     .uninit          = uninit,
     .query_formats   = query_formats,
-    .inputs          = fspp_inputs,
+    FILTER_INPUTS(fspp_inputs),
-    .outputs         = fspp_outputs,
+    FILTER_OUTPUTS(fspp_outputs),
     .priv_class      = &fspp_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_gblur.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad gblur_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_gblur = {
     .priv_class    = &gblur_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = gblur_inputs,
+    FILTER_INPUTS(gblur_inputs),
-    .outputs       = gblur_outputs,
+    FILTER_OUTPUTS(gblur_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_geq.c+2−4

         .config_props = geq_config_props,
         .filter_frame = geq_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad geq_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_geq = {
     .init          = geq_init,
     .uninit        = geq_uninit,
     .query_formats = geq_query_formats,
-    .inputs        = geq_inputs,
+    FILTER_INPUTS(geq_inputs),
-    .outputs       = geq_outputs,
+    FILTER_OUTPUTS(geq_outputs),
     .priv_class    = &geq_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_gradfun.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_gradfun_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_gradfun = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_gradfun_inputs,
+    FILTER_INPUTS(avfilter_vf_gradfun_inputs),
-    .outputs       = avfilter_vf_gradfun_outputs,
+    FILTER_OUTPUTS(avfilter_vf_gradfun_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_guided.c+1−2

         .type = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_guided = {
     .priv_class      = &guided_class,
     .activate        = activate,
     .inputs          = NULL,
-    .outputs         = guided_outputs,
+    FILTER_OUTPUTS(guided_outputs),
     .flags           = AVFILTER_FLAG_DYNAMIC_INPUTS | AVFILTER_FLAG_SLICE_THREADS |
                        AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = process_command,

libavfilter/vf_hflip.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_hflip_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_hflip = {
     .priv_size     = sizeof(FlipContext),
     .priv_class    = &hflip_class,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_hflip_inputs,
+    FILTER_INPUTS(avfilter_vf_hflip_inputs),
-    .outputs       = avfilter_vf_hflip_outputs,
+    FILTER_OUTPUTS(avfilter_vf_hflip_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_histeq.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad histeq_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_histeq = {
     .priv_size     = sizeof(HisteqContext),
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = histeq_inputs,
+    FILTER_INPUTS(histeq_inputs),
-    .outputs       = histeq_outputs,
+    FILTER_OUTPUTS(histeq_outputs),
     .priv_class    = &histeq_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_histogram.c+4−6

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 #if CONFIG_HISTOGRAM_FILTER
     .description   = NULL_IF_CONFIG_SMALL("Compute and draw a histogram."),
     .priv_size     = sizeof(HistogramContext),
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .priv_class    = &histogram_class,
 };
     .description   = NULL_IF_CONFIG_SMALL("Compute and draw a temporal histogram."),
     .priv_size     = sizeof(HistogramContext),
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .uninit        = uninit,
     .priv_class    = &thistogram_class,
 };

libavfilter/vf_hqdn3d.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO
     },
-    { NULL }
 };
 const AVFilter ff_vf_hqdn3d = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_hqdn3d_inputs,
+    FILTER_INPUTS(avfilter_vf_hqdn3d_inputs),
-    .outputs       = avfilter_vf_hqdn3d_outputs,
+    FILTER_OUTPUTS(avfilter_vf_hqdn3d_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_hqx.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad hqx_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_hqx = {
     .priv_size     = sizeof(HQXContext),
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = hqx_inputs,
+    FILTER_INPUTS(hqx_inputs),
-    .outputs       = hqx_outputs,
+    FILTER_OUTPUTS(hqx_outputs),
     .priv_class    = &hqx_class,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_hue.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad hue_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_hue = {
     .uninit          = uninit,
     .query_formats   = query_formats,
     .process_command = process_command,
-    .inputs          = hue_inputs,
+    FILTER_INPUTS(hue_inputs),
-    .outputs         = hue_outputs,
+    FILTER_OUTPUTS(hue_outputs),
     .priv_class      = &hue_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_hwdownload.c+2−4

         .config_props = hwdownload_config_input,
         .filter_frame = hwdownload_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad hwdownload_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = hwdownload_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_hwdownload = {
     .query_formats = hwdownload_query_formats,
     .priv_size     = sizeof(HWDownloadContext),
     .priv_class    = &hwdownload_class,
-    .inputs        = hwdownload_inputs,
+    FILTER_INPUTS(hwdownload_inputs),
-    .outputs       = hwdownload_outputs,
+    FILTER_OUTPUTS(hwdownload_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_hwmap.c+2−4

         .get_buffer.video = hwmap_get_buffer,
         .filter_frame     = hwmap_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad hwmap_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = hwmap_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_hwmap = {
     .priv_size      = sizeof(HWMapContext),
     .priv_class     = &hwmap_class,
     .query_formats  = hwmap_query_formats,
-    .inputs         = hwmap_inputs,
+    FILTER_INPUTS(hwmap_inputs),
-    .outputs        = hwmap_outputs,
+    FILTER_OUTPUTS(hwmap_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_hwupload.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = hwupload_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad hwupload_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = hwupload_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_hwupload = {
     .query_formats = hwupload_query_formats,
     .priv_size     = sizeof(HWUploadContext),
     .priv_class    = &hwupload_class,
-    .inputs        = hwupload_inputs,
+    FILTER_INPUTS(hwupload_inputs),
-    .outputs       = hwupload_outputs,
+    FILTER_OUTPUTS(hwupload_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_hwupload_cuda.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = cudaupload_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad cudaupload_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = cudaupload_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_hwupload_cuda = {
     .priv_size  = sizeof(CudaUploadContext),
     .priv_class = &cudaupload_class,
-    .inputs    = cudaupload_inputs,
+    FILTER_INPUTS(cudaupload_inputs),
-    .outputs   = cudaupload_outputs,
+    FILTER_OUTPUTS(cudaupload_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_hysteresis.c+2−4

         .name         = "alt",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad hysteresis_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_hysteresis = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = hysteresis_inputs,
+    FILTER_INPUTS(hysteresis_inputs),
-    .outputs       = hysteresis_outputs,
+    FILTER_OUTPUTS(hysteresis_outputs),
     .priv_class    = &hysteresis_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_identity.c+4−6

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_ref,
     },
-    { NULL }
 };
 static const AVFilterPad identity_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 static const AVOption options[] = {
     .activate      = activate,
     .priv_size     = sizeof(IdentityContext),
     .priv_class    = &identity_class,
-    .inputs        = identity_inputs,
+    FILTER_INPUTS(identity_inputs),
-    .outputs       = identity_outputs,
+    FILTER_OUTPUTS(identity_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };
     .activate      = activate,
     .priv_size     = sizeof(IdentityContext),
     .priv_class    = &msad_class,
-    .inputs        = identity_inputs,
+    FILTER_INPUTS(identity_inputs),
-    .outputs       = identity_outputs,
+    FILTER_OUTPUTS(identity_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_idet.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad idet_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame
     },
-    { NULL }
 };
 const AVFilter ff_vf_idet = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = idet_inputs,
+    FILTER_INPUTS(idet_inputs),
-    .outputs       = idet_outputs,
+    FILTER_OUTPUTS(idet_outputs),
     .priv_class    = &idet_class,
 };

libavfilter/vf_il.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_il = {
     .description   = NULL_IF_CONFIG_SMALL("Deinterleave or interleave fields."),
     .priv_size     = sizeof(IlContext),
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .priv_class    = &il_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = ff_filter_process_command,

libavfilter/vf_kerndeint.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad kerndeint_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
     .priv_class    = &kerndeint_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = kerndeint_inputs,
+    FILTER_INPUTS(kerndeint_inputs),
-    .outputs       = kerndeint_outputs,
+    FILTER_OUTPUTS(kerndeint_outputs),
 };

libavfilter/vf_lagfun.c+2−4

         .type          = AVMEDIA_TYPE_VIDEO,
         .filter_frame  = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(lagfun);
     .priv_class    = &lagfun_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_lenscorrection.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad lenscorrection_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_lenscorrection = {
     .description   = NULL_IF_CONFIG_SMALL("Rectify the image by correcting for lens distortion."),
     .priv_size     = sizeof(LenscorrectionCtx),
     .query_formats = query_formats,
-    .inputs        = lenscorrection_inputs,
+    FILTER_INPUTS(lenscorrection_inputs),
-    .outputs       = lenscorrection_outputs,
+    FILTER_OUTPUTS(lenscorrection_outputs),
     .priv_class    = &lenscorrection_class,
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

libavfilter/vf_lensfun.c+2−4

         .config_props = config_props,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad lensfun_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_lensfun = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = lensfun_inputs,
+    FILTER_INPUTS(lensfun_inputs),
-    .outputs       = lensfun_outputs,
+    FILTER_OUTPUTS(lensfun_outputs),
     .priv_class    = &lensfun_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_libopencv.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_ocv_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_ocv = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = avfilter_vf_ocv_inputs,
+    FILTER_INPUTS(avfilter_vf_ocv_inputs),
-    .outputs       = avfilter_vf_ocv_outputs,
+    FILTER_OUTPUTS(avfilter_vf_ocv_outputs),
 };

libavfilter/vf_libvmaf.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_ref,
     },
-    { NULL }
 };
 static const AVFilterPad libvmaf_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_libvmaf = {
     .activate      = activate,
     .priv_size     = sizeof(LIBVMAFContext),
     .priv_class    = &libvmaf_class,
-    .inputs        = libvmaf_inputs,
+    FILTER_INPUTS(libvmaf_inputs),
-    .outputs       = libvmaf_outputs,
+    FILTER_OUTPUTS(libvmaf_outputs),
 };

libavfilter/vf_limiter.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_limiter = {
     .priv_class    = &limiter_class,
     .init          = init,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_lumakey.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad lumakey_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(LumakeyContext, x)
     .priv_size     = sizeof(LumakeyContext),
     .priv_class    = &lumakey_class,
     .query_formats = query_formats,
-    .inputs        = lumakey_inputs,
+    FILTER_INPUTS(lumakey_inputs),
-    .outputs       = lumakey_outputs,
+    FILTER_OUTPUTS(lumakey_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_lut.c+2−4

       .filter_frame = filter_frame,
       .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
     { .name = "default",
       .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define DEFINE_LUT_FILTER(name_, description_)                          \
         .init          = name_##_init,                                  \
         .uninit        = uninit,                                        \
         .query_formats = query_formats,                                 \
-        .inputs        = inputs,                                        \
+        FILTER_INPUTS(inputs),                                          \
-        .outputs       = outputs,                                       \
+        FILTER_OUTPUTS(outputs),                                        \
         .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |       \
                          AVFILTER_FLAG_SLICE_THREADS,                   \
         .process_command = process_command,                             \

libavfilter/vf_lut2.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_inputy,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = lut2_config_output,
     },
-    { NULL }
 };
 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
     .uninit        = uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
         .filter_frame  = tlut2_filter_frame,
         .config_props  = config_inputx,
     },
-    { NULL }
 };
 static const AVFilterPad tlut2_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tlut2 = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = tlut2_inputs,
+    FILTER_INPUTS(tlut2_inputs),
-    .outputs       = tlut2_outputs,
+    FILTER_OUTPUTS(tlut2_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,

libavfilter/vf_lut3d.c+6−12

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad lut3d_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_lut3d = {
     .init          = lut3d_init,
     .uninit        = lut3d_uninit,
     .query_formats = query_formats,
-    .inputs        = lut3d_inputs,
+    FILTER_INPUTS(lut3d_inputs),
-    .outputs       = lut3d_outputs,
+    FILTER_OUTPUTS(lut3d_outputs),
     .priv_class    = &lut3d_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_clut,
     },
-    { NULL }
 };
 static const AVFilterPad haldclut_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_haldclut = {
     .uninit        = haldclut_uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = haldclut_inputs,
+    FILTER_INPUTS(haldclut_inputs),
-    .outputs       = haldclut_outputs,
+    FILTER_OUTPUTS(haldclut_outputs),
     .priv_class    = &haldclut_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
         .filter_frame = filter_frame_1d,
         .config_props = config_input_1d,
     },
-    { NULL }
 };
 static const AVFilterPad lut1d_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_lut1d = {
     .priv_size     = sizeof(LUT1DContext),
     .init          = lut1d_init,
     .query_formats = query_formats,
-    .inputs        = lut1d_inputs,
+    FILTER_INPUTS(lut1d_inputs),
-    .outputs       = lut1d_outputs,
+    FILTER_OUTPUTS(lut1d_outputs),
     .priv_class    = &lut1d_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = lut1d_process_command,

libavfilter/vf_maskedclamp.c+2−4

         .name         = "bright",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad maskedclamp_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_maskedclamp = {
     .uninit        = uninit,
     .activate      = activate,
     .query_formats = query_formats,
-    .inputs        = maskedclamp_inputs,
+    FILTER_INPUTS(maskedclamp_inputs),
-    .outputs       = maskedclamp_outputs,
+    FILTER_OUTPUTS(maskedclamp_outputs),
     .priv_class    = &maskedclamp_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,

libavfilter/vf_maskedmerge.c+2−4

         .name         = "mask",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad maskedmerge_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_maskedmerge = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = maskedmerge_inputs,
+    FILTER_INPUTS(maskedmerge_inputs),
-    .outputs       = maskedmerge_outputs,
+    FILTER_OUTPUTS(maskedmerge_outputs),
     .priv_class    = &maskedmerge_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,

libavfilter/vf_maskedminmax.c+4−6

         .name         = "filter2",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad maskedminmax_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 #define maskedmin_options maskedminmax_options
     .uninit        = uninit,
     .activate      = activate,
     .query_formats = query_formats,
-    .inputs        = maskedminmax_inputs,
+    FILTER_INPUTS(maskedminmax_inputs),
-    .outputs       = maskedminmax_outputs,
+    FILTER_OUTPUTS(maskedminmax_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };
     .uninit        = uninit,
     .activate      = activate,
     .query_formats = query_formats,
-    .inputs        = maskedminmax_inputs,
+    FILTER_INPUTS(maskedminmax_inputs),
-    .outputs       = maskedminmax_outputs,
+    FILTER_OUTPUTS(maskedminmax_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_maskedthreshold.c+2−4

         .name         = "reference",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad maskedthreshold_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(maskedthreshold);
     .uninit        = uninit,
     .activate      = activate,
     .query_formats = query_formats,
-    .inputs        = maskedthreshold_inputs,
+    FILTER_INPUTS(maskedthreshold_inputs),
-    .outputs       = maskedthreshold_outputs,
+    FILTER_OUTPUTS(maskedthreshold_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_maskfun.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad maskfun_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_maskfun = {
     .priv_size     = sizeof(MaskFunContext),
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = maskfun_inputs,
+    FILTER_INPUTS(maskfun_inputs),
-    .outputs       = maskfun_outputs,
+    FILTER_OUTPUTS(maskfun_outputs),
     .priv_class    = &maskfun_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,

libavfilter/vf_mcdeint.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad mcdeint_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_mcdeint = {
     .priv_size     = sizeof(MCDeintContext),
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = mcdeint_inputs,
+    FILTER_INPUTS(mcdeint_inputs),
-    .outputs       = mcdeint_outputs,
+    FILTER_OUTPUTS(mcdeint_outputs),
     .priv_class    = &mcdeint_class,
 };

libavfilter/vf_median.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad median_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_median = {
     .priv_class    = &median_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = median_inputs,
+    FILTER_INPUTS(median_inputs),
-    .outputs       = median_outputs,
+    FILTER_OUTPUTS(median_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_mergeplanes.c+1−2

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_mergeplanes = {
     .query_formats = query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = mergeplanes_outputs,
+    FILTER_OUTPUTS(mergeplanes_outputs),
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/vf_mestimate.c+2−4

         .filter_frame  = filter_frame,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad mestimate_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_mestimate = {
     .priv_class    = &mestimate_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = mestimate_inputs,
+    FILTER_INPUTS(mestimate_inputs),
-    .outputs       = mestimate_outputs,
+    FILTER_OUTPUTS(mestimate_outputs),
 };

libavfilter/vf_midequalizer.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input1,
     },
-    { NULL }
 };
 static const AVFilterPad midequalizer_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_midequalizer = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = midequalizer_inputs,
+    FILTER_INPUTS(midequalizer_inputs),
-    .outputs       = midequalizer_outputs,
+    FILTER_OUTPUTS(midequalizer_outputs),
     .priv_class    = &midequalizer_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_minterpolate.c+2−4

         .filter_frame  = filter_frame,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad minterpolate_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_minterpolate = {
     .priv_class    = &minterpolate_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = minterpolate_inputs,
+    FILTER_INPUTS(minterpolate_inputs),
-    .outputs       = minterpolate_outputs,
+    FILTER_OUTPUTS(minterpolate_outputs),
 };

libavfilter/vf_misc_vaapi.c+4−6

         .filter_frame = &misc_vaapi_filter_frame,
         .config_props = &ff_vaapi_vpp_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad misc_vaapi_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_vaapi_vpp_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_denoise_vaapi = {
     .init          = &denoise_vaapi_init,
     .uninit        = &ff_vaapi_vpp_ctx_uninit,
     .query_formats = &ff_vaapi_vpp_query_formats,
-    .inputs        = misc_vaapi_inputs,
+    FILTER_INPUTS(misc_vaapi_inputs),
-    .outputs       = misc_vaapi_outputs,
+    FILTER_OUTPUTS(misc_vaapi_outputs),
     .priv_class    = &denoise_vaapi_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
     .init          = &sharpness_vaapi_init,
     .uninit        = &ff_vaapi_vpp_ctx_uninit,
     .query_formats = &ff_vaapi_vpp_query_formats,
-    .inputs        = misc_vaapi_inputs,
+    FILTER_INPUTS(misc_vaapi_inputs),
-    .outputs       = misc_vaapi_outputs,
+    FILTER_OUTPUTS(misc_vaapi_outputs),
     .priv_class    = &sharpness_vaapi_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_mix.c+3−5

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 #if CONFIG_MIX_FILTER
     .priv_size     = sizeof(MixContext),
     .priv_class    = &mix_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .init          = init,
     .uninit        = uninit,
     .activate      = activate,
         .type          = AVMEDIA_TYPE_VIDEO,
         .filter_frame  = tmix_filter_frame,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(tmix);
     .priv_size     = sizeof(MixContext),
     .priv_class    = &tmix_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
     .init          = init,
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,

libavfilter/vf_monochrome.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad monochrome_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(MonochromeContext, x)
     .priv_size     = sizeof(MonochromeContext),
     .priv_class    = &monochrome_class,
     .query_formats = query_formats,
-    .inputs        = monochrome_inputs,
+    FILTER_INPUTS(monochrome_inputs),
-    .outputs       = monochrome_outputs,
+    FILTER_OUTPUTS(monochrome_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_mpdecimate.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad mpdecimate_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_mpdecimate = {
     .priv_size     = sizeof(DecimateContext),
     .priv_class    = &mpdecimate_class,
     .query_formats = query_formats,
-    .inputs        = mpdecimate_inputs,
+    FILTER_INPUTS(mpdecimate_inputs),
-    .outputs       = mpdecimate_outputs,
+    FILTER_OUTPUTS(mpdecimate_outputs),
 };

libavfilter/vf_neighbor.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad neighbor_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(NContext, x)
     .priv_size     = sizeof(NContext),                       \
     .priv_class    = &name_##_class,                         \
     .query_formats = query_formats,                          \
-    .inputs        = neighbor_inputs,                        \
+    FILTER_INPUTS(neighbor_inputs),                          \
-    .outputs       = neighbor_outputs,                       \
+    FILTER_OUTPUTS(neighbor_outputs),                        \
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC| \
                      AVFILTER_FLAG_SLICE_THREADS,            \
     .process_command = ff_filter_process_command,            \

libavfilter/vf_neighbor_opencl.c+4−6

         .filter_frame = &neighbor_opencl_filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad neighbor_opencl_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(NeighborOpenCLContext, x)
     .init           = &ff_opencl_filter_init,
     .uninit         = &neighbor_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = neighbor_opencl_inputs,
+    FILTER_INPUTS(neighbor_opencl_inputs),
-    .outputs        = neighbor_opencl_outputs,
+    FILTER_OUTPUTS(neighbor_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
     .init           = &ff_opencl_filter_init,
     .uninit         = &neighbor_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = neighbor_opencl_inputs,
+    FILTER_INPUTS(neighbor_opencl_inputs),
-    .outputs        = neighbor_opencl_outputs,
+    FILTER_OUTPUTS(neighbor_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_nlmeans.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad nlmeans_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_nlmeans = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = nlmeans_inputs,
+    FILTER_INPUTS(nlmeans_inputs),
-    .outputs       = nlmeans_outputs,
+    FILTER_OUTPUTS(nlmeans_outputs),
     .priv_class    = &nlmeans_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_nlmeans_opencl.c+2−4

         .filter_frame = &nlmeans_opencl_filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad nlmeans_opencl_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_nlmeans_opencl = {
     .init           = &ff_opencl_filter_init,
     .uninit         = &nlmeans_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = nlmeans_opencl_inputs,
+    FILTER_INPUTS(nlmeans_opencl_inputs),
-    .outputs        = nlmeans_opencl_outputs,
+    FILTER_OUTPUTS(nlmeans_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_nnedi.c+2−4

         .filter_frame  = filter_frame,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_nnedi = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_noise.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad noise_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_noise = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = noise_inputs,
+    FILTER_INPUTS(noise_inputs),
-    .outputs       = noise_outputs,
+    FILTER_OUTPUTS(noise_outputs),
     .priv_class    = &noise_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_normalize.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_normalize = {
     .priv_class    = &normalize_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_null.c+2−4

         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_null_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_null = {
     .name        = "null",
     .description = NULL_IF_CONFIG_SMALL("Pass the source unchanged to the output."),
-    .inputs      = avfilter_vf_null_inputs,
+    FILTER_INPUTS(avfilter_vf_null_inputs),
-    .outputs     = avfilter_vf_null_outputs,
+    FILTER_OUTPUTS(avfilter_vf_null_outputs),
 };

libavfilter/vf_ocr.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad ocr_outputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_ocr = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = ocr_inputs,
+    FILTER_INPUTS(ocr_inputs),
-    .outputs       = ocr_outputs,
+    FILTER_OUTPUTS(ocr_outputs),
 };

libavfilter/vf_overlay.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_overlay,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_overlay_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_overlay = {
     .query_formats = query_formats,
     .activate      = activate,
     .process_command = process_command,
-    .inputs        = avfilter_vf_overlay_inputs,
+    FILTER_INPUTS(avfilter_vf_overlay_inputs),
-    .outputs       = avfilter_vf_overlay_outputs,
+    FILTER_OUTPUTS(avfilter_vf_overlay_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_overlay_cuda.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_overlay,
     },
-    { NULL }
 };
 static const AVFilterPad overlay_cuda_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = &overlay_cuda_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_overlay_cuda = {
     .uninit          = &overlay_cuda_uninit,
     .activate        = &overlay_cuda_activate,
     .query_formats   = &overlay_cuda_query_formats,
-    .inputs          = overlay_cuda_inputs,
+    FILTER_INPUTS(overlay_cuda_inputs),
-    .outputs         = overlay_cuda_outputs,
+    FILTER_OUTPUTS(overlay_cuda_outputs),
     .preinit         = overlay_cuda_framesync_preinit,
     .flags_internal  = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_overlay_opencl.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad overlay_opencl_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = &overlay_opencl_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_overlay_opencl = {
     .uninit          = &overlay_opencl_uninit,
     .query_formats   = &ff_opencl_filter_query_formats,
     .activate        = &overlay_opencl_activate,
-    .inputs          = overlay_opencl_inputs,
+    FILTER_INPUTS(overlay_opencl_inputs),
-    .outputs         = overlay_opencl_outputs,
+    FILTER_OUTPUTS(overlay_opencl_outputs),
     .flags_internal  = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_overlay_qsv.c+2−4

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_overlay_input,
     },
-    { NULL }
 };
 static const AVFilterPad overlay_qsv_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_overlay_qsv = {
     .init           = overlay_qsv_init,
     .uninit         = overlay_qsv_uninit,
     .activate       = activate,
-    .inputs         = overlay_qsv_inputs,
+    FILTER_INPUTS(overlay_qsv_inputs),
-    .outputs        = overlay_qsv_outputs,
+    FILTER_OUTPUTS(overlay_qsv_outputs),
     .priv_class     = &overlay_qsv_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_overlay_vulkan.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_vk_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad overlay_vulkan_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &overlay_vulkan_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_overlay_vulkan = {
     .uninit         = &overlay_vulkan_uninit,
     .query_formats  = &ff_vk_filter_query_formats,
     .activate       = &overlay_vulkan_activate,
-    .inputs         = overlay_vulkan_inputs,
+    FILTER_INPUTS(overlay_vulkan_inputs),
-    .outputs        = overlay_vulkan_outputs,
+    FILTER_OUTPUTS(overlay_vulkan_outputs),
     .priv_class     = &overlay_vulkan_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_owdenoise.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad owdenoise_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_owdenoise = {
     .priv_size     = sizeof(OWDenoiseContext),
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = owdenoise_inputs,
+    FILTER_INPUTS(owdenoise_inputs),
-    .outputs       = owdenoise_outputs,
+    FILTER_OUTPUTS(owdenoise_outputs),
     .priv_class    = &owdenoise_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_pad.c+2−4

         .get_buffer.video = get_video_buffer,
         .filter_frame     = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_pad_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_pad = {
     .priv_size     = sizeof(PadContext),
     .priv_class    = &pad_class,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_pad_inputs,
+    FILTER_INPUTS(avfilter_vf_pad_inputs),
-    .outputs       = avfilter_vf_pad_outputs,
+    FILTER_OUTPUTS(avfilter_vf_pad_outputs),
 };

libavfilter/vf_pad_opencl.c+2−4

         .filter_frame = filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad pad_opencl_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &pad_opencl_config_output,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(PadOpenCLContext, x)
     .init           = &ff_opencl_filter_init,
     .uninit         = &pad_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = pad_opencl_inputs,
+    FILTER_INPUTS(pad_opencl_inputs),
-    .outputs        = pad_opencl_outputs,
+    FILTER_OUTPUTS(pad_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE
 };

libavfilter/vf_palettegen.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad palettegen_outputs[] = {
         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_palettegen = {
     .priv_size     = sizeof(PaletteGenContext),
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = palettegen_inputs,
+    FILTER_INPUTS(palettegen_inputs),
-    .outputs       = palettegen_outputs,
+    FILTER_OUTPUTS(palettegen_outputs),
     .priv_class    = &palettegen_class,
 };

libavfilter/vf_paletteuse.c+2−4

         .type           = AVMEDIA_TYPE_VIDEO,
         .config_props   = config_input_palette,
     },
-    { NULL }
 };
 static const AVFilterPad paletteuse_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_paletteuse = {
     .init          = init,
     .uninit        = uninit,
     .activate      = activate,
-    .inputs        = paletteuse_inputs,
+    FILTER_INPUTS(paletteuse_inputs),
-    .outputs       = paletteuse_outputs,
+    FILTER_OUTPUTS(paletteuse_outputs),
     .priv_class    = &paletteuse_class,
 };

libavfilter/vf_perspective.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad perspective_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_perspective = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = perspective_inputs,
+    FILTER_INPUTS(perspective_inputs),
-    .outputs       = perspective_outputs,
+    FILTER_OUTPUTS(perspective_outputs),
     .priv_class    = &perspective_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_phase.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad phase_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_phase = {
     .priv_class    = &phase_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = phase_inputs,
+    FILTER_INPUTS(phase_inputs),
-    .outputs       = phase_outputs,
+    FILTER_OUTPUTS(phase_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_photosensitivity.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_photosensitivity = {
     .priv_class    = &photosensitivity_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/vf_pixdesctest.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_pixdesctest_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_pixdesctest = {
     .description = NULL_IF_CONFIG_SMALL("Test pixel format definitions."),
     .priv_size   = sizeof(PixdescTestContext),
     .uninit      = uninit,
-    .inputs      = avfilter_vf_pixdesctest_inputs,
+    FILTER_INPUTS(avfilter_vf_pixdesctest_inputs),
-    .outputs     = avfilter_vf_pixdesctest_outputs,
+    FILTER_OUTPUTS(avfilter_vf_pixdesctest_outputs),
 };

libavfilter/vf_pp.c+2−4

         .config_props = pp_config_props,
         .filter_frame = pp_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad pp_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_pp = {
     .init            = pp_init,
     .uninit          = pp_uninit,
     .query_formats   = pp_query_formats,
-    .inputs          = pp_inputs,
+    FILTER_INPUTS(pp_inputs),
-    .outputs         = pp_outputs,
+    FILTER_OUTPUTS(pp_outputs),
     .process_command = pp_process_command,
     .priv_class      = &pp_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

libavfilter/vf_pp7.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad pp7_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_pp7 = {
     .priv_size       = sizeof(PP7Context),
     .uninit          = uninit,
     .query_formats   = query_formats,
-    .inputs          = pp7_inputs,
+    FILTER_INPUTS(pp7_inputs),
-    .outputs         = pp7_outputs,
+    FILTER_OUTPUTS(pp7_outputs),
     .priv_class      = &pp7_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_premultiply.c+2−3

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 #if CONFIG_PREMULTIPLY_FILTER
     .query_formats = query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = premultiply_outputs,
+    FILTER_OUTPUTS(premultiply_outputs),
     .priv_class    = &premultiply_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_DYNAMIC_INPUTS |
     .query_formats = query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = premultiply_outputs,
+    FILTER_OUTPUTS(premultiply_outputs),
     .priv_class    = &unpremultiply_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                      AVFILTER_FLAG_DYNAMIC_INPUTS |

libavfilter/vf_procamp_vaapi.c+2−4

         .filter_frame = &procamp_vaapi_filter_frame,
         .config_props = &ff_vaapi_vpp_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad procamp_vaapi_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_vaapi_vpp_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_procamp_vaapi = {
     .init          = &procamp_vaapi_init,
     .uninit        = &ff_vaapi_vpp_ctx_uninit,
     .query_formats = &ff_vaapi_vpp_query_formats,
-    .inputs        = procamp_vaapi_inputs,
+    FILTER_INPUTS(procamp_vaapi_inputs),
-    .outputs       = procamp_vaapi_outputs,
+    FILTER_OUTPUTS(procamp_vaapi_outputs),
     .priv_class    = &procamp_vaapi_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_program_opencl.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &program_opencl_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_program_opencl = {
     .query_formats  = &ff_opencl_filter_query_formats,
     .activate       = &program_opencl_activate,
     .inputs         = NULL,
-    .outputs        = program_opencl_outputs,
+    FILTER_OUTPUTS(program_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
         .config_props  = &program_opencl_config_output,
         .request_frame = &program_opencl_request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_openclsrc = {
     .uninit         = &program_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
     .inputs         = NULL,
-    .outputs        = openclsrc_outputs,
+    FILTER_OUTPUTS(openclsrc_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_pseudocolor.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static av_cold void uninit(AVFilterContext *ctx)
     .priv_class    = &pseudocolor_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,
 };

libavfilter/vf_psnr.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_ref,
     },
-    { NULL }
 };
 static const AVFilterPad psnr_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_psnr = {
     .activate      = activate,
     .priv_size     = sizeof(PSNRContext),
     .priv_class    = &psnr_class,
-    .inputs        = psnr_inputs,
+    FILTER_INPUTS(psnr_inputs),
-    .outputs       = psnr_outputs,
+    FILTER_OUTPUTS(psnr_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_pullup.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad pullup_outputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_pullup = {
     .priv_class    = &pullup_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = pullup_inputs,
+    FILTER_INPUTS(pullup_inputs),
-    .outputs       = pullup_outputs,
+    FILTER_OUTPUTS(pullup_outputs),
 };

libavfilter/vf_qp.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad qp_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_qp = {
     .name          = "qp",
     .description   = NULL_IF_CONFIG_SMALL("Change video quantization parameters."),
     .priv_size     = sizeof(QPContext),
-    .inputs        = qp_inputs,
+    FILTER_INPUTS(qp_inputs),
-    .outputs       = qp_outputs,
+    FILTER_OUTPUTS(qp_outputs),
     .priv_class    = &qp_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_random.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad random_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_random = {
     .priv_class  = &random_class,
     .init        = init,
     .uninit      = uninit,
-    .inputs      = random_inputs,
+    FILTER_INPUTS(random_inputs),
-    .outputs     = random_outputs,
+    FILTER_OUTPUTS(random_outputs),
 };

libavfilter/vf_readeia608.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad readeia608_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_readeia608 = {
     .priv_size     = sizeof(ReadEIA608Context),
     .priv_class    = &readeia608_class,
     .query_formats = query_formats,
-    .inputs        = readeia608_inputs,
+    FILTER_INPUTS(readeia608_inputs),
-    .outputs       = readeia608_outputs,
+    FILTER_OUTPUTS(readeia608_outputs),
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,

libavfilter/vf_readvitc.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_readvitc = {
     .description   = NULL_IF_CONFIG_SMALL("Read vertical interval timecode and write it to frame metadata."),
     .priv_size     = sizeof(ReadVitcContext),
     .priv_class    = &readvitc_class,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .init          = init,
     .query_formats = query_formats,
 };

libavfilter/vf_remap.c+2−4

         .name         = "ymap",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad remap_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_remap = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = remap_inputs,
+    FILTER_INPUTS(remap_inputs),
-    .outputs       = remap_outputs,
+    FILTER_OUTPUTS(remap_outputs),
     .priv_class    = &remap_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_removegrain.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad removegrain_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_removegrain = {
     .description   = NULL_IF_CONFIG_SMALL("Remove grain."),
     .priv_size     = sizeof(RemoveGrainContext),
     .query_formats = query_formats,
-    .inputs        = removegrain_inputs,
+    FILTER_INPUTS(removegrain_inputs),
-    .outputs       = removegrain_outputs,
+    FILTER_OUTPUTS(removegrain_outputs),
     .priv_class    = &removegrain_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_removelogo.c+2−4

         .config_props = config_props_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad removelogo_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_removelogo = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = removelogo_inputs,
+    FILTER_INPUTS(removelogo_inputs),
-    .outputs       = removelogo_outputs,
+    FILTER_OUTPUTS(removelogo_outputs),
     .priv_class    = &removelogo_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_repeatfields.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad repeatfields_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_repeatfields = {
     .description   = NULL_IF_CONFIG_SMALL("Hard repeat fields based on MPEG repeat field flag."),
     .priv_size     = sizeof(RepeatFieldsContext),
     .uninit        = uninit,
-    .inputs        = repeatfields_inputs,
+    FILTER_INPUTS(repeatfields_inputs),
-    .outputs       = repeatfields_outputs,
+    FILTER_OUTPUTS(repeatfields_outputs),
     .query_formats = query_formats,
 };

libavfilter/vf_rotate.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad rotate_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_rotate = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .process_command = process_command,
-    .inputs        = rotate_inputs,
+    FILTER_INPUTS(rotate_inputs),
-    .outputs       = rotate_outputs,
+    FILTER_OUTPUTS(rotate_outputs),
     .priv_class    = &rotate_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_sab.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad sab_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_sab = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = sab_inputs,
+    FILTER_INPUTS(sab_inputs),
-    .outputs       = sab_outputs,
+    FILTER_OUTPUTS(sab_outputs),
     .priv_class    = &sab_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_scale.c+4−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_scale_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scale = {
     .query_formats   = query_formats,
     .priv_size       = sizeof(ScaleContext),
     .priv_class      = &scale_class,
-    .inputs          = avfilter_vf_scale_inputs,
+    FILTER_INPUTS(avfilter_vf_scale_inputs),
-    .outputs         = avfilter_vf_scale_outputs,
+    FILTER_OUTPUTS(avfilter_vf_scale_outputs),
     .process_command = process_command,
 };
         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame_ref,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_scale2ref_outputs[] = {
         .config_props = config_props_ref,
         .request_frame= request_frame_ref,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scale2ref = {
     .query_formats   = query_formats,
     .priv_size       = sizeof(ScaleContext),
     .priv_class      = &scale2ref_class,
-    .inputs          = avfilter_vf_scale2ref_inputs,
+    FILTER_INPUTS(avfilter_vf_scale2ref_inputs),
-    .outputs         = avfilter_vf_scale2ref_outputs,
+    FILTER_OUTPUTS(avfilter_vf_scale2ref_outputs),
     .process_command = process_command,
 };

libavfilter/vf_scale_cuda.c+2−4

         .filter_frame = cudascale_filter_frame,
         .get_buffer.video = cudascale_get_video_buffer,
     },
-    { NULL }
 };
 static const AVFilterPad cudascale_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = cudascale_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scale_cuda = {
     .priv_size = sizeof(CUDAScaleContext),
     .priv_class = &cudascale_class,
-    .inputs    = cudascale_inputs,
+    FILTER_INPUTS(cudascale_inputs),
-    .outputs   = cudascale_outputs,
+    FILTER_OUTPUTS(cudascale_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_scale_npp.c+2−4

         .type        = AVMEDIA_TYPE_VIDEO,
         .filter_frame = nppscale_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad nppscale_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = nppscale_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scale_npp = {
     .priv_size = sizeof(NPPScaleContext),
     .priv_class = &nppscale_class,
-    .inputs    = nppscale_inputs,
+    FILTER_INPUTS(nppscale_inputs),
-    .outputs   = nppscale_outputs,
+    FILTER_OUTPUTS(nppscale_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_scale_qsv.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = qsvscale_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad qsvscale_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = qsvscale_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scale_qsv = {
     .priv_size = sizeof(QSVScaleContext),
     .priv_class = &qsvscale_class,
-    .inputs    = qsvscale_inputs,
+    FILTER_INPUTS(qsvscale_inputs),
-    .outputs   = qsvscale_outputs,
+    FILTER_OUTPUTS(qsvscale_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_scale_vaapi.c+2−4

         .filter_frame = &scale_vaapi_filter_frame,
         .config_props = &ff_vaapi_vpp_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad scale_vaapi_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &scale_vaapi_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scale_vaapi = {
     .init          = &scale_vaapi_init,
     .uninit        = &ff_vaapi_vpp_ctx_uninit,
     .query_formats = &ff_vaapi_vpp_query_formats,
-    .inputs        = scale_vaapi_inputs,
+    FILTER_INPUTS(scale_vaapi_inputs),
-    .outputs       = scale_vaapi_outputs,
+    FILTER_OUTPUTS(scale_vaapi_outputs),
     .priv_class    = &scale_vaapi_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_scale_vulkan.c+2−4

         .filter_frame = &scale_vulkan_filter_frame,
         .config_props = &ff_vk_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad scale_vulkan_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &scale_vulkan_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scale_vulkan = {
     .init           = &ff_vk_filter_init,
     .uninit         = &scale_vulkan_uninit,
     .query_formats  = &ff_vk_filter_query_formats,
-    .inputs         = scale_vulkan_inputs,
+    FILTER_INPUTS(scale_vulkan_inputs),
-    .outputs        = scale_vulkan_outputs,
+    FILTER_OUTPUTS(scale_vulkan_outputs),
     .priv_class     = &scale_vulkan_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_scdet.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad scdet_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scdet = {
     .priv_class    = &scdet_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = scdet_inputs,
+    FILTER_INPUTS(scdet_inputs),
-    .outputs       = scdet_outputs,
+    FILTER_OUTPUTS(scdet_outputs),
     .activate      = activate,
 };

libavfilter/vf_scroll.c+2−4

         .config_props   = config_input,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad scroll_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_scroll = {
     .priv_size     = sizeof(ScrollContext),
     .priv_class    = &scroll_class,
     .query_formats = query_formats,
-    .inputs        = scroll_inputs,
+    FILTER_INPUTS(scroll_inputs),
-    .outputs       = scroll_outputs,
+    FILTER_OUTPUTS(scroll_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_selectivecolor.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad selectivecolor_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_selectivecolor = {
     .description   = NULL_IF_CONFIG_SMALL("Apply CMYK adjustments to specific color ranges."),
     .priv_size     = sizeof(SelectiveColorContext),
     .query_formats = query_formats,
-    .inputs        = selectivecolor_inputs,
+    FILTER_INPUTS(selectivecolor_inputs),
-    .outputs       = selectivecolor_outputs,
+    FILTER_OUTPUTS(selectivecolor_outputs),
     .priv_class    = &selectivecolor_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_separatefields.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad separatefields_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_props_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_separatefields = {
     .priv_size   = sizeof(SeparateFieldsContext),
     .activate    = activate,
     .uninit      = uninit,
-    .inputs      = separatefields_inputs,
+    FILTER_INPUTS(separatefields_inputs),
-    .outputs     = separatefields_outputs,
+    FILTER_OUTPUTS(separatefields_outputs),
 };

libavfilter/vf_setparams.c+6−8

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_setparams = {
     .description = NULL_IF_CONFIG_SMALL("Force field, or color property for the output video frame."),
     .priv_size   = sizeof(SetParamsContext),
     .priv_class  = &setparams_class,
-    .inputs      = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs     = outputs,
+    FILTER_OUTPUTS(outputs),
 };
 #if CONFIG_SETRANGE_FILTER
     .priv_size   = sizeof(SetParamsContext),
     .init        = init_setrange,
     .priv_class  = &setrange_class,
-    .inputs      = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs     = outputs,
+    FILTER_OUTPUTS(outputs),
 };
 #endif /* CONFIG_SETRANGE_FILTER */
     .priv_size   = sizeof(SetParamsContext),
     .init        = init_setfield,
     .priv_class  = &setfield_class,
-    .inputs      = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs     = outputs,
+    FILTER_OUTPUTS(outputs),
 };
 #endif /* CONFIG_SETFIELD_FILTER */

libavfilter/vf_shear.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_shear = {
     .priv_size       = sizeof(ShearContext),
     .init            = init,
     .query_formats   = query_formats,
-    .inputs          = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs         = outputs,
+    FILTER_OUTPUTS(outputs),
     .priv_class      = &shear_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,

libavfilter/vf_showinfo.c+2−4

         .filter_frame     = filter_frame,
         .config_props     = config_props_in,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_showinfo_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_props_out,
     },
-    { NULL }
 };
 const AVFilter ff_vf_showinfo = {
     .name        = "showinfo",
     .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
-    .inputs      = avfilter_vf_showinfo_inputs,
+    FILTER_INPUTS(avfilter_vf_showinfo_inputs),
-    .outputs     = avfilter_vf_showinfo_outputs,
+    FILTER_OUTPUTS(avfilter_vf_showinfo_outputs),
     .priv_size   = sizeof(ShowInfoContext),
     .priv_class  = &showinfo_class,
 };

libavfilter/vf_showpalette.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad showpalette_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_showpalette = {
     .description   = NULL_IF_CONFIG_SMALL("Display frame palette."),
     .priv_size     = sizeof(ShowPaletteContext),
     .query_formats = query_formats,
-    .inputs        = showpalette_inputs,
+    FILTER_INPUTS(showpalette_inputs),
-    .outputs       = showpalette_outputs,
+    FILTER_OUTPUTS(showpalette_outputs),
     .priv_class    = &showpalette_class,
 };

libavfilter/vf_shuffleframes.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL },
 };
 static const AVFilterPad shuffleframes_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL },
 };
 const AVFilter ff_vf_shuffleframes = {
     .priv_class    = &shuffleframes_class,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = shuffleframes_inputs,
+    FILTER_INPUTS(shuffleframes_inputs),
-    .outputs       = shuffleframes_outputs,
+    FILTER_OUTPUTS(shuffleframes_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_shufflepixels.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL },
 };
 static const AVFilterPad shufflepixels_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL },
 };
 const AVFilter ff_vf_shufflepixels = {
     .priv_class    = &shufflepixels_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = shufflepixels_inputs,
+    FILTER_INPUTS(shufflepixels_inputs),
-    .outputs       = shufflepixels_outputs,
+    FILTER_OUTPUTS(shufflepixels_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_shuffleplanes.c+2−4

         .config_props     = shuffleplanes_config_input,
         .filter_frame     = shuffleplanes_filter_frame,
     },
-    { NULL },
 };
 static const AVFilterPad shuffleplanes_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL },
 };
 const AVFilter ff_vf_shuffleplanes = {
     .priv_size    = sizeof(ShufflePlanesContext),
     .priv_class   = &shuffleplanes_class,
     .query_formats = query_formats,
-    .inputs       = shuffleplanes_inputs,
+    FILTER_INPUTS(shuffleplanes_inputs),
-    .outputs      = shuffleplanes_outputs,
+    FILTER_OUTPUTS(shuffleplanes_outputs),
     .flags        = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_signalstats.c+2−4

         .type           = AVMEDIA_TYPE_VIDEO,
         .filter_frame   = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad signalstats_outputs[] = {
         .config_props   = config_output,
         .type           = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_signalstats = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(SignalstatsContext),
-    .inputs        = signalstats_inputs,
+    FILTER_INPUTS(signalstats_inputs),
-    .outputs       = signalstats_outputs,
+    FILTER_OUTPUTS(signalstats_outputs),
     .priv_class    = &signalstats_class,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_signature.c+1−2

         .request_frame = request_frame,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_signature = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .outputs       = signature_outputs,
+    FILTER_OUTPUTS(signature_outputs),
     .inputs        = NULL,
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };

libavfilter/vf_smartblur.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad smartblur_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_smartblur = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = smartblur_inputs,
+    FILTER_INPUTS(smartblur_inputs),
-    .outputs       = smartblur_outputs,
+    FILTER_OUTPUTS(smartblur_outputs),
     .priv_class    = &smartblur_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_spp.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad spp_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_spp = {
     .init_dict       = init_dict,
     .uninit          = uninit,
     .query_formats   = query_formats,
-    .inputs          = spp_inputs,
+    FILTER_INPUTS(spp_inputs),
-    .outputs         = spp_outputs,
+    FILTER_OUTPUTS(spp_outputs),
     .process_command = process_command,
     .priv_class      = &spp_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,

libavfilter/vf_sr.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad sr_outputs[] = {
         .config_props = config_output,
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_sr = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = sr_inputs,
+    FILTER_INPUTS(sr_inputs),
-    .outputs       = sr_outputs,
+    FILTER_OUTPUTS(sr_outputs),
     .priv_class    = &sr_class,
 };

libavfilter/vf_ssim.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_ref,
     },
-    { NULL }
 };
 static const AVFilterPad ssim_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_ssim = {
     .activate      = activate,
     .priv_size     = sizeof(SSIMContext),
     .priv_class    = &ssim_class,
-    .inputs        = ssim_inputs,
+    FILTER_INPUTS(ssim_inputs),
-    .outputs       = ssim_outputs,
+    FILTER_OUTPUTS(ssim_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_stack.c+3−4

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 #if CONFIG_HSTACK_FILTER
     .priv_size     = sizeof(StackContext),
     .priv_class    = &hstack_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .init          = init,
     .uninit        = uninit,
     .activate      = activate,
     .priv_size     = sizeof(StackContext),
     .priv_class    = &vstack_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .init          = init,
     .uninit        = uninit,
     .activate      = activate,
     .priv_size     = sizeof(StackContext),
     .priv_class    = &xstack_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .init          = init,
     .uninit        = uninit,
     .activate      = activate,

libavfilter/vf_stereo3d.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad stereo3d_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_stereo3d = {
     .priv_size     = sizeof(Stereo3DContext),
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = stereo3d_inputs,
+    FILTER_INPUTS(stereo3d_inputs),
-    .outputs       = stereo3d_outputs,
+    FILTER_OUTPUTS(stereo3d_outputs),
     .priv_class    = &stereo3d_class,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_subtitles.c+4−6

         .filter_frame     = filter_frame,
         .config_props     = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad ass_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #if CONFIG_ASS_FILTER
     .init          = init_ass,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = ass_inputs,
+    FILTER_INPUTS(ass_inputs),
-    .outputs       = ass_outputs,
+    FILTER_OUTPUTS(ass_outputs),
     .priv_class    = &ass_class,
 };
 #endif
     .init          = init_subtitles,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = ass_inputs,
+    FILTER_INPUTS(ass_inputs),
-    .outputs       = ass_outputs,
+    FILTER_OUTPUTS(ass_outputs),
     .priv_class    = &subtitles_class,
 };
 #endif

libavfilter/vf_super2xsai.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad super2xsai_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_super2xsai = {
     .description   = NULL_IF_CONFIG_SMALL("Scale the input by 2x using the Super2xSaI pixel art algorithm."),
     .priv_size     = sizeof(Super2xSaIContext),
     .query_formats = query_formats,
-    .inputs        = super2xsai_inputs,
+    FILTER_INPUTS(super2xsai_inputs),
-    .outputs       = super2xsai_outputs,
+    FILTER_OUTPUTS(super2xsai_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_swaprect.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_swaprect = {
     .priv_class    = &swaprect_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_swapuv.c+2−4

         .get_buffer.video = get_video_buffer,
         .filter_frame     = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad swapuv_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_swapuv = {
     .query_formats = query_formats,
     .priv_size     = sizeof(SwapUVContext),
     .priv_class    = &swapuv_class,
-    .inputs        = swapuv_inputs,
+    FILTER_INPUTS(swapuv_inputs),
-    .outputs       = swapuv_outputs,
+    FILTER_OUTPUTS(swapuv_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_telecine.c+2−4

         .filter_frame  = filter_frame,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad telecine_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_telecine = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = telecine_inputs,
+    FILTER_INPUTS(telecine_inputs),
-    .outputs       = telecine_outputs,
+    FILTER_OUTPUTS(telecine_outputs),
 };

libavfilter/vf_threshold.c+2−4

         .name         = "max",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_threshold = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_thumbnail.c+2−4

         .config_props = config_props,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad thumbnail_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_thumbnail = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = thumbnail_inputs,
+    FILTER_INPUTS(thumbnail_inputs),
-    .outputs       = thumbnail_outputs,
+    FILTER_OUTPUTS(thumbnail_outputs),
     .priv_class    = &thumbnail_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_thumbnail_cuda.c+2−4

         .config_props = config_props,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad thumbnail_cuda_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_thumbnail_cuda = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = thumbnail_cuda_inputs,
+    FILTER_INPUTS(thumbnail_cuda_inputs),
-    .outputs       = thumbnail_cuda_outputs,
+    FILTER_OUTPUTS(thumbnail_cuda_outputs),
     .priv_class    = &thumbnail_cuda_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_tile.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad tile_outputs[] = {
         .config_props  = config_props,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tile = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(TileContext),
-    .inputs        = tile_inputs,
+    FILTER_INPUTS(tile_inputs),
-    .outputs       = tile_outputs,
+    FILTER_OUTPUTS(tile_outputs),
     .priv_class    = &tile_class,
 };

libavfilter/vf_tinterlace.c+4−6

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad tinterlace_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_out_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tinterlace = {
     .priv_size     = sizeof(TInterlaceContext),
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = tinterlace_inputs,
+    FILTER_INPUTS(tinterlace_inputs),
-    .outputs       = tinterlace_outputs,
+    FILTER_OUTPUTS(tinterlace_outputs),
     .priv_class    = &tinterlace_class,
 };
     .init          = init_interlace,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = tinterlace_inputs,
+    FILTER_INPUTS(tinterlace_inputs),
-    .outputs       = tinterlace_outputs,
+    FILTER_OUTPUTS(tinterlace_outputs),
     .priv_class    = &interlace_class,
 };

libavfilter/vf_tmidequalizer.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad tmidequalizer_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tmidequalizer = {
     .priv_size     = sizeof(TMidEqualizerContext),
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = tmidequalizer_inputs,
+    FILTER_INPUTS(tmidequalizer_inputs),
-    .outputs       = tmidequalizer_outputs,
+    FILTER_OUTPUTS(tmidequalizer_outputs),
     .priv_class    = &tmidequalizer_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_tonemap.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad tonemap_outputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tonemap = {
     .query_formats   = query_formats,
     .priv_size       = sizeof(TonemapContext),
     .priv_class      = &tonemap_class,
-    .inputs          = tonemap_inputs,
+    FILTER_INPUTS(tonemap_inputs),
-    .outputs         = tonemap_outputs,
+    FILTER_OUTPUTS(tonemap_outputs),
     .flags           = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_tonemap_opencl.c+2−4

         .filter_frame = &tonemap_opencl_filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad tonemap_opencl_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &tonemap_opencl_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tonemap_opencl = {
     .init           = &ff_opencl_filter_init,
     .uninit         = &tonemap_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = tonemap_opencl_inputs,
+    FILTER_INPUTS(tonemap_opencl_inputs),
-    .outputs        = tonemap_opencl_outputs,
+    FILTER_OUTPUTS(tonemap_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_tonemap_vaapi.c+2−4

         .filter_frame = &tonemap_vaapi_filter_frame,
         .config_props = &ff_vaapi_vpp_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad tonemap_vaapi_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_vaapi_vpp_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tonemap_vaapi = {
     .init           = &tonemap_vaapi_init,
     .uninit         = &ff_vaapi_vpp_ctx_uninit,
     .query_formats  = &ff_vaapi_vpp_query_formats,
-    .inputs         = tonemap_vaapi_inputs,
+    FILTER_INPUTS(tonemap_vaapi_inputs),
-    .outputs        = tonemap_vaapi_outputs,
+    FILTER_OUTPUTS(tonemap_vaapi_outputs),
     .priv_class     = &tonemap_vaapi_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_tpad.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad tpad_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_tpad = {
     .query_formats = query_formats,
     .activate      = activate,
     .uninit        = uninit,
-    .inputs        = tpad_inputs,
+    FILTER_INPUTS(tpad_inputs),
-    .outputs       = tpad_outputs,
+    FILTER_OUTPUTS(tpad_outputs),
 };

libavfilter/vf_transpose.c+2−4

         .get_buffer.video = get_video_buffer,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_transpose_outputs[] = {
         .config_props = config_props_output,
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_transpose = {
     .priv_size     = sizeof(TransContext),
     .priv_class    = &transpose_class,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_transpose_inputs,
+    FILTER_INPUTS(avfilter_vf_transpose_inputs),
-    .outputs       = avfilter_vf_transpose_outputs,
+    FILTER_OUTPUTS(avfilter_vf_transpose_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_transpose_npp.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = npptranspose_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad npptranspose_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = npptranspose_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_transpose_npp = {
     .query_formats  = npptranspose_query_formats,
     .priv_size      = sizeof(NPPTransposeContext),
     .priv_class     = &npptranspose_class,
-    .inputs         = npptranspose_inputs,
+    FILTER_INPUTS(npptranspose_inputs),
-    .outputs        = npptranspose_outputs,
+    FILTER_OUTPUTS(npptranspose_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_transpose_opencl.c+2−4

         .filter_frame = &transpose_opencl_filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad transpose_opencl_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &transpose_opencl_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_transpose_opencl = {
     .init           = &ff_opencl_filter_init,
     .uninit         = &transpose_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = transpose_opencl_inputs,
+    FILTER_INPUTS(transpose_opencl_inputs),
-    .outputs        = transpose_opencl_outputs,
+    FILTER_OUTPUTS(transpose_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_transpose_vaapi.c+2−4

         .get_buffer.video = get_video_buffer,
         .config_props = &ff_vaapi_vpp_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad transpose_vaapi_outputs[] = {
         .type = AVMEDIA_TYPE_VIDEO,
         .config_props = &transpose_vaapi_vpp_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_transpose_vaapi = {
     .init           = &transpose_vaapi_init,
     .uninit         = &ff_vaapi_vpp_ctx_uninit,
     .query_formats  = &ff_vaapi_vpp_query_formats,
-    .inputs         = transpose_vaapi_inputs,
+    FILTER_INPUTS(transpose_vaapi_inputs),
-    .outputs        = transpose_vaapi_outputs,
+    FILTER_OUTPUTS(transpose_vaapi_outputs),
     .priv_class     = &transpose_vaapi_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_unsharp.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_unsharp_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_unsharp = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_unsharp_inputs,
+    FILTER_INPUTS(avfilter_vf_unsharp_inputs),
-    .outputs       = avfilter_vf_unsharp_outputs,
+    FILTER_OUTPUTS(avfilter_vf_unsharp_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_unsharp_opencl.c+2−4

         .filter_frame = &unsharp_opencl_filter_frame,
         .config_props = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad unsharp_opencl_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = &ff_opencl_filter_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_unsharp_opencl = {
     .init           = &ff_opencl_filter_init,
     .uninit         = &unsharp_opencl_uninit,
     .query_formats  = &ff_opencl_filter_query_formats,
-    .inputs         = unsharp_opencl_inputs,
+    FILTER_INPUTS(unsharp_opencl_inputs),
-    .outputs        = unsharp_opencl_outputs,
+    FILTER_OUTPUTS(unsharp_opencl_outputs),
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_untile.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad untile_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_untile = {
     .query_formats = query_formats,
     .activate      = activate,
     .priv_size     = sizeof(UntileContext),
-    .inputs        = untile_inputs,
+    FILTER_INPUTS(untile_inputs),
-    .outputs       = untile_outputs,
+    FILTER_OUTPUTS(untile_outputs),
     .priv_class    = &untile_class,
 };

libavfilter/vf_uspp.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad uspp_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_uspp = {
     .priv_size       = sizeof(USPPContext),
     .uninit          = uninit,
     .query_formats   = query_formats,
-    .inputs          = uspp_inputs,
+    FILTER_INPUTS(uspp_inputs),
-    .outputs         = uspp_outputs,
+    FILTER_OUTPUTS(uspp_outputs),
     .priv_class      = &uspp_class,
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };

libavfilter/vf_v360.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_v360 = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .priv_class    = &v360_class,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
     .process_command = process_command,

libavfilter/vf_vaguedenoiser.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO
     },
-    { NULL }
 };
 const AVFilter ff_vf_vaguedenoiser = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = vaguedenoiser_inputs,
+    FILTER_INPUTS(vaguedenoiser_inputs),
-    .outputs       = vaguedenoiser_outputs,
+    FILTER_OUTPUTS(vaguedenoiser_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_vectorscope.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vectorscope = {
     .priv_class    = &vectorscope_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/vf_vflip.c+2−4

         .filter_frame     = filter_frame,
         .config_props     = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_vflip_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vflip = {
     .description = NULL_IF_CONFIG_SMALL("Flip the input video vertically."),
     .priv_size   = sizeof(FlipContext),
     .priv_class  = &vflip_class,
-    .inputs      = avfilter_vf_vflip_inputs,
+    FILTER_INPUTS(avfilter_vf_vflip_inputs),
-    .outputs     = avfilter_vf_vflip_outputs,
+    FILTER_OUTPUTS(avfilter_vf_vflip_outputs),
     .flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_vfrdet.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad vfrdet_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vfrdet = {
     .priv_size   = sizeof(VFRDETContext),
     .init        = init,
     .uninit      = uninit,
-    .inputs      = vfrdet_inputs,
+    FILTER_INPUTS(vfrdet_inputs),
-    .outputs     = vfrdet_outputs,
+    FILTER_OUTPUTS(vfrdet_outputs),
 };

libavfilter/vf_vibrance.c+2−4

         .filter_frame   = filter_frame,
         .config_props   = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad vibrance_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(VibranceContext, x)
     .priv_size     = sizeof(VibranceContext),
     .priv_class    = &vibrance_class,
     .query_formats = query_formats,
-    .inputs        = vibrance_inputs,
+    FILTER_INPUTS(vibrance_inputs),
-    .outputs       = vibrance_outputs,
+    FILTER_OUTPUTS(vibrance_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_vidstabdetect.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_vidstabdetect_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vidstabdetect = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_vidstabdetect_inputs,
+    FILTER_INPUTS(avfilter_vf_vidstabdetect_inputs),
-    .outputs       = avfilter_vf_vidstabdetect_outputs,
+    FILTER_OUTPUTS(avfilter_vf_vidstabdetect_outputs),
     .priv_class    = &vidstabdetect_class,
 };

libavfilter/vf_vidstabtransform.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_vidstabtransform_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vidstabtransform = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_vidstabtransform_inputs,
+    FILTER_INPUTS(avfilter_vf_vidstabtransform_inputs),
-    .outputs       = avfilter_vf_vidstabtransform_outputs,
+    FILTER_OUTPUTS(avfilter_vf_vidstabtransform_outputs),
     .priv_class    = &vidstabtransform_class,
 };

libavfilter/vf_vif.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_ref,
     },
-    { NULL }
 };
 static const AVFilterPad vif_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vif = {
     .priv_size     = sizeof(VIFContext),
     .priv_class    = &vif_class,
     .activate      = activate,
-    .inputs        = vif_inputs,
+    FILTER_INPUTS(vif_inputs),
-    .outputs       = vif_outputs,
+    FILTER_OUTPUTS(vif_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_vignette.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_props,
     },
-    { NULL }
 };
 static const AVFilterPad vignette_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vignette = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = vignette_inputs,
+    FILTER_INPUTS(vignette_inputs),
-    .outputs       = vignette_outputs,
+    FILTER_OUTPUTS(vignette_outputs),
     .priv_class    = &vignette_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };

libavfilter/vf_vmafmotion.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input_ref,
     },
-    { NULL }
 };
 static const AVFilterPad vmafmotion_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vmafmotion = {
     .query_formats = query_formats,
     .priv_size     = sizeof(VMAFMotionContext),
     .priv_class    = &vmafmotion_class,
-    .inputs        = vmafmotion_inputs,
+    FILTER_INPUTS(vmafmotion_inputs),
-    .outputs       = vmafmotion_outputs,
+    FILTER_OUTPUTS(vmafmotion_outputs),
 };

libavfilter/vf_vpp_qsv.c+2−4

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad vpp_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_vpp_qsv = {
     .query_formats = query_formats,
     .init          = vpp_init,
     .uninit        = vpp_uninit,
-    .inputs        = vpp_inputs,
+    FILTER_INPUTS(vpp_inputs),
-    .outputs       = vpp_outputs,
+    FILTER_OUTPUTS(vpp_outputs),
     .activate      = activate,
     .priv_class    = &vpp_class,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,

libavfilter/vf_w3fdif.c+2−4

         .filter_frame  = filter_frame,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad w3fdif_outputs[] = {
         .config_props  = config_output,
         .request_frame = request_frame,
     },
-    { NULL }
 };
 const AVFilter ff_vf_w3fdif = {
     .priv_class    = &w3fdif_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = w3fdif_inputs,
+    FILTER_INPUTS(w3fdif_inputs),
-    .outputs       = w3fdif_outputs,
+    FILTER_OUTPUTS(w3fdif_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_waveform.c+2−4

         .filter_frame = filter_frame,
         .config_props = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_waveform = {
     .priv_class    = &waveform_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_weave.c+4−6

         .type             = AVMEDIA_TYPE_VIDEO,
         .filter_frame     = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad weave_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_props_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_weave = {
     .priv_class    = &weave_class,
     .query_formats = query_formats,
     .uninit        = uninit,
-    .inputs        = weave_inputs,
+    FILTER_INPUTS(weave_inputs),
-    .outputs       = weave_outputs,
+    FILTER_OUTPUTS(weave_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
-    .inputs        = weave_inputs,
+    FILTER_INPUTS(weave_inputs),
-    .outputs       = weave_outputs,
+    FILTER_OUTPUTS(weave_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_xbr.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad xbr_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_xbr = {
     .name          = "xbr",
     .description   = NULL_IF_CONFIG_SMALL("Scale the input using xBR algorithm."),
-    .inputs        = xbr_inputs,
+    FILTER_INPUTS(xbr_inputs),
-    .outputs       = xbr_outputs,
+    FILTER_OUTPUTS(xbr_outputs),
     .query_formats = query_formats,
     .priv_size     = sizeof(XBRContext),
     .priv_class    = &xbr_class,

libavfilter/vf_xfade.c+2−4

         .name          = "xfade",
         .type          = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad xfade_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_xfade = {
     .query_formats = query_formats,
     .activate      = xfade_activate,
     .uninit        = uninit,
-    .inputs        = xfade_inputs,
+    FILTER_INPUTS(xfade_inputs),
-    .outputs       = xfade_outputs,
+    FILTER_OUTPUTS(xfade_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_xfade_opencl.c+2−4

         .get_buffer.video = get_video_buffer,
         .config_props     = &ff_opencl_filter_config_input,
     },
-    { NULL }
 };
 static const AVFilterPad xfade_opencl_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = &xfade_opencl_config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_xfade_opencl = {
     .uninit          = &xfade_opencl_uninit,
     .query_formats   = &ff_opencl_filter_query_formats,
     .activate        = &xfade_opencl_activate,
-    .inputs          = xfade_opencl_inputs,
+    FILTER_INPUTS(xfade_opencl_inputs),
-    .outputs         = xfade_opencl_outputs,
+    FILTER_OUTPUTS(xfade_opencl_outputs),
     .flags_internal  = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_xmedian.c+3−6

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 #if CONFIG_XMEDIAN_FILTER
     .priv_size     = sizeof(XMedianContext),
     .priv_class    = &xmedian_class,
     .query_formats = query_formats,
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
     .preinit       = xmedian_framesync_preinit,
     .init          = init,
     .uninit        = uninit,
         .type          = AVMEDIA_TYPE_VIDEO,
         .filter_frame  = tmedian_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad tmedian_outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 AVFILTER_DEFINE_CLASS(tmedian);
     .priv_size     = sizeof(XMedianContext),
     .priv_class    = &tmedian_class,
     .query_formats = query_formats,
-    .inputs        = tmedian_inputs,
+    FILTER_INPUTS(tmedian_inputs),
-    .outputs       = tmedian_outputs,
+    FILTER_OUTPUTS(tmedian_outputs),
     .init          = init,
     .uninit        = uninit,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,

libavfilter/vf_yadif.c+2−4

         .type          = AVMEDIA_TYPE_VIDEO,
         .filter_frame  = ff_yadif_filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_yadif_outputs[] = {
         .request_frame = ff_yadif_request_frame,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_yadif = {
     .priv_class    = &yadif_class,
     .uninit        = uninit,
     .query_formats = query_formats,
-    .inputs        = avfilter_vf_yadif_inputs,
+    FILTER_INPUTS(avfilter_vf_yadif_inputs),
-    .outputs       = avfilter_vf_yadif_outputs,
+    FILTER_OUTPUTS(avfilter_vf_yadif_outputs),
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vf_yadif_cuda.c+2−4

         .filter_frame  = ff_yadif_filter_frame,
         .config_props  = config_input,
     },
-    { NULL }
 };
 static const AVFilterPad deint_cuda_outputs[] = {
         .request_frame = ff_yadif_request_frame,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_yadif_cuda = {
     .priv_class     = &yadif_cuda_class,
     .uninit         = deint_cuda_uninit,
     .query_formats  = deint_cuda_query_formats,
-    .inputs         = deint_cuda_inputs,
+    FILTER_INPUTS(deint_cuda_inputs),
-    .outputs        = deint_cuda_outputs,
+    FILTER_OUTPUTS(deint_cuda_outputs),
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };

libavfilter/vf_yaepblur.c+2−4

         .config_props = config_input,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad yaep_outputs[] = {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 #define OFFSET(x) offsetof(YAEPContext, x)
     .priv_class      = &yaepblur_class,
     .uninit          = uninit,
     .query_formats   = query_formats,
-    .inputs          = yaep_inputs,
+    FILTER_INPUTS(yaep_inputs),
-    .outputs         = yaep_outputs,
+    FILTER_OUTPUTS(yaep_outputs),
     .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
     .process_command = ff_filter_process_command,
 };

libavfilter/vf_zoompan.c+2−4

         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
     },
-    { NULL }
 };
 static const AVFilterPad outputs[] = {
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vf_zoompan = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .activate      = activate,
-    .inputs        = inputs,
+    FILTER_INPUTS(inputs),
-    .outputs       = outputs,
+    FILTER_OUTPUTS(outputs),
 };

libavfilter/vf_zscale.c+2−4

         .type         = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL }
 };
 static const AVFilterPad avfilter_vf_zscale_outputs[] = {
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vf_zscale = {
     .priv_size       = sizeof(ZScaleContext),
     .priv_class      = &zscale_class,
     .uninit          = uninit,
-    .inputs          = avfilter_vf_zscale_inputs,
+    FILTER_INPUTS(avfilter_vf_zscale_inputs),
-    .outputs         = avfilter_vf_zscale_outputs,
+    FILTER_OUTPUTS(avfilter_vf_zscale_outputs),
     .process_command = process_command,
 };

libavfilter/vsink_nullsink.c+1−2

         .type        = AVMEDIA_TYPE_VIDEO,
         .filter_frame = filter_frame,
     },
-    { NULL },
 };
 const AVFilter ff_vsink_nullsink = {
     .name        = "nullsink",
     .description = NULL_IF_CONFIG_SMALL("Do absolutely nothing with the input video."),
     .priv_size   = 0,
-    .inputs      = avfilter_vsink_nullsink_inputs,
+    FILTER_INPUTS(avfilter_vsink_nullsink_inputs),
     .outputs     = NULL,
 };

libavfilter/vsrc_cellauto.c+1−2

         .request_frame = request_frame,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_cellauto = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .inputs        = NULL,
-    .outputs       = cellauto_outputs,
+    FILTER_OUTPUTS(cellauto_outputs),
 };

libavfilter/vsrc_gradients.c+1−2

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_gradients = {
     .priv_class    = &gradients_class,
     .query_formats = query_formats,
     .inputs        = NULL,
-    .outputs       = gradients_outputs,
+    FILTER_OUTPUTS(gradients_outputs),
     .activate      = activate,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vsrc_life.c+1−2

         .request_frame = request_frame,
         .config_props  = config_props,
     },
-    { NULL}
 };
 const AVFilter ff_vsrc_life = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .inputs        = NULL,
-    .outputs       = life_outputs,
+    FILTER_OUTPUTS(life_outputs),
 };

libavfilter/vsrc_mandelbrot.c+1−2

         .request_frame = request_frame,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_mandelbrot = {
     .uninit        = uninit,
     .query_formats = query_formats,
     .inputs        = NULL,
-    .outputs       = mandelbrot_outputs,
+    FILTER_OUTPUTS(mandelbrot_outputs),
 };

libavfilter/vsrc_mptestsrc.c+1−2

         .request_frame = request_frame,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_mptestsrc = {
     .init          = init,
     .query_formats = query_formats,
     .inputs        = NULL,
-    .outputs       = mptestsrc_outputs,
+    FILTER_OUTPUTS(mptestsrc_outputs),
 };

libavfilter/vsrc_sierpinski.c+1−2

         .request_frame = sierpinski_request_frame,
         .config_props  = config_output,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_sierpinski = {
     .priv_class    = &sierpinski_class,
     .query_formats = query_formats,
     .inputs        = NULL,
-    .outputs       = sierpinski_outputs,
+    FILTER_OUTPUTS(sierpinski_outputs),
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };

libavfilter/vsrc_testsrc.c+13−23

         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = color_config_props,
     },
-    {  NULL }
 };
 const AVFilter ff_vsrc_color = {
     .activate        = activate,
     .query_formats   = color_query_formats,
     .inputs          = NULL,
-    .outputs         = color_outputs,
+    FILTER_OUTPUTS(color_outputs),
     .process_command = color_process_command,
 };
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = haldclutsrc_config_props,
     },
-    {  NULL }
 };
 const AVFilter ff_vsrc_haldclutsrc = {
     .query_formats = haldclutsrc_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = haldclutsrc_outputs,
+    FILTER_OUTPUTS(haldclutsrc_outputs),
 };
 #endif /* CONFIG_HALDCLUTSRC_FILTER */
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_props,
     },
-    { NULL },
 };
 const AVFilter ff_vsrc_nullsrc = {
     .priv_size   = sizeof(TestSourceContext),
     .priv_class  = &nullsrc_class,
     .inputs      = NULL,
-    .outputs     = nullsrc_outputs,
+    FILTER_OUTPUTS(nullsrc_outputs),
 };
 #endif /* CONFIG_NULLSRC_FILTER */
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_testsrc = {
     .query_formats = test_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = avfilter_vsrc_testsrc_outputs,
+    FILTER_OUTPUTS(avfilter_vsrc_testsrc_outputs),
 };
 #endif /* CONFIG_TESTSRC_FILTER */
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = test2_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_testsrc2 = {
     .query_formats = test2_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = avfilter_vsrc_testsrc2_outputs,
+    FILTER_OUTPUTS(avfilter_vsrc_testsrc2_outputs),
 };
 #endif /* CONFIG_TESTSRC2_FILTER */
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = rgbtest_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_rgbtestsrc = {
     .query_formats = rgbtest_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = avfilter_vsrc_rgbtestsrc_outputs,
+    FILTER_OUTPUTS(avfilter_vsrc_rgbtestsrc_outputs),
 };
 #endif /* CONFIG_RGBTESTSRC_FILTER */
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = yuvtest_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_yuvtestsrc = {
     .query_formats = yuvtest_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = avfilter_vsrc_yuvtestsrc_outputs,
+    FILTER_OUTPUTS(avfilter_vsrc_yuvtestsrc_outputs),
 };
 #endif /* CONFIG_YUVTESTSRC_FILTER */
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_props,
     },
-    { NULL }
 };
 #if CONFIG_PAL75BARS_FILTER
     .query_formats = smptebars_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = smptebars_outputs,
+    FILTER_OUTPUTS(smptebars_outputs),
 };
 #endif  /* CONFIG_PAL75BARS_FILTER */
     .query_formats = smptebars_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = smptebars_outputs,
+    FILTER_OUTPUTS(smptebars_outputs),
 };
 #endif  /* CONFIG_PAL100BARS_FILTER */
     .query_formats = smptebars_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = smptebars_outputs,
+    FILTER_OUTPUTS(smptebars_outputs),
 };
 #endif  /* CONFIG_SMPTEBARS_FILTER */
     .query_formats = smptebars_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = smptebars_outputs,
+    FILTER_OUTPUTS(smptebars_outputs),
 };
 #endif  /* CONFIG_SMPTEHDBARS_FILTER */
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_allyuv = {
     .query_formats = allyuv_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = avfilter_vsrc_allyuv_outputs,
+    FILTER_OUTPUTS(avfilter_vsrc_allyuv_outputs),
 };
 #endif /* CONFIG_ALLYUV_FILTER */
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = allrgb_config_props,
     },
-    { NULL }
 };
 const AVFilter ff_vsrc_allrgb = {
     .query_formats = allrgb_query_formats,
     .activate      = activate,
     .inputs        = NULL,
-    .outputs       = avfilter_vsrc_allrgb_outputs,
+    FILTER_OUTPUTS(avfilter_vsrc_allrgb_outputs),
 };
 #endif /* CONFIG_ALLRGB_FILTER */

avfilter/avfilter: Add numbers of (in|out)pads directly to AVFilter

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code