sigrid/ffmpeg

libavcodec/8svx.c+2−4

   FF_CODEC_DECODE_CB(eightsvx_decode_frame),
   .close          = eightsvx_decode_close,
   .p.capabilities = AV_CODEC_CAP_DR1,
-  .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P),
-                                                    AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_EIGHTSVX_EXP_DECODER
   FF_CODEC_DECODE_CB(eightsvx_decode_frame),
   .close          = eightsvx_decode_close,
   .p.capabilities = AV_CODEC_CAP_DR1,
-  .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P),
-                                                    AV_SAMPLE_FMT_NONE },
 };
 #endif

libavcodec/a64multienc.c+2−2

@@ -403,7 +403,7 @@ const FFCodec ff_a64multi_encoder = { · 402 unmodified lines
403	.init = a64multi_encode_init,	403	.init = a64multi_encode_init,
404	FF_CODEC_ENCODE_CB(a64multi_encode_frame),	404	FF_CODEC_ENCODE_CB(a64multi_encode_frame),
405	.close = a64multi_close_encoder,	405	.close = a64multi_close_encoder,
406	.p.pix_fmts = (const enum AVPixelFormat[]) {AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE},	406	CODEC_PIXFMTS(AV_PIX_FMT_GRAY8),
407	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	407	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
408	};	408	};
409	#endif	409	#endif
@@ -418,7 +418,7 @@ const FFCodec ff_a64multi5_encoder = { · 8 unmodified lines
418	.init = a64multi_encode_init,	418	.init = a64multi_encode_init,
419	FF_CODEC_ENCODE_CB(a64multi_encode_frame),	419	FF_CODEC_ENCODE_CB(a64multi_encode_frame),
420	.close = a64multi_close_encoder,	420	.close = a64multi_close_encoder,
421	.p.pix_fmts = (const enum AVPixelFormat[]) {AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE},	421	CODEC_PIXFMTS(AV_PIX_FMT_GRAY8),
422	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	422	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
423	};	423	};
424	#endif	424	#endif

libavcodec/aac/aacdec.c+4−8

     .init            = ff_aac_decode_init_float,
     .close           = decode_close,
     FF_CODEC_DECODE_CB(aac_decode_frame),
-    .p.sample_fmts   = (const enum AVSampleFormat[]) {
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-        AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE
-    },
     .p.capabilities  = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
     .caps_internal   = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.ch_layouts    = ff_aac_ch_layout,
+    CODEC_CH_LAYOUTS_ARRAY(ff_aac_ch_layout),
     .flush = flush,
     .p.profiles      = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
 };
     .init            = ff_aac_decode_init_fixed,
     .close           = decode_close,
     FF_CODEC_DECODE_CB(aac_decode_frame),
-    .p.sample_fmts   = (const enum AVSampleFormat[]) {
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32P),
-        AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE
-    },
     .p.capabilities  = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
     .caps_internal   = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.ch_layouts    = ff_aac_ch_layout,
+    CODEC_CH_LAYOUTS_ARRAY(ff_aac_ch_layout),
     .p.profiles      = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
     .flush = flush,
 };

libavcodec/aac/aacdec_latm.h+2−4

     .init            = latm_decode_init,
     .close           = decode_close,
     FF_CODEC_DECODE_CB(latm_decode_frame),
-    .p.sample_fmts   = (const enum AVSampleFormat[]) {
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-        AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE
-    },
     .p.capabilities  = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
     .caps_internal   = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.ch_layouts    = ff_aac_ch_layout,
+    CODEC_CH_LAYOUTS_ARRAY(ff_aac_ch_layout),
     .flush = flush,
     .p.profiles      = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
 };

libavcodec/aacenc.c+2−3

     FF_CODEC_ENCODE_CB(aac_encode_frame),
     .close          = aac_encode_end,
     .defaults       = aac_encode_defaults,
-    .p.supported_samplerates = ff_mpeg4audio_sample_rates,
+    CODEC_SAMPLERATES_ARRAY(ff_mpeg4audio_sample_rates),
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                     AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &aacenc_class,
 };

libavcodec/ac3dec_fixed.c+1−2

@@ -186,7 +186,6 @@ const FFCodec ff_ac3_fixed_decoder = { · 185 unmodified lines
186	FF_CODEC_DECODE_CB(ac3_decode_frame),	186	FF_CODEC_DECODE_CB(ac3_decode_frame),
187	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|	187	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|
188	AV_CODEC_CAP_DR1,	188	AV_CODEC_CAP_DR1,
189	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,	189	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
190	AV_SAMPLE_FMT_NONE },
191	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	190	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
192	};	191	};

libavcodec/ac3dec_float.c+2−4

     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     CODEC_LONG_NAME("ATSC A/52A (AC-3)"),
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &ac3_eac3_decoder_class,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     CODEC_LONG_NAME("ATSC A/52B (AC-3, E-AC-3)"),
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &ac3_eac3_decoder_class,
     .p.profiles     = NULL_IF_CONFIG_SMALL(ff_eac3_profiles),
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,

libavcodec/ac3enc_fixed.c+3−4

     .init            = ac3_fixed_encode_init,
     FF_CODEC_ENCODE_CB(ff_ac3_encode_frame),
     .close           = ff_ac3_encode_close,
-    .p.sample_fmts   = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32P),
-                                                      AV_SAMPLE_FMT_NONE },
     .p.priv_class    = &ff_ac3enc_class,
     .caps_internal   = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.supported_samplerates = ff_ac3_sample_rate_tab,
+    CODEC_SAMPLERATES_ARRAY(ff_ac3_sample_rate_tab),
-    .p.ch_layouts    = ff_ac3_ch_layouts,
+    CODEC_CH_LAYOUTS_ARRAY(ff_ac3_ch_layouts),
     .defaults        = ff_ac3_enc_defaults,
 };

libavcodec/ac3enc_float.c+3−4

     .init            = ff_ac3_float_encode_init,
     FF_CODEC_ENCODE_CB(ff_ac3_encode_frame),
     .close           = ff_ac3_encode_close,
-    .p.sample_fmts   = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .p.priv_class    = &ff_ac3enc_class,
-    .p.supported_samplerates = ff_ac3_sample_rate_tab,
+    CODEC_SAMPLERATES_ARRAY(ff_ac3_sample_rate_tab),
-    .p.ch_layouts    = ff_ac3_ch_layouts,
+    CODEC_CH_LAYOUTS_ARRAY(ff_ac3_ch_layouts),
     .defaults        = ff_ac3_enc_defaults,
     .caps_internal   = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/adpcm.c+1−1

@@ -2395,7 +2395,7 @@ const FFCodec ff_ ## name_ ## _decoder = { \ · 2394 unmodified lines
2395	.p.type = AVMEDIA_TYPE_AUDIO, \	2395	.p.type = AVMEDIA_TYPE_AUDIO, \
2396	.p.id = id_, \	2396	.p.id = id_, \
2397	.p.capabilities = AV_CODEC_CAP_DR1, \	2397	.p.capabilities = AV_CODEC_CAP_DR1, \
2398	.p.sample_fmts = sample_fmts_, \	2398	CODEC_SAMPLEFMTS_ARRAY(sample_fmts_), \
2399	.priv_data_size = sizeof(ADPCMDecodeContext), \	2399	.priv_data_size = sizeof(ADPCMDecodeContext), \
2400	.init = adpcm_decode_init, \	2400	.init = adpcm_decode_init, \
2401	FF_CODEC_DECODE_CB(adpcm_decode_frame), \	2401	FF_CODEC_DECODE_CB(adpcm_decode_frame), \

libavcodec/adpcmenc.c+2−2

     CODEC_LONG_NAME(long_name_),                                           \
     .p.type         = AVMEDIA_TYPE_AUDIO,                                  \
     .p.id           = id_,                                                 \
-    .p.sample_fmts  = sample_fmts_,                                        \
-    .p.ch_layouts   = ch_layouts,                                          \
     .p.capabilities = capabilities_ | AV_CODEC_CAP_DR1 |                   \
                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,               \
     .p.priv_class   = &adpcm_encoder_class,                                \
+    CODEC_CH_LAYOUTS_ARRAY(ch_layouts),                                    \
+    CODEC_SAMPLEFMTS_ARRAY(sample_fmts_),                                  \
     .priv_data_size = sizeof(ADPCMEncodeContext),                          \
     .init           = adpcm_encode_init,                                   \
     FF_CODEC_ENCODE_CB(adpcm_encode_frame),                                \

libavcodec/adxdec.c+1−2

@@ -264,6 +264,5 @@ const FFCodec ff_adpcm_adx_decoder = { · 263 unmodified lines
264	.flush = adx_decode_flush,	264	.flush = adx_decode_flush,
265	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|	265	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|
266	AV_CODEC_CAP_DR1,	266	AV_CODEC_CAP_DR1,
267	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,	267	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
268	AV_SAMPLE_FMT_NONE },
269	};	268	};

libavcodec/adxenc.c+1−2

@@ -197,7 +197,6 @@ const FFCodec ff_adpcm_adx_encoder = { · 196 unmodified lines
197	.priv_data_size = sizeof(ADXContext),	197	.priv_data_size = sizeof(ADXContext),
198	.init = adx_encode_init,	198	.init = adx_encode_init,
199	FF_CODEC_ENCODE_CB(adx_encode_frame),	199	FF_CODEC_ENCODE_CB(adx_encode_frame),
200	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,	200	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
201	AV_SAMPLE_FMT_NONE },
202	.caps_internal = FF_CODEC_CAP_EOF_FLUSH,	201	.caps_internal = FF_CODEC_CAP_EOF_FLUSH,
203	};	202	};

libavcodec/alacenc.c+2−4

     .init           = alac_encode_init,
     FF_CODEC_ENCODE_CB(alac_encode_frame),
     .close          = alac_encode_close,
-    .p.ch_layouts   = ff_alac_ch_layouts,
+    CODEC_CH_LAYOUTS_ARRAY(ff_alac_ch_layouts),
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_S16P),
-                                                     AV_SAMPLE_FMT_S16P,
-                                                     AV_SAMPLE_FMT_NONE },
 };

libavcodec/aliaspixenc.c+1−3

@@ -108,7 +108,5 @@ const FFCodec ff_alias_pix_encoder = { · 107 unmodified lines
108	.p.id = AV_CODEC_ID_ALIAS_PIX,	108	.p.id = AV_CODEC_ID_ALIAS_PIX,
109	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	109	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
110	FF_CODEC_ENCODE_CB(encode_frame),	110	FF_CODEC_ENCODE_CB(encode_frame),
111	.p.pix_fmts = (const enum AVPixelFormat[]) {	111	CODEC_PIXFMTS(AV_PIX_FMT_BGR24, AV_PIX_FMT_GRAY8),
112	AV_PIX_FMT_BGR24, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
113	},
114	};	112	};

libavcodec/amfdec.c+1−1

@@ -705,7 +705,7 @@ const FFCodec ff_##x##_amf_decoder = { \ · 704 unmodified lines
705	.bsfs = bsf_name, \	705	.bsfs = bsf_name, \
706	.p.capabilities = AV_CODEC_CAP_HARDWARE \| AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_AVOID_PROBING, \	706	.p.capabilities = AV_CODEC_CAP_HARDWARE \| AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_AVOID_PROBING, \
707	.p.priv_class = &amf_decode_class, \	707	.p.priv_class = &amf_decode_class, \
708	.p.pix_fmts = amf_dec_pix_fmts, \	708	CODEC_PIXFMTS_ARRAY(amf_dec_pix_fmts), \
709	.hw_configs = amf_hw_configs, \	709	.hw_configs = amf_hw_configs, \
710	.p.wrapper_name = "amf", \	710	.p.wrapper_name = "amf", \
711	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE, \	711	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE, \

libavcodec/amfenc_av1.c+1−1

@@ -713,7 +713,7 @@ const FFCodec ff_av1_amf_encoder = { · 712 unmodified lines
713	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_HARDWARE \|	713	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_HARDWARE \|
714	AV_CODEC_CAP_DR1,	714	AV_CODEC_CAP_DR1,
715	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	715	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
716	.p.pix_fmts = ff_amf_pix_fmts,	716	CODEC_PIXFMTS_ARRAY(ff_amf_pix_fmts),
717	.color_ranges = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */	717	.color_ranges = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
718	.p.wrapper_name = "amf",	718	.p.wrapper_name = "amf",
719	.hw_configs = ff_amfenc_hw_configs,	719	.hw_configs = ff_amfenc_hw_configs,

libavcodec/amfenc_h264.c+1−1

@@ -609,7 +609,7 @@ const FFCodec ff_h264_amf_encoder = { · 608 unmodified lines
609	AV_CODEC_CAP_DR1,	609	AV_CODEC_CAP_DR1,
610	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|	610	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|
611	FF_CODEC_CAP_INIT_CLEANUP,	611	FF_CODEC_CAP_INIT_CLEANUP,
612	.p.pix_fmts = ff_amf_pix_fmts,	612	CODEC_PIXFMTS_ARRAY(ff_amf_pix_fmts),
613	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	613	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
614	.p.wrapper_name = "amf",	614	.p.wrapper_name = "amf",
615	.hw_configs = ff_amfenc_hw_configs,	615	.hw_configs = ff_amfenc_hw_configs,

libavcodec/amfenc_hevc.c+1−1

@@ -558,7 +558,7 @@ const FFCodec ff_hevc_amf_encoder = { · 557 unmodified lines
558	AV_CODEC_CAP_DR1,	558	AV_CODEC_CAP_DR1,
559	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|	559	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|
560	FF_CODEC_CAP_INIT_CLEANUP,	560	FF_CODEC_CAP_INIT_CLEANUP,
561	.p.pix_fmts = ff_amf_pix_fmts,	561	CODEC_PIXFMTS_ARRAY(ff_amf_pix_fmts),
562	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	562	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
563	.p.wrapper_name = "amf",	563	.p.wrapper_name = "amf",
564	.hw_configs = ff_amfenc_hw_configs,	564	.hw_configs = ff_amfenc_hw_configs,

libavcodec/amrnbdec.c+1−2

@@ -1104,6 +1104,5 @@ const FFCodec ff_amrnb_decoder = { · 1103 unmodified lines
1104	.init = amrnb_decode_init,	1104	.init = amrnb_decode_init,
1105	FF_CODEC_DECODE_CB(amrnb_decode_frame),	1105	FF_CODEC_DECODE_CB(amrnb_decode_frame),
1106	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,	1106	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,
1107	.p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,	1107	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
1108	AV_SAMPLE_FMT_NONE },
1109	};	1108	};

libavcodec/amrwbdec.c+1−2

@@ -1307,6 +1307,5 @@ const FFCodec ff_amrwb_decoder = { · 1306 unmodified lines
1307	.init = amrwb_decode_init,	1307	.init = amrwb_decode_init,
1308	FF_CODEC_DECODE_CB(amrwb_decode_frame),	1308	FF_CODEC_DECODE_CB(amrwb_decode_frame),
1309	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,	1309	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,
1310	.p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,	1310	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
1311	AV_SAMPLE_FMT_NONE },
1312	};	1311	};

libavcodec/apac.c+1−3

@@ -274,7 +274,5 @@ const FFCodec ff_apac_decoder = { · 273 unmodified lines
274	#endif	274	#endif
275	AV_CODEC_CAP_DR1,	275	AV_CODEC_CAP_DR1,
276	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	276	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
277	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,	277	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P),
278	AV_SAMPLE_FMT_S16P,
279	AV_SAMPLE_FMT_NONE },
280	};	278	};

libavcodec/apedec.c+1−4

                       AV_CODEC_CAP_DR1,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
     .flush          = ape_flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P),
-                                                      AV_SAMPLE_FMT_S16P,
-                                                      AV_SAMPLE_FMT_S32P,
-                                                      AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &ape_decoder_class,
 };

libavcodec/aptxdec.c+4−6

     .init                  = ff_aptx_init,
     FF_CODEC_DECODE_CB(aptx_decode_frame),
     .p.capabilities        = AV_CODEC_CAP_DR1,
-    .p.ch_layouts          = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_STEREO, { 0 } },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_STEREO),
-    .p.sample_fmts         = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32P),
-                                                             AV_SAMPLE_FMT_NONE },
 };
 #endif
     .init                  = ff_aptx_init,
     FF_CODEC_DECODE_CB(aptx_decode_frame),
     .p.capabilities        = AV_CODEC_CAP_DR1,
-    .p.ch_layouts          = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_STEREO, { 0 } },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_STEREO),
-    .p.sample_fmts         = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32P),
-                                                             AV_SAMPLE_FMT_NONE },
 };
 #endif

libavcodec/aptxenc.c+6−8

     .init                  = aptx_encode_init,
     FF_CODEC_ENCODE_CB(aptx_encode_frame),
     .close                 = aptx_close,
-    .p.ch_layouts          = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_STEREO, { 0 } },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_STEREO),
-    .p.sample_fmts         = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32P),
-                                                             AV_SAMPLE_FMT_NONE },
+    CODEC_SAMPLERATES(8000, 16000, 24000, 32000, 44100, 48000),
-    .p.supported_samplerates = (const int[]) {8000, 16000, 24000, 32000, 44100, 48000, 0},
 };
 #endif
     .init                  = aptx_encode_init,
     FF_CODEC_ENCODE_CB(aptx_encode_frame),
     .close                 = aptx_close,
-    .p.ch_layouts          = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_STEREO, { 0 } },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_STEREO),
-    .p.sample_fmts         = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32P),
-                                                             AV_SAMPLE_FMT_NONE },
+    CODEC_SAMPLERATES(8000, 16000, 24000, 32000, 44100, 48000),
-    .p.supported_samplerates = (const int[]) {8000, 16000, 24000, 32000, 44100, 48000, 0},
 };
 #endif

