@@ -2160,7 +2160,7 @@ void show_help_default(const char *opt, const char *arg)

     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;

     int show_advanced = 0, show_avoptions = 0;

-    if (opt) {

+    if (opt && *opt) {

         if (!strcmp(opt, "long"))

             show_advanced = 1;

         else if (!strcmp(opt, "full"))

@@ -122,10 +122,11 @@ static av_cold int flashsv_decode_init(AVCodecContext *avctx)

 }

-static void flashsv2_prime(FlashSVContext *s, uint8_t *src,

-                           int size, int unp_size)

+static int flashsv2_prime(FlashSVContext *s, uint8_t *src,

+                          int size, int unp_size)

 {

     z_stream zs;

+    int zret; // Zlib return code

     zs.zalloc = NULL;

     zs.zfree  = NULL;

@@ -145,13 +146,18 @@ static void flashsv2_prime(FlashSVContext *s, uint8_t *src,

     deflate(&zs, Z_SYNC_FLUSH);

     deflateEnd(&zs);

-    inflateReset(&s->zstream);

+    if ((zret = inflateReset(&s->zstream)) != Z_OK) {

+        av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);

+        return AVERROR_UNKNOWN;

+    }

     s->zstream.next_in   = s->deflate_block;

     s->zstream.avail_in  = s->deflate_block_size - zs.avail_out;

     s->zstream.next_out  = s->tmpblock;

     s->zstream.avail_out = s->block_size * 3;

     inflate(&s->zstream, Z_SYNC_FLUSH);

+

+    return 0;

 }

 static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt,

@@ -164,11 +170,14 @@ static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt,

     int k;

     int ret = inflateReset(&s->zstream);

     if (ret != Z_OK) {

-        //return -1;

+        av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);

+        return AVERROR_UNKNOWN;

     }

     if (s->zlibprime_curr || s->zlibprime_prev) {

-        flashsv2_prime(s, s->blocks[blk_idx].pos, s->blocks[blk_idx].size,

+        ret = flashsv2_prime(s, s->blocks[blk_idx].pos, s->blocks[blk_idx].size,

                        s->blocks[blk_idx].unp_size);

+        if (ret < 0)

+            return ret;

     }

     s->zstream.next_in   = avpkt->data + get_bits_count(gb) / 8;

     s->zstream.avail_in  = block_size;

@@ -830,9 +830,9 @@ int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

     if (ctx->is_scalable) {

         if (avctx->codec_id == AV_CODEC_ID_INDEO4)

-            ff_ivi_recompose_haar(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0], 4);

+            ff_ivi_recompose_haar(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);

         else

-            ff_ivi_recompose53   (&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0], 4);

+            ff_ivi_recompose53   (&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);

     } else {

         ff_ivi_output_plane(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);

     }

@@ -33,7 +33,7 @@

 #include "ivi_dsp.h"

 void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,

-                        const int dst_pitch, const int num_bands)

+                        const int dst_pitch)

 {

     int             x, y, indx;

     int32_t         p0, p1, p2, p3, tmp0, tmp1, tmp2;

@@ -41,6 +41,7 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,

     int32_t         b3_1, b3_2, b3_3, b3_4, b3_5, b3_6, b3_7, b3_8, b3_9;

     int32_t         pitch, back_pitch;

     const IDWTELEM *b0_ptr, *b1_ptr, *b2_ptr, *b3_ptr;

+    const int       num_bands = 4;

     /* all bands should have the same pitch */

     pitch = plane->bands[0].pitch;

@@ -189,7 +190,7 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,

 }

 void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst,

-                           const int dst_pitch, const int num_bands)

+                           const int dst_pitch)

 {

     int             x, y, indx, b0, b1, b2, b3, p0, p1, p2, p3;

     const IDWTELEM *b0_ptr, *b1_ptr, *b2_ptr, *b3_ptr;

@@ -38,10 +38,9 @@

  *  @param[in]   plane        pointer to the descriptor of the plane being processed

  *  @param[out]  dst          pointer to the destination buffer

  *  @param[in]   dst_pitch    pitch of the destination buffer

- *  @param[in]   num_bands    number of wavelet bands to be processed

  */

 void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,

-                        const int dst_pitch, const int num_bands);