libavcodec/asvenc.c+2−4

     .priv_data_size = sizeof(ASVEncContext),
     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
-                                                     AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG,
 };
 #endif
     .priv_data_size = sizeof(ASVEncContext),
     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
-                                                     AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG,
 };
 #endif

libavcodec/atrac1.c+1−2

@@ -399,7 +399,6 @@ const FFCodec ff_atrac1_decoder = { · 398 unmodified lines
399	.close = atrac1_decode_end,	399	.close = atrac1_decode_end,
400	FF_CODEC_DECODE_CB(atrac1_decode_frame),	400	FF_CODEC_DECODE_CB(atrac1_decode_frame),
401	.p.capabilities = AV_CODEC_CAP_DR1,	401	.p.capabilities = AV_CODEC_CAP_DR1,
402	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,	402	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
403	AV_SAMPLE_FMT_NONE },
404	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	403	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
405	};	404	};

libavcodec/atrac3.c+2−4

                         AV_CODEC_CAP_SUBFRAMES |
 #endif
                         AV_CODEC_CAP_DR1,
-    .p.sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                        AV_SAMPLE_FMT_NONE },
     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
 };
                         AV_CODEC_CAP_SUBFRAMES |
 #endif
                         AV_CODEC_CAP_DR1,
-    .p.sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                        AV_SAMPLE_FMT_NONE },
     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/audiotoolboxenc.c+2−5

         .p.priv_class   = &ffat_##NAME##_enc_class, \
         .p.capabilities = AV_CODEC_CAP_DELAY | \
                           AV_CODEC_CAP_ENCODER_FLUSH CAPS, \
-        .p.ch_layouts   = CH_LAYOUTS, \
-        .p.sample_fmts  = (const enum AVSampleFormat[]) { \
-            AV_SAMPLE_FMT_S16, \
-            AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_NONE \
-        }, \
         .p.profiles     = PROFILES, \
         .p.wrapper_name = "at", \
+        CODEC_CH_LAYOUTS_ARRAY(CH_LAYOUTS), \
+        CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), \
     };
 static const AVChannelLayout aac_at_ch_layouts[] = {

libavcodec/avuienc.c+1−1

@@ -99,7 +99,7 @@ const FFCodec ff_avui_encoder = { · 98 unmodified lines
99	.p.id = AV_CODEC_ID_AVUI,	99	.p.id = AV_CODEC_ID_AVUI,
100	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_EXPERIMENTAL \|	100	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_EXPERIMENTAL \|
101	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	101	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
102	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_UYVY422, AV_PIX_FMT_NONE },	102	CODEC_PIXFMTS(AV_PIX_FMT_UYVY422),
103	.color_ranges = AVCOL_RANGE_MPEG,	103	.color_ranges = AVCOL_RANGE_MPEG,
104	.init = avui_encode_init,	104	.init = avui_encode_init,
105	FF_CODEC_ENCODE_CB(avui_encode_frame),	105	FF_CODEC_ENCODE_CB(avui_encode_frame),

libavcodec/bitpacked_enc.c+1−2

@@ -114,6 +114,5 @@ const FFCodec ff_bitpacked_encoder = { · 113 unmodified lines
114	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	114	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
115	.init = encode_init,	115	.init = encode_init,
116	FF_CODEC_ENCODE_CB(encode_frame),	116	FF_CODEC_ENCODE_CB(encode_frame),
117	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV422P10,	117	CODEC_PIXFMTS(AV_PIX_FMT_YUV422P10),
118	AV_PIX_FMT_NONE },
119	};	118	};

libavcodec/bmpenc.c+5−7

@@ -164,11 +164,9 @@ const FFCodec ff_bmp_encoder = { · 163 unmodified lines
164	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	164	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
165	.init = bmp_encode_init,	165	.init = bmp_encode_init,
166	FF_CODEC_ENCODE_CB(bmp_encode_frame),	166	FF_CODEC_ENCODE_CB(bmp_encode_frame),
167	.p.pix_fmts = (const enum AVPixelFormat[]){	167	CODEC_PIXFMTS(AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR24,
168	AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR24,	168	AV_PIX_FMT_RGB565, AV_PIX_FMT_RGB555, AV_PIX_FMT_RGB444,
169	AV_PIX_FMT_RGB565, AV_PIX_FMT_RGB555, AV_PIX_FMT_RGB444,	169	AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE,
170	AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,	170	AV_PIX_FMT_BGR4_BYTE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,
171	AV_PIX_FMT_MONOBLACK,	171	AV_PIX_FMT_MONOBLACK),
172	AV_PIX_FMT_NONE
173	},
174	};	172	};

libavcodec/bonk.c+1−2

@@ -432,6 +432,5 @@ const FFCodec ff_bonk_decoder = { · 431 unmodified lines
432	#endif	432	#endif
433	AV_CODEC_CAP_DR1,	433	AV_CODEC_CAP_DR1,
434	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	434	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
435	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,	435	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
436	AV_SAMPLE_FMT_NONE },
437	};	436	};

libavcodec/cfhdenc.c+1−6

     .init             = cfhd_encode_init,
     .close            = cfhd_encode_close,
     FF_CODEC_ENCODE_CB(cfhd_encode_frame),
-    .p.pix_fmts       = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV422P10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12),
-                          AV_PIX_FMT_YUV422P10,
-                          AV_PIX_FMT_GBRP12,
-                          AV_PIX_FMT_GBRAP12,
-                          AV_PIX_FMT_NONE
-                        },
     .color_ranges     = AVCOL_RANGE_MPEG,
     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/cinepakenc.c+1−1

@@ -1223,7 +1223,7 @@ const FFCodec ff_cinepak_encoder = { · 1222 unmodified lines
1223	.init = cinepak_encode_init,	1223	.init = cinepak_encode_init,
1224	FF_CODEC_ENCODE_CB(cinepak_encode_frame),	1224	FF_CODEC_ENCODE_CB(cinepak_encode_frame),
1225	.close = cinepak_encode_end,	1225	.close = cinepak_encode_end,
1226	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB24, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE },	1226	CODEC_PIXFMTS(AV_PIX_FMT_RGB24, AV_PIX_FMT_GRAY8),
1227	.p.priv_class = &cinepak_class,	1227	.p.priv_class = &cinepak_class,
1228	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1228	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1229	};	1229	};

libavcodec/cljrenc.c+1−2

     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     .priv_data_size = sizeof(CLJRContext),
     FF_CODEC_ENCODE_CB(encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV411P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV411P),
-                                                   AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &cljr_class,
 };

libavcodec/cngdec.c+1−2

     FF_CODEC_DECODE_CB(cng_decode_frame),
     .flush          = cng_decode_flush,
     .close          = cng_decode_close,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/cngenc.c+2−3

     .init           = cng_encode_init,
     FF_CODEC_ENCODE_CB(cng_encode_frame),
     .close          = cng_encode_close,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
-    .p.ch_layouts   = (const AVChannelLayout[]){ AV_CHANNEL_LAYOUT_MONO, { 0 } },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/codec_internal.h+28−0

@@ -327,6 +327,34 @@ int ff_default_get_supported_config(const struct AVCodecContext *avctx, · 326 unmodified lines
327	.cb_type = FF_CODEC_CB_TYPE_RECEIVE_PACKET, \	327	.cb_type = FF_CODEC_CB_TYPE_RECEIVE_PACKET, \
328	.cb.receive_packet = (func)	328	.cb.receive_packet = (func)
329		329
		330	#ifdef __clang__
		331	#define DISABLE_DEPRECATION_WARNINGS FF_DISABLE_DEPRECATION_WARNINGS
		332	#define ENABLE_DEPRECATION_WARNINGS FF_ENABLE_DEPRECATION_WARNINGS
		333	#else
		334	#define DISABLE_DEPRECATION_WARNINGS
		335	#define ENABLE_DEPRECATION_WARNINGS
		336	#endif
		337
		338	#define CODEC_CH_LAYOUTS(...) CODEC_CH_LAYOUTS_ARRAY(((const AVChannelLayout[]) { __VA_ARGS__, { 0 } }))
		339	#define CODEC_CH_LAYOUTS_ARRAY(array) CODEC_ARRAY(ch_layouts, (array))
		340
		341	#define CODEC_SAMPLERATES(...) CODEC_SAMPLERATES_ARRAY(((const int[]) { __VA_ARGS__, 0 }))
		342	#define CODEC_SAMPLERATES_ARRAY(array) CODEC_ARRAY(supported_samplerates, (array))
		343
		344	#define CODEC_SAMPLEFMTS(...) CODEC_SAMPLEFMTS_ARRAY(((const enum AVSampleFormat[]) { __VA_ARGS__, AV_SAMPLE_FMT_NONE }))
		345	#define CODEC_SAMPLEFMTS_ARRAY(array) CODEC_ARRAY(sample_fmts, (array))
		346
		347	#define CODEC_FRAMERATES(...) CODEC_FRAMERATES_ARRAY(((const AVRational[]) { __VA_ARGS__, { 0, 0 } }))
		348	#define CODEC_FRAMERATES_ARRAY(array) CODEC_ARRAY(supported_framerates, (array))
		349
		350	#define CODEC_PIXFMTS(...) CODEC_PIXFMTS_ARRAY(((const enum AVPixelFormat[]) { __VA_ARGS__, AV_PIX_FMT_NONE }))
		351	#define CODEC_PIXFMTS_ARRAY(array) CODEC_ARRAY(pix_fmts, (array))
		352
		353	#define CODEC_ARRAY(field, array) \
		354	DISABLE_DEPRECATION_WARNINGS \
		355	.p.field = (array) \
		356	ENABLE_DEPRECATION_WARNINGS
		357
330	static av_always_inline const FFCodec ffcodec(const AVCodec codec)	358	static av_always_inline const FFCodec ffcodec(const AVCodec codec)
331	{	359	{
332	return (const FFCodec*)codec;	360	return (const FFCodec*)codec;

libavcodec/cook.c+1−2

@@ -1308,7 +1308,6 @@ const FFCodec ff_cook_decoder = { · 1307 unmodified lines
1308	.close = cook_decode_close,	1308	.close = cook_decode_close,
1309	FF_CODEC_DECODE_CB(cook_decode_frame),	1309	FF_CODEC_DECODE_CB(cook_decode_frame),
1310	.p.capabilities = AV_CODEC_CAP_DR1,	1310	.p.capabilities = AV_CODEC_CAP_DR1,
1311	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,	1311	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
1312	AV_SAMPLE_FMT_NONE },
1313	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1312	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1314	};	1313	};

libavcodec/d3d12va_encode_hevc.c+1−4

     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = d3d12va_encode_hevc_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_D3D12),
-        AV_PIX_FMT_D3D12,
-        AV_PIX_FMT_NONE,
-    },
     .hw_configs     = ff_d3d12va_encode_hw_configs,
     .p.wrapper_name = "d3d12va",
 };

libavcodec/dcadec.c+1−2

     .close          = dcadec_close,
     .flush          = dcadec_flush,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &dcadec_class,
     .p.profiles     = NULL_IF_CONFIG_SMALL(ff_dca_profiles),
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,

libavcodec/dcaenc.c+5−11

     .close                 = encode_close,
     FF_CODEC_ENCODE_CB(encode_frame),
     .caps_internal         = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.sample_fmts         = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32),
-                                                            AV_SAMPLE_FMT_NONE },
+    CODEC_SAMPLERATES_ARRAY(sample_rates),
-    .p.supported_samplerates = sample_rates,
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO,
-    .p.ch_layouts     = (const AVChannelLayout[]){
+                     AV_CHANNEL_LAYOUT_2_2,  AV_CHANNEL_LAYOUT_5POINT0,
-        AV_CHANNEL_LAYOUT_MONO,
+                     AV_CHANNEL_LAYOUT_5POINT1),
-        AV_CHANNEL_LAYOUT_STEREO,
-        AV_CHANNEL_LAYOUT_2_2,
-        AV_CHANNEL_LAYOUT_5POINT0,
-        AV_CHANNEL_LAYOUT_5POINT1,
-        { 0 },
-    },
     .defaults              = defaults,
     .p.priv_class          = &dcaenc_class,
 };

libavcodec/dfpwmenc.c+1−1

@@ -115,7 +115,7 @@ const FFCodec ff_dfpwm_encoder = { · 114 unmodified lines
115	.priv_data_size = sizeof(DFPWMState),	115	.priv_data_size = sizeof(DFPWMState),
116	.init = dfpwm_enc_init,	116	.init = dfpwm_enc_init,
117	FF_CODEC_ENCODE_CB(dfpwm_enc_frame),	117	FF_CODEC_ENCODE_CB(dfpwm_enc_frame),
118	.p.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_NONE},	118	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8),
119	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_VARIABLE_FRAME_SIZE \|	119	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_VARIABLE_FRAME_SIZE \|
120	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	120	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
121	};	121	};

libavcodec/dnxhdenc.c+2−7

     .init           = dnxhd_encode_init,
     FF_CODEC_ENCODE_CB(dnxhd_encode_picture),
     .close          = dnxhd_encode_end,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P10,
-        AV_PIX_FMT_YUV422P,
+                  AV_PIX_FMT_YUV444P10, AV_PIX_FMT_GBRP10),
-        AV_PIX_FMT_YUV422P10,
-        AV_PIX_FMT_YUV444P10,
-        AV_PIX_FMT_GBRP10,
-        AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &dnxhd_class,
     .defaults       = dnxhd_defaults,

libavcodec/dolby_e.c+1−1

@@ -1310,6 +1310,6 @@ const FFCodec ff_dolby_e_decoder = { · 1309 unmodified lines
1310	.close = dolby_e_close,	1310	.close = dolby_e_close,
1311	.flush = dolby_e_flush,	1311	.flush = dolby_e_flush,
1312	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,	1312	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,
1313	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },	1313	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
1314	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1314	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1315	};	1315	};

libavcodec/dpxenc.c+7−9

@@ -283,13 +283,11 @@ const FFCodec ff_dpx_encoder = { · 282 unmodified lines
283	.priv_data_size = sizeof(DPXContext),	283	.priv_data_size = sizeof(DPXContext),
284	.init = encode_init,	284	.init = encode_init,
285	FF_CODEC_ENCODE_CB(encode_frame),	285	FF_CODEC_ENCODE_CB(encode_frame),
286	.p.pix_fmts = (const enum AVPixelFormat[]){	286	CODEC_PIXFMTS(AV_PIX_FMT_GRAY8,
287	AV_PIX_FMT_GRAY8,	287	AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR,
288	AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR,	288	AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_GRAY16BE,
289	AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_GRAY16BE,	289	AV_PIX_FMT_RGB48LE, AV_PIX_FMT_RGB48BE,
290	AV_PIX_FMT_RGB48LE, AV_PIX_FMT_RGB48BE,	290	AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_RGBA64BE,
291	AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_RGBA64BE,	291	AV_PIX_FMT_GBRP10LE, AV_PIX_FMT_GBRP10BE,
292	AV_PIX_FMT_GBRP10LE, AV_PIX_FMT_GBRP10BE,	292	AV_PIX_FMT_GBRP12LE, AV_PIX_FMT_GBRP12BE),
293	AV_PIX_FMT_GBRP12LE, AV_PIX_FMT_GBRP12BE,
294	AV_PIX_FMT_NONE},
295	};	293	};

libavcodec/dsddec.c+1−2

@@ -126,8 +126,7 @@ const FFCodec ff_ ## name_ ## _decoder = { \ · 125 unmodified lines
126	.init = decode_init, \	126	.init = decode_init, \
127	FF_CODEC_DECODE_CB(decode_frame), \	127	FF_CODEC_DECODE_CB(decode_frame), \
128	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_SLICE_THREADS, \	128	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_SLICE_THREADS, \
129	.p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP, \	129	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP), \
130	AV_SAMPLE_FMT_NONE }, \
131	};	130	};
132		131
133	DSD_DECODER(DSD_LSBF, dsd_lsbf, "DSD (Direct Stream Digital), least significant bit first")	132	DSD_DECODER(DSD_LSBF, dsd_lsbf, "DSD (Direct Stream Digital), least significant bit first")

libavcodec/dstdec.c+1−2

@@ -392,6 +392,5 @@ const FFCodec ff_dst_decoder = { · 391 unmodified lines
392	.init = decode_init,	392	.init = decode_init,
393	FF_CODEC_DECODE_CB(decode_frame),	393	FF_CODEC_DECODE_CB(decode_frame),
394	.p.capabilities = AV_CODEC_CAP_DR1,	394	.p.capabilities = AV_CODEC_CAP_DR1,
395	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,	395	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLT),
396	AV_SAMPLE_FMT_NONE },
397	};	396	};

libavcodec/dvenc.c+1−4

     .priv_data_size = sizeof(DVEncContext),
     .init           = dvvideo_encode_init,
     FF_CODEC_ENCODE_CB(dvvideo_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P),
-        AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &dvvideo_encode_class,
 };

libavcodec/dxvenc.c+1−3

                       AV_CODEC_CAP_SLICE_THREADS |
                       AV_CODEC_CAP_FRAME_THREADS,
     .p.priv_class   = &dxvenc_class,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_RGBA),
-        AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE,
-    },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/eac3enc.c+3−4

     .init            = eac3_encode_init,
     FF_CODEC_ENCODE_CB(ff_ac3_encode_frame),
     .close           = ff_ac3_encode_close,
-    .p.sample_fmts   = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .p.priv_class    = &eac3enc_class,
-    .p.supported_samplerates = ff_ac3_sample_rate_tab,
+    CODEC_SAMPLERATES_ARRAY(ff_ac3_sample_rate_tab),
-    .p.ch_layouts    = ff_ac3_ch_layouts,
+    CODEC_CH_LAYOUTS_ARRAY(ff_ac3_ch_layouts),
     .defaults        = ff_ac3_enc_defaults,
     .caps_internal   = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/exrenc.c+1−5

     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = encode_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_GRAYF32, AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32),
-                                                 AV_PIX_FMT_GRAYF32,
-                                                 AV_PIX_FMT_GBRPF32,
-                                                 AV_PIX_FMT_GBRAPF32,
-                                                 AV_PIX_FMT_NONE },
 };

libavcodec/fastaudio.c+1−2

@@ -195,6 +195,5 @@ const FFCodec ff_fastaudio_decoder = { · 194 unmodified lines
195	FF_CODEC_DECODE_CB(fastaudio_decode),	195	FF_CODEC_DECODE_CB(fastaudio_decode),
196	.close = fastaudio_close,	196	.close = fastaudio_close,
197	.p.capabilities = AV_CODEC_CAP_DR1,	197	.p.capabilities = AV_CODEC_CAP_DR1,
198	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,	198	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
199	AV_SAMPLE_FMT_NONE },
200	};	199	};

libavcodec/ffv1enc.c+2−5

     .init           = encode_init_internal,
     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = encode_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(
         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
         AV_PIX_FMT_GRAY9,
         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
         AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
-        AV_PIX_FMT_GBRPF16,
+        AV_PIX_FMT_GBRPF16),
-        AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &ffv1_class,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,

libavcodec/ffv1enc_vulkan.c+1−4

                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
     .defaults       = vulkan_encode_ffv1_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VULKAN),
-        AV_PIX_FMT_VULKAN,
-        AV_PIX_FMT_NONE,
-    },
     .hw_configs     = vulkan_encode_ffv1_hw_configs,
     .p.wrapper_name = "vulkan",
 };

libavcodec/fitsenc.c+2−7

     .p.id           = AV_CODEC_ID_FITS,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     FF_CODEC_ENCODE_CB(fits_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_GBRAP16BE,
+    CODEC_PIXFMTS(AV_PIX_FMT_GBRAP16BE, AV_PIX_FMT_GBRP16BE, AV_PIX_FMT_GBRP,
-                                                     AV_PIX_FMT_GBRP16BE,
+                  AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_GRAY8),
-                                                     AV_PIX_FMT_GBRP,
-                                                     AV_PIX_FMT_GBRAP,
-                                                     AV_PIX_FMT_GRAY16BE,
-                                                     AV_PIX_FMT_GRAY8,
-                                                     AV_PIX_FMT_NONE },
 };

libavcodec/flacdec.c+2−5

     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1 |
                       AV_CODEC_CAP_FRAME_THREADS,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
-                                                      AV_SAMPLE_FMT_S16P,
+                     AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P),
-                                                      AV_SAMPLE_FMT_S32,
-                                                      AV_SAMPLE_FMT_S32P,
-                                                      AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &flac_decoder_class,
 };

libavcodec/flacenc.c+1−3

     .init           = flac_encode_init,
     FF_CODEC_ENCODE_CB(flac_encode_frame),
     .close          = flac_encode_close,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32),
-                                                     AV_SAMPLE_FMT_S32,
-                                                     AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &flac_encoder_class,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
 };

libavcodec/flashsv2enc.c+1−1

@@ -920,6 +920,6 @@ const FFCodec ff_flashsv2_encoder = { · 919 unmodified lines
920	.init = flashsv2_encode_init,	920	.init = flashsv2_encode_init,
921	FF_CODEC_ENCODE_CB(flashsv2_encode_frame),	921	FF_CODEC_ENCODE_CB(flashsv2_encode_frame),
922	.close = flashsv2_encode_end,	922	.close = flashsv2_encode_end,
923	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },	923	CODEC_PIXFMTS(AV_PIX_FMT_BGR24),
924	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	924	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
925	};	925	};

libavcodec/flashsvenc.c+1−1

@@ -262,5 +262,5 @@ const FFCodec ff_flashsv_encoder = { · 261 unmodified lines
262	.init = flashsv_encode_init,	262	.init = flashsv_encode_init,
263	FF_CODEC_ENCODE_CB(flashsv_encode_frame),	263	FF_CODEC_ENCODE_CB(flashsv_encode_frame),
264	.close = flashsv_encode_end,	264	.close = flashsv_encode_end,
265	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },	265	CODEC_PIXFMTS(AV_PIX_FMT_BGR24),
266	};	266	};

libavcodec/flvenc.c+1−2

@@ -94,7 +94,6 @@ const FFCodec ff_flv_encoder = { · 93 unmodified lines
94	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),	94	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
95	.close = ff_mpv_encode_end,	95	.close = ff_mpv_encode_end,
96	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	96	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
97	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,	97	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
98	AV_PIX_FMT_NONE},
99	.color_ranges = AVCOL_RANGE_MPEG,	98	.color_ranges = AVCOL_RANGE_MPEG,
100	};	99	};

libavcodec/g722enc.c+2−4

     .init            = g722_encode_init,
     .close           = g722_encode_close,
     FF_CODEC_ENCODE_CB(g722_encode_frame),
-    .p.sample_fmts   = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-    .p.ch_layouts   = (const AVChannelLayout[]){
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
-        AV_CHANNEL_LAYOUT_MONO, { 0 }
-    },
     .caps_internal   = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/g723_1enc.c+2−6

     .init           = g723_1_encode_init,
     FF_CODEC_ENCODE_CB(g723_1_encode_frame),
     .defaults       = defaults,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) {
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-        AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
-    },
-    .p.ch_layouts   = (const AVChannelLayout[]){
-        AV_CHANNEL_LAYOUT_MONO, { 0 }
-    },
 };

libavcodec/g726.c+2−4

     .priv_data_size = sizeof(G726Context),
     .init           = g726_encode_init,
     FF_CODEC_ENCODE_CB(g726_encode_frame),
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &g726_class,
     .defaults       = defaults,
 };
     .priv_data_size = sizeof(G726Context),
     .init           = g726_encode_init,
     FF_CODEC_ENCODE_CB(g726_encode_frame),
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &g726_class,
     .defaults       = defaults,
 };

libavcodec/gif.c+2−4

     .init           = gif_encode_init,
     FF_CODEC_ENCODE_CB(gif_encode_frame),
     .close          = gif_encode_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE,
-        AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,
+                  AV_PIX_FMT_BGR4_BYTE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8),
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE
-    },
     .p.priv_class   = &gif_class,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/h261enc.c+1−2

@@ -395,7 +395,6 @@ const FFCodec ff_h261_encoder = { · 394 unmodified lines
395	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),	395	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
396	.close = ff_mpv_encode_end,	396	.close = ff_mpv_encode_end,
397	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	397	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
398	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,	398	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
399	AV_PIX_FMT_NONE },
400	.color_ranges = AVCOL_RANGE_MPEG,	399	.color_ranges = AVCOL_RANGE_MPEG,
401	};	400	};

libavcodec/hapenc.c+1−3

     .init           = hap_init,
     FF_CODEC_ENCODE_CB(hap_encode),
     .close          = hap_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_RGBA),
-        AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE,
-    },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/hcadec.c+1−2

@@ -634,6 +634,5 @@ const FFCodec ff_hca_decoder = { · 633 unmodified lines
634	.close = decode_close,	634	.close = decode_close,
635	.p.capabilities = AV_CODEC_CAP_DR1,	635	.p.capabilities = AV_CODEC_CAP_DR1,
636	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	636	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
637	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,	637	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
638	AV_SAMPLE_FMT_NONE },
639	};	638	};

libavcodec/hdrenc.c+1−4

     .init           = hdr_encode_init,
     FF_CODEC_ENCODE_CB(hdr_encode_frame),
     .close          = hdr_encode_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_GBRPF32),
-        AV_PIX_FMT_GBRPF32,
-        AV_PIX_FMT_NONE
-    },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/huffyuvenc.c+3−7

     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = encode_end,
     .p.priv_class   = &normal_class,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32),
-        AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24,
-        AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = encode_end,
     .p.priv_class   = &ff_class,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV411P,
         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P,
         AV_PIX_FMT_GBRP,
         AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA422P16,
         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P16,
         AV_PIX_FMT_RGB24,
-        AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
+        AV_PIX_FMT_RGB32),
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/imc.c+2−4

     FF_CODEC_DECODE_CB(imc_decode_frame),
     .flush          = flush,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif
     FF_CODEC_DECODE_CB(imc_decode_frame),
     .flush          = flush,
     .p.capabilities = AV_CODEC_CAP_DR1,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif

libavcodec/ituh263enc.c+2−2

@@ -903,7 +903,7 @@ const FFCodec ff_h263_encoder = { · 902 unmodified lines
903	CODEC_LONG_NAME("H.263 / H.263-1996"),	903	CODEC_LONG_NAME("H.263 / H.263-1996"),
904	.p.type = AVMEDIA_TYPE_VIDEO,	904	.p.type = AVMEDIA_TYPE_VIDEO,
905	.p.id = AV_CODEC_ID_H263,	905	.p.id = AV_CODEC_ID_H263,
906	.p.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},	906	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
907	.color_ranges = AVCOL_RANGE_MPEG,	907	.color_ranges = AVCOL_RANGE_MPEG,
908	.p.priv_class = &h263_class,	908	.p.priv_class = &h263_class,
909	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	909	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
@@ -935,7 +935,7 @@ const FFCodec ff_h263p_encoder = { · 25 unmodified lines
935	CODEC_LONG_NAME("H.263+ / H.263-1998 / H.263 version 2"),	935	CODEC_LONG_NAME("H.263+ / H.263-1998 / H.263 version 2"),
936	.p.type = AVMEDIA_TYPE_VIDEO,	936	.p.type = AVMEDIA_TYPE_VIDEO,
937	.p.id = AV_CODEC_ID_H263P,	937	.p.id = AV_CODEC_ID_H263P,
938	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	938	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
939	.color_ranges = AVCOL_RANGE_MPEG,	939	.color_ranges = AVCOL_RANGE_MPEG,
940	.p.priv_class = &h263p_class,	940	.p.priv_class = &h263p_class,
941	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_SLICE_THREADS \|	941	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_SLICE_THREADS \|

libavcodec/j2kenc.c+2−4

     .init           = j2kenc_init,
     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = j2kenc_destroy,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(
         AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48,
         AV_PIX_FMT_GBR24P,AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
         AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA422P16,
         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P16,
-        AV_PIX_FMT_PAL8,
+        AV_PIX_FMT_PAL8),
-        AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &j2k_class,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,

libavcodec/jpeglsenc.c+2−5

     .init           = encode_jpegls_init,
     FF_CODEC_ENCODE_CB(encode_picture_ls),
     .close          = encode_jpegls_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,
-        AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,
+                  AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16),
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
-        AV_PIX_FMT_NONE
-    },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/lclenc.c+1−1

@@ -162,6 +162,6 @@ const FFCodec ff_zlib_encoder = { · 161 unmodified lines
162	.init = encode_init,	162	.init = encode_init,
163	FF_CODEC_ENCODE_CB(encode_frame),	163	FF_CODEC_ENCODE_CB(encode_frame),
164	.close = encode_end,	164	.close = encode_end,
165	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },	165	CODEC_PIXFMTS(AV_PIX_FMT_BGR24),
166	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	166	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
167	};	167	};

libavcodec/libcodec2.c+6−6

@@ -182,9 +182,9 @@ const FFCodec ff_libcodec2_decoder = { · 181 unmodified lines
182	.p.type = AVMEDIA_TYPE_AUDIO,	182	.p.type = AVMEDIA_TYPE_AUDIO,
183	.p.id = AV_CODEC_ID_CODEC2,	183	.p.id = AV_CODEC_ID_CODEC2,
184	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF,	184	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF,
185	.p.supported_samplerates = (const int[]){ 8000, 0 },	185	CODEC_SAMPLERATES(8000),
186	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },	186	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
187	.p.ch_layouts = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO, { 0 } },	187	CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
188	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE,	188	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE,
189	.priv_data_size = sizeof(LibCodec2Context),	189	.priv_data_size = sizeof(LibCodec2Context),
190	.init = libcodec2_init_decoder,	190	.init = libcodec2_init_decoder,
@@ -199,9 +199,9 @@ const FFCodec ff_libcodec2_encoder = { · 8 unmodified lines
199	.p.id = AV_CODEC_ID_CODEC2,	199	.p.id = AV_CODEC_ID_CODEC2,
200	.p.capabilities = AV_CODEC_CAP_DR1 \|	200	.p.capabilities = AV_CODEC_CAP_DR1 \|
201	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	201	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
202	.p.supported_samplerates = (const int[]){ 8000, 0 },	202	CODEC_SAMPLERATES(8000),
203	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },	203	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
204	.p.ch_layouts = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO, { 0 } },	204	CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
205	.p.priv_class = &libcodec2_enc_class,	205	.p.priv_class = &libcodec2_enc_class,
206	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE,	206	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE,
207	.priv_data_size = sizeof(LibCodec2Context),	207	.priv_data_size = sizeof(LibCodec2Context),

libavcodec/libfdk-aacenc.c+3−4

     FF_CODEC_ENCODE_CB(aac_encode_frame),
     .flush                 = aac_encode_flush,
     .close                 = aac_encode_close,
-    .p.sample_fmts         = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                            AV_SAMPLE_FMT_NONE },
     .p.priv_class          = &aac_enc_class,
     .defaults              = aac_encode_defaults,
     .p.profiles            = profiles,
-    .p.supported_samplerates = aac_sample_rates,
+    CODEC_SAMPLERATES_ARRAY(aac_sample_rates),
     .p.wrapper_name        = "libfdk",
-    .p.ch_layouts          = aac_ch_layouts,
+    CODEC_CH_LAYOUTS_ARRAY(aac_ch_layouts),
 };

libavcodec/libgsmenc.c+4−6

     FF_CODEC_ENCODE_CB(libgsm_encode_frame),
     .close          = libgsm_encode_close,
     .defaults       = libgsm_defaults,
-    .p.ch_layouts   = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO, { 0 } },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
     .p.wrapper_name = "libgsm",
     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE,
 };
     FF_CODEC_ENCODE_CB(libgsm_encode_frame),
     .close          = libgsm_encode_close,
     .defaults       = libgsm_defaults,
-    .p.ch_layouts   = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO, { 0 } },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
     .p.wrapper_name = "libgsm",
     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE,
 };

libavcodec/libilbc.c+1−2

     .priv_data_size = sizeof(ILBCEncContext),
     .init           = ilbc_encode_init,
     FF_CODEC_ENCODE_CB(ilbc_encode_frame),
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
     .defaults       = ilbc_encode_defaults,
     .p.priv_class   = &ilbc_enc_class,
     .p.wrapper_name = "libbilbc",

libavcodec/libjxlenc.c+2−2

@@ -699,7 +699,7 @@ const FFCodec ff_libjxl_encoder = { · 698 unmodified lines
699	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|	699	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|
700	FF_CODEC_CAP_AUTO_THREADS \| FF_CODEC_CAP_INIT_CLEANUP \|	700	FF_CODEC_CAP_AUTO_THREADS \| FF_CODEC_CAP_INIT_CLEANUP \|
701	FF_CODEC_CAP_ICC_PROFILES,	701	FF_CODEC_CAP_ICC_PROFILES,
702	.p.pix_fmts = libjxl_supported_pixfmts,	702	CODEC_PIXFMTS_ARRAY(libjxl_supported_pixfmts),
703	.p.priv_class = &libjxl_encode_class,	703	.p.priv_class = &libjxl_encode_class,
704	.p.wrapper_name = "libjxl",	704	.p.wrapper_name = "libjxl",
705	};	705	};
@@ -719,7 +719,7 @@ const FFCodec ff_libjxl_anim_encoder = { · 13 unmodified lines
719	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|	719	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|
720	FF_CODEC_CAP_AUTO_THREADS \| FF_CODEC_CAP_INIT_CLEANUP \|	720	FF_CODEC_CAP_AUTO_THREADS \| FF_CODEC_CAP_INIT_CLEANUP \|
721	FF_CODEC_CAP_ICC_PROFILES,	721	FF_CODEC_CAP_ICC_PROFILES,
722	.p.pix_fmts = libjxl_supported_pixfmts,	722	CODEC_PIXFMTS_ARRAY(libjxl_supported_pixfmts),
723	.p.priv_class = &libjxl_encode_class,	723	.p.priv_class = &libjxl_encode_class,
724	.p.wrapper_name = "libjxl",	724	.p.wrapper_name = "libjxl",
725	};	725	};

libavcodec/libkvazaar.c+1−1