+                        const int dst_pitch);

 /**

  *  Haar wavelet recomposition filter for Indeo 4

@@ -49,10 +48,9 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,

  *  @param[in]  plane        pointer to the descriptor of the plane being processed

  *  @param[out] dst          pointer to the destination buffer

  *  @param[in]  dst_pitch    pitch of the destination buffer

- *  @param[in]  num_bands    number of wavelet bands to be processed

  */

 void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst,

-                           const int dst_pitch, const int num_bands);

+                           const int dst_pitch);

 /**

  *  two-dimensional inverse Haar 8x8 transform for Indeo 4

@@ -1274,6 +1274,11 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)

         break;

     }

+    if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {

+        v->range_x <<= 1;

+        v->range_y <<= 1;

+    }

+

     /* AC Syntax */

     v->c_ac_table_index = decode012(gb);

     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {

@@ -1575,10 +1575,6 @@ static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,

         }

     }

-    if (v->field_mode && !s->quarter_sample) {

-        r_x <<= 1;

-        r_y <<= 1;

-    }

     if (v->field_mode && v->numref)

         r_y >>= 1;

     if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)

@@ -126,6 +126,22 @@ static int query_formats(AVFilterContext *ctx)

     return 0;

 }

+static const AVFilterPad avfilter_af_aformat_inputs[] = {

+    {

+        .name = "default",

+        .type = AVMEDIA_TYPE_AUDIO,

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_af_aformat_outputs[] = {

+    {

+        .name = "default",

+        .type = AVMEDIA_TYPE_AUDIO

+    },

+    { NULL }

+};

+

 AVFilter avfilter_af_aformat = {

     .name          = "aformat",

     .description   = NULL_IF_CONFIG_SMALL("Convert the input audio to one of the specified formats."),

@@ -133,11 +149,7 @@ AVFilter avfilter_af_aformat = {

     .query_formats = query_formats,

     .priv_size     = sizeof(AFormatContext),

-    .inputs        = (const AVFilterPad[]) {{ .name            = "default",

-                                              .type            = AVMEDIA_TYPE_AUDIO, },

-                                            { .name = NULL}},

-    .outputs       = (const AVFilterPad[]) {{ .name            = "default",

-                                              .type            = AVMEDIA_TYPE_AUDIO},

-                                            { .name = NULL}},

-    .priv_class = &aformat_class,

+    .inputs        = avfilter_af_aformat_inputs,

+    .outputs       = avfilter_af_aformat_outputs,

+    .priv_class    = &aformat_class,

 };

@@ -542,6 +542,16 @@ static int query_formats(AVFilterContext *ctx)

     return 0;

 }

+static const AVFilterPad avfilter_af_amix_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_AUDIO,

+        .config_props  = config_output,

+        .request_frame = request_frame

+    },

+    { NULL }

+};