@@ -333,7 +333,7 @@ const FFCodec ff_libkvazaar_encoder = { · 332 unmodified lines
333	.p.id = AV_CODEC_ID_HEVC,	333	.p.id = AV_CODEC_ID_HEVC,
334	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|	334	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|
335	AV_CODEC_CAP_OTHER_THREADS,	335	AV_CODEC_CAP_OTHER_THREADS,
336	.p.pix_fmts = pix_fmts,	336	CODEC_PIXFMTS_ARRAY(pix_fmts),
337	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	337	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
338		338
339	.p.priv_class = &class,	339	.p.priv_class = &class,

libavcodec/liblc3enc.c+2−4

     .p.type         = AVMEDIA_TYPE_AUDIO,
     .p.id           = AV_CODEC_ID_LC3,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .p.supported_samplerates = (const int [])
-        { 96000, 48000, 32000, 24000, 16000, 8000, 0 },
-    .p.sample_fmts = (const enum AVSampleFormat[])
-        { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &class,
     .p.wrapper_name = "liblc3",
+    CODEC_SAMPLERATES(96000, 48000, 32000, 24000, 16000, 8000),
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
     .priv_data_size = sizeof(LibLC3EncContext),
     .init           = liblc3_encode_init,
     .close          = liblc3_encode_close,

libavcodec/libmp3lame.c+3−9

     .init                  = mp3lame_encode_init,
     FF_CODEC_ENCODE_CB(mp3lame_encode_frame),
     .close                 = mp3lame_encode_close,
-    .p.sample_fmts         = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_S16P),
-                                                             AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLERATES_ARRAY(libmp3lame_sample_rates),
-                                                             AV_SAMPLE_FMT_S16P,
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-                                                             AV_SAMPLE_FMT_NONE },
-    .p.supported_samplerates = libmp3lame_sample_rates,
-    .p.ch_layouts          = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO,
-                                                         AV_CHANNEL_LAYOUT_STEREO,
-                                                         { 0 },
-    },
     .p.priv_class          = &libmp3lame_class,
     .defaults              = libmp3lame_defaults,
     .p.wrapper_name        = "libmp3lame",

libavcodec/libopencore-amr.c+1−2

     .init           = amr_nb_encode_init,
     FF_CODEC_ENCODE_CB(amr_nb_encode_frame),
     .close          = amr_nb_encode_close,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &amrnb_class,
 };
 #endif /* CONFIG_LIBOPENCORE_AMRNB_ENCODER */

libavcodec/libopenh264enc.c+1−3

     .close          = svc_encode_close,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP |
                       FF_CODEC_CAP_AUTO_THREADS,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
-                                                    AV_PIX_FMT_YUVJ420P,
-                                                    AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .defaults       = svc_enc_defaults,
     .p.priv_class   = &class,

libavcodec/libopenjpegenc.c+2−4

     FF_CODEC_ENCODE_CB(libopenjpeg_encode_frame),
     .p.capabilities = AV_CODEC_CAP_FRAME_THREADS |
                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(
         AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48,
         AV_PIX_FMT_RGBA64, AV_PIX_FMT_GBR24P,
         AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
-        AV_PIX_FMT_XYZ12,
+        AV_PIX_FMT_XYZ12),
-        AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &openjpeg_class,
     .p.wrapper_name = "libopenjpeg",

libavcodec/libopusdec.c+1−3

     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_S16,
-                                                     AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &libopusdec_class,
     .p.wrapper_name = "libopus",
 };

libavcodec/libopusenc.c+2−4

     .init            = libopus_encode_init,
     FF_CODEC_ENCODE_CB(libopus_encode),
     .close           = libopus_encode_close,
-    .p.sample_fmts   = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT),
-                                                      AV_SAMPLE_FMT_FLT,
+    CODEC_SAMPLERATES_ARRAY(libopus_sample_rates),
-                                                      AV_SAMPLE_FMT_NONE },
-    .p.supported_samplerates = libopus_sample_rates,
     .p.priv_class    = &libopus_class,
     .defaults        = libopus_defaults,
     .p.wrapper_name  = "libopus",

libavcodec/librav1e.c+1−1

@@ -667,7 +667,7 @@ const FFCodec ff_librav1e_encoder = { · 666 unmodified lines
667	.priv_data_size = sizeof(librav1eContext),	667	.priv_data_size = sizeof(librav1eContext),
668	.p.priv_class = &class,	668	.p.priv_class = &class,
669	.defaults = librav1e_defaults,	669	.defaults = librav1e_defaults,
670	.p.pix_fmts = librav1e_pix_fmts,	670	CODEC_PIXFMTS_ARRAY(librav1e_pix_fmts),
671	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	671	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
672	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_OTHER_THREADS \|	672	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_OTHER_THREADS \|
673	AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_RECON_FRAME \|	673	AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_RECON_FRAME \|

libavcodec/libshine.c+3−7

     .init                  = libshine_encode_init,
     FF_CODEC_ENCODE_CB(libshine_encode_frame),
     .close                 = libshine_encode_close,
-    .p.sample_fmts         = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
-                                                            AV_SAMPLE_FMT_NONE },
+    CODEC_SAMPLERATES_ARRAY(libshine_sample_rates),
-    .p.supported_samplerates = libshine_sample_rates,
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-    .p.ch_layouts          = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO,
-                                                         AV_CHANNEL_LAYOUT_STEREO,
-                                                         { 0 },
-    },
     .p.wrapper_name        = "libshine",
 };

libavcodec/libspeexenc.c+3−7

     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = encode_close,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-    .p.ch_layouts    = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO,
+    CODEC_SAMPLERATES(8000, 16000, 32000),
-                                                   AV_CHANNEL_LAYOUT_STEREO,
-                                                   { 0 },
-    },
-    .p.supported_samplerates = (const int[]){ 8000, 16000, 32000, 0 },
     .p.priv_class   = &speex_class,
     .defaults       = defaults,
     .p.wrapper_name = "libspeex",

libavcodec/libsvtav1.c+1−3

     .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS,
     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_AUTO_THREADS | FF_CODEC_CAP_INIT_CLEANUP,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P10),
-                                                    AV_PIX_FMT_YUV420P10,
-                                                    AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .p.priv_class   = &class,
     .defaults       = eb_enc_defaults,

libavcodec/libtheoraenc.c+1−3

     .init           = encode_init,
     .close          = encode_close,
     FF_CODEC_ENCODE_CB(encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P),
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.wrapper_name = "libtheora",
 };

libavcodec/libtwolame.c+4−13

     .close          = twolame_encode_close,
     .defaults       = twolame_defaults,
     .p.priv_class   = &twolame_class,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) {
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
-        AV_SAMPLE_FMT_FLT,
+                     AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P),
-        AV_SAMPLE_FMT_FLTP,
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-        AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLERATES_ARRAY(twolame_samplerates),
-        AV_SAMPLE_FMT_S16P,
-        AV_SAMPLE_FMT_NONE
-    },
-    .p.ch_layouts    = (const AVChannelLayout[]) {
-        AV_CHANNEL_LAYOUT_MONO,
-        AV_CHANNEL_LAYOUT_STEREO,
-        { 0 },
-    },
-    .p.supported_samplerates = twolame_samplerates,
     .p.wrapper_name = "libtwolame",
 };

libavcodec/libvo-amrwbenc.c+1−2

@@ -153,6 +153,5 @@ const FFCodec ff_libvo_amrwbenc_encoder = { · 152 unmodified lines
153	.init = amr_wb_encode_init,	153	.init = amr_wb_encode_init,
154	FF_CODEC_ENCODE_CB(amr_wb_encode_frame),	154	FF_CODEC_ENCODE_CB(amr_wb_encode_frame),
155	.close = amr_wb_encode_close,	155	.close = amr_wb_encode_close,
156	.p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,	156	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
157	AV_SAMPLE_FMT_NONE },
158	};	157	};

libavcodec/libvorbisenc.c+1−2

     .init           = libvorbis_encode_init,
     FF_CODEC_ENCODE_CB(libvorbis_encode_frame),
     .close          = libvorbis_encode_close,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .p.priv_class   = &vorbis_class,
     .defaults       = defaults,
     .p.wrapper_name = "libvorbis",

libavcodec/libvpxenc.c+1−1

@@ -2044,7 +2044,7 @@ const FFCodec ff_libvpx_vp8_encoder = { · 2043 unmodified lines
2044	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|	2044	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|
2045	FF_CODEC_CAP_INIT_CLEANUP \|	2045	FF_CODEC_CAP_INIT_CLEANUP \|
2046	FF_CODEC_CAP_AUTO_THREADS,	2046	FF_CODEC_CAP_AUTO_THREADS,
2047	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_NONE },	2047	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P),
2048	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	2048	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
2049	.p.priv_class = &class_vp8,	2049	.p.priv_class = &class_vp8,
2050	.defaults = defaults,	2050	.defaults = defaults,

libavcodec/libvvenc.c+1−1

@@ -482,7 +482,7 @@ const FFCodec ff_libvvenc_encoder = { · 481 unmodified lines
482	.p.priv_class = &class,	482	.p.priv_class = &class,
483	.p.wrapper_name = "libvvenc",	483	.p.wrapper_name = "libvvenc",
484	.priv_data_size = sizeof(VVenCContext),	484	.priv_data_size = sizeof(VVenCContext),
485	.p.pix_fmts = pix_fmts_vvenc,	485	CODEC_PIXFMTS_ARRAY(pix_fmts_vvenc),
486	.init = vvenc_init,	486	.init = vvenc_init,
487	FF_CODEC_ENCODE_CB(vvenc_frame),	487	FF_CODEC_ENCODE_CB(vvenc_frame),
488	.close = vvenc_close,	488	.close = vvenc_close,

libavcodec/libwebpenc.c+1−1

@@ -94,7 +94,7 @@ const FFCodec ff_libwebp_encoder = { · 93 unmodified lines
94	.p.type = AVMEDIA_TYPE_VIDEO,	94	.p.type = AVMEDIA_TYPE_VIDEO,
95	.p.id = AV_CODEC_ID_WEBP,	95	.p.id = AV_CODEC_ID_WEBP,
96	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	96	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
97	.p.pix_fmts = ff_libwebpenc_pix_fmts,	97	CODEC_PIXFMTS_ARRAY(ff_libwebpenc_pix_fmts),
98	.color_ranges = AVCOL_RANGE_MPEG,	98	.color_ranges = AVCOL_RANGE_MPEG,
99	.p.priv_class = &ff_libwebpenc_class,	99	.p.priv_class = &ff_libwebpenc_class,
100	.p.wrapper_name = "libwebp",	100	.p.wrapper_name = "libwebp",

libavcodec/libwebpenc_animencoder.c+1−1

@@ -167,7 +167,7 @@ const FFCodec ff_libwebp_anim_encoder = { · 166 unmodified lines
167	.p.id = AV_CODEC_ID_WEBP,	167	.p.id = AV_CODEC_ID_WEBP,
168	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|	168	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|
169	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	169	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
170	.p.pix_fmts = ff_libwebpenc_pix_fmts,	170	CODEC_PIXFMTS_ARRAY(ff_libwebpenc_pix_fmts),
171	.color_ranges = AVCOL_RANGE_MPEG,	171	.color_ranges = AVCOL_RANGE_MPEG,
172	.p.priv_class = &ff_libwebpenc_class,	172	.p.priv_class = &ff_libwebpenc_class,
173	.p.wrapper_name = "libwebp",	173	.p.wrapper_name = "libwebp",

libavcodec/libx264.c+3−3

@@ -1633,7 +1633,7 @@ const FFCodec ff_libx264_encoder = { · 1632 unmodified lines
1633	.flush = X264_flush,	1633	.flush = X264_flush,
1634	.close = X264_close,	1634	.close = X264_close,
1635	.defaults = x264_defaults,	1635	.defaults = x264_defaults,
1636	.p.pix_fmts = pix_fmts_all,	1636	CODEC_PIXFMTS_ARRAY(pix_fmts_all),
1637	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	1637	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
1638	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP \| FF_CODEC_CAP_AUTO_THREADS	1638	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP \| FF_CODEC_CAP_AUTO_THREADS
1639	#if X264_BUILD < 158	1639	#if X264_BUILD < 158
@@ -1659,7 +1659,7 @@ const FFCodec ff_libx264rgb_encoder = { · 19 unmodified lines
1659	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|	1659	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|
1660	AV_CODEC_CAP_OTHER_THREADS \|	1660	AV_CODEC_CAP_OTHER_THREADS \|
1661	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	1661	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1662	.p.pix_fmts = pix_fmts_8bit_rgb,	1662	CODEC_PIXFMTS_ARRAY(pix_fmts_8bit_rgb),
1663	.p.priv_class = &rgbclass,	1663	.p.priv_class = &rgbclass,
1664	.p.wrapper_name = "libx264",	1664	.p.wrapper_name = "libx264",
1665	.priv_data_size = sizeof(X264Context),	1665	.priv_data_size = sizeof(X264Context),
@@ -1691,7 +1691,7 @@ const FFCodec ff_libx262_encoder = { · 25 unmodified lines
1691	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|	1691	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|
1692	AV_CODEC_CAP_OTHER_THREADS \|	1692	AV_CODEC_CAP_OTHER_THREADS \|
1693	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	1693	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1694	.p.pix_fmts = pix_fmts_8bit,	1694	CODEC_PIXFMTS_ARRAY(pix_fmts_8bit),
1695	.color_ranges = AVCOL_RANGE_MPEG,	1695	.color_ranges = AVCOL_RANGE_MPEG,
1696	.p.priv_class = &X262_class,	1696	.p.priv_class = &X262_class,
1697	.p.wrapper_name = "libx264",	1697	.p.wrapper_name = "libx264",

libavcodec/libxavs.c+1−1

@@ -434,7 +434,7 @@ const FFCodec ff_libxavs_encoder = { · 433 unmodified lines
434	.close = XAVS_close,	434	.close = XAVS_close,
435	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|	435	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|
436	FF_CODEC_CAP_AUTO_THREADS,	436	FF_CODEC_CAP_AUTO_THREADS,
437	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	437	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
438	.color_ranges = AVCOL_RANGE_MPEG,	438	.color_ranges = AVCOL_RANGE_MPEG,
439	.p.priv_class = &xavs_class,	439	.p.priv_class = &xavs_class,
440	.defaults = xavs_defaults,	440	.defaults = xavs_defaults,

libavcodec/libxavs2.c+1−2

     .close          = xavs2_close,
     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_AUTO_THREADS,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
-                                                     AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &libxavs2,
     .defaults       = xavs2_defaults,

libavcodec/libxeve.c+1−1

@@ -613,7 +613,7 @@ const FFCodec ff_libxeve_encoder = { · 612 unmodified lines
613	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_OTHER_THREADS \| AV_CODEC_CAP_DR1,	613	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_OTHER_THREADS \| AV_CODEC_CAP_DR1,
614	.p.profiles = NULL_IF_CONFIG_SMALL(ff_evc_profiles),	614	.p.profiles = NULL_IF_CONFIG_SMALL(ff_evc_profiles),
615	.p.wrapper_name = "libxeve",	615	.p.wrapper_name = "libxeve",
616	.p.pix_fmts = supported_pixel_formats,	616	CODEC_PIXFMTS_ARRAY(supported_pixel_formats),
617	.color_ranges = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */	617	.color_ranges = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
618	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP \| FF_CODEC_CAP_NOT_INIT_THREADSAFE,	618	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP \| FF_CODEC_CAP_NOT_INIT_THREADSAFE,
619	};	619	};

libavcodec/libxvid.c+1−1

@@ -911,7 +911,7 @@ const FFCodec ff_libxvid_encoder = { · 910 unmodified lines
911	.init = xvid_encode_init,	911	.init = xvid_encode_init,
912	FF_CODEC_ENCODE_CB(xvid_encode_frame),	912	FF_CODEC_ENCODE_CB(xvid_encode_frame),
913	.close = xvid_encode_close,	913	.close = xvid_encode_close,
914	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	914	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
915	.color_ranges = AVCOL_RANGE_MPEG,	915	.color_ranges = AVCOL_RANGE_MPEG,
916	.p.priv_class = &xvid_class,	916	.p.priv_class = &xvid_class,
917	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	917	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

libavcodec/ljpegenc.c+3−5

     .init           = ljpeg_encode_init,
     FF_CODEC_ENCODE_CB(ljpeg_encode_frame),
     .close          = ljpeg_encode_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_BGR24,    AV_PIX_FMT_BGRA,     AV_PIX_FMT_BGR0,
-        AV_PIX_FMT_BGR24   , AV_PIX_FMT_BGRA    , AV_PIX_FMT_BGR0,
+                  AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
+                  AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P),
-        AV_PIX_FMT_YUV420P , AV_PIX_FMT_YUV444P , AV_PIX_FMT_YUV422P,
-        AV_PIX_FMT_NONE},
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
 };

libavcodec/mace.c+2−4

     .init           = mace_decode_init,
     FF_CODEC_DECODE_CB(mace_decode_frame),
     .p.capabilities = AV_CODEC_CAP_DR1,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
-                                                      AV_SAMPLE_FMT_NONE },
 };
 const FFCodec ff_mace6_decoder = {
     .init           = mace_decode_init,
     FF_CODEC_DECODE_CB(mace_decode_frame),
     .p.capabilities = AV_CODEC_CAP_DR1,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
-                                                      AV_SAMPLE_FMT_NONE },
 };

libavcodec/magicyuvenc.c+3−5

     .init             = magy_encode_init,
     .close            = magy_encode_close,
     FF_CODEC_ENCODE_CB(magy_encode_frame),
-    .p.pix_fmts       = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_YUV422P,
-                          AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_YUV422P,
+                  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,
-                          AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_GRAY8,
+                  AV_PIX_FMT_GRAY8),
-                          AV_PIX_FMT_NONE
-                      },
     .color_ranges     = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/mediacodecenc.c+1−1

@@ -1094,7 +1094,7 @@ const FFCodec ff_ ## short_name ## _mediacodec_encoder = { \ · 1093 unmodified lines
1094	AV_CODEC_CAP_HARDWARE \| \	1094	AV_CODEC_CAP_HARDWARE \| \
1095	AV_CODEC_CAP_ENCODER_FLUSH, \	1095	AV_CODEC_CAP_ENCODER_FLUSH, \
1096	.priv_data_size = sizeof(MediaCodecEncContext), \	1096	.priv_data_size = sizeof(MediaCodecEncContext), \
1097	.p.pix_fmts = avc_pix_fmts, \	1097	CODEC_PIXFMTS_ARRAY(avc_pix_fmts), \
1098	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG, \	1098	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG, \
1099	.defaults = mediacodec_defaults, \	1099	.defaults = mediacodec_defaults, \
1100	.init = mediacodec_init, \	1100	.init = mediacodec_init, \

libavcodec/metasound.c+1−2

@@ -374,7 +374,6 @@ const FFCodec ff_metasound_decoder = { · 373 unmodified lines
374	.close = ff_twinvq_decode_close,	374	.close = ff_twinvq_decode_close,
375	FF_CODEC_DECODE_CB(ff_twinvq_decode_frame),	375	FF_CODEC_DECODE_CB(ff_twinvq_decode_frame),
376	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,	376	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,
377	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,	377	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
378	AV_SAMPLE_FMT_NONE },
379	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	378	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
380	};	379	};

libavcodec/mfenc.c+2−5

     };
 #define AFMTS \
-        .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,    \
+        CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                         AV_SAMPLE_FMT_NONE },
 #define ACAPS \
         .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID |           \
                           AV_CODEC_CAP_DR1 | AV_CODEC_CAP_VARIABLE_FRAME_SIZE,
 };
 #define VFMTS \
-        .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,       \
+        CODEC_PIXFMTS(AV_PIX_FMT_NV12, AV_PIX_FMT_YUV420P),
-                                                        AV_PIX_FMT_YUV420P,    \
-                                                        AV_PIX_FMT_NONE },
 #define VCAPS \
         .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID |           \
                           AV_CODEC_CAP_DR1,

libavcodec/misc4.c+1−2

@@ -184,6 +184,5 @@ const FFCodec ff_misc4_decoder = { · 183 unmodified lines
184	AV_CODEC_CAP_SUBFRAMES \|	184	AV_CODEC_CAP_SUBFRAMES \|
185	#endif	185	#endif
186	AV_CODEC_CAP_CHANNEL_CONF,	186	AV_CODEC_CAP_CHANNEL_CONF,
187	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,	187	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
188	AV_SAMPLE_FMT_NONE },
189	};	188	};

libavcodec/mjpegenc.c+3−8

                       AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS |
                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_ICC_PROFILES,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
+                  AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV444P),
-        AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV444P,
-        AV_PIX_FMT_NONE
-    },
     .p.priv_class   = &mjpeg_class,
     .p.profiles     = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
     .get_supported_config = mjpeg_get_supported_config,
     FF_CODEC_ENCODE_CB(amv_encode_picture),
     .close          = mjpeg_encode_close,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_YUVJ420P),
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_JPEG,
     .p.priv_class   = &amv_class,
 };

libavcodec/mlpenc.c+10−17

     FF_CODEC_ENCODE_CB(mlp_encode_frame),
     .close                  = mlp_encode_close,
     .p.priv_class           = &mlp_class,
-    .p.sample_fmts          = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE},
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P),
-    .p.supported_samplerates = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
+    CODEC_SAMPLERATES(44100, 48000, 88200, 96000, 176400, 192000),
-    .p.ch_layouts           = ff_mlp_ch_layouts,
+    CODEC_CH_LAYOUTS_ARRAY(ff_mlp_ch_layouts),
     .caps_internal          = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif
     FF_CODEC_ENCODE_CB(mlp_encode_frame),
     .close                  = mlp_encode_close,
     .p.priv_class           = &mlp_class,
-    .p.sample_fmts          = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE},
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P),
-    .p.supported_samplerates = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
+    CODEC_SAMPLERATES(44100, 48000, 88200, 96000, 176400, 192000),
-    .p.ch_layouts           = (const AVChannelLayout[]) {
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO,    AV_CHANNEL_LAYOUT_STEREO,
-                                  AV_CHANNEL_LAYOUT_MONO,
+                     AV_CHANNEL_LAYOUT_2POINT1, AV_CHANNEL_LAYOUT_SURROUND,
-                                  AV_CHANNEL_LAYOUT_STEREO,
+                     AV_CHANNEL_LAYOUT_3POINT1, AV_CHANNEL_LAYOUT_4POINT0,
-                                  AV_CHANNEL_LAYOUT_2POINT1,
+                     AV_CHANNEL_LAYOUT_4POINT1, AV_CHANNEL_LAYOUT_5POINT0,
-                                  AV_CHANNEL_LAYOUT_SURROUND,
+                     AV_CHANNEL_LAYOUT_5POINT1),
-                                  AV_CHANNEL_LAYOUT_3POINT1,
-                                  AV_CHANNEL_LAYOUT_4POINT0,
-                                  AV_CHANNEL_LAYOUT_4POINT1,
-                                  AV_CHANNEL_LAYOUT_5POINT0,
-                                  AV_CHANNEL_LAYOUT_5POINT1,
-                                  { 0 }
-                              },
     .caps_internal          = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif

libavcodec/mpc7.c+1−2

@@ -323,6 +323,5 @@ const FFCodec ff_mpc7_decoder = { · 322 unmodified lines
323	FF_CODEC_DECODE_CB(mpc7_decode_frame),	323	FF_CODEC_DECODE_CB(mpc7_decode_frame),
324	.flush = mpc7_decode_flush,	324	.flush = mpc7_decode_flush,
325	.p.capabilities = AV_CODEC_CAP_DR1,	325	.p.capabilities = AV_CODEC_CAP_DR1,
326	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,	326	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
327	AV_SAMPLE_FMT_NONE },
328	};	327	};

libavcodec/mpc8.c+1−2

@@ -393,6 +393,5 @@ const FFCodec ff_mpc8_decoder = { · 392 unmodified lines
393	FF_CODEC_DECODE_CB(mpc8_decode_frame),	393	FF_CODEC_DECODE_CB(mpc8_decode_frame),
394	.flush = mpc8_decode_flush,	394	.flush = mpc8_decode_flush,
395	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,	395	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,
396	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,	396	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
397	AV_SAMPLE_FMT_NONE },
398	};	397	};

libavcodec/mpeg12enc.c+4−7

     .init                 = encode_init,
     FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
     .close                = ff_mpv_encode_end,
-    .p.supported_framerates = ff_mpeg12_frame_rate_tab + 1,
+    CODEC_FRAMERATES_ARRAY(ff_mpeg12_frame_rate_tab + 1),
-    .p.pix_fmts           = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
-                                                           AV_PIX_FMT_NONE },
     .color_ranges         = AVCOL_RANGE_MPEG,
     .p.capabilities       = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
                             AV_CODEC_CAP_SLICE_THREADS |
     .init                 = encode_init,
     FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
     .close                = ff_mpv_encode_end,
-    .p.supported_framerates = ff_mpeg2_frame_rate_tab,
+    CODEC_FRAMERATES_ARRAY(ff_mpeg2_frame_rate_tab),
-    .p.pix_fmts           = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P),
-                                                           AV_PIX_FMT_YUV422P,
-                                                           AV_PIX_FMT_NONE },
     .color_ranges         = AVCOL_RANGE_MPEG,
     .p.capabilities       = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
                             AV_CODEC_CAP_SLICE_THREADS |

libavcodec/mpeg4videoenc.c+1−1

@@ -1399,7 +1399,7 @@ const FFCodec ff_mpeg4_encoder = { · 1398 unmodified lines
1399	.init = encode_init,	1399	.init = encode_init,
1400	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),	1400	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
1401	.close = ff_mpv_encode_end,	1401	.close = ff_mpv_encode_end,
1402	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	1402	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
1403	.color_ranges = AVCOL_RANGE_MPEG,	1403	.color_ranges = AVCOL_RANGE_MPEG,
1404	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|	1404	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|
1405	AV_CODEC_CAP_SLICE_THREADS \|	1405	AV_CODEC_CAP_SLICE_THREADS \|

libavcodec/mpegaudiodec_fixed.c+5−14

     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S16),
-                                                      AV_SAMPLE_FMT_S16,
-                                                      AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_MP2_DECODER
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S16),
-                                                      AV_SAMPLE_FMT_S16,
-                                                      AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_MP3_DECODER
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S16),
-                                                      AV_SAMPLE_FMT_S16,
-                                                      AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_MP3ADU_DECODER
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S16),
-                                                      AV_SAMPLE_FMT_S16,
-                                                      AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_MP3ON4_DECODER
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush_mp3on4,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif

libavcodec/mpegaudiodec_float.c+5−14

     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_FLT),
-                                                      AV_SAMPLE_FMT_FLT,
-                                                      AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_MP2FLOAT_DECODER
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_FLT),
-                                                      AV_SAMPLE_FMT_FLT,
-                                                      AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_MP3FLOAT_DECODER
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_FLT),
-                                                      AV_SAMPLE_FMT_FLT,
-                                                      AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_MP3ADUFLOAT_DECODER
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_FLT),
-                                                      AV_SAMPLE_FMT_FLT,
-                                                      AV_SAMPLE_FMT_NONE },
 };
 #endif
 #if CONFIG_MP3ON4FLOAT_DECODER
     .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                       AV_CODEC_CAP_DR1,
     .flush          = flush_mp3on4,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif

libavcodec/mpegaudioenc_fixed.c+3−8

     .priv_data_size        = sizeof(MpegAudioContext),
     .init                  = MPA_encode_init,
     FF_CODEC_ENCODE_CB(MPA_encode_frame),
-    .p.sample_fmts         = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                            AV_SAMPLE_FMT_NONE },
+    CODEC_SAMPLERATES(44100, 48000, 32000, 22050, 24000, 16000),
-    .p.supported_samplerates = (const int[]){
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-        44100, 48000,  32000, 22050, 24000, 16000, 0
-    },
-    .p.ch_layouts          = (const AVChannelLayout[]){ AV_CHANNEL_LAYOUT_MONO,
-                                                        AV_CHANNEL_LAYOUT_STEREO,
-                                                        { 0 } },
     .defaults              = mp2_defaults,
 };

libavcodec/mpegaudioenc_float.c+3−8

     .priv_data_size        = sizeof(MpegAudioContext),
     .init                  = MPA_encode_init,
     FF_CODEC_ENCODE_CB(MPA_encode_frame),
-    .p.sample_fmts         = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                            AV_SAMPLE_FMT_NONE },
+    CODEC_SAMPLERATES(44100, 48000, 32000, 22050, 24000, 16000),
-    .p.supported_samplerates = (const int[]){
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-        44100, 48000,  32000, 22050, 24000, 16000, 0
-    },
-    .p.ch_layouts          = (const AVChannelLayout[]){ AV_CHANNEL_LAYOUT_MONO,
-                                                        AV_CHANNEL_LAYOUT_STEREO,
-                                                        { 0 } },
     .defaults              = mp2_defaults,
 };

libavcodec/msmpeg4enc.c+3−3

@@ -680,7 +680,7 @@ const FFCodec ff_msmpeg4v2_encoder = { · 679 unmodified lines
680	CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 2"),	680	CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 2"),
681	.p.type = AVMEDIA_TYPE_VIDEO,	681	.p.type = AVMEDIA_TYPE_VIDEO,
682	.p.id = AV_CODEC_ID_MSMPEG4V2,	682	.p.id = AV_CODEC_ID_MSMPEG4V2,
683	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	683	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
684	.color_ranges = AVCOL_RANGE_MPEG,	684	.color_ranges = AVCOL_RANGE_MPEG,
685	.p.priv_class = &ff_mpv_enc_class,	685	.p.priv_class = &ff_mpv_enc_class,
686	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	686	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
@@ -696,7 +696,7 @@ const FFCodec ff_msmpeg4v3_encoder = { · 9 unmodified lines
696	CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 3"),	696	CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 3"),
697	.p.type = AVMEDIA_TYPE_VIDEO,	697	.p.type = AVMEDIA_TYPE_VIDEO,
698	.p.id = AV_CODEC_ID_MSMPEG4V3,	698	.p.id = AV_CODEC_ID_MSMPEG4V3,
699	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	699	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
700	.color_ranges = AVCOL_RANGE_MPEG,	700	.color_ranges = AVCOL_RANGE_MPEG,
701	.p.priv_class = &ff_mpv_enc_class,	701	.p.priv_class = &ff_mpv_enc_class,
702	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	702	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
@@ -712,7 +712,7 @@ const FFCodec ff_wmv1_encoder = { · 9 unmodified lines
712	CODEC_LONG_NAME("Windows Media Video 7"),	712	CODEC_LONG_NAME("Windows Media Video 7"),
713	.p.type = AVMEDIA_TYPE_VIDEO,	713	.p.type = AVMEDIA_TYPE_VIDEO,
714	.p.id = AV_CODEC_ID_WMV1,	714	.p.id = AV_CODEC_ID_WMV1,
715	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	715	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
716	.color_ranges = AVCOL_RANGE_MPEG,	716	.color_ranges = AVCOL_RANGE_MPEG,
717	.p.priv_class = &ff_mpv_enc_class,	717	.p.priv_class = &ff_mpv_enc_class,
718	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	718	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

libavcodec/msrleenc.c+1−3

     .init           = msrle_encode_init,
     FF_CODEC_ENCODE_CB(msrle_encode_frame),
     .close          = msrle_encode_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_PAL8),
-        AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE
-    },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/msvideo1enc.c+1−1

@@ -315,5 +315,5 @@ const FFCodec ff_msvideo1_encoder = { · 314 unmodified lines
315	.init = encode_init,	315	.init = encode_init,
316	FF_CODEC_ENCODE_CB(encode_frame),	316	FF_CODEC_ENCODE_CB(encode_frame),
317	.close = encode_end,	317	.close = encode_end,
318	.p.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_RGB555, AV_PIX_FMT_NONE},	318	CODEC_PIXFMTS(AV_PIX_FMT_RGB555),
319	};	319	};

libavcodec/nellymoserdec.c+1−2

@@ -202,6 +202,5 @@ const FFCodec ff_nellymoser_decoder = { · 201 unmodified lines
202	.close = decode_end,	202	.close = decode_end,
203	FF_CODEC_DECODE_CB(decode_tag),	203	FF_CODEC_DECODE_CB(decode_tag),
204	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_PARAM_CHANGE \| AV_CODEC_CAP_CHANNEL_CONF,	204	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_PARAM_CHANGE \| AV_CODEC_CAP_CHANNEL_CONF,
205	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,	205	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLT),
206	AV_SAMPLE_FMT_NONE },
207	};	206	};

libavcodec/nellymoserenc.c+2−3

     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = encode_end,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLT),
-                                                     AV_SAMPLE_FMT_NONE },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
-    .p.ch_layouts   = (const AVChannelLayout[]){ AV_CHANNEL_LAYOUT_MONO, { 0 } },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/null.c+6−9

     .p.type         = AVMEDIA_TYPE_AUDIO,
     .p.id           = AV_CODEC_ID_ANULL,
     .p.capabilities = AV_CODEC_CAP_VARIABLE_FRAME_SIZE,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_U8P,
-        AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_U8P,
+                     AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
-        AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
+                     AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P,
-        AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P,
+                     AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64P,
-        AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64P,
+                     AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
-        AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
+                     AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP),
-        AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP,
-        AV_SAMPLE_FMT_NONE,
-    },
     FF_CODEC_ENCODE_CB(null_encode),
 };
 #endif

libavcodec/nvenc_av1.c+1−1