+

 AVFilter avfilter_af_amix = {

     .name          = "amix",

     .description   = NULL_IF_CONFIG_SMALL("Audio mixing."),

@@ -552,10 +562,6 @@ AVFilter avfilter_af_amix = {

     .query_formats  = query_formats,

     .inputs    = NULL,

-    .outputs   = (const AVFilterPad[]) {{ .name          = "default",

-                                          .type          = AVMEDIA_TYPE_AUDIO,

-                                          .config_props  = config_output,

-                                          .request_frame = request_frame },

-                                        { .name = NULL}},

+    .outputs   = avfilter_af_amix_outputs,

     .priv_class = &amix_class,

 };

@@ -27,18 +27,30 @@

 #include "internal.h"

 #include "libavutil/internal.h"

+static const AVFilterPad avfilter_af_anull_inputs[] = {

+    {

+        .name             = "default",

+        .type             = AVMEDIA_TYPE_AUDIO,

+        .get_audio_buffer = ff_null_get_audio_buffer,

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_af_anull_outputs[] = {

+    {

+        .name = "default",

+        .type = AVMEDIA_TYPE_AUDIO,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_af_anull = {

     .name      = "anull",

     .description = NULL_IF_CONFIG_SMALL("Pass the source unchanged to the output."),

     .priv_size = 0,

-    .inputs    = (const AVFilterPad[]) {{ .name             = "default",

-                                          .type             = AVMEDIA_TYPE_AUDIO,

-                                          .get_audio_buffer = ff_null_get_audio_buffer, },

-                                        { .name = NULL}},

+    .inputs    = avfilter_af_anull_inputs,

-    .outputs   = (const AVFilterPad[]) {{ .name             = "default",

-                                          .type             = AVMEDIA_TYPE_AUDIO, },

-                                        { .name = NULL}},

+    .outputs   = avfilter_af_anull_outputs,

 };

@@ -233,6 +233,25 @@ fail:

     return ret;

 }

+static const AVFilterPad avfilter_af_asyncts_inputs[] = {

+    {

+        .name           = "default",

+        .type           = AVMEDIA_TYPE_AUDIO,

+        .filter_samples = filter_samples

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_af_asyncts_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_AUDIO,

+        .config_props  = config_props,

+        .request_frame = request_frame

+    },

+    { NULL }

+};

+

 AVFilter avfilter_af_asyncts = {

     .name        = "asyncts",

     .description = NULL_IF_CONFIG_SMALL("Sync audio data to timestamps"),

@@ -242,14 +261,7 @@ AVFilter avfilter_af_asyncts = {

     .priv_size   = sizeof(ASyncContext),

-    .inputs      = (const AVFilterPad[]) {{ .name           = "default",

-                                            .type           = AVMEDIA_TYPE_AUDIO,

-                                            .filter_samples = filter_samples },

-                                          { NULL }},

-    .outputs     = (const AVFilterPad[]) {{ .name           = "default",

-                                            .type           = AVMEDIA_TYPE_AUDIO,

-                                            .config_props   = config_props,

-                                            .request_frame  = request_frame },

-                                          { NULL }},

+    .inputs      = avfilter_af_asyncts_inputs,

+    .outputs     = avfilter_af_asyncts_outputs,

     .priv_class = &asyncts_class,

 };

@@ -385,6 +385,25 @@ static int channelmap_config_input(AVFilterLink *inlink)

     return err;

 }

+static const AVFilterPad avfilter_af_channelmap_inputs[] = {

+    {

+        .name           = "default",

+        .type           = AVMEDIA_TYPE_AUDIO,

+        .min_perms      = AV_PERM_READ | AV_PERM_WRITE,

+        .filter_samples = channelmap_filter_samples,

+        .config_props   = channelmap_config_input

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_af_channelmap_outputs[] = {

+    {

+        .name = "default",

+        .type = AVMEDIA_TYPE_AUDIO

+    },

+    { NULL }

+};

+

 AVFilter avfilter_af_channelmap = {

     .name          = "channelmap",

     .description   = NULL_IF_CONFIG_SMALL("Remap audio channels."),

@@ -392,14 +411,7 @@ AVFilter avfilter_af_channelmap = {

     .query_formats = channelmap_query_formats,

     .priv_size     = sizeof(ChannelMapContext),

-    .inputs        = (const AVFilterPad[]) {{ .name            = "default",

-                                              .type            = AVMEDIA_TYPE_AUDIO,

-                                              .min_perms       = AV_PERM_READ | AV_PERM_WRITE,

-                                              .filter_samples  = channelmap_filter_samples,

-                                              .config_props    = channelmap_config_input },

-                                            { .name = NULL }},

-    .outputs       = (const AVFilterPad[]) {{ .name            = "default",

-                                              .type            = AVMEDIA_TYPE_AUDIO },

-                                            { .name = NULL }},

-    .priv_class = &channelmap_class,

+    .inputs        = avfilter_af_channelmap_inputs,

+    .outputs       = avfilter_af_channelmap_outputs,

+    .priv_class    = &channelmap_class,

 };

@@ -130,6 +130,15 @@ static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

     return ret;

 }

+static const AVFilterPad avfilter_af_channelsplit_inputs[] = {

+    {

+        .name           = "default",

+        .type           = AVMEDIA_TYPE_AUDIO,

+        .filter_samples = filter_samples,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_af_channelsplit = {

     .name           = "channelsplit",

     .description    = NULL_IF_CONFIG_SMALL("Split audio into per-channel streams"),

@@ -138,10 +147,7 @@ AVFilter avfilter_af_channelsplit = {

     .init           = init,

     .query_formats  = query_formats,

-    .inputs  = (const AVFilterPad[]){{ .name           = "default",

-                                       .type           = AVMEDIA_TYPE_AUDIO,

-                                       .filter_samples = filter_samples, },

-                                     { NULL }},

+    .inputs  = avfilter_af_channelsplit_inputs,

     .outputs = NULL,

     .priv_class = &channelsplit_class,

 };

@@ -484,6 +484,16 @@ fail:

     return AVERROR(ENOMEM);

 }

+static const AVFilterPad avfilter_af_join_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_AUDIO,

+        .config_props  = join_config_output,

+        .request_frame = join_request_frame,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_af_join = {

     .name           = "join",

     .description    = NULL_IF_CONFIG_SMALL("Join multiple audio streams into "

@@ -495,10 +505,6 @@ AVFilter avfilter_af_join = {

     .query_formats  = join_query_formats,

     .inputs  = NULL,

-    .outputs = (const AVFilterPad[]){{ .name          = "default",

-                                       .type          = AVMEDIA_TYPE_AUDIO,

-                                       .config_props  = join_config_output,

-                                       .request_frame = join_request_frame, },

-                                     { NULL }},

+    .outputs = avfilter_af_join_outputs,

     .priv_class = &join_class,

 };

@@ -239,6 +239,26 @@ fail:

     return ret;

 }

+static const AVFilterPad avfilter_af_resample_inputs[] = {

+    {

+        .name           = "default",

+        .type           = AVMEDIA_TYPE_AUDIO,

+        .filter_samples = filter_samples,

+        .min_perms      = AV_PERM_READ

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_af_resample_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_AUDIO,

+        .config_props  = config_output,

+        .request_frame = request_frame

+    },

+    { NULL }

+};

+

 AVFilter avfilter_af_resample = {

     .name          = "resample",

     .description   = NULL_IF_CONFIG_SMALL("Audio resampling and conversion."),

@@ -247,14 +267,6 @@ AVFilter avfilter_af_resample = {

     .uninit         = uninit,

     .query_formats  = query_formats,

-    .inputs    = (const AVFilterPad[]) {{ .name            = "default",

-                                          .type            = AVMEDIA_TYPE_AUDIO,

-                                          .filter_samples  = filter_samples,

-                                          .min_perms       = AV_PERM_READ },

-                                        { .name = NULL}},

-    .outputs   = (const AVFilterPad[]) {{ .name          = "default",

-                                          .type          = AVMEDIA_TYPE_AUDIO,

-                                          .config_props  = config_output,

-                                          .request_frame = request_frame },

-                                        { .name = NULL}},

+    .inputs    = avfilter_af_resample_inputs,

+    .outputs   = avfilter_af_resample_outputs,

 };

@@ -27,19 +27,21 @@ static int null_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref

     return 0;

 }

+static const AVFilterPad avfilter_asink_anullsink_inputs[] = {

+    {

+        .name           = "default",

+        .type           = AVMEDIA_TYPE_AUDIO,

+        .filter_samples = null_filter_samples,

+    },

+    { NULL },

+};

+

 AVFilter avfilter_asink_anullsink = {

     .name        = "anullsink",

     .description = NULL_IF_CONFIG_SMALL("Do absolutely nothing with the input audio."),

     .priv_size = 0,

-    .inputs    = (const AVFilterPad[]) {

-        {

-            .name            = "default",

-            .type            = AVMEDIA_TYPE_AUDIO,

-            .filter_samples  = null_filter_samples,

-        },

-        { .name = NULL},

-    },

+    .inputs    = avfilter_asink_anullsink_inputs,

     .outputs   = NULL,

 };

@@ -119,6 +119,16 @@ static int request_frame(AVFilterLink *outlink)

     return 0;

 }

+static const AVFilterPad avfilter_asrc_anullsrc_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_AUDIO,

+        .config_props  = config_props,

+        .request_frame = request_frame,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_asrc_anullsrc = {

     .name        = "anullsrc",

     .description = NULL_IF_CONFIG_SMALL("Null audio source, return empty audio frames."),

@@ -128,10 +138,6 @@ AVFilter avfilter_asrc_anullsrc = {

     .inputs      = NULL,

-    .outputs     = (const AVFilterPad[]) {{ .name = "default",

-                                            .type = AVMEDIA_TYPE_AUDIO,

-                                            .config_props = config_props,

-                                            .request_frame = request_frame, },

-                                          { .name = NULL}},

+    .outputs     = avfilter_asrc_anullsrc_outputs,

     .priv_class = &anullsrc_class,

 };

@@ -140,6 +140,17 @@ int ff_buffersink_read_samples_compat(AVFilterContext *ctx, AVFilterBufferRef **

     return ret;

 }

+static const AVFilterPad avfilter_vsink_buffer_inputs[] = {

+    {

+        .name        = "default",

+        .type        = AVMEDIA_TYPE_VIDEO,

+        .start_frame = start_frame,

+        .min_perms   = AV_PERM_READ,

+        .needs_fifo  = 1

+    },

+    { NULL }

+};

+

 AVFilter avfilter_vsink_buffer = {

 #if AV_HAVE_INCOMPATIBLE_FORK_ABI

     .name      = "buffersink",

@@ -150,15 +161,21 @@ AVFilter avfilter_vsink_buffer = {

     .priv_size = sizeof(BufferSinkContext),

     .uninit    = uninit,

-    .inputs    = (const AVFilterPad[]) {{ .name          = "default",

-                                          .type          = AVMEDIA_TYPE_VIDEO,

-                                          .start_frame   = start_frame,

-                                          .min_perms     = AV_PERM_READ,

-                                          .needs_fifo    = 1 },

-                                        { .name = NULL }},

+    .inputs    = avfilter_vsink_buffer_inputs,

     .outputs   = NULL,

 };

+static const AVFilterPad avfilter_asink_abuffer_inputs[] = {

+    {

+        .name           = "default",

+        .type           = AVMEDIA_TYPE_AUDIO,

+        .filter_samples = start_frame,

+        .min_perms      = AV_PERM_READ,

+        .needs_fifo     = 1

+    },

+    { NULL }

+};

+

 AVFilter avfilter_asink_abuffer = {

 #if AV_HAVE_INCOMPATIBLE_FORK_ABI

     .name      = "abuffersink",

@@ -169,11 +186,6 @@ AVFilter avfilter_asink_abuffer = {

     .priv_size = sizeof(BufferSinkContext),

     .uninit    = uninit,

-    .inputs    = (const AVFilterPad[]) {{ .name           = "default",

-                                          .type           = AVMEDIA_TYPE_AUDIO,

-                                          .filter_samples = start_frame,

-                                          .min_perms      = AV_PERM_READ,

-                                          .needs_fifo     = 1 },

-                                        { .name = NULL }},

+    .inputs    = avfilter_asink_abuffer_inputs,

     .outputs   = NULL,

 };

@@ -400,6 +400,17 @@ static int poll_frame(AVFilterLink *link)

     return size/sizeof(AVFilterBufferRef*);

 }

+static const AVFilterPad avfilter_vsrc_buffer_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_VIDEO,

+        .request_frame = request_frame,

+        .poll_frame    = poll_frame,

+        .config_props  = config_props,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_vsrc_buffer = {

     .name      = "buffer",

     .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them accessible to the filterchain."),

@@ -410,15 +421,21 @@ AVFilter avfilter_vsrc_buffer = {

     .uninit    = uninit,

     .inputs    = NULL,

-    .outputs   = (const AVFilterPad[]) {{ .name            = "default",

-                                          .type            = AVMEDIA_TYPE_VIDEO,

-                                          .request_frame   = request_frame,

-                                          .poll_frame      = poll_frame,

-                                          .config_props    = config_props, },

-                                        { .name = NULL}},

+    .outputs   = avfilter_vsrc_buffer_outputs,

     .priv_class = &buffer_class,

 };

+static const AVFilterPad avfilter_asrc_abuffer_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_AUDIO,

+        .request_frame = request_frame,

+        .poll_frame    = poll_frame,

+        .config_props  = config_props,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_asrc_abuffer = {

     .name          = "abuffer",

     .description   = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),

@@ -429,11 +446,6 @@ AVFilter avfilter_asrc_abuffer = {

     .uninit    = uninit,

     .inputs    = NULL,

-    .outputs   = (const AVFilterPad[]) {{ .name            = "default",

-                                          .type            = AVMEDIA_TYPE_AUDIO,

-                                          .request_frame   = request_frame,

-                                          .poll_frame      = poll_frame,

-                                          .config_props    = config_props, },

-                                        { .name = NULL}},

+    .outputs   = avfilter_asrc_abuffer_outputs,

     .priv_class = &abuffer_class,

 };

@@ -216,6 +216,25 @@ AVFilter avfilter_af_asetpts = {

 #endif /* CONFIG_ASETPTS_FILTER */

 #if CONFIG_SETPTS_FILTER

+static const AVFilterPad avfilter_vf_setpts_inputs[] = {

+    {

+        .name             = "default",

+        .type             = AVMEDIA_TYPE_VIDEO,

+        .get_video_buffer = ff_null_get_video_buffer,

+        .config_props     = config_input,

+        .start_frame      = filter_frame,

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_vf_setpts_outputs[] = {

+    {

+        .name = "default",

+        .type = AVMEDIA_TYPE_VIDEO,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_vf_setpts = {

     .name      = "setpts",

     .description = NULL_IF_CONFIG_SMALL("Set PTS for the output video frame."),

@@ -224,14 +243,7 @@ AVFilter avfilter_vf_setpts = {

     .priv_size = sizeof(SetPTSContext),

-    .inputs    = (const AVFilterPad[]) {{ .name             = "default",

-                                          .type             = AVMEDIA_TYPE_VIDEO,

-                                          .get_video_buffer = ff_null_get_video_buffer,

-                                          .config_props     = config_input,

-                                          .start_frame      = filter_frame, },

-                                        { .name = NULL }},

-    .outputs   = (const AVFilterPad[]) {{ .name             = "default",

-                                          .type             = AVMEDIA_TYPE_VIDEO, },

-                                        { .name = NULL}},

+    .inputs    = avfilter_vf_setpts_inputs,

+    .outputs   = avfilter_vf_setpts_outputs,

 };

 #endif /* CONFIG_SETPTS_FILTER */

@@ -137,6 +137,26 @@ static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)

 }

 #if CONFIG_SETTB_FILTER

+static const AVFilterPad avfilter_vf_settb_inputs[] = {

+    {

+        .name             = "default",

+        .type             = AVMEDIA_TYPE_VIDEO,

+        .get_video_buffer = ff_null_get_video_buffer,

+        .start_frame      = start_frame,

+        .end_frame        = ff_null_end_frame

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_vf_settb_outputs[] = {

+    {

+        .name         = "default",

+        .type         = AVMEDIA_TYPE_VIDEO,

+        .config_props = config_output_props,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_vf_settb = {

     .name      = "settb",

     .description = NULL_IF_CONFIG_SMALL("Set timebase for the video output link."),

@@ -144,20 +164,8 @@ AVFilter avfilter_vf_settb = {

     .priv_size = sizeof(SetTBContext),

-    .inputs    = (const AVFilterPad[]) {

-        { .name             = "default",

-          .type             = AVMEDIA_TYPE_VIDEO,

-          .get_video_buffer = ff_null_get_video_buffer,

-          .start_frame      = start_frame,

-          .end_frame        = ff_null_end_frame },

-        { .name = NULL }

-    },

-    .outputs   = (const AVFilterPad[]) {

-        { .name            = "default",

-          .type            = AVMEDIA_TYPE_VIDEO,

-          .config_props    = config_output_props, },

-        { .name = NULL}

-    },

+    .inputs    = avfilter_vf_settb_inputs,

+    .outputs   = avfilter_vf_settb_outputs,

 };

 #endif

@@ -267,6 +267,28 @@ static int request_frame(AVFilterLink *outlink)

     return ret;

 }

+static const AVFilterPad avfilter_vf_fifo_inputs[] = {

+    {

+        .name             = "default",

+        .type             = AVMEDIA_TYPE_VIDEO,

+        .get_video_buffer = ff_null_get_video_buffer,

+        .start_frame      = add_to_queue,

+        .draw_slice       = draw_slice,

+        .end_frame        = end_frame,

+        .min_perms        = AV_PERM_PRESERVE,

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_vf_fifo_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_VIDEO,

+        .request_frame = request_frame,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_vf_fifo = {

     .name      = "fifo",

     .description = NULL_IF_CONFIG_SMALL("Buffer input images and send them when they are requested."),

@@ -276,18 +298,28 @@ AVFilter avfilter_vf_fifo = {

     .priv_size = sizeof(FifoContext),

-    .inputs    = (const AVFilterPad[]) {{ .name            = "default",

-                                          .type            = AVMEDIA_TYPE_VIDEO,

-                                          .get_video_buffer= ff_null_get_video_buffer,

-                                          .start_frame     = add_to_queue,

-                                          .draw_slice      = draw_slice,

-                                          .end_frame       = end_frame,

-                                          .min_perms       = AV_PERM_PRESERVE, },

-                                        { .name = NULL}},

-    .outputs   = (const AVFilterPad[]) {{ .name            = "default",

-                                          .type            = AVMEDIA_TYPE_VIDEO,

-                                          .request_frame   = request_frame, },

-                                        { .name = NULL}},

+    .inputs    = avfilter_vf_fifo_inputs,

+    .outputs   = avfilter_vf_fifo_outputs,

+};

+

+static const AVFilterPad avfilter_af_afifo_inputs[] = {

+    {

+        .name             = "default",

+        .type             = AVMEDIA_TYPE_AUDIO,

+        .get_audio_buffer = ff_null_get_audio_buffer,

+        .filter_samples   = add_to_queue,

+        .min_perms        = AV_PERM_PRESERVE,

+    },

+    { NULL }

+};

+

+static const AVFilterPad avfilter_af_afifo_outputs[] = {

+    {

+        .name          = "default",

+        .type          = AVMEDIA_TYPE_AUDIO,

+        .request_frame = request_frame,

+    },

+    { NULL }

 };

 AVFilter avfilter_af_afifo = {

@@ -299,14 +331,6 @@ AVFilter avfilter_af_afifo = {

     .priv_size = sizeof(FifoContext),

-    .inputs    = (const AVFilterPad[]) {{ .name             = "default",

-                                          .type             = AVMEDIA_TYPE_AUDIO,

-                                          .get_audio_buffer = ff_null_get_audio_buffer,

-                                          .filter_samples   = add_to_queue,

-                                          .min_perms        = AV_PERM_PRESERVE, },

-                                        { .name = NULL}},

-    .outputs   = (const AVFilterPad[]) {{ .name             = "default",

-                                          .type             = AVMEDIA_TYPE_AUDIO,

-                                          .request_frame    = request_frame, },

-                                        { .name = NULL}},

+    .inputs    = avfilter_af_afifo_inputs,

+    .outputs   = avfilter_af_afifo_outputs,

 };

@@ -119,6 +119,18 @@ static int end_frame(AVFilterLink *inlink)

     return ret;

 }

+static const AVFilterPad avfilter_vf_split_inputs[] = {

+    {

+        .name             = "default",

+        .type             = AVMEDIA_TYPE_VIDEO,

+        .get_video_buffer = ff_null_get_video_buffer,

+        .start_frame      = start_frame,

+        .draw_slice       = draw_slice,

+        .end_frame        = end_frame,

+    },

+    { NULL }

+};

+

 AVFilter avfilter_vf_split = {

     .name      = "split",

     .description = NULL_IF_CONFIG_SMALL("Pass on the input video to N outputs."),

@@ -126,13 +138,7 @@ AVFilter avfilter_vf_split = {

     .init   = split_init,

     .uninit = split_uninit,

-    .inputs    = (const AVFilterPad[]) {{ .name            = "default",

-                                          .type            = AVMEDIA_TYPE_VIDEO,

-                                          .get_video_buffer= ff_null_get_video_buffer,

-                                          .start_frame     = start_frame,

-                                          .draw_slice      = draw_slice,

-                                          .end_frame       = end_frame, },

-                                        { .name = NULL}},

+    .inputs    = avfilter_vf_split_inputs,

     .outputs   = NULL,

 };

@@ -157,6 +163,16 @@ static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)

     return ret;

 }

+static const AVFilterPad avfilter_af_asplit_inputs[] = {

+    {

+        .name             = "default",

+        .type             = AVMEDIA_TYPE_AUDIO,

+        .get_audio_buffer = ff_null_get_audio_buffer,