@@ -214,7 +214,7 @@ const FFCodec ff_av1_nvenc_encoder = { · 213 unmodified lines
214	.priv_data_size = sizeof(NvencContext),	214	.priv_data_size = sizeof(NvencContext),
215	.p.priv_class = &av1_nvenc_class,	215	.p.priv_class = &av1_nvenc_class,
216	.defaults = defaults,	216	.defaults = defaults,
217	.p.pix_fmts = ff_nvenc_pix_fmts,	217	CODEC_PIXFMTS_ARRAY(ff_nvenc_pix_fmts),
218	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	218	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
219	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_HARDWARE \|	219	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_HARDWARE \|
220	AV_CODEC_CAP_ENCODER_FLUSH \| AV_CODEC_CAP_DR1 \|	220	AV_CODEC_CAP_ENCODER_FLUSH \| AV_CODEC_CAP_DR1 \|

libavcodec/nvenc_h264.c+1−1

@@ -286,7 +286,7 @@ const FFCodec ff_h264_nvenc_encoder = { · 285 unmodified lines
286	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	286	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
287	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|	287	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \|
288	FF_CODEC_CAP_INIT_CLEANUP,	288	FF_CODEC_CAP_INIT_CLEANUP,
289	.p.pix_fmts = ff_nvenc_pix_fmts,	289	CODEC_PIXFMTS_ARRAY(ff_nvenc_pix_fmts),
290	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	290	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
291	.p.wrapper_name = "nvenc",	291	.p.wrapper_name = "nvenc",
292	.hw_configs = ff_nvenc_hw_configs,	292	.hw_configs = ff_nvenc_hw_configs,

libavcodec/nvenc_hevc.c+1−1

@@ -267,7 +267,7 @@ const FFCodec ff_hevc_nvenc_encoder = { · 266 unmodified lines
267	.priv_data_size = sizeof(NvencContext),	267	.priv_data_size = sizeof(NvencContext),
268	.p.priv_class = &hevc_nvenc_class,	268	.p.priv_class = &hevc_nvenc_class,
269	.defaults = defaults,	269	.defaults = defaults,
270	.p.pix_fmts = ff_nvenc_pix_fmts,	270	CODEC_PIXFMTS_ARRAY(ff_nvenc_pix_fmts),
271	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	271	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
272	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_HARDWARE \|	272	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_HARDWARE \|
273	AV_CODEC_CAP_ENCODER_FLUSH \| AV_CODEC_CAP_DR1 \|	273	AV_CODEC_CAP_ENCODER_FLUSH \| AV_CODEC_CAP_DR1 \|

libavcodec/omx.c+2−2

@@ -951,7 +951,7 @@ const FFCodec ff_mpeg4_omx_encoder = { · 950 unmodified lines
951	.init = omx_encode_init,	951	.init = omx_encode_init,
952	FF_CODEC_ENCODE_CB(omx_encode_frame),	952	FF_CODEC_ENCODE_CB(omx_encode_frame),
953	.close = omx_encode_end,	953	.close = omx_encode_end,
954	.p.pix_fmts = omx_encoder_pix_fmts,	954	CODEC_PIXFMTS_ARRAY(omx_encoder_pix_fmts),
955	.color_ranges = AVCOL_RANGE_MPEG,	955	.color_ranges = AVCOL_RANGE_MPEG,
956	.p.capabilities = AV_CODEC_CAP_DELAY,	956	.p.capabilities = AV_CODEC_CAP_DELAY,
957	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	957	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
@@ -973,7 +973,7 @@ const FFCodec ff_h264_omx_encoder = { · 15 unmodified lines
973	.init = omx_encode_init,	973	.init = omx_encode_init,
974	FF_CODEC_ENCODE_CB(omx_encode_frame),	974	FF_CODEC_ENCODE_CB(omx_encode_frame),
975	.close = omx_encode_end,	975	.close = omx_encode_end,
976	.p.pix_fmts = omx_encoder_pix_fmts,	976	CODEC_PIXFMTS_ARRAY(omx_encoder_pix_fmts),
977	.color_ranges = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */	977	.color_ranges = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
978	.p.capabilities = AV_CODEC_CAP_DELAY,	978	.p.capabilities = AV_CODEC_CAP_DELAY,
979	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	979	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

libavcodec/on2avc.c+1−2

@@ -1023,6 +1023,5 @@ const FFCodec ff_on2avc_decoder = { · 1022 unmodified lines
1023	.close = on2avc_decode_close,	1023	.close = on2avc_decode_close,
1024	.p.capabilities = AV_CODEC_CAP_DR1,	1024	.p.capabilities = AV_CODEC_CAP_DR1,
1025	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1025	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1026	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,	1026	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
1027	AV_SAMPLE_FMT_NONE },
1028	};	1027	};

libavcodec/opus/enc.c+3−5

     FF_CODEC_ENCODE_CB(opus_encode_frame),
     .close          = opus_encode_end,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.supported_samplerates = (const int []){ 48000, 0 },
+    CODEC_SAMPLERATES(48000),
-    .p.ch_layouts    = (const AVChannelLayout []){ AV_CHANNEL_LAYOUT_MONO,
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-                                                   AV_CHANNEL_LAYOUT_STEREO, { 0 } },
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
-                                                     AV_SAMPLE_FMT_NONE },
 };

libavcodec/osq.c+1−4

     .p.capabilities   = AV_CODEC_CAP_CHANNEL_CONF |
                         AV_CODEC_CAP_DR1,
     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
-    .p.sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P),
-                                                        AV_SAMPLE_FMT_S16P,
-                                                        AV_SAMPLE_FMT_S32P,
-                                                        AV_SAMPLE_FMT_NONE },
     .flush            = osq_flush,
 };

libavcodec/pamenc.c+5−7

@@ -135,11 +135,9 @@ const FFCodec ff_pam_encoder = { · 134 unmodified lines
135	.p.id = AV_CODEC_ID_PAM,	135	.p.id = AV_CODEC_ID_PAM,
136	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	136	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
137	FF_CODEC_ENCODE_CB(pam_encode_frame),	137	FF_CODEC_ENCODE_CB(pam_encode_frame),
138	.p.pix_fmts = (const enum AVPixelFormat[]){	138	CODEC_PIXFMTS(AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
139	AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,	139	AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,
140	AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,	140	AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,
141	AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,	141	AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_YA16BE,
142	AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_YA16BE,	142	AV_PIX_FMT_MONOBLACK),
143	AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
144	},
145	};	143	};

libavcodec/pcm-bluray.c+1−3

@@ -307,7 +307,5 @@ const FFCodec ff_pcm_bluray_decoder = { · 306 unmodified lines
307	.p.id = AV_CODEC_ID_PCM_BLURAY,	307	.p.id = AV_CODEC_ID_PCM_BLURAY,
308	FF_CODEC_DECODE_CB(pcm_bluray_decode_frame),	308	FF_CODEC_DECODE_CB(pcm_bluray_decode_frame),
309	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,	309	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,
310	.p.sample_fmts = (const enum AVSampleFormat[]){	310	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32),
311	AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE
312	},
313	};	311	};

libavcodec/pcm-blurayenc.c+7−15

     .priv_data_size        = sizeof(BlurayPCMEncContext),
     .init                  = pcm_bluray_encode_init,
     FF_CODEC_ENCODE_CB(pcm_bluray_encode_frame),
-    .p.supported_samplerates = (const int[]) { 48000, 96000, 192000, 0 },
+    CODEC_SAMPLERATES(48000, 96000, 192000),
-    .p.ch_layouts   = (const AVChannelLayout[]) {
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO,     AV_CHANNEL_LAYOUT_STEREO,
-        AV_CHANNEL_LAYOUT_MONO,
+                     AV_CHANNEL_LAYOUT_SURROUND, AV_CHANNEL_LAYOUT_2_1,
-        AV_CHANNEL_LAYOUT_STEREO,
+                     AV_CHANNEL_LAYOUT_4POINT0,  AV_CHANNEL_LAYOUT_2_2,
-        AV_CHANNEL_LAYOUT_SURROUND,
+                     AV_CHANNEL_LAYOUT_5POINT0,  AV_CHANNEL_LAYOUT_5POINT1,
-        AV_CHANNEL_LAYOUT_2_1,
+                     AV_CHANNEL_LAYOUT_7POINT0,  AV_CHANNEL_LAYOUT_7POINT1),
-        AV_CHANNEL_LAYOUT_4POINT0,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32),
-        AV_CHANNEL_LAYOUT_2_2,
-        AV_CHANNEL_LAYOUT_5POINT0,
-        AV_CHANNEL_LAYOUT_5POINT1,
-        AV_CHANNEL_LAYOUT_7POINT0,
-        AV_CHANNEL_LAYOUT_7POINT1,
-        { 0 } },
-    .p.sample_fmts         = (const enum AVSampleFormat[]) {
-        AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE },
     .p.capabilities        = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
 };

libavcodec/pcm-dvd.c+1−3

@@ -305,7 +305,5 @@ const FFCodec ff_pcm_dvd_decoder = { · 304 unmodified lines
305	FF_CODEC_DECODE_CB(pcm_dvd_decode_frame),	305	FF_CODEC_DECODE_CB(pcm_dvd_decode_frame),
306	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|	306	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|
307	AV_CODEC_CAP_DR1,	307	AV_CODEC_CAP_DR1,
308	.p.sample_fmts = (const enum AVSampleFormat[]) {	308	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32),
309	AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE
310	},
311	};	309	};

libavcodec/pcm-dvdenc.c+4−9

     .priv_data_size = sizeof(PCMDVDContext),
     .init           = pcm_dvd_encode_init,
     FF_CODEC_ENCODE_CB(pcm_dvd_encode_frame),
-    .p.supported_samplerates = (const int[]) { 48000, 96000, 0},
+    CODEC_SAMPLERATES(48000, 96000),
-    .p.ch_layouts   = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO,
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO,    AV_CHANNEL_LAYOUT_STEREO,
-                                                  AV_CHANNEL_LAYOUT_STEREO,
+                     AV_CHANNEL_LAYOUT_5POINT1, AV_CHANNEL_LAYOUT_7POINT1),
-                                                  AV_CHANNEL_LAYOUT_5POINT1,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32),
-                                                  AV_CHANNEL_LAYOUT_7POINT1,
-                                                  { 0 } },
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
-                                                     AV_SAMPLE_FMT_S32,
-                                                     AV_SAMPLE_FMT_NONE },
 };

libavcodec/pcm.c+2−4

                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,                \
     .init         = pcm_encode_init,                                        \
     FF_CODEC_ENCODE_CB(pcm_encode_frame),                                   \
-    .p.sample_fmts = (const enum AVSampleFormat[]){ sample_fmt_,             \
+    CODEC_SAMPLEFMTS(sample_fmt_),                                          \
-                                                   AV_SAMPLE_FMT_NONE },    \
 }
 #define PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)                  \
     .init           = pcm_decode_init,                                      \
     FF_CODEC_DECODE_CB(pcm_decode_frame),                                    \
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_PARAM_CHANGE,         \
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ sample_fmt_,           \
+    CODEC_SAMPLEFMTS(sample_fmt_),                                          \
-                                                     AV_SAMPLE_FMT_NONE },  \
 }
 #define PCM_DECODER_2(cf, id, sample_fmt, name, long_name)                  \

libavcodec/pcxenc.c+5−7

@@ -199,11 +199,9 @@ const FFCodec ff_pcx_encoder = { · 198 unmodified lines
199	.p.id = AV_CODEC_ID_PCX,	199	.p.id = AV_CODEC_ID_PCX,
200	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	200	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
201	FF_CODEC_ENCODE_CB(pcx_encode_frame),	201	FF_CODEC_ENCODE_CB(pcx_encode_frame),
202	.p.pix_fmts = (const enum AVPixelFormat[]){	202	CODEC_PIXFMTS(AV_PIX_FMT_RGB24,
203	AV_PIX_FMT_RGB24,	203	AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8,
204	AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,	204	AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,
205	AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,	205	AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,
206	AV_PIX_FMT_MONOBLACK,	206	AV_PIX_FMT_MONOBLACK),
207	AV_PIX_FMT_NONE
208	},
209	};	207	};

libavcodec/pngenc.c+11−16

     .init           = png_enc_init,
     .close          = png_enc_close,
     FF_CODEC_ENCODE_CB(encode_png),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
-        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
+                  AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,
-        AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,
+                  AV_PIX_FMT_PAL8,
-        AV_PIX_FMT_PAL8,
+                  AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,
+                  AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_YA16BE,
-        AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_YA16BE,
+                  AV_PIX_FMT_MONOBLACK),
-        AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
-    },
     .p.priv_class   = &pngenc_class,
     .caps_internal  = FF_CODEC_CAP_ICC_PROFILES,
 };
     .init           = png_enc_init,
     .close          = png_enc_close,
     FF_CODEC_ENCODE_CB(encode_apng),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
-        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
+                  AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,
-        AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,
+                  AV_PIX_FMT_PAL8,
-        AV_PIX_FMT_PAL8,
+                  AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,
+                  AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_YA16BE),
-        AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_YA16BE,
-        AV_PIX_FMT_NONE
-    },
     .p.priv_class   = &pngenc_class,
     .caps_internal  = FF_CODEC_CAP_ICC_PROFILES,
 };

libavcodec/pnmenc.c+7−19

     .p.id           = AV_CODEC_ID_PGM,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     FF_CODEC_ENCODE_CB(pnm_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16BE),
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_NONE
-    },
 };
 #endif
     .p.id           = AV_CODEC_ID_PGMYUV,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     FF_CODEC_ENCODE_CB(pnm_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P16BE),
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P16BE, AV_PIX_FMT_NONE
-    },
 };
 #endif
     .p.id           = AV_CODEC_ID_PPM,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     FF_CODEC_ENCODE_CB(pnm_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48BE),
-        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48BE, AV_PIX_FMT_NONE
-    },
 };
 #endif
     .p.id           = AV_CODEC_ID_PBM,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     FF_CODEC_ENCODE_CB(pnm_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_MONOWHITE,
+    CODEC_PIXFMTS(AV_PIX_FMT_MONOWHITE),
-                                                  AV_PIX_FMT_NONE },
 };
 #endif
     .p.id           = AV_CODEC_ID_PFM,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     FF_CODEC_ENCODE_CB(pnm_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_GBRPF32LE,
+    CODEC_PIXFMTS(AV_PIX_FMT_GBRPF32LE, AV_PIX_FMT_GRAYF32LE,
-                                                    AV_PIX_FMT_GRAYF32LE,
+                  AV_PIX_FMT_GBRPF32BE, AV_PIX_FMT_GRAYF32BE),
-                                                    AV_PIX_FMT_GBRPF32BE,
-                                                    AV_PIX_FMT_GRAYF32BE,
-                                                    AV_PIX_FMT_NONE },
 };
 #endif
     .priv_data_size = sizeof(PHMEncContext),
     .init           = phm_enc_init,
     FF_CODEC_ENCODE_CB(pnm_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_GBRPF32,
+    CODEC_PIXFMTS(AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GRAYF32),
-                                                    AV_PIX_FMT_GRAYF32,
-                                                    AV_PIX_FMT_NONE },
 };
 #endif

libavcodec/proresenc_anatoliy.c+2−2

@@ -955,7 +955,7 @@ const FFCodec ff_prores_aw_encoder = { · 954 unmodified lines
955	.p.id = AV_CODEC_ID_PRORES,	955	.p.id = AV_CODEC_ID_PRORES,
956	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_FRAME_THREADS \|	956	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_FRAME_THREADS \|
957	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	957	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
958	.p.pix_fmts = pix_fmts,	958	CODEC_PIXFMTS_ARRAY(pix_fmts),
959	.color_ranges = AVCOL_RANGE_MPEG,	959	.color_ranges = AVCOL_RANGE_MPEG,
960	.priv_data_size = sizeof(ProresContext),	960	.priv_data_size = sizeof(ProresContext),
961	.init = prores_encode_init,	961	.init = prores_encode_init,
@@ -973,7 +973,7 @@ const FFCodec ff_prores_encoder = { · 11 unmodified lines
973	.p.id = AV_CODEC_ID_PRORES,	973	.p.id = AV_CODEC_ID_PRORES,
974	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_FRAME_THREADS \|	974	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_FRAME_THREADS \|
975	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	975	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
976	.p.pix_fmts = pix_fmts,	976	CODEC_PIXFMTS_ARRAY(pix_fmts),
977	.color_ranges = AVCOL_RANGE_MPEG,	977	.color_ranges = AVCOL_RANGE_MPEG,
978	.priv_data_size = sizeof(ProresContext),	978	.priv_data_size = sizeof(ProresContext),
979	.init = prores_encode_init,	979	.init = prores_encode_init,

libavcodec/proresenc_kostya.c+1−4

     FF_CODEC_ENCODE_CB(encode_frame),
     .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS |
                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10),
-                          AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
-                          AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
-                      },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &proresenc_class,
     .p.profiles     = NULL_IF_CONFIG_SMALL(ff_prores_profiles),

libavcodec/qoadec.c+1−2

@@ -165,6 +165,5 @@ const FFCodec ff_qoa_decoder = { · 164 unmodified lines
165	FF_CODEC_DECODE_CB(qoa_decode_frame),	165	FF_CODEC_DECODE_CB(qoa_decode_frame),
166	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|	166	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|
167	AV_CODEC_CAP_DR1,	167	AV_CODEC_CAP_DR1,
168	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,	168	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
169	AV_SAMPLE_FMT_NONE },
170	};	169	};

libavcodec/qoienc.c+1−4

     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     FF_CODEC_ENCODE_CB(qoi_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB24),
-        AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB24,
-        AV_PIX_FMT_NONE
-    },
 };

libavcodec/qsvenc_av1.c+1−4

     FF_CODEC_ENCODE_CB(qsv_enc_frame),
     .close            = qsv_enc_close,
     .p.capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
-    .p.pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+    CODEC_PIXFMTS(AV_PIX_FMT_NV12, AV_PIX_FMT_P010, AV_PIX_FMT_QSV),
-                                                    AV_PIX_FMT_P010,
-                                                    AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_NONE },
     .color_ranges     = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .p.priv_class     = &class,
     .defaults       = qsv_enc_defaults,

libavcodec/qsvenc_h264.c+1−3

     FF_CODEC_ENCODE_CB(qsv_enc_frame),
     .close          = qsv_enc_close,
     .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+    CODEC_PIXFMTS(AV_PIX_FMT_NV12, AV_PIX_FMT_QSV),
-                                                    AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .p.priv_class   = &class,
     .defaults       = qsv_enc_defaults,

libavcodec/qsvenc_hevc.c+4−11

     FF_CODEC_ENCODE_CB(qsv_enc_frame),
     .close          = qsv_enc_close,
     .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+    CODEC_PIXFMTS(AV_PIX_FMT_NV12, AV_PIX_FMT_P010, AV_PIX_FMT_P012,
-                                                    AV_PIX_FMT_P010,
+                  AV_PIX_FMT_YUYV422, AV_PIX_FMT_Y210, AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_P012,
+                  AV_PIX_FMT_BGRA, AV_PIX_FMT_X2RGB10, AV_PIX_FMT_VUYX,
-                                                    AV_PIX_FMT_YUYV422,
+                  AV_PIX_FMT_XV30),
-                                                    AV_PIX_FMT_Y210,
-                                                    AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_BGRA,
-                                                    AV_PIX_FMT_X2RGB10,
-                                                    AV_PIX_FMT_VUYX,
-                                                    AV_PIX_FMT_XV30,
-                                                    AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .p.priv_class   = &class,
     .defaults       = qsv_enc_defaults,

libavcodec/qsvenc_jpeg.c+2−5

     FF_CODEC_ENCODE_CB(qsv_enc_frame),
     .close          = qsv_enc_close,
     .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+    CODEC_PIXFMTS(AV_PIX_FMT_NV12, AV_PIX_FMT_YUYV422, AV_PIX_FMT_BGRA,
-                                                    AV_PIX_FMT_YUYV422,
+                  AV_PIX_FMT_QSV),
-                                                    AV_PIX_FMT_BGRA,
-                                                    AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .p.priv_class   = &class,
     .defaults       = qsv_enc_defaults,

libavcodec/qsvenc_mpeg2.c+1−3

     FF_CODEC_ENCODE_CB(qsv_enc_frame),
     .close          = qsv_enc_close,
     .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+    CODEC_PIXFMTS(AV_PIX_FMT_NV12, AV_PIX_FMT_QSV),
-                                                    AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &class,
     .defaults       = qsv_enc_defaults,

libavcodec/qsvenc_vp9.c+2−6

     FF_CODEC_ENCODE_CB(qsv_enc_frame),
     .close          = qsv_enc_close,
     .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+    CODEC_PIXFMTS(AV_PIX_FMT_NV12, AV_PIX_FMT_P010, AV_PIX_FMT_VUYX,
-                                                    AV_PIX_FMT_P010,
+                  AV_PIX_FMT_QSV, AV_PIX_FMT_XV30),
-                                                    AV_PIX_FMT_VUYX,
-                                                    AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_XV30,
-                                                    AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .p.priv_class   = &class,
     .defaults       = qsv_enc_defaults,

libavcodec/qtrleenc.c+2−3

     .init           = qtrle_encode_init,
     FF_CODEC_ENCODE_CB(qtrle_encode_frame),
     .close          = qtrle_encode_end,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_ARGB,
-        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_ARGB, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
+                  AV_PIX_FMT_GRAY8),
-    },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/r210enc.c+3−3

@@ -99,7 +99,7 @@ const FFCodec ff_r210_encoder = { · 98 unmodified lines
99	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	99	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
100	.init = encode_init,	100	.init = encode_init,
101	FF_CODEC_ENCODE_CB(encode_frame),	101	FF_CODEC_ENCODE_CB(encode_frame),
102	.p.pix_fmts = pix_fmt,	102	CODEC_PIXFMTS_ARRAY(pix_fmt),
103	};	103	};
104	#endif	104	#endif
105	#if CONFIG_R10K_ENCODER	105	#if CONFIG_R10K_ENCODER
@@ -111,7 +111,7 @@ const FFCodec ff_r10k_encoder = { · 5 unmodified lines
111	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	111	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
112	.init = encode_init,	112	.init = encode_init,
113	FF_CODEC_ENCODE_CB(encode_frame),	113	FF_CODEC_ENCODE_CB(encode_frame),
114	.p.pix_fmts = pix_fmt,	114	CODEC_PIXFMTS_ARRAY(pix_fmt),
115	};	115	};
116	#endif	116	#endif
117	#if CONFIG_AVRP_ENCODER	117	#if CONFIG_AVRP_ENCODER
@@ -123,6 +123,6 @@ const FFCodec ff_avrp_encoder = { · 5 unmodified lines
123	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	123	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
124	.init = encode_init,	124	.init = encode_init,
125	FF_CODEC_ENCODE_CB(encode_frame),	125	FF_CODEC_ENCODE_CB(encode_frame),
126	.p.pix_fmts = pix_fmt,	126	CODEC_PIXFMTS_ARRAY(pix_fmt),
127	};	127	};
128	#endif	128	#endif

libavcodec/ra144enc.c+3−4

     .init           = ra144_encode_init,
     FF_CODEC_ENCODE_CB(ra144_encode_frame),
     .close          = ra144_encode_close,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                     AV_SAMPLE_FMT_NONE },
+    CODEC_SAMPLERATES(8000),
-    .p.supported_samplerates = (const int[]){ 8000, 0 },
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO),
-    .p.ch_layouts   = (const AVChannelLayout[]){ AV_CHANNEL_LAYOUT_MONO, { 0 } },
 };

libavcodec/ralf.c+1−2

@@ -523,7 +523,6 @@ const FFCodec ff_ralf_decoder = { · 522 unmodified lines
523	.flush = decode_flush,	523	.flush = decode_flush,
524	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|	524	.p.capabilities = AV_CODEC_CAP_CHANNEL_CONF \|
525	AV_CODEC_CAP_DR1,	525	AV_CODEC_CAP_DR1,
526	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,	526	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
527	AV_SAMPLE_FMT_NONE },
528	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	527	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
529	};	528	};

libavcodec/roqaudioenc.c+1−2

@@ -198,6 +198,5 @@ const FFCodec ff_roq_dpcm_encoder = { · 197 unmodified lines
198	.init = roq_dpcm_encode_init,	198	.init = roq_dpcm_encode_init,
199	FF_CODEC_ENCODE_CB(roq_dpcm_encode_frame),	199	FF_CODEC_ENCODE_CB(roq_dpcm_encode_frame),
200	.close = roq_dpcm_encode_close,	200	.close = roq_dpcm_encode_close,
201	.p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,	201	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
202	AV_SAMPLE_FMT_NONE },
203	};	202	};

libavcodec/roqvideoenc.c+1−2

     .init                 = roq_encode_init,
     FF_CODEC_ENCODE_CB(roq_encode_frame),
     .close                = roq_encode_end,
-    .p.pix_fmts           = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUVJ444P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUVJ444P),
-                                                        AV_PIX_FMT_NONE },
     .color_ranges         = AVCOL_RANGE_JPEG,
     .p.priv_class   = &roq_class,
     .caps_internal        = FF_CODEC_CAP_INIT_CLEANUP,

libavcodec/rpzaenc.c+1−2

@@ -884,6 +884,5 @@ const FFCodec ff_rpza_encoder = { · 883 unmodified lines
884	.init = rpza_encode_init,	884	.init = rpza_encode_init,
885	FF_CODEC_ENCODE_CB(rpza_encode_frame),	885	FF_CODEC_ENCODE_CB(rpza_encode_frame),
886	.close = rpza_encode_end,	886	.close = rpza_encode_end,
887	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB555,	887	CODEC_PIXFMTS(AV_PIX_FMT_RGB555),
888	AV_PIX_FMT_NONE},
889	};	888	};

libavcodec/rv10enc.c+1−1

@@ -77,6 +77,6 @@ const FFCodec ff_rv10_encoder = { · 76 unmodified lines
77	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),	77	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
78	.close = ff_mpv_encode_end,	78	.close = ff_mpv_encode_end,
79	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	79	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
80	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	80	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
81	.color_ranges = AVCOL_RANGE_MPEG,	81	.color_ranges = AVCOL_RANGE_MPEG,
82	};	82	};

libavcodec/rv20enc.c+1−1

@@ -74,6 +74,6 @@ const FFCodec ff_rv20_encoder = { · 73 unmodified lines
74	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),	74	FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
75	.close = ff_mpv_encode_end,	75	.close = ff_mpv_encode_end,
76	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	76	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
77	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	77	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
78	.color_ranges = AVCOL_RANGE_MPEG,	78	.color_ranges = AVCOL_RANGE_MPEG,
79	};	79	};

libavcodec/s302menc.c+2−4

     .priv_data_size        = sizeof(S302MEncContext),
     .init                  = s302m_encode_init,
     FF_CODEC_ENCODE_CB(s302m_encode2_frame),
-    .p.sample_fmts         = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16),
-                                                            AV_SAMPLE_FMT_S16,
+    CODEC_SAMPLERATES(48000),
-                                                            AV_SAMPLE_FMT_NONE },
-    .p.supported_samplerates = (const int[]) { 48000, 0 },
 };

libavcodec/sbcdec.c+3−6

     .init                  = sbc_decode_init,
     FF_CODEC_DECODE_CB(sbc_decode_frame),
     .p.capabilities        = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
-    .p.ch_layouts          = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO,
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-                                                         AV_CHANNEL_LAYOUT_STEREO,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P),
-                                                         { 0 } },
+    CODEC_SAMPLERATES(16000, 32000, 44100, 48000),
-    .p.sample_fmts         = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
-                                                             AV_SAMPLE_FMT_NONE },
-    .p.supported_samplerates = (const int[]) { 16000, 32000, 44100, 48000, 0 },
 };

libavcodec/sbcenc.c+3−6

     .priv_data_size        = sizeof(SBCEncContext),
     .init                  = sbc_encode_init,
     FF_CODEC_ENCODE_CB(sbc_encode_frame),
-    .p.ch_layouts          = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO,
+    CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),
-                                                         AV_CHANNEL_LAYOUT_STEREO,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
-                                                         { 0 } },
+    CODEC_SAMPLERATES_ARRAY(sbc_samplerates),
-    .p.sample_fmts         = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
-                                                             AV_SAMPLE_FMT_NONE },
-    .p.supported_samplerates = sbc_samplerates,
     .p.priv_class          = &sbc_class,
     .p.profiles            = NULL_IF_CONFIG_SMALL(ff_sbc_profiles),
 };

libavcodec/sgienc.c+4−7

     .p.priv_class = &sgi_class,
     .init      = encode_init,
     FF_CODEC_ENCODE_CB(encode_frame),
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_RGB24,    AV_PIX_FMT_RGBA,
-        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
+                  AV_PIX_FMT_RGB48LE,  AV_PIX_FMT_RGB48BE,
-        AV_PIX_FMT_RGB48LE, AV_PIX_FMT_RGB48BE,
+                  AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_RGBA64BE,
-        AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_RGBA64BE,
+                  AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_GRAY8),
-        AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_GRAY8,
-        AV_PIX_FMT_NONE
-    },
 };

libavcodec/shorten.c+1−3

@@ -821,7 +821,5 @@ const FFCodec ff_shorten_decoder = { · 820 unmodified lines
821	AV_CODEC_CAP_SUBFRAMES \|	821	AV_CODEC_CAP_SUBFRAMES \|
822	#endif	822	#endif
823	AV_CODEC_CAP_DR1,	823	AV_CODEC_CAP_DR1,
824	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,	824	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_U8P),
825	AV_SAMPLE_FMT_U8P,
826	AV_SAMPLE_FMT_NONE },
827	};	825	};

libavcodec/smcenc.c+1−2

@@ -599,6 +599,5 @@ const FFCodec ff_smc_encoder = { · 598 unmodified lines
599	.init = smc_encode_init,	599	.init = smc_encode_init,
600	FF_CODEC_ENCODE_CB(smc_encode_frame),	600	FF_CODEC_ENCODE_CB(smc_encode_frame),
601	.close = smc_encode_end,	601	.close = smc_encode_end,
602	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_PAL8,	602	CODEC_PIXFMTS(AV_PIX_FMT_PAL8),
603	AV_PIX_FMT_NONE},
604	};	603	};

libavcodec/snowenc.c+2−5

     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = encode_end,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV444P,
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV444P,
+                  AV_PIX_FMT_GRAY8),
-        AV_PIX_FMT_GRAY8,
-        AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &snowenc_class,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,

libavcodec/sonic.c+2−2

@@ -1102,7 +1102,7 @@ const FFCodec ff_sonic_encoder = { · 1101 unmodified lines
1102	.priv_data_size = sizeof(SonicContext),	1102	.priv_data_size = sizeof(SonicContext),
1103	.init = sonic_encode_init,	1103	.init = sonic_encode_init,
1104	FF_CODEC_ENCODE_CB(sonic_encode_frame),	1104	FF_CODEC_ENCODE_CB(sonic_encode_frame),
1105	.p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },	1105	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
1106	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1106	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1107	.close = sonic_encode_close,	1107	.close = sonic_encode_close,
1108	};	1108	};
@@ -1119,7 +1119,7 @@ const FFCodec ff_sonic_ls_encoder = { · 10 unmodified lines
1119	.priv_data_size = sizeof(SonicContext),	1119	.priv_data_size = sizeof(SonicContext),
1120	.init = sonic_encode_init,	1120	.init = sonic_encode_init,
1121	FF_CODEC_ENCODE_CB(sonic_encode_frame),	1121	FF_CODEC_ENCODE_CB(sonic_encode_frame),
1122	.p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },	1122	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
1123	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1123	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1124	.close = sonic_encode_close,	1124	.close = sonic_encode_close,
1125	};	1125	};

libavcodec/speedhqenc.c+1−4

     .close          = ff_mpv_encode_end,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
     .color_ranges   = AVCOL_RANGE_MPEG,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P),
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
-        AV_PIX_FMT_NONE
-    },
 };

libavcodec/sunrastenc.c+4−5

@@ -218,9 +218,8 @@ const FFCodec ff_sunrast_encoder = { · 217 unmodified lines
218	.init = sunrast_encode_init,	218	.init = sunrast_encode_init,
219	FF_CODEC_ENCODE_CB(sunrast_encode_frame),	219	FF_CODEC_ENCODE_CB(sunrast_encode_frame),
220	.p.priv_class = &sunrast_class,	220	.p.priv_class = &sunrast_class,
221	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24,	221	CODEC_PIXFMTS(AV_PIX_FMT_BGR24,
222	AV_PIX_FMT_PAL8,	222	AV_PIX_FMT_PAL8,
223	AV_PIX_FMT_GRAY8,	223	AV_PIX_FMT_GRAY8,
224	AV_PIX_FMT_MONOWHITE,	224	AV_PIX_FMT_MONOWHITE),
225	AV_PIX_FMT_NONE },
226	};	225	};

libavcodec/svq1enc.c+1−2

     .init           = svq1_encode_init,
     FF_CODEC_ENCODE_CB(svq1_encode_frame),
     .close          = svq1_encode_end,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
+    CODEC_PIXFMTS(AV_PIX_FMT_YUV410P),
-                                                     AV_PIX_FMT_NONE },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/takdec.c+1−4

     FF_CODEC_DECODE_CB(tak_decode_frame),
     UPDATE_THREAD_CONTEXT(update_thread_context),
     .p.capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_CHANNEL_CONF,
-    .p.sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P),
-                                                        AV_SAMPLE_FMT_S16P,
-                                                        AV_SAMPLE_FMT_S32P,
-                                                        AV_SAMPLE_FMT_NONE },
 };

libavcodec/targaenc.c+2−4

     .p.priv_class   = &targa_class,
     .init           = targa_encode_init,
     FF_CODEC_ENCODE_CB(targa_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_BGR24, AV_PIX_FMT_BGRA, AV_PIX_FMT_RGB555LE,
-        AV_PIX_FMT_BGR24, AV_PIX_FMT_BGRA, AV_PIX_FMT_RGB555LE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,
+                  AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8),
-        AV_PIX_FMT_NONE
-    },
 };

libavcodec/tiffenc.c+2−4

     .init           = encode_init,
     .close          = encode_close,
     FF_CODEC_ENCODE_CB(encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(
         AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48LE, AV_PIX_FMT_PAL8,
         AV_PIX_FMT_RGBA, AV_PIX_FMT_RGBA64LE,
         AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_YA16LE,
         AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_MONOWHITE,
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
+        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P),
-        AV_PIX_FMT_NONE
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .p.priv_class   = &tiffenc_class,
 };

libavcodec/ttaenc.c+1−4

     .init           = tta_encode_init,
     .close          = tta_encode_close,
     FF_CODEC_ENCODE_CB(tta_encode_frame),
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_U8,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32),
-                                                     AV_SAMPLE_FMT_S16,
-                                                     AV_SAMPLE_FMT_S32,
-                                                     AV_SAMPLE_FMT_NONE },
 };

libavcodec/twinvqdec.c+1−2

@@ -423,7 +423,6 @@ const FFCodec ff_twinvq_decoder = { · 422 unmodified lines
423	.close = ff_twinvq_decode_close,	423	.close = ff_twinvq_decode_close,
424	FF_CODEC_DECODE_CB(ff_twinvq_decode_frame),	424	FF_CODEC_DECODE_CB(ff_twinvq_decode_frame),
425	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,	425	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,
426	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,	426	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
427	AV_SAMPLE_FMT_NONE },
428	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	427	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
429	};	428	};

libavcodec/utvideoenc.c+2−4

     .init           = utvideo_encode_init,
     FF_CODEC_ENCODE_CB(utvideo_encode_frame),
     .close          = utvideo_encode_close,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
-                          AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_YUV422P,
+                  AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P),
-                          AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE
-                      },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/v210enc.c+1−1

@@ -117,5 +117,5 @@ const FFCodec ff_v210_encoder = { · 116 unmodified lines
117	.priv_data_size = sizeof(V210EncContext),	117	.priv_data_size = sizeof(V210EncContext),
118	.init = encode_init,	118	.init = encode_init,
119	FF_CODEC_ENCODE_CB(encode_frame),	119	FF_CODEC_ENCODE_CB(encode_frame),
120	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P, AV_PIX_FMT_NONE },	120	CODEC_PIXFMTS(AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P),
121	};	121	};

libavcodec/v308enc.c+1−1

@@ -80,5 +80,5 @@ const FFCodec ff_v308_encoder = { · 79 unmodified lines
80	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	80	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
81	.init = v308_encode_init,	81	.init = v308_encode_init,
82	FF_CODEC_ENCODE_CB(v308_encode_frame),	82	FF_CODEC_ENCODE_CB(v308_encode_frame),
83	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE },	83	CODEC_PIXFMTS(AV_PIX_FMT_YUV444P),
84	};	84	};

libavcodec/v408enc.c+1−1

@@ -79,5 +79,5 @@ const FFCodec ff_v408_encoder = { · 78 unmodified lines
79	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	79	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
80	.init = v408_encode_init,	80	.init = v408_encode_init,
81	FF_CODEC_ENCODE_CB(v408_encode_frame),	81	FF_CODEC_ENCODE_CB(v408_encode_frame),
82	.p.pix_fmts = pix_fmt,	82	CODEC_PIXFMTS_ARRAY(pix_fmt),
83	};	83	};

libavcodec/v410enc.c+1−1

@@ -84,5 +84,5 @@ const FFCodec ff_v410_encoder = { · 83 unmodified lines
84	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	84	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
85	.init = v410_encode_init,	85	.init = v410_encode_init,
86	FF_CODEC_ENCODE_CB(v410_encode_frame),	86	FF_CODEC_ENCODE_CB(v410_encode_frame),
87	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV444P10, AV_PIX_FMT_NONE },	87	CODEC_PIXFMTS(AV_PIX_FMT_YUV444P10),
88	};	88	};

libavcodec/vaapi_encode_av1.c+1−4

     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vaapi_encode_av1_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VAAPI),
-        AV_PIX_FMT_VAAPI,
-        AV_PIX_FMT_NONE,
-    },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .hw_configs     = ff_vaapi_encode_hw_configs,
     .p.wrapper_name = "vaapi",

libavcodec/vaapi_encode_h264.c+1−4

     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vaapi_encode_h264_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VAAPI),
-        AV_PIX_FMT_VAAPI,
-        AV_PIX_FMT_NONE,
-    },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .hw_configs     = ff_vaapi_encode_hw_configs,
     .p.wrapper_name = "vaapi",

libavcodec/vaapi_encode_h265.c+1−4

     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vaapi_encode_h265_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VAAPI),
-        AV_PIX_FMT_VAAPI,
-        AV_PIX_FMT_NONE,
-    },
     .color_ranges   = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
     .hw_configs     = ff_vaapi_encode_hw_configs,
     .p.wrapper_name = "vaapi",

libavcodec/vaapi_encode_mjpeg.c+1−4

     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vaapi_encode_mjpeg_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VAAPI),
-        AV_PIX_FMT_VAAPI,
-        AV_PIX_FMT_NONE,
-    },
     .color_ranges   = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
     .hw_configs     = ff_vaapi_encode_hw_configs,
     .p.wrapper_name = "vaapi",

libavcodec/vaapi_encode_mpeg2.c+1−4

     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vaapi_encode_mpeg2_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VAAPI),
-        AV_PIX_FMT_VAAPI,
-        AV_PIX_FMT_NONE,
-    },
     .color_ranges   = AVCOL_RANGE_MPEG,
     .hw_configs     = ff_vaapi_encode_hw_configs,
     .p.wrapper_name = "vaapi",

libavcodec/vaapi_encode_vp8.c+1−4

     .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vaapi_encode_vp8_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VAAPI),
-        AV_PIX_FMT_VAAPI,
-        AV_PIX_FMT_NONE,
-    },
     .color_ranges   = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
     .hw_configs     = ff_vaapi_encode_hw_configs,
     .p.wrapper_name = "vaapi",

libavcodec/vaapi_encode_vp9.c+1−4

                       FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vaapi_encode_vp9_defaults,
     .color_ranges   = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VAAPI),
-        AV_PIX_FMT_VAAPI,
-        AV_PIX_FMT_NONE,
-    },
     .hw_configs     = ff_vaapi_encode_hw_configs,
     .p.wrapper_name = "vaapi",
 };

libavcodec/vbnenc.c+1−3

     .init           = vbn_init,
     FF_CODEC_ENCODE_CB(vbn_encode),
     .priv_data_size = sizeof(VBNContext),
-    .p.pix_fmts     = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB24),
-        AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE,
-    },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/vc2enc.c+1−1

@@ -1244,6 +1244,6 @@ const FFCodec ff_vc2_encoder = { · 1243 unmodified lines
1244	FF_CODEC_ENCODE_CB(vc2_encode_frame),	1244	FF_CODEC_ENCODE_CB(vc2_encode_frame),
1245	.p.priv_class = &vc2enc_class,	1245	.p.priv_class = &vc2enc_class,
1246	.defaults = vc2enc_defaults,	1246	.defaults = vc2enc_defaults,
1247	.p.pix_fmts = allowed_pix_fmts,	1247	CODEC_PIXFMTS_ARRAY(allowed_pix_fmts),
1248	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	1248	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
1249	};	1249	};

libavcodec/videotoolboxenc.c+3−3

@@ -2974,7 +2974,7 @@ const FFCodec ff_h264_videotoolbox_encoder = { · 2973 unmodified lines
2974	.p.id = AV_CODEC_ID_H264,	2974	.p.id = AV_CODEC_ID_H264,
2975	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY,	2975	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY,
2976	.priv_data_size = sizeof(VTEncContext),	2976	.priv_data_size = sizeof(VTEncContext),
2977	.p.pix_fmts = avc_pix_fmts,	2977	CODEC_PIXFMTS_ARRAY(avc_pix_fmts),
2978	.defaults = vt_defaults,	2978	.defaults = vt_defaults,
2979	.init = vtenc_init,	2979	.init = vtenc_init,
2980	FF_CODEC_ENCODE_CB(vtenc_frame),	2980	FF_CODEC_ENCODE_CB(vtenc_frame),
@@ -3012,7 +3012,7 @@ const FFCodec ff_hevc_videotoolbox_encoder = { · 31 unmodified lines
3012	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|	3012	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|
3013	AV_CODEC_CAP_HARDWARE,	3013	AV_CODEC_CAP_HARDWARE,
3014	.priv_data_size = sizeof(VTEncContext),	3014	.priv_data_size = sizeof(VTEncContext),
3015	.p.pix_fmts = hevc_pix_fmts,	3015	CODEC_PIXFMTS_ARRAY(hevc_pix_fmts),
3016	.defaults = vt_defaults,	3016	.defaults = vt_defaults,
3017	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	3017	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
3018	.init = vtenc_init,	3018	.init = vtenc_init,
@@ -3053,7 +3053,7 @@ const FFCodec ff_prores_videotoolbox_encoder = { · 34 unmodified lines
3053	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|	3053	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY \|
3054	AV_CODEC_CAP_HARDWARE,	3054	AV_CODEC_CAP_HARDWARE,
3055	.priv_data_size = sizeof(VTEncContext),	3055	.priv_data_size = sizeof(VTEncContext),
3056	.p.pix_fmts = prores_pix_fmts,	3056	CODEC_PIXFMTS_ARRAY(prores_pix_fmts),
3057	.defaults = vt_defaults,	3057	.defaults = vt_defaults,
3058	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,	3058	.color_ranges = AVCOL_RANGE_MPEG \| AVCOL_RANGE_JPEG,
3059	.init = vtenc_init,	3059	.init = vtenc_init,

libavcodec/vorbisdec.c+2−3

@@ -1894,7 +1894,6 @@ const FFCodec ff_vorbis_decoder = { · 1893 unmodified lines
1894	.flush = vorbis_decode_flush,	1894	.flush = vorbis_decode_flush,
1895	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,	1895	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_CHANNEL_CONF,
1896	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1896	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1897	.p.ch_layouts = ff_vorbis_ch_layouts,	1897	CODEC_CH_LAYOUTS_ARRAY(ff_vorbis_ch_layouts),
1898	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,	1898	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
1899	AV_SAMPLE_FMT_NONE },
1900	};	1899	};

libavcodec/vorbisenc.c+1−2

@@ -1312,7 +1312,6 @@ const FFCodec ff_vorbis_encoder = { · 1311 unmodified lines
1312	.init = vorbis_encode_init,	1312	.init = vorbis_encode_init,
1313	FF_CODEC_ENCODE_CB(vorbis_encode_frame),	1313	FF_CODEC_ENCODE_CB(vorbis_encode_frame),
1314	.close = vorbis_encode_close,	1314	.close = vorbis_encode_close,
1315	.p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,	1315	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
1316	AV_SAMPLE_FMT_NONE },
1317	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1316	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1318	};	1317	};

libavcodec/vulkan_encode_h264.c+1−4

                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vulkan_encode_h264_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VULKAN),
-        AV_PIX_FMT_VULKAN,
-        AV_PIX_FMT_NONE,
-    },
     .hw_configs     = ff_vulkan_encode_hw_configs,
     .p.wrapper_name = "vulkan",
 };

libavcodec/vulkan_encode_h265.c+1−4

                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
     .defaults       = vulkan_encode_h265_defaults,
-    .p.pix_fmts = (const enum AVPixelFormat[]) {
+    CODEC_PIXFMTS(AV_PIX_FMT_VULKAN),
-        AV_PIX_FMT_VULKAN,
-        AV_PIX_FMT_NONE,
-    },
     .hw_configs     = ff_vulkan_encode_hw_configs,
     .p.wrapper_name = "vulkan",
 };

libavcodec/wavarc.c+1−3

@@ -885,7 +885,5 @@ const FFCodec ff_wavarc_decoder = { · 884 unmodified lines
885	AV_CODEC_CAP_SUBFRAMES \|	885	AV_CODEC_CAP_SUBFRAMES \|
886	#endif	886	#endif
887	AV_CODEC_CAP_DELAY,	887	AV_CODEC_CAP_DELAY,
888	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,	888	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P),
889	AV_SAMPLE_FMT_S16P,
890	AV_SAMPLE_FMT_NONE },
891	};	889	};

libavcodec/wavpackenc.c+2−5

     .init           = wavpack_encode_init,
     FF_CODEC_ENCODE_CB(wavpack_encode_frame),
     .close          = wavpack_encode_close,
-    .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_U8P,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P,  AV_SAMPLE_FMT_S16P,
-                                                     AV_SAMPLE_FMT_S16P,
+                     AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_FLTP),
-                                                     AV_SAMPLE_FMT_S32P,
-                                                     AV_SAMPLE_FMT_FLTP,
-                                                     AV_SAMPLE_FMT_NONE },
 };

libavcodec/wbmpenc.c+1−4

     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     FF_CODEC_ENCODE_CB(wbmp_encode_frame),
-    .p.pix_fmts     = (const enum AVPixelFormat[]){
+    CODEC_PIXFMTS(AV_PIX_FMT_MONOBLACK),
-        AV_PIX_FMT_MONOBLACK,
-        AV_PIX_FMT_NONE
-    },
 };

libavcodec/wmadec.c+2−4

     FF_CODEC_DECODE_CB(wma_decode_superframe),
     .flush          = flush,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif
     FF_CODEC_DECODE_CB(wma_decode_superframe),
     .flush          = flush,
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif

libavcodec/wmaenc.c+2−4

     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_superframe),
     .close          = ff_wma_end,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif
     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_superframe),
     .close          = ff_wma_end,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 #endif

libavcodec/wmalosslessdec.c+1−3

@@ -1341,7 +1341,5 @@ const FFCodec ff_wmalossless_decoder = { · 1340 unmodified lines
1341	#endif	1341	#endif
1342	AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY,	1342	AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_DELAY,
1343	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	1343	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1344	.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,	1344	CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P),
1345	AV_SAMPLE_FMT_S32P,
1346	AV_SAMPLE_FMT_NONE },
1347	};	1345	};

libavcodec/wmaprodec.c+3−6

 #endif
                       AV_CODEC_CAP_DR1,
     .flush          = wmapro_flush,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
                       AV_CODEC_CAP_SUBFRAMES |
 #endif
                       AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
                       AV_CODEC_CAP_SUBFRAMES |
 #endif
                       AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .p.sample_fmts  = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
-                                                      AV_SAMPLE_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/wmv2enc.c+1−2

@@ -250,6 +250,5 @@ const FFCodec ff_wmv2_encoder = { · 249 unmodified lines
250	.close = ff_mpv_encode_end,	250	.close = ff_mpv_encode_end,
251	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,	251	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
252	.color_ranges = AVCOL_RANGE_MPEG,	252	.color_ranges = AVCOL_RANGE_MPEG,
253	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,	253	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
254	AV_PIX_FMT_NONE },
255	};	254	};

libavcodec/xbmenc.c+1−2

@@ -93,6 +93,5 @@ const FFCodec ff_xbm_encoder = { · 92 unmodified lines
93	.p.id = AV_CODEC_ID_XBM,	93	.p.id = AV_CODEC_ID_XBM,
94	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	94	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
95	FF_CODEC_ENCODE_CB(xbm_encode_frame),	95	FF_CODEC_ENCODE_CB(xbm_encode_frame),
96	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_MONOWHITE,	96	CODEC_PIXFMTS(AV_PIX_FMT_MONOWHITE),
97	AV_PIX_FMT_NONE },
98	};	97	};

libavcodec/xfaceenc.c+1−1

@@ -217,7 +217,7 @@ const FFCodec ff_xface_encoder = { · 216 unmodified lines
217	.p.type = AVMEDIA_TYPE_VIDEO,	217	.p.type = AVMEDIA_TYPE_VIDEO,
218	.p.id = AV_CODEC_ID_XFACE,	218	.p.id = AV_CODEC_ID_XFACE,
219	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	219	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
220	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_MONOWHITE, AV_PIX_FMT_NONE },	220	CODEC_PIXFMTS(AV_PIX_FMT_MONOWHITE),
221	.priv_data_size = sizeof(XFaceContext),	221	.priv_data_size = sizeof(XFaceContext),
222	FF_CODEC_ENCODE_CB(xface_encode_frame),	222	FF_CODEC_ENCODE_CB(xface_encode_frame),
223	};	223	};

libavcodec/xwdenc.c+8−22

@@ -219,26 +219,12 @@ const FFCodec ff_xwd_encoder = { · 218 unmodified lines
219	.p.id = AV_CODEC_ID_XWD,	219	.p.id = AV_CODEC_ID_XWD,
220	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	220	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
221	FF_CODEC_ENCODE_CB(xwd_encode_frame),	221	FF_CODEC_ENCODE_CB(xwd_encode_frame),
222	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGRA,	222	CODEC_PIXFMTS(AV_PIX_FMT_BGRA, AV_PIX_FMT_RGBA, AV_PIX_FMT_ARGB,
223	AV_PIX_FMT_RGBA,	223	AV_PIX_FMT_ABGR, AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
224	AV_PIX_FMT_ARGB,	224	AV_PIX_FMT_RGB565BE, AV_PIX_FMT_RGB565LE, AV_PIX_FMT_BGR565BE,
225	AV_PIX_FMT_ABGR,	225	AV_PIX_FMT_BGR565LE, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_RGB555LE,
226	AV_PIX_FMT_RGB24,	226	AV_PIX_FMT_BGR555BE, AV_PIX_FMT_BGR555LE,
227	AV_PIX_FMT_BGR24,	227	AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8,
228	AV_PIX_FMT_RGB565BE,	228	AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,
229	AV_PIX_FMT_RGB565LE,	229	AV_PIX_FMT_PAL8, AV_PIX_FMT_GRAY8, AV_PIX_FMT_MONOWHITE),
230	AV_PIX_FMT_BGR565BE,
231	AV_PIX_FMT_BGR565LE,
232	AV_PIX_FMT_RGB555BE,
233	AV_PIX_FMT_RGB555LE,
234	AV_PIX_FMT_BGR555BE,
235	AV_PIX_FMT_BGR555LE,
236	AV_PIX_FMT_RGB8,
237	AV_PIX_FMT_BGR8,
238	AV_PIX_FMT_RGB4_BYTE,
239	AV_PIX_FMT_BGR4_BYTE,
240	AV_PIX_FMT_PAL8,
241	AV_PIX_FMT_GRAY8,
242	AV_PIX_FMT_MONOWHITE,
243	AV_PIX_FMT_NONE },
244	};	230	};

libavcodec/y41penc.c+1−2

@@ -85,6 +85,5 @@ const FFCodec ff_y41p_encoder = { · 84 unmodified lines
85	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	85	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
86	.init = y41p_encode_init,	86	.init = y41p_encode_init,
87	FF_CODEC_ENCODE_CB(y41p_encode_frame),	87	FF_CODEC_ENCODE_CB(y41p_encode_frame),
88	.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV411P,	88	CODEC_PIXFMTS(AV_PIX_FMT_YUV411P),
89	AV_PIX_FMT_NONE },
90	};	89	};

libavcodec/yuv4enc.c+1−1

@@ -76,6 +76,6 @@ const FFCodec ff_yuv4_encoder = { · 75 unmodified lines
76	.p.type = AVMEDIA_TYPE_VIDEO,	76	.p.type = AVMEDIA_TYPE_VIDEO,
77	.p.id = AV_CODEC_ID_YUV4,	77	.p.id = AV_CODEC_ID_YUV4,
78	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,	78	.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
79	.p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },	79	CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
80	FF_CODEC_ENCODE_CB(yuv4_encode_frame),	80	FF_CODEC_ENCODE_CB(yuv4_encode_frame),
81	};	81	};

libavcodec/zmbvenc.c+12−8

     return ff_deflate_init(&c->zstream, lvl, avctx);
 }
+static const enum AVPixelFormat zmbv_pixfmts_list[] = {
+    AV_PIX_FMT_PAL8,
+    AV_PIX_FMT_RGB555LE,
+    AV_PIX_FMT_RGB565LE,
+#ifdef ZMBV_ENABLE_24BPP
+    AV_PIX_FMT_BGR24,
+#endif
+    AV_PIX_FMT_BGR0,
+    AV_PIX_FMT_NONE
+};
 const FFCodec ff_zmbv_encoder = {
     .p.name         = "zmbv",
     CODEC_LONG_NAME("Zip Motion Blocks Video"),
     .init           = encode_init,
     FF_CODEC_ENCODE_CB(encode_frame),
     .close          = encode_end,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_PAL8,
+    CODEC_PIXFMTS_ARRAY(zmbv_pixfmts_list),
-                                                     AV_PIX_FMT_RGB555LE,
-                                                     AV_PIX_FMT_RGB565LE,
-#ifdef ZMBV_ENABLE_24BPP
-                                                     AV_PIX_FMT_BGR24,
-#endif //ZMBV_ENABLE_24BPP
-                                                     AV_PIX_FMT_BGR0,
-                                                     AV_PIX_FMT_NONE },
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

avcodec/codec_internal, all: Use macros to set deprecated AVCodec fields

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code