diff --git a/libavcodec/4xm.c b/libavcodec/4xm.c
index d89b494b09..cf98e91766 100644
--- a/libavcodec/4xm.c
+++ b/libavcodec/4xm.c
@@ -865,15 +865,14 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_fourxm_decoder = {
-    "4xm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_4XM,
-    sizeof(FourXContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "4xm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_4XM,
+    .priv_data_size = sizeof(FourXContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
 };
 
diff --git a/libavcodec/8bps.c b/libavcodec/8bps.c
index 832298b98e..6828c5c667 100644
--- a/libavcodec/8bps.c
+++ b/libavcodec/8bps.c
@@ -222,14 +222,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 
 AVCodec ff_eightbps_decoder = {
-        "8bps",
-        AVMEDIA_TYPE_VIDEO,
-        CODEC_ID_8BPS,
-        sizeof(EightBpsContext),
-        decode_init,
-        NULL,
-        decode_end,
-        decode_frame,
-        CODEC_CAP_DR1,
+    .name           = "8bps",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_8BPS,
+    .priv_data_size = sizeof(EightBpsContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
         .long_name = NULL_IF_CONFIG_SMALL("QuickTime 8BPS video"),
 };
diff --git a/libavcodec/aacdec.c b/libavcodec/aacdec.c
index d9f60d6d23..7fce228193 100644
--- a/libavcodec/aacdec.c
+++ b/libavcodec/aacdec.c
@@ -2541,14 +2541,13 @@ av_cold static int latm_decode_init(AVCodecContext *avctx)
 
 
 AVCodec ff_aac_decoder = {
-    "aac",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AAC,
-    sizeof(AACContext),
-    aac_decode_init,
-    NULL,
-    aac_decode_close,
-    aac_decode_frame,
+    .name           = "aac",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AAC,
+    .priv_data_size = sizeof(AACContext),
+    .init           = aac_decode_init,
+    .close          = aac_decode_close,
+    .decode         = aac_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
     .sample_fmts = (const enum AVSampleFormat[]) {
         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
diff --git a/libavcodec/aacenc.c b/libavcodec/aacenc.c
index b877e4eaef..8205cf0bc2 100644
--- a/libavcodec/aacenc.c
+++ b/libavcodec/aacenc.c
@@ -692,13 +692,13 @@ static const AVClass aacenc_class = {
 };
 
 AVCodec ff_aac_encoder = {
-    "aac",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AAC,
-    sizeof(AACEncContext),
-    aac_encode_init,
-    aac_encode_frame,
-    aac_encode_end,
+    .name           = "aac",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AAC,
+    .priv_data_size = sizeof(AACEncContext),
+    .init           = aac_encode_init,
+    .encode         = aac_encode_frame,
+    .close          = aac_encode_end,
     .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
diff --git a/libavcodec/aasc.c b/libavcodec/aasc.c
index e6f363de4c..f0407bc94b 100644
--- a/libavcodec/aasc.c
+++ b/libavcodec/aasc.c
@@ -110,14 +110,13 @@ static av_cold int aasc_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_aasc_decoder = {
-    "aasc",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_AASC,
-    sizeof(AascContext),
-    aasc_decode_init,
-    NULL,
-    aasc_decode_end,
-    aasc_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "aasc",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_AASC,
+    .priv_data_size = sizeof(AascContext),
+    .init           = aasc_decode_init,
+    .close          = aasc_decode_end,
+    .decode         = aasc_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Autodesk RLE"),
 };
diff --git a/libavcodec/ac3enc_fixed.c b/libavcodec/ac3enc_fixed.c
index 906b0a594e..c2e51552bc 100644
--- a/libavcodec/ac3enc_fixed.c
+++ b/libavcodec/ac3enc_fixed.c
@@ -121,14 +121,13 @@ static av_cold int ac3_fixed_encode_init(AVCodecContext *avctx)
 
 
 AVCodec ff_ac3_fixed_encoder = {
-    "ac3_fixed",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AC3,
-    sizeof(AC3EncodeContext),
-    ac3_fixed_encode_init,
-    ff_ac3_fixed_encode_frame,
-    ff_ac3_encode_close,
-    NULL,
+    .name           = "ac3_fixed",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AC3,
+    .priv_data_size = sizeof(AC3EncodeContext),
+    .init           = ac3_fixed_encode_init,
+    .encode         = ff_ac3_fixed_encode_frame,
+    .close          = ff_ac3_encode_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
     .priv_class = &ac3enc_class,
diff --git a/libavcodec/ac3enc_float.c b/libavcodec/ac3enc_float.c
index cb75314164..8845518fe0 100644
--- a/libavcodec/ac3enc_float.c
+++ b/libavcodec/ac3enc_float.c
@@ -121,14 +121,13 @@ static void clip_coefficients(DSPContext *dsp, float *coef, unsigned int len)
 
 #if CONFIG_AC3_ENCODER
 AVCodec ff_ac3_float_encoder = {
-    "ac3_float",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AC3,
-    sizeof(AC3EncodeContext),
-    ff_ac3_encode_init,
-    ff_ac3_float_encode_frame,
-    ff_ac3_encode_close,
-    NULL,
+    .name           = "ac3 float",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AC3,
+    .priv_data_size = sizeof(AC3EncodeContext),
+    .init           = ff_ac3_encode_init,
+    .encode         = ff_ac3_float_encode_frame,
+    .close          = ff_ac3_encode_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
     .priv_class = &ac3enc_class,
diff --git a/libavcodec/adxdec.c b/libavcodec/adxdec.c
index 991528a7d2..df3e8dd355 100644
--- a/libavcodec/adxdec.c
+++ b/libavcodec/adxdec.c
@@ -167,14 +167,12 @@ static int adx_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_adpcm_adx_decoder = {
-    "adpcm_adx",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_ADPCM_ADX,
-    sizeof(ADXContext),
-    adx_decode_init,
-    NULL,
-    NULL,
-    adx_decode_frame,
+    .name           = "adpcm_adx",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_ADPCM_ADX,
+    .priv_data_size = sizeof(ADXContext),
+    .init           = adx_decode_init,
+    .decode         = adx_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
 };
 
diff --git a/libavcodec/adxenc.c b/libavcodec/adxenc.c
index ca48f94b71..893afe0981 100644
--- a/libavcodec/adxenc.c
+++ b/libavcodec/adxenc.c
@@ -184,14 +184,13 @@ static int adx_encode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_adpcm_adx_encoder = {
-    "adpcm_adx",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_ADPCM_ADX,
-    sizeof(ADXContext),
-    adx_encode_init,
-    adx_encode_frame,
-    adx_encode_close,
-    NULL,
+    .name           = "adpcm_adx",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_ADPCM_ADX,
+    .priv_data_size = sizeof(ADXContext),
+    .init           = adx_encode_init,
+    .encode         = adx_encode_frame,
+    .close          = adx_encode_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
 };
diff --git a/libavcodec/alac.c b/libavcodec/alac.c
index 740bf96f90..06bf6f8c78 100644
--- a/libavcodec/alac.c
+++ b/libavcodec/alac.c
@@ -679,13 +679,12 @@ static av_cold int alac_decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_alac_decoder = {
-    "alac",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_ALAC,
-    sizeof(ALACContext),
-    alac_decode_init,
-    NULL,
-    alac_decode_close,
-    alac_decode_frame,
+    .name           = "alac",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_ALAC,
+    .priv_data_size = sizeof(ALACContext),
+    .init           = alac_decode_init,
+    .close          = alac_decode_close,
+    .decode         = alac_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
 };
diff --git a/libavcodec/alacenc.c b/libavcodec/alacenc.c
index bb618e16f2..c399471c1d 100644
--- a/libavcodec/alacenc.c
+++ b/libavcodec/alacenc.c
@@ -529,13 +529,13 @@ static av_cold int alac_encode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_alac_encoder = {
-    "alac",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_ALAC,
-    sizeof(AlacEncodeContext),
-    alac_encode_init,
-    alac_encode_frame,
-    alac_encode_close,
+    .name           = "alac",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_ALAC,
+    .priv_data_size = sizeof(AlacEncodeContext),
+    .init           = alac_encode_init,
+    .encode         = alac_encode_frame,
+    .close          = alac_encode_close,
     .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
     .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
diff --git a/libavcodec/alsdec.c b/libavcodec/alsdec.c
index 509d49c694..9a79180d82 100644
--- a/libavcodec/alsdec.c
+++ b/libavcodec/alsdec.c
@@ -1739,14 +1739,13 @@ static av_cold void flush(AVCodecContext *avctx)
 
 
 AVCodec ff_als_decoder = {
-    "als",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_MP4ALS,
-    sizeof(ALSDecContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
+    .name           = "als",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_MP4ALS,
+    .priv_data_size = sizeof(ALSDecContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
     .flush = flush,
     .capabilities = CODEC_CAP_SUBFRAMES,
     .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
diff --git a/libavcodec/anm.c b/libavcodec/anm.c
index 02244f70e1..b84aef1c1b 100644
--- a/libavcodec/anm.c
+++ b/libavcodec/anm.c
@@ -184,14 +184,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_anm_decoder = {
-    "anm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ANM,
-    sizeof(AnmContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "anm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ANM,
+    .priv_data_size = sizeof(AnmContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
 };
diff --git a/libavcodec/apedec.c b/libavcodec/apedec.c
index f036c4a1d7..300a0097d8 100644
--- a/libavcodec/apedec.c
+++ b/libavcodec/apedec.c
@@ -885,14 +885,13 @@ static void ape_flush(AVCodecContext *avctx)
 }
 
 AVCodec ff_ape_decoder = {
-    "ape",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_APE,
-    sizeof(APEContext),
-    ape_decode_init,
-    NULL,
-    ape_decode_close,
-    ape_decode_frame,
+    .name           = "ape",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_APE,
+    .priv_data_size = sizeof(APEContext),
+    .init           = ape_decode_init,
+    .close          = ape_decode_close,
+    .decode         = ape_decode_frame,
     .capabilities = CODEC_CAP_SUBFRAMES,
     .flush = ape_flush,
     .long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
diff --git a/libavcodec/asv1.c b/libavcodec/asv1.c
index ff0d9eff01..a53d238fdd 100644
--- a/libavcodec/asv1.c
+++ b/libavcodec/asv1.c
@@ -603,39 +603,37 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_asv1_decoder = {
-    "asv1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ASV1,
-    sizeof(ASV1Context),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "asv1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ASV1,
+    .priv_data_size = sizeof(ASV1Context),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),
 };
 
 AVCodec ff_asv2_decoder = {
-    "asv2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ASV2,
-    sizeof(ASV1Context),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "asv2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ASV2,
+    .priv_data_size = sizeof(ASV1Context),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name= NULL_IF_CONFIG_SMALL("ASUS V2"),
 };
 
 #if CONFIG_ASV1_ENCODER
 AVCodec ff_asv1_encoder = {
-    "asv1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ASV1,
-    sizeof(ASV1Context),
-    encode_init,
-    encode_frame,
+    .name           = "asv1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ASV1,
+    .priv_data_size = sizeof(ASV1Context),
+    .init           = encode_init,
+    .encode         = encode_frame,
     //encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),
@@ -644,12 +642,12 @@ AVCodec ff_asv1_encoder = {
 
 #if CONFIG_ASV2_ENCODER
 AVCodec ff_asv2_encoder = {
-    "asv2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ASV2,
-    sizeof(ASV1Context),
-    encode_init,
-    encode_frame,
+    .name           = "asv2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ASV2,
+    .priv_data_size = sizeof(ASV1Context),
+    .init           = encode_init,
+    .encode         = encode_frame,
     //encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("ASUS V2"),
diff --git a/libavcodec/aura.c b/libavcodec/aura.c
index 18024f1c08..e2c90b45f7 100644
--- a/libavcodec/aura.c
+++ b/libavcodec/aura.c
@@ -124,16 +124,14 @@ static av_cold int aura_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_aura2_decoder = {
-    "aura2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_AURA2,
-    sizeof(AuraDecodeContext),
-    aura_decode_init,
-    NULL,
-    aura_decode_end,
-    aura_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "aura2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_AURA2,
+    .priv_data_size = sizeof(AuraDecodeContext),
+    .init           = aura_decode_init,
+    .close          = aura_decode_end,
+    .decode         = aura_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Auravision Aura 2"),
 };
 
diff --git a/libavcodec/avs.c b/libavcodec/avs.c
index 06fcd5cd0e..14f7cf0507 100644
--- a/libavcodec/avs.c
+++ b/libavcodec/avs.c
@@ -153,14 +153,12 @@ static av_cold int avs_decode_init(AVCodecContext * avctx)
 }
 
 AVCodec ff_avs_decoder = {
-    "avs",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_AVS,
-    sizeof(AvsContext),
-    avs_decode_init,
-    NULL,
-    NULL,
-    avs_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "avs",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_AVS,
+    .priv_data_size = sizeof(AvsContext),
+    .init           = avs_decode_init,
+    .decode         = avs_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("AVS (Audio Video Standard) video"),
 };
diff --git a/libavcodec/bink.c b/libavcodec/bink.c
index 62edea26c6..534d63b5a6 100644
--- a/libavcodec/bink.c
+++ b/libavcodec/bink.c
@@ -1334,13 +1334,12 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_bink_decoder = {
-    "binkvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_BINKVIDEO,
-    sizeof(BinkContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
+    .name           = "binkvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_BINKVIDEO,
+    .priv_data_size = sizeof(BinkContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Bink video"),
 };
diff --git a/libavcodec/binkaudio.c b/libavcodec/binkaudio.c
index d7dbd283e8..2d06aaa9e9 100644
--- a/libavcodec/binkaudio.c
+++ b/libavcodec/binkaudio.c
@@ -292,25 +292,23 @@ static int decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_binkaudio_rdft_decoder = {
-    "binkaudio_rdft",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_BINKAUDIO_RDFT,
-    sizeof(BinkAudioContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
+    .name           = "binkaudio_rdft",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_BINKAUDIO_RDFT,
+    .priv_data_size = sizeof(BinkAudioContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
 };
 
 AVCodec ff_binkaudio_dct_decoder = {
-    "binkaudio_dct",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_BINKAUDIO_DCT,
-    sizeof(BinkAudioContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
+    .name           = "binkaudio_dct",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_BINKAUDIO_DCT,
+    .priv_data_size = sizeof(BinkAudioContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)")
 };
diff --git a/libavcodec/bmp.c b/libavcodec/bmp.c
index 4c5166404b..0b387249e6 100644
--- a/libavcodec/bmp.c
+++ b/libavcodec/bmp.c
@@ -336,14 +336,13 @@ static av_cold int bmp_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_bmp_decoder = {
-    "bmp",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_BMP,
-    sizeof(BMPContext),
-    bmp_decode_init,
-    NULL,
-    bmp_decode_end,
-    bmp_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "bmp",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_BMP,
+    .priv_data_size = sizeof(BMPContext),
+    .init           = bmp_decode_init,
+    .close          = bmp_decode_end,
+    .decode         = bmp_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("BMP image"),
 };
diff --git a/libavcodec/bmpenc.c b/libavcodec/bmpenc.c
index 3719a539f5..63c3b729a9 100644
--- a/libavcodec/bmpenc.c
+++ b/libavcodec/bmpenc.c
@@ -150,13 +150,12 @@ static int bmp_encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_s
 }
 
 AVCodec ff_bmp_encoder = {
-    "bmp",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_BMP,
-    sizeof(BMPContext),
-    bmp_encode_init,
-    bmp_encode_frame,
-    NULL, //encode_end,
+    .name           = "bmp",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_BMP,
+    .priv_data_size = sizeof(BMPContext),
+    .init           = bmp_encode_init,
+    .encode         = bmp_encode_frame,
     .pix_fmts = (const enum PixelFormat[]){
         PIX_FMT_BGR24,
         PIX_FMT_RGB555, PIX_FMT_RGB565,
diff --git a/libavcodec/c93.c b/libavcodec/c93.c
index 31296395f7..1f4ed1fdf0 100644
--- a/libavcodec/c93.c
+++ b/libavcodec/c93.c
@@ -247,14 +247,13 @@ static int decode_frame(AVCodecContext *avctx, void *data,
 }
 
 AVCodec ff_c93_decoder = {
-    "c93",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_C93,
-    sizeof(C93DecoderContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "c93",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_C93,
+    .priv_data_size = sizeof(C93DecoderContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Interplay C93"),
 };
diff --git a/libavcodec/cavsdec.c b/libavcodec/cavsdec.c
index cb61fa7e48..6f4c83b850 100644
--- a/libavcodec/cavsdec.c
+++ b/libavcodec/cavsdec.c
@@ -710,15 +710,14 @@ static int cavs_decode_frame(AVCodecContext * avctx,void *data, int *data_size,
 }
 
 AVCodec ff_cavs_decoder = {
-    "cavs",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_CAVS,
-    sizeof(AVSContext),
-    ff_cavs_init,
-    NULL,
-    ff_cavs_end,
-    cavs_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
+    .name           = "cavs",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_CAVS,
+    .priv_data_size = sizeof(AVSContext),
+    .init           = ff_cavs_init,
+    .close          = ff_cavs_end,
+    .decode         = cavs_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
     .flush= cavs_flush,
     .long_name= NULL_IF_CONFIG_SMALL("Chinese AVS video (AVS1-P2, JiZhun profile)"),
 };
diff --git a/libavcodec/cdgraphics.c b/libavcodec/cdgraphics.c
index c774ce2c3e..f7d9e5f7e3 100644
--- a/libavcodec/cdgraphics.c
+++ b/libavcodec/cdgraphics.c
@@ -368,14 +368,13 @@ static av_cold int cdg_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_cdgraphics_decoder = {
-    "cdgraphics",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_CDGRAPHICS,
-    sizeof(CDGraphicsContext),
-    cdg_decode_init,
-    NULL,
-    cdg_decode_end,
-    cdg_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "cdgraphics",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_CDGRAPHICS,
+    .priv_data_size = sizeof(CDGraphicsContext),
+    .init           = cdg_decode_init,
+    .close          = cdg_decode_end,
+    .decode         = cdg_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("CD Graphics video"),
 };
diff --git a/libavcodec/cinepak.c b/libavcodec/cinepak.c
index 57657afaa4..d2e0c26ddc 100644
--- a/libavcodec/cinepak.c
+++ b/libavcodec/cinepak.c
@@ -460,14 +460,13 @@ static av_cold int cinepak_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_cinepak_decoder = {
-    "cinepak",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_CINEPAK,
-    sizeof(CinepakContext),
-    cinepak_decode_init,
-    NULL,
-    cinepak_decode_end,
-    cinepak_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "cinepak",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_CINEPAK,
+    .priv_data_size = sizeof(CinepakContext),
+    .init           = cinepak_decode_init,
+    .close          = cinepak_decode_end,
+    .decode         = cinepak_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Cinepak"),
 };
diff --git a/libavcodec/cljr.c b/libavcodec/cljr.c
index c9b0911674..ed02c27665 100644
--- a/libavcodec/cljr.c
+++ b/libavcodec/cljr.c
@@ -142,26 +142,24 @@ static av_cold int encode_init(AVCodecContext *avctx){
 #endif
 
 AVCodec ff_cljr_decoder = {
-    "cljr",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_CLJR,
-    sizeof(CLJRContext),
-    decode_init,
-    NULL,
-    NULL,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "cljr",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_CLJR,
+    .priv_data_size = sizeof(CLJRContext),
+    .init           = decode_init,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
 };
 
 #if CONFIG_CLJR_ENCODER
 AVCodec ff_cljr_encoder = {
-    "cljr",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_CLJR,
-    sizeof(CLJRContext),
-    encode_init,
-    encode_frame,
+    .name           = "cljr",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_CLJR,
+    .priv_data_size = sizeof(CLJRContext),
+    .init           = encode_init,
+    .encode         = encode_frame,
     //encode_end,
     .long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
 };
diff --git a/libavcodec/cscd.c b/libavcodec/cscd.c
index 9255503e05..8f7f132271 100644
--- a/libavcodec/cscd.c
+++ b/libavcodec/cscd.c
@@ -256,15 +256,14 @@ static av_cold int decode_end(AVCodecContext *avctx) {
 }
 
 AVCodec ff_cscd_decoder = {
-    "camstudio",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_CSCD,
-    sizeof(CamStudioContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "camstudio",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_CSCD,
+    .priv_data_size = sizeof(CamStudioContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("CamStudio"),
 };
 
diff --git a/libavcodec/cyuv.c b/libavcodec/cyuv.c
index 1c665aefc8..2df6087ae0 100644
--- a/libavcodec/cyuv.c
+++ b/libavcodec/cyuv.c
@@ -180,32 +180,28 @@ static av_cold int cyuv_decode_end(AVCodecContext *avctx)
 
 #if CONFIG_AURA_DECODER
 AVCodec ff_aura_decoder = {
-    "aura",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_AURA,
-    sizeof(CyuvDecodeContext),
-    cyuv_decode_init,
-    NULL,
-    cyuv_decode_end,
-    cyuv_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "aura",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_AURA,
+    .priv_data_size = sizeof(CyuvDecodeContext),
+    .init           = cyuv_decode_init,
+    .close          = cyuv_decode_end,
+    .decode         = cyuv_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Auravision AURA"),
 };
 #endif
 
 #if CONFIG_CYUV_DECODER
 AVCodec ff_cyuv_decoder = {
-    "cyuv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_CYUV,
-    sizeof(CyuvDecodeContext),
-    cyuv_decode_init,
-    NULL,
-    cyuv_decode_end,
-    cyuv_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "cyuv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_CYUV,
+    .priv_data_size = sizeof(CyuvDecodeContext),
+    .init           = cyuv_decode_init,
+    .close          = cyuv_decode_end,
+    .decode         = cyuv_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Creative YUV (CYUV)"),
 };
 #endif
diff --git a/libavcodec/dfa.c b/libavcodec/dfa.c
index 598fedc980..f222a59459 100644
--- a/libavcodec/dfa.c
+++ b/libavcodec/dfa.c
@@ -384,14 +384,13 @@ static av_cold int dfa_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_dfa_decoder = {
-    "dfa",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DFA,
-    sizeof(DfaContext),
-    dfa_decode_init,
-    NULL,
-    dfa_decode_end,
-    dfa_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "dfa",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DFA,
+    .priv_data_size = sizeof(DfaContext),
+    .init           = dfa_decode_init,
+    .close          = dfa_decode_end,
+    .decode         = dfa_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
 };
diff --git a/libavcodec/dnxhddec.c b/libavcodec/dnxhddec.c
index bfc4de645c..04d42398e7 100644
--- a/libavcodec/dnxhddec.c
+++ b/libavcodec/dnxhddec.c
@@ -399,14 +399,13 @@ static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_dnxhd_decoder = {
-    "dnxhd",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DNXHD,
-    sizeof(DNXHDContext),
-    dnxhd_decode_init,
-    NULL,
-    dnxhd_decode_close,
-    dnxhd_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "dnxhd",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DNXHD,
+    .priv_data_size = sizeof(DNXHDContext),
+    .init           = dnxhd_decode_init,
+    .close          = dnxhd_decode_close,
+    .decode         = dnxhd_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
 };
diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c
index c1f06f28ea..d6506a2c7f 100644
--- a/libavcodec/dnxhdenc.c
+++ b/libavcodec/dnxhdenc.c
@@ -993,13 +993,13 @@ static int dnxhd_encode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_dnxhd_encoder = {
-    "dnxhd",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DNXHD,
-    sizeof(DNXHDEncContext),
-    dnxhd_encode_init,
-    dnxhd_encode_picture,
-    dnxhd_encode_end,
+    .name           = "dnxhd",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DNXHD,
+    .priv_data_size = sizeof(DNXHDEncContext),
+    .init           = dnxhd_encode_init,
+    .encode         = dnxhd_encode_picture,
+    .close          = dnxhd_encode_end,
     .capabilities = CODEC_CAP_SLICE_THREADS,
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_YUV422P10, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
diff --git a/libavcodec/dpx.c b/libavcodec/dpx.c
index afd71cc173..e8dae300e5 100644
--- a/libavcodec/dpx.c
+++ b/libavcodec/dpx.c
@@ -234,15 +234,12 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_dpx_decoder = {
-    "dpx",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DPX,
-    sizeof(DPXContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    0,
-    NULL,
+    .name           = "dpx",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DPX,
+    .priv_data_size = sizeof(DPXContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("DPX image"),
 };
diff --git a/libavcodec/dsicinav.c b/libavcodec/dsicinav.c
index f12560714a..27f42041ba 100644
--- a/libavcodec/dsicinav.c
+++ b/libavcodec/dsicinav.c
@@ -345,26 +345,23 @@ static int cinaudio_decode_frame(AVCodecContext *avctx,
 
 
 AVCodec ff_dsicinvideo_decoder = {
-    "dsicinvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DSICINVIDEO,
-    sizeof(CinVideoContext),
-    cinvideo_decode_init,
-    NULL,
-    cinvideo_decode_end,
-    cinvideo_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "dsicinvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DSICINVIDEO,
+    .priv_data_size = sizeof(CinVideoContext),
+    .init           = cinvideo_decode_init,
+    .close          = cinvideo_decode_end,
+    .decode         = cinvideo_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"),
 };
 
 AVCodec ff_dsicinaudio_decoder = {
-    "dsicinaudio",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_DSICINAUDIO,
-    sizeof(CinAudioContext),
-    cinaudio_decode_init,
-    NULL,
-    NULL,
-    cinaudio_decode_frame,
+    .name           = "dsicinaudio",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_DSICINAUDIO,
+    .priv_data_size = sizeof(CinAudioContext),
+    .init           = cinaudio_decode_init,
+    .decode         = cinaudio_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN audio"),
 };
diff --git a/libavcodec/dv.c b/libavcodec/dv.c
index bd9290a768..c616a60d87 100644
--- a/libavcodec/dv.c
+++ b/libavcodec/dv.c
@@ -1280,12 +1280,12 @@ static int dvvideo_close(AVCodecContext *c)
 
 #if CONFIG_DVVIDEO_ENCODER
 AVCodec ff_dvvideo_encoder = {
-    "dvvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DVVIDEO,
-    sizeof(DVVideoContext),
-    dvvideo_init_encoder,
-    dvvideo_encode_frame,
+    .name           = "dvvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DVVIDEO,
+    .priv_data_size = sizeof(DVVideoContext),
+    .init           = dvvideo_init_encoder,
+    .encode         = dvvideo_encode_frame,
     .capabilities = CODEC_CAP_SLICE_THREADS,
     .pix_fmts  = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
@@ -1294,16 +1294,14 @@ AVCodec ff_dvvideo_encoder = {
 
 #if CONFIG_DVVIDEO_DECODER
 AVCodec ff_dvvideo_decoder = {
-    "dvvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DVVIDEO,
-    sizeof(DVVideoContext),
-    dvvideo_init,
-    NULL,
-    dvvideo_close,
-    dvvideo_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
-    NULL,
+    .name           = "dvvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DVVIDEO,
+    .priv_data_size = sizeof(DVVideoContext),
+    .init           = dvvideo_init,
+    .close          = dvvideo_close,
+    .decode         = dvvideo_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
     .max_lowres = 3,
     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
 };
diff --git a/libavcodec/dvbsub.c b/libavcodec/dvbsub.c
index ed128234e8..2df8b58021 100644
--- a/libavcodec/dvbsub.c
+++ b/libavcodec/dvbsub.c
@@ -403,11 +403,10 @@ static int dvbsub_encode(AVCodecContext *avctx,
 }
 
 AVCodec ff_dvbsub_encoder = {
-    "dvbsub",
-    AVMEDIA_TYPE_SUBTITLE,
-    CODEC_ID_DVB_SUBTITLE,
-    sizeof(DVBSubtitleContext),
-    NULL,
-    dvbsub_encode,
+    .name           = "dvbsub",
+    .type           = AVMEDIA_TYPE_SUBTITLE,
+    .id             = CODEC_ID_DVB_SUBTITLE,
+    .priv_data_size = sizeof(DVBSubtitleContext),
+    .encode         = dvbsub_encode,
     .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
 };
diff --git a/libavcodec/dvbsubdec.c b/libavcodec/dvbsubdec.c
index c5e7b1735b..1ee7aad5d1 100644
--- a/libavcodec/dvbsubdec.c
+++ b/libavcodec/dvbsubdec.c
@@ -1482,13 +1482,12 @@ static int dvbsub_decode(AVCodecContext *avctx,
 
 
 AVCodec ff_dvbsub_decoder = {
-    "dvbsub",
-    AVMEDIA_TYPE_SUBTITLE,
-    CODEC_ID_DVB_SUBTITLE,
-    sizeof(DVBSubContext),
-    dvbsub_init_decoder,
-    NULL,
-    dvbsub_close_decoder,
-    dvbsub_decode,
+    .name           = "dvbsub",
+    .type           = AVMEDIA_TYPE_SUBTITLE,
+    .id             = CODEC_ID_DVB_SUBTITLE,
+    .priv_data_size = sizeof(DVBSubContext),
+    .init           = dvbsub_init_decoder,
+    .close          = dvbsub_close_decoder,
+    .decode         = dvbsub_decode,
     .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
 };
diff --git a/libavcodec/dvdsubdec.c b/libavcodec/dvdsubdec.c
index 6d5973c59b..27a33eaef2 100644
--- a/libavcodec/dvdsubdec.c
+++ b/libavcodec/dvdsubdec.c
@@ -494,13 +494,9 @@ static int dvdsub_decode(AVCodecContext *avctx,
 }
 
 AVCodec ff_dvdsub_decoder = {
-    "dvdsub",
-    AVMEDIA_TYPE_SUBTITLE,
-    CODEC_ID_DVD_SUBTITLE,
-    0,
-    NULL,
-    NULL,
-    NULL,
-    dvdsub_decode,
+    .name           = "dvdsub",
+    .type           = AVMEDIA_TYPE_SUBTITLE,
+    .id             = CODEC_ID_DVD_SUBTITLE,
+    .decode         = dvdsub_decode,
     .long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
 };
diff --git a/libavcodec/dvdsubenc.c b/libavcodec/dvdsubenc.c
index d09ac269ed..1aa6ce7b78 100644
--- a/libavcodec/dvdsubenc.c
+++ b/libavcodec/dvdsubenc.c
@@ -216,11 +216,9 @@ static int dvdsub_encode(AVCodecContext *avctx,
 }
 
 AVCodec ff_dvdsub_encoder = {
-    "dvdsub",
-    AVMEDIA_TYPE_SUBTITLE,
-    CODEC_ID_DVD_SUBTITLE,
-    0,
-    NULL,
-    dvdsub_encode,
+    .name           = "dvdsub",
+    .type           = AVMEDIA_TYPE_SUBTITLE,
+    .id             = CODEC_ID_DVD_SUBTITLE,
+    .encode         = dvdsub_encode,
     .long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
 };
diff --git a/libavcodec/dxa.c b/libavcodec/dxa.c
index 807ecd85ee..b3bdae5c55 100644
--- a/libavcodec/dxa.c
+++ b/libavcodec/dxa.c
@@ -321,15 +321,14 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_dxa_decoder = {
-    "dxa",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DXA,
-    sizeof(DxaDecContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "dxa",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DXA,
+    .priv_data_size = sizeof(DxaDecContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Feeble Files/ScummVM DXA"),
 };
 
diff --git a/libavcodec/eacmv.c b/libavcodec/eacmv.c
index 408d948812..76de9c9810 100644
--- a/libavcodec/eacmv.c
+++ b/libavcodec/eacmv.c
@@ -210,14 +210,13 @@ static av_cold int cmv_decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_eacmv_decoder = {
-    "eacmv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_CMV,
-    sizeof(CmvContext),
-    cmv_decode_init,
-    NULL,
-    cmv_decode_end,
-    cmv_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "eacmv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_CMV,
+    .priv_data_size = sizeof(CmvContext),
+    .init           = cmv_decode_init,
+    .close          = cmv_decode_end,
+    .decode         = cmv_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts CMV video"),
 };
diff --git a/libavcodec/eamad.c b/libavcodec/eamad.c
index d4881ab843..74fb4c121b 100644
--- a/libavcodec/eamad.c
+++ b/libavcodec/eamad.c
@@ -307,14 +307,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_eamad_decoder = {
-    "eamad",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MAD,
-    sizeof(MadContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "eamad",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MAD,
+    .priv_data_size = sizeof(MadContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video")
 };
diff --git a/libavcodec/eatgq.c b/libavcodec/eatgq.c
index a353580a15..95692a471b 100644
--- a/libavcodec/eatgq.c
+++ b/libavcodec/eatgq.c
@@ -244,14 +244,13 @@ static av_cold int tgq_decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_eatgq_decoder = {
-    "eatgq",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TGQ,
-    sizeof(TgqContext),
-    tgq_decode_init,
-    NULL,
-    tgq_decode_end,
-    tgq_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "eatgq",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TGQ,
+    .priv_data_size = sizeof(TgqContext),
+    .init           = tgq_decode_init,
+    .close          = tgq_decode_end,
+    .decode         = tgq_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TGQ video"),
 };
diff --git a/libavcodec/eatgv.c b/libavcodec/eatgv.c
index 0855f10417..991c5d12b8 100644
--- a/libavcodec/eatgv.c
+++ b/libavcodec/eatgv.c
@@ -337,13 +337,12 @@ static av_cold int tgv_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_eatgv_decoder = {
-    "eatgv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TGV,
-    sizeof(TgvContext),
-    tgv_decode_init,
-    NULL,
-    tgv_decode_end,
-    tgv_decode_frame,
+    .name           = "eatgv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TGV,
+    .priv_data_size = sizeof(TgvContext),
+    .init           = tgv_decode_init,
+    .close          = tgv_decode_end,
+    .decode         = tgv_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TGV video"),
 };
diff --git a/libavcodec/eatqi.c b/libavcodec/eatqi.c
index bb028a17fc..a1ad8147dc 100644
--- a/libavcodec/eatqi.c
+++ b/libavcodec/eatqi.c
@@ -153,14 +153,13 @@ static av_cold int tqi_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_eatqi_decoder = {
-    "eatqi",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TQI,
-    sizeof(TqiContext),
-    tqi_decode_init,
-    NULL,
-    tqi_decode_end,
-    tqi_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "eatqi",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TQI,
+    .priv_data_size = sizeof(TqiContext),
+    .init           = tqi_decode_init,
+    .close          = tqi_decode_end,
+    .decode         = tqi_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TQI Video"),
 };
diff --git a/libavcodec/escape124.c b/libavcodec/escape124.c
index 12e478fe19..2c86d5f34f 100644
--- a/libavcodec/escape124.c
+++ b/libavcodec/escape124.c
@@ -366,15 +366,14 @@ static int escape124_decode_frame(AVCodecContext *avctx,
 
 
 AVCodec ff_escape124_decoder = {
-    "escape124",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ESCAPE124,
-    sizeof(Escape124Context),
-    escape124_decode_init,
-    NULL,
-    escape124_decode_close,
-    escape124_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "escape124",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ESCAPE124,
+    .priv_data_size = sizeof(Escape124Context),
+    .init           = escape124_decode_init,
+    .close          = escape124_decode_close,
+    .decode         = escape124_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Escape 124"),
 };
 
diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index 070e0240a2..8d9dc72018 100644
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -1764,28 +1764,26 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
 }
 
 AVCodec ff_ffv1_decoder = {
-    "ffv1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FFV1,
-    sizeof(FFV1Context),
-    decode_init,
-    NULL,
-    common_end,
-    decode_frame,
-    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
-    NULL,
+    .name           = "ffv1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FFV1,
+    .priv_data_size = sizeof(FFV1Context),
+    .init           = decode_init,
+    .close          = common_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
 };
 
 #if CONFIG_FFV1_ENCODER
 AVCodec ff_ffv1_encoder = {
-    "ffv1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FFV1,
-    sizeof(FFV1Context),
-    encode_init,
-    encode_frame,
-    common_end,
+    .name           = "ffv1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FFV1,
+    .priv_data_size = sizeof(FFV1Context),
+    .init           = encode_init,
+    .encode         = encode_frame,
+    .close          = common_end,
     .capabilities = CODEC_CAP_SLICE_THREADS,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
diff --git a/libavcodec/flacdec.c b/libavcodec/flacdec.c
index d45be6cb35..d5662736b5 100644
--- a/libavcodec/flacdec.c
+++ b/libavcodec/flacdec.c
@@ -652,13 +652,12 @@ static av_cold int flac_decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_flac_decoder = {
-    "flac",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_FLAC,
-    sizeof(FLACContext),
-    flac_decode_init,
-    NULL,
-    flac_decode_close,
-    flac_decode_frame,
+    .name           = "flac",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_FLAC,
+    .priv_data_size = sizeof(FLACContext),
+    .init           = flac_decode_init,
+    .close          = flac_decode_close,
+    .decode         = flac_decode_frame,
     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 };
diff --git a/libavcodec/flacenc.c b/libavcodec/flacenc.c
index a80f0f9fe3..4df3a1b11b 100644
--- a/libavcodec/flacenc.c
+++ b/libavcodec/flacenc.c
@@ -1379,14 +1379,13 @@ static const AVClass flac_encoder_class = {
 };
 
 AVCodec ff_flac_encoder = {
-    "flac",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_FLAC,
-    sizeof(FlacEncodeContext),
-    flac_encode_init,
-    flac_encode_frame,
-    flac_encode_close,
-    NULL,
+    .name           = "flac",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_FLAC,
+    .priv_data_size = sizeof(FlacEncodeContext),
+    .init           = flac_encode_init,
+    .encode         = flac_encode_frame,
+    .close          = flac_encode_close,
     .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_LOSSLESS,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
diff --git a/libavcodec/flicvideo.c b/libavcodec/flicvideo.c
index f516d23c63..be1ea50f75 100644
--- a/libavcodec/flicvideo.c
+++ b/libavcodec/flicvideo.c
@@ -748,18 +748,13 @@ static av_cold int flic_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_flic_decoder = {
-    "flic",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FLIC,
-    sizeof(FlicDecodeContext),
-    flic_decode_init,
-    NULL,
-    flic_decode_end,
-    flic_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
-    NULL,
-    NULL,
-    NULL,
+    .name           = "flic",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FLIC,
+    .priv_data_size = sizeof(FlicDecodeContext),
+    .init           = flic_decode_init,
+    .close          = flic_decode_end,
+    .decode         = flic_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"),
 };
diff --git a/libavcodec/flvdec.c b/libavcodec/flvdec.c
index 2a6694403b..7337107469 100644
--- a/libavcodec/flvdec.c
+++ b/libavcodec/flvdec.c
@@ -119,15 +119,14 @@ int ff_flv_decode_picture_header(MpegEncContext *s)
 }
 
 AVCodec ff_flv_decoder = {
-    "flv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FLV1,
-    sizeof(MpegEncContext),
-    ff_h263_decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
+    .name           = "flv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FLV1,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = ff_h263_decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"),
     .pix_fmts= ff_pixfmt_list_420,
diff --git a/libavcodec/flvenc.c b/libavcodec/flvenc.c
index fc8c2a474f..99caa18d2d 100644
--- a/libavcodec/flvenc.c
+++ b/libavcodec/flvenc.c
@@ -85,13 +85,13 @@ void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, in
 }
 
 AVCodec ff_flv_encoder = {
-    "flv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FLV1,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "flv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FLV1,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"),
 };
diff --git a/libavcodec/fraps.c b/libavcodec/fraps.c
index 7e96b0d312..aad8731028 100644
--- a/libavcodec/fraps.c
+++ b/libavcodec/fraps.c
@@ -361,14 +361,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 
 AVCodec ff_fraps_decoder = {
-    "fraps",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FRAPS,
-    sizeof(FrapsContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "fraps",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FRAPS,
+    .priv_data_size = sizeof(FrapsContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Fraps"),
 };
diff --git a/libavcodec/frwu.c b/libavcodec/frwu.c
index 08dfbf0c9b..2a2146d601 100644
--- a/libavcodec/frwu.c
+++ b/libavcodec/frwu.c
@@ -110,14 +110,12 @@ static av_cold int decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_frwu_decoder = {
-    "frwu",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FRWU,
-    0,
-    decode_init,
-    NULL,
-    decode_close,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "FRWU",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FRWU,
+    .init           = decode_init,
+    .close          = decode_close,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Forward Uncompressed"),
 };
diff --git a/libavcodec/g726.c b/libavcodec/g726.c
index 30bd96fcc9..2ce113b24b 100644
--- a/libavcodec/g726.c
+++ b/libavcodec/g726.c
@@ -392,14 +392,13 @@ static int g726_decode_frame(AVCodecContext *avctx,
 
 #if CONFIG_ADPCM_G726_ENCODER
 AVCodec ff_adpcm_g726_encoder = {
-    "g726",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_ADPCM_G726,
-    sizeof(G726Context),
-    g726_init,
-    g726_encode_frame,
-    g726_close,
-    NULL,
+    .name           = "g726",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_ADPCM_G726,
+    .priv_data_size = sizeof(G726Context),
+    .init           = g726_init,
+    .encode         = g726_encode_frame,
+    .close          = g726_close,
     .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
@@ -407,13 +406,12 @@ AVCodec ff_adpcm_g726_encoder = {
 #endif
 
 AVCodec ff_adpcm_g726_decoder = {
-    "g726",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_ADPCM_G726,
-    sizeof(G726Context),
-    g726_init,
-    NULL,
-    g726_close,
-    g726_decode_frame,
+    .name           = "g726",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_ADPCM_G726,
+    .priv_data_size = sizeof(G726Context),
+    .init           = g726_init,
+    .close          = g726_close,
+    .decode         = g726_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
 };
diff --git a/libavcodec/gif.c b/libavcodec/gif.c
index 121b873888..8736f0f46c 100644
--- a/libavcodec/gif.c
+++ b/libavcodec/gif.c
@@ -167,13 +167,13 @@ static int gif_encode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_gif_encoder = {
-    "gif",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_GIF,
-    sizeof(GIFContext),
-    gif_encode_init,
-    gif_encode_frame,
-    gif_encode_close,
+    .name           = "gif",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_GIF,
+    .priv_data_size = sizeof(GIFContext),
+    .init           = gif_encode_init,
+    .encode         = gif_encode_frame,
+    .close          = gif_encode_close,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
 };
diff --git a/libavcodec/gifdec.c b/libavcodec/gifdec.c
index 39d0db9c24..7a22fa702f 100644
--- a/libavcodec/gifdec.c
+++ b/libavcodec/gifdec.c
@@ -326,14 +326,13 @@ static av_cold int gif_decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_gif_decoder = {
-    "gif",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_GIF,
-    sizeof(GifState),
-    gif_decode_init,
-    NULL,
-    gif_decode_close,
-    gif_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "gif",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_GIF,
+    .priv_data_size = sizeof(GifState),
+    .init           = gif_decode_init,
+    .close          = gif_decode_close,
+    .decode         = gif_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
 };
diff --git a/libavcodec/gsmdec.c b/libavcodec/gsmdec.c
index 4ce36b48bc..a3f67d3b52 100644
--- a/libavcodec/gsmdec.c
+++ b/libavcodec/gsmdec.c
@@ -85,25 +85,21 @@ static int gsm_decode_frame(AVCodecContext *avctx, void *data,
 }
 
 AVCodec ff_gsm_decoder = {
-    "gsm",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_GSM,
-    sizeof(GSMContext),
-    gsm_init,
-    NULL,
-    NULL,
-    gsm_decode_frame,
+    .name           = "gsm",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_GSM,
+    .priv_data_size = sizeof(GSMContext),
+    .init           = gsm_init,
+    .decode         = gsm_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("GSM"),
 };
 
 AVCodec ff_gsm_ms_decoder = {
-    "gsm_ms",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_GSM_MS,
-    sizeof(GSMContext),
-    gsm_init,
-    NULL,
-    NULL,
-    gsm_decode_frame,
+    .name           = "gsm_ms",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_GSM_MS,
+    .priv_data_size = sizeof(GSMContext),
+    .init           = gsm_init,
+    .decode         = gsm_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("GSM Microsoft variant"),
 };
diff --git a/libavcodec/h261dec.c b/libavcodec/h261dec.c
index 8418af31b3..a526bc1c60 100644
--- a/libavcodec/h261dec.c
+++ b/libavcodec/h261dec.c
@@ -640,15 +640,14 @@ static av_cold int h261_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_h261_decoder = {
-    "h261",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_H261,
-    sizeof(H261Context),
-    h261_decode_init,
-    NULL,
-    h261_decode_end,
-    h261_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "h261",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_H261,
+    .priv_data_size = sizeof(H261Context),
+    .init           = h261_decode_init,
+    .close          = h261_decode_end,
+    .decode         = h261_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .max_lowres = 3,
     .long_name = NULL_IF_CONFIG_SMALL("H.261"),
 };
diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index cd282fba75..91d90d8989 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -322,13 +322,13 @@ static void h261_encode_block(H261Context * h, DCTELEM * block, int n){
 }
 
 AVCodec ff_h261_encoder = {
-    "h261",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_H261,
-    sizeof(H261Context),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "h261",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_H261,
+    .priv_data_size = sizeof(H261Context),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("H.261"),
 };
diff --git a/libavcodec/h263dec.c b/libavcodec/h263dec.c
index e32e4e6a4c..32105b40d3 100644
--- a/libavcodec/h263dec.c
+++ b/libavcodec/h263dec.c
@@ -734,15 +734,14 @@ av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time);
 }
 
 AVCodec ff_h263_decoder = {
-    "h263",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_H263,
-    sizeof(MpegEncContext),
-    ff_h263_decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
+    .name           = "h263",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_H263,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = ff_h263_decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
     .flush= ff_mpeg_flush,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
diff --git a/libavcodec/h264.c b/libavcodec/h264.c
index 8dfb2b263e..08d66cd2e7 100644
--- a/libavcodec/h264.c
+++ b/libavcodec/h264.c
@@ -4006,16 +4006,15 @@ static const AVProfile profiles[] = {
 };
 
 AVCodec ff_h264_decoder = {
-    "h264",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_H264,
-    sizeof(H264Context),
-    ff_h264_decode_init,
-    NULL,
-    ff_h264_decode_end,
-    decode_frame,
-    /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |
-        CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
+    .name           = "h264",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_H264,
+    .priv_data_size = sizeof(H264Context),
+    .init           = ff_h264_decode_init,
+    .close          = ff_h264_decode_end,
+    .decode         = decode_frame,
+    .capabilities   = /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |
+                      CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
     .flush= flush_dpb,
     .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
@@ -4025,15 +4024,14 @@ AVCodec ff_h264_decoder = {
 
 #if CONFIG_H264_VDPAU_DECODER
 AVCodec ff_h264_vdpau_decoder = {
-    "h264_vdpau",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_H264,
-    sizeof(H264Context),
-    ff_h264_decode_init,
-    NULL,
-    ff_h264_decode_end,
-    decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
+    .name           = "h264_vdpau",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_H264,
+    .priv_data_size = sizeof(H264Context),
+    .init           = ff_h264_decode_init,
+    .close          = ff_h264_decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
     .flush= flush_dpb,
     .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_H264, PIX_FMT_NONE},
diff --git a/libavcodec/huffyuv.c b/libavcodec/huffyuv.c
index 0f59421bb7..b7a79a857b 100644
--- a/libavcodec/huffyuv.c
+++ b/libavcodec/huffyuv.c
@@ -1436,16 +1436,14 @@ static av_cold int encode_end(AVCodecContext *avctx)
 
 #if CONFIG_HUFFYUV_DECODER
 AVCodec ff_huffyuv_decoder = {
-    "huffyuv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_HUFFYUV,
-    sizeof(HYuvContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
-    NULL,
+    .name           = "huffyuv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_HUFFYUV,
+    .priv_data_size = sizeof(HYuvContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
 };
@@ -1453,16 +1451,14 @@ AVCodec ff_huffyuv_decoder = {
 
 #if CONFIG_FFVHUFF_DECODER
 AVCodec ff_ffvhuff_decoder = {
-    "ffvhuff",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FFVHUFF,
-    sizeof(HYuvContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
-    NULL,
+    .name           = "ffvhuff",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FFVHUFF,
+    .priv_data_size = sizeof(HYuvContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
 };
@@ -1470,13 +1466,13 @@ AVCodec ff_ffvhuff_decoder = {
 
 #if CONFIG_HUFFYUV_ENCODER
 AVCodec ff_huffyuv_encoder = {
-    "huffyuv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_HUFFYUV,
-    sizeof(HYuvContext),
-    encode_init,
-    encode_frame,
-    encode_end,
+    .name           = "huffyuv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_HUFFYUV,
+    .priv_data_size = sizeof(HYuvContext),
+    .init           = encode_init,
+    .encode         = encode_frame,
+    .close          = encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
 };
@@ -1484,13 +1480,13 @@ AVCodec ff_huffyuv_encoder = {
 
 #if CONFIG_FFVHUFF_ENCODER
 AVCodec ff_ffvhuff_encoder = {
-    "ffvhuff",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FFVHUFF,
-    sizeof(HYuvContext),
-    encode_init,
-    encode_frame,
-    encode_end,
+    .name           = "ffvhuff",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FFVHUFF,
+    .priv_data_size = sizeof(HYuvContext),
+    .init           = encode_init,
+    .encode         = encode_frame,
+    .close          = encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
 };
diff --git a/libavcodec/idcinvideo.c b/libavcodec/idcinvideo.c
index 362ba3bde9..c47dc303bf 100644
--- a/libavcodec/idcinvideo.c
+++ b/libavcodec/idcinvideo.c
@@ -255,15 +255,14 @@ static av_cold int idcin_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_idcin_decoder = {
-    "idcinvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_IDCIN,
-    sizeof(IdcinContext),
-    idcin_decode_init,
-    NULL,
-    idcin_decode_end,
-    idcin_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "idcinvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_IDCIN,
+    .priv_data_size = sizeof(IdcinContext),
+    .init           = idcin_decode_init,
+    .close          = idcin_decode_end,
+    .decode         = idcin_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("id Quake II CIN video"),
 };
 
diff --git a/libavcodec/iff.c b/libavcodec/iff.c
index 195ef10ac7..31aa6f0947 100644
--- a/libavcodec/iff.c
+++ b/libavcodec/iff.c
@@ -576,27 +576,25 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_iff_ilbm_decoder = {
-    "iff_ilbm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_IFF_ILBM,
-    sizeof(IffContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame_ilbm,
-    CODEC_CAP_DR1,
+    .name           = "iff_ilbm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_IFF_ILBM,
+    .priv_data_size = sizeof(IffContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame_ilbm,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("IFF ILBM"),
 };
 
 AVCodec ff_iff_byterun1_decoder = {
-    "iff_byterun1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_IFF_BYTERUN1,
-    sizeof(IffContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame_byterun1,
-    CODEC_CAP_DR1,
+    .name           = "iff_byterun1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_IFF_BYTERUN1,
+    .priv_data_size = sizeof(IffContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame_byterun1,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("IFF ByteRun1"),
 };
diff --git a/libavcodec/indeo2.c b/libavcodec/indeo2.c
index f58804bab3..30d4758064 100644
--- a/libavcodec/indeo2.c
+++ b/libavcodec/indeo2.c
@@ -223,14 +223,13 @@ static av_cold int ir2_decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_indeo2_decoder = {
-    "indeo2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_INDEO2,
-    sizeof(Ir2Context),
-    ir2_decode_init,
-    NULL,
-    ir2_decode_end,
-    ir2_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "indeo2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_INDEO2,
+    .priv_data_size = sizeof(Ir2Context),
+    .init           = ir2_decode_init,
+    .close          = ir2_decode_end,
+    .decode         = ir2_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 2"),
 };
diff --git a/libavcodec/indeo3.c b/libavcodec/indeo3.c
index 8e55fbe443..fbbffe230a 100644
--- a/libavcodec/indeo3.c
+++ b/libavcodec/indeo3.c
@@ -1147,15 +1147,13 @@ static av_cold int indeo3_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_indeo3_decoder = {
-    "indeo3",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_INDEO3,
-    sizeof(Indeo3DecodeContext),
-    indeo3_decode_init,
-    NULL,
-    indeo3_decode_end,
-    indeo3_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "indeo3",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_INDEO3,
+    .priv_data_size = sizeof(Indeo3DecodeContext),
+    .init           = indeo3_decode_init,
+    .close          = indeo3_decode_end,
+    .decode         = indeo3_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 3"),
 };
diff --git a/libavcodec/intelh263dec.c b/libavcodec/intelh263dec.c
index a011a9f597..836e98ee88 100644
--- a/libavcodec/intelh263dec.c
+++ b/libavcodec/intelh263dec.c
@@ -125,15 +125,14 @@ int ff_intel_h263_decode_picture_header(MpegEncContext *s)
 }
 
 AVCodec ff_h263i_decoder = {
-    "h263i",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_H263I,
-    sizeof(MpegEncContext),
-    ff_h263_decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
+    .name           = "h263i",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_H263I,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = ff_h263_decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Intel H.263"),
     .pix_fmts= ff_pixfmt_list_420,
 };
diff --git a/libavcodec/interplayvideo.c b/libavcodec/interplayvideo.c
index 7e26e1db7d..c8aa8bf65b 100644
--- a/libavcodec/interplayvideo.c
+++ b/libavcodec/interplayvideo.c
@@ -1092,14 +1092,13 @@ static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_interplay_video_decoder = {
-    "interplayvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_INTERPLAY_VIDEO,
-    sizeof(IpvideoContext),
-    ipvideo_decode_init,
-    NULL,
-    ipvideo_decode_end,
-    ipvideo_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "interplayvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_INTERPLAY_VIDEO,
+    .priv_data_size = sizeof(IpvideoContext),
+    .init           = ipvideo_decode_init,
+    .close          = ipvideo_decode_end,
+    .decode         = ipvideo_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
 };
diff --git a/libavcodec/jpeglsdec.c b/libavcodec/jpeglsdec.c
index 7278e020da..8ea2cb5bdb 100644
--- a/libavcodec/jpeglsdec.c
+++ b/libavcodec/jpeglsdec.c
@@ -364,14 +364,13 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor
 
 
 AVCodec ff_jpegls_decoder = {
-    "jpegls",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_JPEGLS,
-    sizeof(MJpegDecodeContext),
-    ff_mjpeg_decode_init,
-    NULL,
-    ff_mjpeg_decode_end,
-    ff_mjpeg_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "jpegls",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_JPEGLS,
+    .priv_data_size = sizeof(MJpegDecodeContext),
+    .init           = ff_mjpeg_decode_init,
+    .close          = ff_mjpeg_decode_end,
+    .decode         = ff_mjpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
 };
diff --git a/libavcodec/kgv1dec.c b/libavcodec/kgv1dec.c
index 3e3922774e..398b8af0d5 100644
--- a/libavcodec/kgv1dec.c
+++ b/libavcodec/kgv1dec.c
@@ -166,13 +166,12 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_kgv1_decoder = {
-    "kgv1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_KGV1,
-    sizeof(KgvContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
+    .name           = "kgv1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_KGV1,
+    .priv_data_size = sizeof(KgvContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Kega Game Video"),
 };
diff --git a/libavcodec/kmvc.c b/libavcodec/kmvc.c
index aa2aaace6c..7ac4c01fba 100644
--- a/libavcodec/kmvc.c
+++ b/libavcodec/kmvc.c
@@ -399,14 +399,13 @@ static av_cold int decode_end(AVCodecContext * avctx)
 }
 
 AVCodec ff_kmvc_decoder = {
-    "kmvc",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_KMVC,
-    sizeof(KmvcContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "kmvc",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_KMVC,
+    .priv_data_size = sizeof(KmvcContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Karl Morton's video codec"),
 };
diff --git a/libavcodec/lagarith.c b/libavcodec/lagarith.c
index 5cff77f58c..a632e52b0d 100644
--- a/libavcodec/lagarith.c
+++ b/libavcodec/lagarith.c
@@ -509,14 +509,13 @@ static av_cold int lag_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_lagarith_decoder = {
-    "lagarith",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_LAGARITH,
-    sizeof(LagarithContext),
-    lag_decode_init,
-    NULL,
-    lag_decode_end,
-    lag_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "lagarith",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_LAGARITH,
+    .priv_data_size = sizeof(LagarithContext),
+    .init           = lag_decode_init,
+    .close          = lag_decode_end,
+    .decode         = lag_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
 };
diff --git a/libavcodec/lcldec.c b/libavcodec/lcldec.c
index 7359864004..e288fc3f63 100644
--- a/libavcodec/lcldec.c
+++ b/libavcodec/lcldec.c
@@ -611,30 +611,28 @@ static av_cold int decode_end(AVCodecContext *avctx)
 
 #if CONFIG_MSZH_DECODER
 AVCodec ff_mszh_decoder = {
-    "mszh",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MSZH,
-    sizeof(LclDecContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "mszh",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MSZH,
+    .priv_data_size = sizeof(LclDecContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) MSZH"),
 };
 #endif
 
 #if CONFIG_ZLIB_DECODER
 AVCodec ff_zlib_decoder = {
-    "zlib",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ZLIB,
-    sizeof(LclDecContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "zlib",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ZLIB,
+    .priv_data_size = sizeof(LclDecContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
 };
 #endif
diff --git a/libavcodec/lclenc.c b/libavcodec/lclenc.c
index 178fe0ae26..9f66960910 100644
--- a/libavcodec/lclenc.c
+++ b/libavcodec/lclenc.c
@@ -171,13 +171,13 @@ static av_cold int encode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_zlib_encoder = {
-    "zlib",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ZLIB,
-    sizeof(LclEncContext),
-    encode_init,
-    encode_frame,
-    encode_end,
+    .name           = "zlib",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ZLIB,
+    .priv_data_size = sizeof(LclEncContext),
+    .init           = encode_init,
+    .encode         = encode_frame,
+    .close          = encode_end,
     .pix_fmts = (const enum PixelFormat[]) { PIX_FMT_BGR24, PIX_FMT_NONE },
     .long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
 };
diff --git a/libavcodec/libdiracdec.c b/libavcodec/libdiracdec.c
index fb6ff45f0a..24a4a06929 100644
--- a/libavcodec/libdiracdec.c
+++ b/libavcodec/libdiracdec.c
@@ -195,15 +195,14 @@ static void libdirac_flush(AVCodecContext *avccontext)
 
 
 AVCodec ff_libdirac_decoder = {
-    "libdirac",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DIRAC,
-    sizeof(FfmpegDiracDecoderParams),
-    libdirac_decode_init,
-    NULL,
-    libdirac_decode_close,
-    libdirac_decode_frame,
-    CODEC_CAP_DELAY,
+    .name           = "libdirac",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DIRAC,
+    .priv_data_size = sizeof(FfmpegDiracDecoderParams),
+    .init           = libdirac_decode_init,
+    .close          = libdirac_decode_close,
+    .decode         = libdirac_decode_frame,
+    .capabilities   = CODEC_CAP_DELAY,
     .flush = libdirac_flush,
     .long_name = NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"),
 };
diff --git a/libavcodec/libdiracenc.c b/libavcodec/libdiracenc.c
index a9cc6803b9..8bf0da4948 100644
--- a/libavcodec/libdiracenc.c
+++ b/libavcodec/libdiracenc.c
@@ -392,13 +392,13 @@ static av_cold int libdirac_encode_close(AVCodecContext *avccontext)
 
 
 AVCodec ff_libdirac_encoder = {
-    "libdirac",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DIRAC,
-    sizeof(FfmpegDiracEncoderParams),
-    libdirac_encode_init,
-    libdirac_encode_frame,
-    libdirac_encode_close,
+    .name           = "libdirac",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DIRAC,
+    .priv_data_size = sizeof(FfmpegDiracEncoderParams),
+    .init           = libdirac_encode_init,
+    .encode         = libdirac_encode_frame,
+    .close          = libdirac_encode_close,
    .capabilities = CODEC_CAP_DELAY,
    .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"),
diff --git a/libavcodec/libfaac.c b/libavcodec/libfaac.c
index 2acc682581..31dc1a41ed 100644
--- a/libavcodec/libfaac.c
+++ b/libavcodec/libfaac.c
@@ -165,13 +165,13 @@ static const AVProfile profiles[] = {
 };
 
 AVCodec ff_libfaac_encoder = {
-    "libfaac",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AAC,
-    sizeof(FaacAudioContext),
-    Faac_encode_init,
-    Faac_encode_frame,
-    Faac_encode_close,
+    .name           = "libfaac",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AAC,
+    .priv_data_size = sizeof(FaacAudioContext),
+    .init           = Faac_encode_init,
+    .encode         = Faac_encode_frame,
+    .close          = Faac_encode_close,
     .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("libfaac AAC (Advanced Audio Codec)"),
diff --git a/libavcodec/libgsm.c b/libavcodec/libgsm.c
index 45cb256fcf..92f1e98cdd 100644
--- a/libavcodec/libgsm.c
+++ b/libavcodec/libgsm.c
@@ -113,25 +113,23 @@ static int libgsm_encode_frame(AVCodecContext *avctx,
 
 
 AVCodec ff_libgsm_encoder = {
-    "libgsm",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_GSM,
-    0,
-    libgsm_init,
-    libgsm_encode_frame,
-    libgsm_close,
+    .name           = "libgsm",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_GSM,
+    .init           = libgsm_init,
+    .encode         = libgsm_encode_frame,
+    .close          = libgsm_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
 };
 
 AVCodec ff_libgsm_ms_encoder = {
-    "libgsm_ms",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_GSM_MS,
-    0,
-    libgsm_init,
-    libgsm_encode_frame,
-    libgsm_close,
+    .name           = "libgsm_ms",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_GSM_MS,
+    .init           = libgsm_init,
+    .encode         = libgsm_encode_frame,
+    .close          = libgsm_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
 };
@@ -157,25 +155,21 @@ static int libgsm_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_libgsm_decoder = {
-    "libgsm",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_GSM,
-    0,
-    libgsm_init,
-    NULL,
-    libgsm_close,
-    libgsm_decode_frame,
+    .name           = "libgsm",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_GSM,
+    .init           = libgsm_init,
+    .close          = libgsm_close,
+    .decode         = libgsm_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
 };
 
 AVCodec ff_libgsm_ms_decoder = {
-    "libgsm_ms",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_GSM_MS,
-    0,
-    libgsm_init,
-    NULL,
-    libgsm_close,
-    libgsm_decode_frame,
+    .name           = "libgsm_ms",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_GSM_MS,
+    .init           = libgsm_init,
+    .close          = libgsm_close,
+    .decode         = libgsm_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
 };
diff --git a/libavcodec/libmp3lame.c b/libavcodec/libmp3lame.c
index 05893830c1..349363eda1 100644
--- a/libavcodec/libmp3lame.c
+++ b/libavcodec/libmp3lame.c
@@ -269,13 +269,13 @@ static av_cold int MP3lame_encode_close(AVCodecContext *avctx)
 
 
 AVCodec ff_libmp3lame_encoder = {
-    "libmp3lame",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_MP3,
-    sizeof(Mp3AudioContext),
-    MP3lame_encode_init,
-    MP3lame_encode_frame,
-    MP3lame_encode_close,
+    .name           = "libmp3lame",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_MP3,
+    .priv_data_size = sizeof(Mp3AudioContext),
+    .init           = MP3lame_encode_init,
+    .encode         = MP3lame_encode_frame,
+    .close          = MP3lame_encode_close,
     .capabilities= CODEC_CAP_DELAY,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,
 #if 2147483647 == INT_MAX
diff --git a/libavcodec/libopencore-amr.c b/libavcodec/libopencore-amr.c
index 31d1462e23..bef60799f1 100644
--- a/libavcodec/libopencore-amr.c
+++ b/libavcodec/libopencore-amr.c
@@ -158,14 +158,13 @@ static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
 }
 
 AVCodec ff_libopencore_amrnb_decoder = {
-    "libopencore_amrnb",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AMR_NB,
-    sizeof(AMRContext),
-    amr_nb_decode_init,
-    NULL,
-    amr_nb_decode_close,
-    amr_nb_decode_frame,
+    .name           = "libopencore_amrnb",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AMR_NB,
+    .priv_data_size = sizeof(AMRContext),
+    .init           = amr_nb_decode_init,
+    .close          = amr_nb_decode_close,
+    .decode         = amr_nb_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
 };
 
@@ -230,14 +229,13 @@ static int amr_nb_encode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_libopencore_amrnb_encoder = {
-    "libopencore_amrnb",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AMR_NB,
-    sizeof(AMRContext),
-    amr_nb_encode_init,
-    amr_nb_encode_frame,
-    amr_nb_encode_close,
-    NULL,
+    .name           = "libopencore_amrnb",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AMR_NB,
+    .priv_data_size = sizeof(AMRContext),
+    .init           = amr_nb_encode_init,
+    .encode         = amr_nb_encode_frame,
+    .close          = amr_nb_encode_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
     .priv_class = &class,
@@ -308,14 +306,13 @@ static int amr_wb_decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_libopencore_amrwb_decoder = {
-    "libopencore_amrwb",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AMR_WB,
-    sizeof(AMRWBContext),
-    amr_wb_decode_init,
-    NULL,
-    amr_wb_decode_close,
-    amr_wb_decode_frame,
+    .name           = "libopencore_amrwb",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AMR_WB,
+    .priv_data_size = sizeof(AMRWBContext),
+    .init           = amr_wb_decode_init,
+    .close          = amr_wb_decode_close,
+    .decode         = amr_wb_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"),
 };
 
diff --git a/libavcodec/libschroedingerdec.c b/libavcodec/libschroedingerdec.c
index d42147188a..2c019b2fa6 100644
--- a/libavcodec/libschroedingerdec.c
+++ b/libavcodec/libschroedingerdec.c
@@ -345,15 +345,14 @@ static void libschroedinger_flush(AVCodecContext *avccontext)
 }
 
 AVCodec ff_libschroedinger_decoder = {
-    "libschroedinger",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DIRAC,
-    sizeof(FfmpegSchroDecoderParams),
-    libschroedinger_decode_init,
-    NULL,
-    libschroedinger_decode_close,
-    libschroedinger_decode_frame,
-    CODEC_CAP_DELAY,
+    .name           = "libschroedinger",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DIRAC,
+    .priv_data_size = sizeof(FfmpegSchroDecoderParams),
+    .init           = libschroedinger_decode_init,
+    .close          = libschroedinger_decode_close,
+    .decode         = libschroedinger_decode_frame,
+    .capabilities   = CODEC_CAP_DELAY,
     .flush = libschroedinger_flush,
     .long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
 };
diff --git a/libavcodec/libschroedingerenc.c b/libavcodec/libschroedingerenc.c
index 4f42d28b3b..f36b90e4eb 100644
--- a/libavcodec/libschroedingerenc.c
+++ b/libavcodec/libschroedingerenc.c
@@ -423,13 +423,13 @@ static int libschroedinger_encode_close(AVCodecContext *avccontext)
 
 
 AVCodec ff_libschroedinger_encoder = {
-    "libschroedinger",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_DIRAC,
-    sizeof(FfmpegSchroEncoderParams),
-    libschroedinger_encode_init,
-    libschroedinger_encode_frame,
-    libschroedinger_encode_close,
+    .name           = "libschroedinger",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_DIRAC,
+    .priv_data_size = sizeof(FfmpegSchroEncoderParams),
+    .init           = libschroedinger_encode_init,
+    .encode         = libschroedinger_encode_frame,
+    .close          = libschroedinger_encode_close,
    .capabilities = CODEC_CAP_DELAY,
    .pix_fmts     = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE},
    .long_name    = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
diff --git a/libavcodec/libspeexdec.c b/libavcodec/libspeexdec.c
index d0fdd5633d..7ee53b04e5 100644
--- a/libavcodec/libspeexdec.c
+++ b/libavcodec/libspeexdec.c
@@ -139,13 +139,12 @@ static av_cold int libspeex_decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_libspeex_decoder = {
-    "libspeex",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_SPEEX,
-    sizeof(LibSpeexContext),
-    libspeex_decode_init,
-    NULL,
-    libspeex_decode_close,
-    libspeex_decode_frame,
+    .name           = "libspeex",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_SPEEX,
+    .priv_data_size = sizeof(LibSpeexContext),
+    .init           = libspeex_decode_init,
+    .close          = libspeex_decode_close,
+    .decode         = libspeex_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("libspeex Speex"),
 };
diff --git a/libavcodec/libvo-aacenc.c b/libavcodec/libvo-aacenc.c
index 0efb79b1c1..c99b53f225 100644
--- a/libavcodec/libvo-aacenc.c
+++ b/libavcodec/libvo-aacenc.c
@@ -116,14 +116,13 @@ static int aac_encode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_libvo_aacenc_encoder = {
-    "libvo_aacenc",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AAC,
-    sizeof(AACContext),
-    aac_encode_init,
-    aac_encode_frame,
-    aac_encode_close,
-    NULL,
+    .name           = "libvo_aacenc",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AAC,
+    .priv_data_size = sizeof(AACContext),
+    .init           = aac_encode_init,
+    .encode         = aac_encode_frame,
+    .close          = aac_encode_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Android VisualOn AAC"),
 };
diff --git a/libavcodec/libvo-amrwbenc.c b/libavcodec/libvo-amrwbenc.c
index 31964e66c3..c7f827fc19 100644
--- a/libavcodec/libvo-amrwbenc.c
+++ b/libavcodec/libvo-amrwbenc.c
@@ -118,14 +118,13 @@ static int amr_wb_encode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_libvo_amrwbenc_encoder = {
-    "libvo_amrwbenc",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_AMR_WB,
-    sizeof(AMRWBContext),
-    amr_wb_encode_init,
-    amr_wb_encode_frame,
-    amr_wb_encode_close,
-    NULL,
+    .name           = "libvo_amrwbenc",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_AMR_WB,
+    .priv_data_size = sizeof(AMRWBContext),
+    .init           = amr_wb_encode_init,
+    .encode         = amr_wb_encode_frame,
+    .close          = amr_wb_encode_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Android VisualOn Adaptive Multi-Rate "
                                       "(AMR) Wide-Band"),
diff --git a/libavcodec/libvpxdec.c b/libavcodec/libvpxdec.c
index 29b8eec43e..15329f3f31 100644
--- a/libavcodec/libvpxdec.c
+++ b/libavcodec/libvpxdec.c
@@ -112,14 +112,12 @@ static av_cold int vp8_free(AVCodecContext *avctx)
 }
 
 AVCodec ff_libvpx_decoder = {
-    "libvpx",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VP8,
-    sizeof(VP8Context),
-    vp8_init,
-    NULL, /* encode */
-    vp8_free,
-    vp8_decode,
-    0, /* capabilities */
+    .name           = "libvpx",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VP8,
+    .priv_data_size = sizeof(VP8Context),
+    .init           = vp8_init,
+    .close          = vp8_free,
+    .decode         = vp8_decode,
     .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
 };
diff --git a/libavcodec/libvpxenc.c b/libavcodec/libvpxenc.c
index ac1b79fcc7..7e7a3012b8 100644
--- a/libavcodec/libvpxenc.c
+++ b/libavcodec/libvpxenc.c
@@ -546,15 +546,14 @@ static int vp8_encode(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 }
 
 AVCodec ff_libvpx_encoder = {
-    "libvpx",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VP8,
-    sizeof(VP8Context),
-    vp8_init,
-    vp8_encode,
-    vp8_free,
-    NULL,
-    CODEC_CAP_DELAY,
+    .name           = "libvpx",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VP8,
+    .priv_data_size = sizeof(VP8Context),
+    .init           = vp8_init,
+    .encode         = vp8_encode,
+    .close          = vp8_free,
+    .capabilities   = CODEC_CAP_DELAY,
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
     .priv_class= &class,
diff --git a/libavcodec/libxvidff.c b/libavcodec/libxvidff.c
index a739dc07d3..d8d44bf42b 100644
--- a/libavcodec/libxvidff.c
+++ b/libavcodec/libxvidff.c
@@ -810,13 +810,13 @@ int xvid_ff_2pass(void *ref, int cmd, void *p1, void *p2) {
  * Xvid codec definition for libavcodec.
  */
 AVCodec ff_libxvid_encoder = {
-    "libxvid",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG4,
-    sizeof(struct xvid_context),
-    xvid_encode_init,
-    xvid_encode_frame,
-    xvid_encode_close,
+    .name           = "libxvid",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG4,
+    .priv_data_size = sizeof(struct xvid_context),
+    .init           = xvid_encode_init,
+    .encode         = xvid_encode_frame,
+    .close          = xvid_encode_close,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
 };
diff --git a/libavcodec/loco.c b/libavcodec/loco.c
index f5807b8f0a..505f566ba6 100644
--- a/libavcodec/loco.c
+++ b/libavcodec/loco.c
@@ -288,14 +288,13 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_loco_decoder = {
-    "loco",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_LOCO,
-    sizeof(LOCOContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "loco",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_LOCO,
+    .priv_data_size = sizeof(LOCOContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("LOCO"),
 };
diff --git a/libavcodec/mace.c b/libavcodec/mace.c
index 1b8c9d0836..9f8749110e 100644
--- a/libavcodec/mace.c
+++ b/libavcodec/mace.c
@@ -280,26 +280,22 @@ static int mace_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_mace3_decoder = {
-    "mace3",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_MACE3,
-    sizeof(MACEContext),
-    mace_decode_init,
-    NULL,
-    NULL,
-    mace_decode_frame,
+    .name           = "mace3",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_MACE3,
+    .priv_data_size = sizeof(MACEContext),
+    .init           = mace_decode_init,
+    .decode         = mace_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 3:1"),
 };
 
 AVCodec ff_mace6_decoder = {
-    "mace6",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_MACE6,
-    sizeof(MACEContext),
-    mace_decode_init,
-    NULL,
-    NULL,
-    mace_decode_frame,
+    .name           = "mace6",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_MACE6,
+    .priv_data_size = sizeof(MACEContext),
+    .init           = mace_decode_init,
+    .decode         = mace_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 6:1"),
 };
 
diff --git a/libavcodec/mdec.c b/libavcodec/mdec.c
index 5f540f05f2..cf606935a6 100644
--- a/libavcodec/mdec.c
+++ b/libavcodec/mdec.c
@@ -267,15 +267,14 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_mdec_decoder = {
-    "mdec",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MDEC,
-    sizeof(MDECContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
+    .name           = "mdec",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MDEC,
+    .priv_data_size = sizeof(MDECContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
     .long_name= NULL_IF_CONFIG_SMALL("Sony PlayStation MDEC (Motion DECoder)"),
     .init_thread_copy= ONLY_IF_THREADS_ENABLED(decode_init_thread_copy)
 };
diff --git a/libavcodec/mimic.c b/libavcodec/mimic.c
index ee625d0dbf..1deed0b87f 100644
--- a/libavcodec/mimic.c
+++ b/libavcodec/mimic.c
@@ -416,15 +416,14 @@ static av_cold int mimic_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_mimic_decoder = {
-    "mimic",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MIMIC,
-    sizeof(MimicContext),
-    mimic_decode_init,
-    NULL,
-    mimic_decode_end,
-    mimic_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
+    .name           = "mimic",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MIMIC,
+    .priv_data_size = sizeof(MimicContext),
+    .init           = mimic_decode_init,
+    .close          = mimic_decode_end,
+    .decode         = mimic_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
     .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
     .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context)
 };
diff --git a/libavcodec/mjpegbdec.c b/libavcodec/mjpegbdec.c
index 5f863433ef..0ad9cb49c9 100644
--- a/libavcodec/mjpegbdec.c
+++ b/libavcodec/mjpegbdec.c
@@ -146,16 +146,14 @@ read_header:
 }
 
 AVCodec ff_mjpegb_decoder = {
-    "mjpegb",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MJPEGB,
-    sizeof(MJpegDecodeContext),
-    ff_mjpeg_decode_init,
-    NULL,
-    ff_mjpeg_decode_end,
-    mjpegb_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "mjpegb",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MJPEGB,
+    .priv_data_size = sizeof(MJpegDecodeContext),
+    .init           = ff_mjpeg_decode_init,
+    .close          = ff_mjpeg_decode_end,
+    .decode         = mjpegb_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .max_lowres = 3,
     .long_name = NULL_IF_CONFIG_SMALL("Apple MJPEG-B"),
 };
diff --git a/libavcodec/mjpegdec.c b/libavcodec/mjpegdec.c
index a75dba4d8d..4e38f46f7a 100644
--- a/libavcodec/mjpegdec.c
+++ b/libavcodec/mjpegdec.c
@@ -1578,31 +1578,27 @@ av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_mjpeg_decoder = {
-    "mjpeg",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MJPEG,
-    sizeof(MJpegDecodeContext),
-    ff_mjpeg_decode_init,
-    NULL,
-    ff_mjpeg_decode_end,
-    ff_mjpeg_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "mjpeg",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MJPEG,
+    .priv_data_size = sizeof(MJpegDecodeContext),
+    .init           = ff_mjpeg_decode_init,
+    .close          = ff_mjpeg_decode_end,
+    .decode         = ff_mjpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .max_lowres = 3,
     .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
 };
 
 AVCodec ff_thp_decoder = {
-    "thp",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_THP,
-    sizeof(MJpegDecodeContext),
-    ff_mjpeg_decode_init,
-    NULL,
-    ff_mjpeg_decode_end,
-    ff_mjpeg_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "thp",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_THP,
+    .priv_data_size = sizeof(MJpegDecodeContext),
+    .init           = ff_mjpeg_decode_init,
+    .close          = ff_mjpeg_decode_end,
+    .decode         = ff_mjpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .max_lowres = 3,
     .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
 };
diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index b721ab3580..48b84701b6 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -446,13 +446,13 @@ void ff_mjpeg_encode_mb(MpegEncContext *s, DCTELEM block[6][64])
 }
 
 AVCodec ff_mjpeg_encoder = {
-    "mjpeg",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MJPEG,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "mjpeg",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MJPEG,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
 };
diff --git a/libavcodec/mlpdec.c b/libavcodec/mlpdec.c
index b13d0795cd..9e59b92342 100644
--- a/libavcodec/mlpdec.c
+++ b/libavcodec/mlpdec.c
@@ -1179,27 +1179,23 @@ error:
 }
 
 AVCodec ff_mlp_decoder = {
-    "mlp",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_MLP,
-    sizeof(MLPDecodeContext),
-    mlp_decode_init,
-    NULL,
-    NULL,
-    read_access_unit,
+    .name           = "mlp",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_MLP,
+    .priv_data_size = sizeof(MLPDecodeContext),
+    .init           = mlp_decode_init,
+    .decode         = read_access_unit,
     .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
 };
 
 #if CONFIG_TRUEHD_DECODER
 AVCodec ff_truehd_decoder = {
-    "truehd",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_TRUEHD,
-    sizeof(MLPDecodeContext),
-    mlp_decode_init,
-    NULL,
-    NULL,
-    read_access_unit,
+    .name           = "truehd",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_TRUEHD,
+    .priv_data_size = sizeof(MLPDecodeContext),
+    .init           = mlp_decode_init,
+    .decode         = read_access_unit,
     .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
 };
 #endif /* CONFIG_TRUEHD_DECODER */
diff --git a/libavcodec/mmvideo.c b/libavcodec/mmvideo.c
index 707ddc5f7e..0f30e9d35e 100644
--- a/libavcodec/mmvideo.c
+++ b/libavcodec/mmvideo.c
@@ -215,14 +215,13 @@ static av_cold int mm_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_mmvideo_decoder = {
-    "mmvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MMVIDEO,
-    sizeof(MmContext),
-    mm_decode_init,
-    NULL,
-    mm_decode_end,
-    mm_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "mmvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MMVIDEO,
+    .priv_data_size = sizeof(MmContext),
+    .init           = mm_decode_init,
+    .close          = mm_decode_end,
+    .decode         = mm_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("American Laser Games MM Video"),
 };
diff --git a/libavcodec/motionpixels.c b/libavcodec/motionpixels.c
index 01558ab95b..a3868e10cc 100644
--- a/libavcodec/motionpixels.c
+++ b/libavcodec/motionpixels.c
@@ -304,14 +304,13 @@ static av_cold int mp_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_motionpixels_decoder = {
-    "motionpixels",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MOTIONPIXELS,
-    sizeof(MotionPixelsContext),
-    mp_decode_init,
-    NULL,
-    mp_decode_end,
-    mp_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "motionpixels",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MOTIONPIXELS,
+    .priv_data_size = sizeof(MotionPixelsContext),
+    .init           = mp_decode_init,
+    .close          = mp_decode_end,
+    .decode         = mp_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Motion Pixels video"),
 };
diff --git a/libavcodec/mpc7.c b/libavcodec/mpc7.c
index bb21469356..ba8828eb52 100644
--- a/libavcodec/mpc7.c
+++ b/libavcodec/mpc7.c
@@ -291,14 +291,12 @@ static void mpc7_decode_flush(AVCodecContext *avctx)
 }
 
 AVCodec ff_mpc7_decoder = {
-    "mpc7",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_MUSEPACK7,
-    sizeof(MPCContext),
-    mpc7_decode_init,
-    NULL,
-    NULL,
-    mpc7_decode_frame,
+    .name           = "mpc7",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_MUSEPACK7,
+    .priv_data_size = sizeof(MPCContext),
+    .init           = mpc7_decode_init,
+    .decode         = mpc7_decode_frame,
     .flush = mpc7_decode_flush,
     .long_name = NULL_IF_CONFIG_SMALL("Musepack SV7"),
 };
diff --git a/libavcodec/mpc8.c b/libavcodec/mpc8.c
index 2864b1a010..cae7244ed5 100644
--- a/libavcodec/mpc8.c
+++ b/libavcodec/mpc8.c
@@ -406,13 +406,11 @@ static int mpc8_decode_frame(AVCodecContext * avctx,
 }
 
 AVCodec ff_mpc8_decoder = {
-    "mpc8",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_MUSEPACK8,
-    sizeof(MPCContext),
-    mpc8_decode_init,
-    NULL,
-    NULL,
-    mpc8_decode_frame,
+    .name           = "mpc8",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_MUSEPACK8,
+    .priv_data_size = sizeof(MPCContext),
+    .init           = mpc8_decode_init,
+    .decode         = mpc8_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),
 };
diff --git a/libavcodec/mpeg12.c b/libavcodec/mpeg12.c
index 20155a0219..91937c820c 100644
--- a/libavcodec/mpeg12.c
+++ b/libavcodec/mpeg12.c
@@ -2569,15 +2569,14 @@ static const AVProfile mpeg2_video_profiles[] = {
 
 
 AVCodec ff_mpeg1video_decoder = {
-    "mpeg1video",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG1VIDEO,
-    sizeof(Mpeg1Context),
-    mpeg_decode_init,
-    NULL,
-    mpeg_decode_end,
-    mpeg_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
+    .name           = "mpeg1video",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG1VIDEO,
+    .priv_data_size = sizeof(Mpeg1Context),
+    .init           = mpeg_decode_init,
+    .close          = mpeg_decode_end,
+    .decode         = mpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
     .flush= flush,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
@@ -2585,15 +2584,14 @@ AVCodec ff_mpeg1video_decoder = {
 };
 
 AVCodec ff_mpeg2video_decoder = {
-    "mpeg2video",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG2VIDEO,
-    sizeof(Mpeg1Context),
-    mpeg_decode_init,
-    NULL,
-    mpeg_decode_end,
-    mpeg_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
+    .name           = "mpeg2video",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG2VIDEO,
+    .priv_data_size = sizeof(Mpeg1Context),
+    .init           = mpeg_decode_init,
+    .close          = mpeg_decode_end,
+    .decode         = mpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
     .flush= flush,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"),
@@ -2602,15 +2600,14 @@ AVCodec ff_mpeg2video_decoder = {
 
 //legacy decoder
 AVCodec ff_mpegvideo_decoder = {
-    "mpegvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG2VIDEO,
-    sizeof(Mpeg1Context),
-    mpeg_decode_init,
-    NULL,
-    mpeg_decode_end,
-    mpeg_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
+    .name           = "mpegvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG2VIDEO,
+    .priv_data_size = sizeof(Mpeg1Context),
+    .init           = mpeg_decode_init,
+    .close          = mpeg_decode_end,
+    .decode         = mpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
     .flush= flush,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
@@ -2634,15 +2631,14 @@ static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){
 }
 
 AVCodec ff_mpeg_xvmc_decoder = {
-    "mpegvideo_xvmc",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG2VIDEO_XVMC,
-    sizeof(Mpeg1Context),
-    mpeg_mc_decode_init,
-    NULL,
-    mpeg_decode_end,
-    mpeg_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
+    .name           = "mpegvideo_xvmc",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG2VIDEO_XVMC,
+    .priv_data_size = sizeof(Mpeg1Context),
+    .init           = mpeg_mc_decode_init,
+    .close          = mpeg_decode_end,
+    .decode         = mpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
     .flush= flush,
     .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
 };
@@ -2651,15 +2647,14 @@ AVCodec ff_mpeg_xvmc_decoder = {
 
 #if CONFIG_MPEG_VDPAU_DECODER
 AVCodec ff_mpeg_vdpau_decoder = {
-    "mpegvideo_vdpau",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG2VIDEO,
-    sizeof(Mpeg1Context),
-    mpeg_decode_init,
-    NULL,
-    mpeg_decode_end,
-    mpeg_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
+    .name           = "mpegvideo_vdpau",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG2VIDEO,
+    .priv_data_size = sizeof(Mpeg1Context),
+    .init           = mpeg_decode_init,
+    .close          = mpeg_decode_end,
+    .decode         = mpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
     .flush= flush,
     .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
 };
@@ -2667,15 +2662,14 @@ AVCodec ff_mpeg_vdpau_decoder = {
 
 #if CONFIG_MPEG1_VDPAU_DECODER
 AVCodec ff_mpeg1_vdpau_decoder = {
-    "mpeg1video_vdpau",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG1VIDEO,
-    sizeof(Mpeg1Context),
-    mpeg_decode_init,
-    NULL,
-    mpeg_decode_end,
-    mpeg_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
+    .name           = "mpeg1video_vdpau",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG1VIDEO,
+    .priv_data_size = sizeof(Mpeg1Context),
+    .init           = mpeg_decode_init,
+    .close          = mpeg_decode_end,
+    .decode         = mpeg_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
     .flush= flush,
     .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
 };
diff --git a/libavcodec/mpeg12enc.c b/libavcodec/mpeg12enc.c
index 1729fb1f5a..852fba5d74 100644
--- a/libavcodec/mpeg12enc.c
+++ b/libavcodec/mpeg12enc.c
@@ -926,13 +926,13 @@ static void mpeg1_encode_block(MpegEncContext *s,
 }
 
 AVCodec ff_mpeg1video_encoder = {
-    "mpeg1video",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG1VIDEO,
-    sizeof(MpegEncContext),
-    encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "mpeg1video",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG1VIDEO,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .supported_framerates= ff_frame_rate_tab+1,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .capabilities= CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
@@ -940,13 +940,13 @@ AVCodec ff_mpeg1video_encoder = {
 };
 
 AVCodec ff_mpeg2video_encoder = {
-    "mpeg2video",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG2VIDEO,
-    sizeof(MpegEncContext),
-    encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "mpeg2video",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG2VIDEO,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .supported_framerates= ff_frame_rate_tab+1,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE},
     .capabilities= CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c
index e35c0993e7..cb5231a4dd 100644
--- a/libavcodec/mpeg4videodec.c
+++ b/libavcodec/mpeg4videodec.c
@@ -2277,15 +2277,14 @@ static const AVProfile mpeg4_video_profiles[] = {
 };
 
 AVCodec ff_mpeg4_decoder = {
-    "mpeg4",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG4,
-    sizeof(MpegEncContext),
-    decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_FRAME_THREADS,
+    .name           = "mpeg4",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG4,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_FRAME_THREADS,
     .flush= ff_mpeg_flush,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
@@ -2297,15 +2296,14 @@ AVCodec ff_mpeg4_decoder = {
 
 #if CONFIG_MPEG4_VDPAU_DECODER
 AVCodec ff_mpeg4_vdpau_decoder = {
-    "mpeg4_vdpau",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG4,
-    sizeof(MpegEncContext),
-    decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
+    .name           = "mpeg4_vdpau",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG4,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_VDPAU_MPEG4, PIX_FMT_NONE},
 };
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index 2801b534b7..db0db045e8 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -1285,13 +1285,13 @@ void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
 }
 
 AVCodec ff_mpeg4_encoder = {
-    "mpeg4",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MPEG4,
-    sizeof(MpegEncContext),
-    encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "mpeg4",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MPEG4,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .capabilities= CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
diff --git a/libavcodec/mpegaudioenc.c b/libavcodec/mpegaudioenc.c
index a9f0edd727..0ca99bac15 100644
--- a/libavcodec/mpegaudioenc.c
+++ b/libavcodec/mpegaudioenc.c
@@ -764,14 +764,13 @@ static av_cold int MPA_encode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_mp2_encoder = {
-    "mp2",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_MP2,
-    sizeof(MpegAudioContext),
-    MPA_encode_init,
-    MPA_encode_frame,
-    MPA_encode_close,
-    NULL,
+    .name           = "mp2",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_MP2,
+    .priv_data_size = sizeof(MpegAudioContext),
+    .init           = MPA_encode_init,
+    .encode         = MPA_encode_frame,
+    .close          = MPA_encode_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .supported_samplerates= (const int[]){44100, 48000,  32000, 22050, 24000, 16000, 0},
     .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 6b2c7c76b6..57b44c3199 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -3770,62 +3770,62 @@ int dct_quantize_c(MpegEncContext *s,
 }
 
 AVCodec ff_h263_encoder = {
-    "h263",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_H263,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "h263",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_H263,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
 };
 
 AVCodec ff_h263p_encoder = {
-    "h263p",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_H263P,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "h263p",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_H263P,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .capabilities = CODEC_CAP_SLICE_THREADS,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
 };
 
 AVCodec ff_msmpeg4v2_encoder = {
-    "msmpeg4v2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MSMPEG4V2,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "msmpeg4v2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MSMPEG4V2,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
 };
 
 AVCodec ff_msmpeg4v3_encoder = {
-    "msmpeg4",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MSMPEG4V3,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "msmpeg4",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MSMPEG4V3,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
 };
 
 AVCodec ff_wmv1_encoder = {
-    "wmv1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_WMV1,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "wmv1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_WMV1,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
 };
diff --git a/libavcodec/msmpeg4.c b/libavcodec/msmpeg4.c
index 62927ac423..5ed03c4ddf 100644
--- a/libavcodec/msmpeg4.c
+++ b/libavcodec/msmpeg4.c
@@ -1884,60 +1884,56 @@ int ff_msmpeg4_decode_motion(MpegEncContext * s,
 }
 
 AVCodec ff_msmpeg4v1_decoder = {
-    "msmpeg4v1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MSMPEG4V1,
-    sizeof(MpegEncContext),
-    ff_msmpeg4_decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
+    .name           = "msmpeg4v1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MSMPEG4V1,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = ff_msmpeg4_decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
     .pix_fmts= ff_pixfmt_list_420,
 };
 
 AVCodec ff_msmpeg4v2_decoder = {
-    "msmpeg4v2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MSMPEG4V2,
-    sizeof(MpegEncContext),
-    ff_msmpeg4_decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
+    .name           = "msmpeg4v2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MSMPEG4V2,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = ff_msmpeg4_decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
     .pix_fmts= ff_pixfmt_list_420,
 };
 
 AVCodec ff_msmpeg4v3_decoder = {
-    "msmpeg4",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MSMPEG4V3,
-    sizeof(MpegEncContext),
-    ff_msmpeg4_decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
+    .name           = "msmpeg4",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MSMPEG4V3,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = ff_msmpeg4_decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
     .pix_fmts= ff_pixfmt_list_420,
 };
 
 AVCodec ff_wmv1_decoder = {
-    "wmv1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_WMV1,
-    sizeof(MpegEncContext),
-    ff_msmpeg4_decode_init,
-    NULL,
-    ff_h263_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
+    .name           = "wmv1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_WMV1,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = ff_msmpeg4_decode_init,
+    .close          = ff_h263_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
     .max_lowres= 3,
     .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
     .pix_fmts= ff_pixfmt_list_420,
diff --git a/libavcodec/msrle.c b/libavcodec/msrle.c
index 496eb40916..8f1f25966b 100644
--- a/libavcodec/msrle.c
+++ b/libavcodec/msrle.c
@@ -149,14 +149,13 @@ static av_cold int msrle_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_msrle_decoder = {
-    "msrle",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MSRLE,
-    sizeof(MsrleContext),
-    msrle_decode_init,
-    NULL,
-    msrle_decode_end,
-    msrle_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "msrle",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MSRLE,
+    .priv_data_size = sizeof(MsrleContext),
+    .init           = msrle_decode_init,
+    .close          = msrle_decode_end,
+    .decode         = msrle_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name= NULL_IF_CONFIG_SMALL("Microsoft RLE"),
 };
diff --git a/libavcodec/msvideo1.c b/libavcodec/msvideo1.c
index c1c7d48080..570c6282e0 100644
--- a/libavcodec/msvideo1.c
+++ b/libavcodec/msvideo1.c
@@ -335,14 +335,13 @@ static av_cold int msvideo1_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_msvideo1_decoder = {
-    "msvideo1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_MSVIDEO1,
-    sizeof(Msvideo1Context),
-    msvideo1_decode_init,
-    NULL,
-    msvideo1_decode_end,
-    msvideo1_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "msvideo1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_MSVIDEO1,
+    .priv_data_size = sizeof(Msvideo1Context),
+    .init           = msvideo1_decode_init,
+    .close          = msvideo1_decode_end,
+    .decode         = msvideo1_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name= NULL_IF_CONFIG_SMALL("Microsoft Video 1"),
 };
diff --git a/libavcodec/nellymoserdec.c b/libavcodec/nellymoserdec.c
index 59c1b3bdd8..a153dc0603 100644
--- a/libavcodec/nellymoserdec.c
+++ b/libavcodec/nellymoserdec.c
@@ -194,14 +194,13 @@ static av_cold int decode_end(AVCodecContext * avctx) {
 }
 
 AVCodec ff_nellymoser_decoder = {
-    "nellymoser",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_NELLYMOSER,
-    sizeof(NellyMoserDecodeContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_tag,
+    .name           = "nellymoser",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_NELLYMOSER,
+    .priv_data_size = sizeof(NellyMoserDecodeContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_tag,
     .long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
 };
 
diff --git a/libavcodec/nuv.c b/libavcodec/nuv.c
index f31be59d8d..2a60fe47fc 100644
--- a/libavcodec/nuv.c
+++ b/libavcodec/nuv.c
@@ -273,15 +273,14 @@ static av_cold int decode_end(AVCodecContext *avctx) {
 }
 
 AVCodec ff_nuv_decoder = {
-    "nuv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_NUV,
-    sizeof(NuvContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "nuv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_NUV,
+    .priv_data_size = sizeof(NuvContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("NuppelVideo/RTJPEG"),
 };
 
diff --git a/libavcodec/pamenc.c b/libavcodec/pamenc.c
index b6d58dec49..d9d849e8ad 100644
--- a/libavcodec/pamenc.c
+++ b/libavcodec/pamenc.c
@@ -109,12 +109,12 @@ static int pam_encode_frame(AVCodecContext *avctx, unsigned char *outbuf,
 
 
 AVCodec ff_pam_encoder = {
-    "pam",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PAM,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    pam_encode_frame,
+    .name           = "pam",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PAM,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .encode         = pam_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
 };
diff --git a/libavcodec/pcm-mpeg.c b/libavcodec/pcm-mpeg.c
index 030507502d..1e8a39ef76 100644
--- a/libavcodec/pcm-mpeg.c
+++ b/libavcodec/pcm-mpeg.c
@@ -297,14 +297,10 @@ static int pcm_bluray_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_pcm_bluray_decoder = {
-    "pcm_bluray",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_PCM_BLURAY,
-    0,
-    NULL,
-    NULL,
-    NULL,
-    pcm_bluray_decode_frame,
+    .name           = "pcm_bluray",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_PCM_BLURAY,
+    .decode         = pcm_bluray_decode_frame,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32,
                                          AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PCM signed 16|20|24-bit big-endian for Blu-ray media"),
diff --git a/libavcodec/pcx.c b/libavcodec/pcx.c
index 2c9f8c07d5..b2d433a13d 100644
--- a/libavcodec/pcx.c
+++ b/libavcodec/pcx.c
@@ -248,15 +248,13 @@ static av_cold int pcx_end(AVCodecContext *avctx) {
 }
 
 AVCodec ff_pcx_decoder = {
-    "pcx",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PCX,
-    sizeof(PCXContext),
-    pcx_init,
-    NULL,
-    pcx_end,
-    pcx_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "pcx",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PCX,
+    .priv_data_size = sizeof(PCXContext),
+    .init           = pcx_init,
+    .close          = pcx_end,
+    .decode         = pcx_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"),
 };
diff --git a/libavcodec/pcxenc.c b/libavcodec/pcxenc.c
index 9d4421f3b2..816223e736 100644
--- a/libavcodec/pcxenc.c
+++ b/libavcodec/pcxenc.c
@@ -190,13 +190,12 @@ static int pcx_encode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_pcx_encoder = {
-    "pcx",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PCX,
-    sizeof(PCXContext),
-    pcx_encode_init,
-    pcx_encode_frame,
-    NULL,
+    .name           = "pcx",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PCX,
+    .priv_data_size = sizeof(PCXContext),
+    .init           = pcx_encode_init,
+    .encode         = pcx_encode_frame,
     .pix_fmts = (const enum PixelFormat[]){
         PIX_FMT_RGB24,
         PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8,
diff --git a/libavcodec/pgssubdec.c b/libavcodec/pgssubdec.c
index 96b400b2bb..5a070e435d 100644
--- a/libavcodec/pgssubdec.c
+++ b/libavcodec/pgssubdec.c
@@ -468,13 +468,12 @@ static int decode(AVCodecContext *avctx, void *data, int *data_size,
 }
 
 AVCodec ff_pgssub_decoder = {
-    "pgssub",
-    AVMEDIA_TYPE_SUBTITLE,
-    CODEC_ID_HDMV_PGS_SUBTITLE,
-    sizeof(PGSSubContext),
-    init_decoder,
-    NULL,
-    close_decoder,
-    decode,
+    .name           = "pgssub",
+    .type           = AVMEDIA_TYPE_SUBTITLE,
+    .id             = CODEC_ID_HDMV_PGS_SUBTITLE,
+    .priv_data_size = sizeof(PGSSubContext),
+    .init           = init_decoder,
+    .close          = close_decoder,
+    .decode         = decode,
     .long_name = NULL_IF_CONFIG_SMALL("HDMV Presentation Graphic Stream subtitles"),
 };
diff --git a/libavcodec/pictordec.c b/libavcodec/pictordec.c
index b87c8643d0..2bbb63633d 100644
--- a/libavcodec/pictordec.c
+++ b/libavcodec/pictordec.c
@@ -246,14 +246,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_pictor_decoder = {
-    "pictor",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PICTOR,
-    sizeof(PicContext),
+    .name           = "pictor",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PICTOR,
+    .priv_data_size = sizeof(PicContext),
     decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Pictor/PC Paint"),
 };
diff --git a/libavcodec/pngdec.c b/libavcodec/pngdec.c
index 05ba027802..70635671c2 100644
--- a/libavcodec/pngdec.c
+++ b/libavcodec/pngdec.c
@@ -647,15 +647,13 @@ static av_cold int png_dec_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_png_decoder = {
-    "png",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PNG,
-    sizeof(PNGDecContext),
-    png_dec_init,
-    NULL,
-    png_dec_end,
-    decode_frame,
-    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
-    NULL,
+    .name           = "png",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PNG,
+    .priv_data_size = sizeof(PNGDecContext),
+    .init           = png_dec_init,
+    .close          = png_dec_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
     .long_name = NULL_IF_CONFIG_SMALL("PNG image"),
 };
diff --git a/libavcodec/pngenc.c b/libavcodec/pngenc.c
index c4ef2fd945..29f4e1a0df 100644
--- a/libavcodec/pngenc.c
+++ b/libavcodec/pngenc.c
@@ -437,13 +437,12 @@ static av_cold int png_enc_init(AVCodecContext *avctx){
 }
 
 AVCodec ff_png_encoder = {
-    "png",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PNG,
-    sizeof(PNGEncContext),
-    png_enc_init,
-    encode_frame,
-    NULL, //encode_end,
+    .name           = "png",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PNG,
+    .priv_data_size = sizeof(PNGEncContext),
+    .init           = png_enc_init,
+    .encode         = encode_frame,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_PAL8, PIX_FMT_GRAY8, PIX_FMT_MONOBLACK, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("PNG image"),
 };
diff --git a/libavcodec/pnmdec.c b/libavcodec/pnmdec.c
index ebecad4006..dc64f9b70e 100644
--- a/libavcodec/pnmdec.c
+++ b/libavcodec/pnmdec.c
@@ -196,15 +196,14 @@ static int pnm_decode_frame(AVCodecContext *avctx, void *data,
 
 #if CONFIG_PGM_DECODER
 AVCodec ff_pgm_decoder = {
-    "pgm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PGM,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    NULL,
-    ff_pnm_end,
-    pnm_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "pgm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PGM,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .close          = ff_pnm_end,
+    .decode         = pnm_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
 };
@@ -212,15 +211,14 @@ AVCodec ff_pgm_decoder = {
 
 #if CONFIG_PGMYUV_DECODER
 AVCodec ff_pgmyuv_decoder = {
-    "pgmyuv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PGMYUV,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    NULL,
-    ff_pnm_end,
-    pnm_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "pgmyuv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PGMYUV,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .close          = ff_pnm_end,
+    .decode         = pnm_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
 };
@@ -228,15 +226,14 @@ AVCodec ff_pgmyuv_decoder = {
 
 #if CONFIG_PPM_DECODER
 AVCodec ff_ppm_decoder = {
-    "ppm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PPM,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    NULL,
-    ff_pnm_end,
-    pnm_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "ppm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PPM,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .close          = ff_pnm_end,
+    .decode         = pnm_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
 };
@@ -244,15 +241,14 @@ AVCodec ff_ppm_decoder = {
 
 #if CONFIG_PBM_DECODER
 AVCodec ff_pbm_decoder = {
-    "pbm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PBM,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    NULL,
-    ff_pnm_end,
-    pnm_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "pbm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PBM,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .close          = ff_pnm_end,
+    .decode         = pnm_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
 };
@@ -260,15 +256,14 @@ AVCodec ff_pbm_decoder = {
 
 #if CONFIG_PAM_DECODER
 AVCodec ff_pam_decoder = {
-    "pam",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PAM,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    NULL,
-    ff_pnm_end,
-    pnm_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "pam",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PAM,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .close          = ff_pnm_end,
+    .decode         = pnm_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
 };
diff --git a/libavcodec/pnmenc.c b/libavcodec/pnmenc.c
index 42c32dc94a..15c71f2514 100644
--- a/libavcodec/pnmenc.c
+++ b/libavcodec/pnmenc.c
@@ -114,12 +114,12 @@ static int pnm_encode_frame(AVCodecContext *avctx, unsigned char *outbuf,
 
 #if CONFIG_PGM_ENCODER
 AVCodec ff_pgm_encoder = {
-    "pgm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PGM,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    pnm_encode_frame,
+    .name           = "pgm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PGM,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .encode         = pnm_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
 };
@@ -127,12 +127,12 @@ AVCodec ff_pgm_encoder = {
 
 #if CONFIG_PGMYUV_ENCODER
 AVCodec ff_pgmyuv_encoder = {
-    "pgmyuv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PGMYUV,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    pnm_encode_frame,
+    .name           = "pgmyuv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PGMYUV,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .encode         = pnm_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
 };
@@ -140,12 +140,12 @@ AVCodec ff_pgmyuv_encoder = {
 
 #if CONFIG_PPM_ENCODER
 AVCodec ff_ppm_encoder = {
-    "ppm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PPM,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    pnm_encode_frame,
+    .name           = "ppm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PPM,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .encode         = pnm_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
 };
@@ -153,12 +153,12 @@ AVCodec ff_ppm_encoder = {
 
 #if CONFIG_PBM_ENCODER
 AVCodec ff_pbm_encoder = {
-    "pbm",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PBM,
-    sizeof(PNMContext),
-    ff_pnm_init,
-    pnm_encode_frame,
+    .name           = "pbm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PBM,
+    .priv_data_size = sizeof(PNMContext),
+    .init           = ff_pnm_init,
+    .encode         = pnm_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
 };
diff --git a/libavcodec/ptx.c b/libavcodec/ptx.c
index 3273fd2f8e..0b809784ab 100644
--- a/libavcodec/ptx.c
+++ b/libavcodec/ptx.c
@@ -107,15 +107,13 @@ static av_cold int ptx_end(AVCodecContext *avctx) {
 }
 
 AVCodec ff_ptx_decoder = {
-    "ptx",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_PTX,
-    sizeof(PTXContext),
-    ptx_init,
-    NULL,
-    ptx_end,
-    ptx_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "ptx",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_PTX,
+    .priv_data_size = sizeof(PTXContext),
+    .init           = ptx_init,
+    .close          = ptx_end,
+    .decode         = ptx_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("V.Flash PTX image"),
 };
diff --git a/libavcodec/qdrw.c b/libavcodec/qdrw.c
index cd3146388e..4c9224c5e9 100644
--- a/libavcodec/qdrw.c
+++ b/libavcodec/qdrw.c
@@ -152,14 +152,13 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_qdraw_decoder = {
-    "qdraw",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_QDRAW,
-    sizeof(QdrawContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "qdraw",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_QDRAW,
+    .priv_data_size = sizeof(QdrawContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Apple QuickDraw"),
 };
diff --git a/libavcodec/qpeg.c b/libavcodec/qpeg.c
index 68232e28e3..84e2b41629 100644
--- a/libavcodec/qpeg.c
+++ b/libavcodec/qpeg.c
@@ -317,14 +317,13 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_qpeg_decoder = {
-    "qpeg",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_QPEG,
-    sizeof(QpegContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "qpeg",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_QPEG,
+    .priv_data_size = sizeof(QpegContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Q-team QPEG"),
 };
diff --git a/libavcodec/qtrle.c b/libavcodec/qtrle.c
index 2cc2de2e23..752bbc1323 100644
--- a/libavcodec/qtrle.c
+++ b/libavcodec/qtrle.c
@@ -543,15 +543,14 @@ static av_cold int qtrle_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_qtrle_decoder = {
-    "qtrle",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_QTRLE,
-    sizeof(QtrleContext),
-    qtrle_decode_init,
-    NULL,
-    qtrle_decode_end,
-    qtrle_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "qtrle",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_QTRLE,
+    .priv_data_size = sizeof(QtrleContext),
+    .init           = qtrle_decode_init,
+    .close          = qtrle_decode_end,
+    .decode         = qtrle_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
 };
 
diff --git a/libavcodec/qtrleenc.c b/libavcodec/qtrleenc.c
index 6258b143ad..0e10c76365 100644
--- a/libavcodec/qtrleenc.c
+++ b/libavcodec/qtrleenc.c
@@ -344,13 +344,13 @@ static av_cold int qtrle_encode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_qtrle_encoder = {
-    "qtrle",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_QTRLE,
-    sizeof(QtrleEncContext),
-    qtrle_encode_init,
-    qtrle_encode_frame,
-    qtrle_encode_end,
+    .name           = "qtrle",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_QTRLE,
+    .priv_data_size = sizeof(QtrleEncContext),
+    .init           = qtrle_encode_init,
+    .encode         = qtrle_encode_frame,
+    .close          = qtrle_encode_end,
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB555BE, PIX_FMT_ARGB, PIX_FMT_GRAY8, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
 };
diff --git a/libavcodec/r210dec.c b/libavcodec/r210dec.c
index 293fe654ad..18086c6916 100644
--- a/libavcodec/r210dec.c
+++ b/libavcodec/r210dec.c
@@ -98,29 +98,25 @@ static av_cold int decode_close(AVCodecContext *avctx)
 
 #if CONFIG_R210_DECODER
 AVCodec ff_r210_decoder = {
-    "r210",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_R210,
-    0,
-    decode_init,
-    NULL,
-    decode_close,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "r210",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_R210,
+    .init           = decode_init,
+    .close          = decode_close,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Uncompressed RGB 10-bit"),
 };
 #endif
 #if CONFIG_R10K_DECODER
 AVCodec ff_r10k_decoder = {
-    "r10k",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_R10K,
-    0,
-    decode_init,
-    NULL,
-    decode_close,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "r10k",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_R10K,
+    .init           = decode_init,
+    .close          = decode_close,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("AJA Kona 10-bit RGB Codec"),
 };
 #endif
diff --git a/libavcodec/rawdec.c b/libavcodec/rawdec.c
index 177f08cb93..48e3282365 100644
--- a/libavcodec/rawdec.c
+++ b/libavcodec/rawdec.c
@@ -236,14 +236,13 @@ static av_cold int raw_close_decoder(AVCodecContext *avctx)
 }
 
 AVCodec ff_rawvideo_decoder = {
-    "rawvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RAWVIDEO,
-    sizeof(RawVideoContext),
-    raw_init_decoder,
-    NULL,
-    raw_close_decoder,
-    raw_decode,
+    .name           = "rawvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RAWVIDEO,
+    .priv_data_size = sizeof(RawVideoContext),
+    .init           = raw_init_decoder,
+    .close          = raw_close_decoder,
+    .decode         = raw_decode,
     .long_name = NULL_IF_CONFIG_SMALL("raw video"),
     .priv_class= &class,
 };
diff --git a/libavcodec/rawenc.c b/libavcodec/rawenc.c
index 772ce94067..7077de170f 100644
--- a/libavcodec/rawenc.c
+++ b/libavcodec/rawenc.c
@@ -56,11 +56,11 @@ static int raw_encode(AVCodecContext *avctx,
 }
 
 AVCodec ff_rawvideo_encoder = {
-    "rawvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RAWVIDEO,
-    sizeof(AVFrame),
-    raw_init_encoder,
-    raw_encode,
+    .name           = "rawvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RAWVIDEO,
+    .priv_data_size = sizeof(AVFrame),
+    .init           = raw_init_encoder,
+    .encode         = raw_encode,
     .long_name = NULL_IF_CONFIG_SMALL("raw video"),
 };
diff --git a/libavcodec/rl2.c b/libavcodec/rl2.c
index f58e4ae8be..7d1cf16aee 100644
--- a/libavcodec/rl2.c
+++ b/libavcodec/rl2.c
@@ -220,15 +220,14 @@ static av_cold int rl2_decode_end(AVCodecContext *avctx)
 
 
 AVCodec ff_rl2_decoder = {
-    "rl2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RL2,
-    sizeof(Rl2Context),
-    rl2_decode_init,
-    NULL,
-    rl2_decode_end,
-    rl2_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "rl2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RL2,
+    .priv_data_size = sizeof(Rl2Context),
+    .init           = rl2_decode_init,
+    .close          = rl2_decode_end,
+    .decode         = rl2_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("RL2 video"),
 };
 
diff --git a/libavcodec/roqaudioenc.c b/libavcodec/roqaudioenc.c
index f6bd726c4f..ac8c94a045 100644
--- a/libavcodec/roqaudioenc.c
+++ b/libavcodec/roqaudioenc.c
@@ -154,14 +154,13 @@ static av_cold int roq_dpcm_encode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_roq_dpcm_encoder = {
-    "roq_dpcm",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_ROQ_DPCM,
-    sizeof(ROQDPCMContext),
-    roq_dpcm_encode_init,
-    roq_dpcm_encode_frame,
-    roq_dpcm_encode_close,
-    NULL,
+    .name           = "roq_dpcm",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_ROQ_DPCM,
+    .priv_data_size = sizeof(ROQDPCMContext),
+    .init           = roq_dpcm_encode_init,
+    .encode         = roq_dpcm_encode_frame,
+    .close          = roq_dpcm_encode_close,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("id RoQ DPCM"),
 };
diff --git a/libavcodec/roqvideodec.c b/libavcodec/roqvideodec.c
index f0977f6491..4af7ede9ad 100644
--- a/libavcodec/roqvideodec.c
+++ b/libavcodec/roqvideodec.c
@@ -213,14 +213,13 @@ static av_cold int roq_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_roq_decoder = {
-    "roqvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ROQ,
-    sizeof(RoqContext),
-    roq_decode_init,
-    NULL,
-    roq_decode_end,
-    roq_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "roqvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ROQ,
+    .priv_data_size = sizeof(RoqContext),
+    .init           = roq_decode_init,
+    .close          = roq_decode_end,
+    .decode         = roq_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("id RoQ video"),
 };
diff --git a/libavcodec/rpza.c b/libavcodec/rpza.c
index 12558563c6..ea90ed6756 100644
--- a/libavcodec/rpza.c
+++ b/libavcodec/rpza.c
@@ -277,14 +277,13 @@ static av_cold int rpza_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_rpza_decoder = {
-    "rpza",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RPZA,
-    sizeof(RpzaContext),
-    rpza_decode_init,
-    NULL,
-    rpza_decode_end,
-    rpza_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "rpza",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RPZA,
+    .priv_data_size = sizeof(RpzaContext),
+    .init           = rpza_decode_init,
+    .close          = rpza_decode_end,
+    .decode         = rpza_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("QuickTime video (RPZA)"),
 };
diff --git a/libavcodec/rv10.c b/libavcodec/rv10.c
index 2f822a8ac2..dfd384a63b 100644
--- a/libavcodec/rv10.c
+++ b/libavcodec/rv10.c
@@ -710,30 +710,28 @@ static int rv10_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_rv10_decoder = {
-    "rv10",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RV10,
-    sizeof(MpegEncContext),
-    rv10_decode_init,
-    NULL,
-    rv10_decode_end,
-    rv10_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "rv10",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RV10,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = rv10_decode_init,
+    .close          = rv10_decode_end,
+    .decode         = rv10_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .max_lowres = 3,
     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
     .pix_fmts= ff_pixfmt_list_420,
 };
 
 AVCodec ff_rv20_decoder = {
-    "rv20",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RV20,
-    sizeof(MpegEncContext),
-    rv10_decode_init,
-    NULL,
-    rv10_decode_end,
-    rv10_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
+    .name           = "rv20",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RV20,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = rv10_decode_init,
+    .close          = rv10_decode_end,
+    .decode         = rv10_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
     .flush= ff_mpeg_flush,
     .max_lowres = 3,
     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
diff --git a/libavcodec/rv10enc.c b/libavcodec/rv10enc.c
index 82b1258799..db9043ceea 100644
--- a/libavcodec/rv10enc.c
+++ b/libavcodec/rv10enc.c
@@ -57,13 +57,13 @@ void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
 }
 
 AVCodec ff_rv10_encoder = {
-    "rv10",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RV10,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "rv10",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RV10,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 };
diff --git a/libavcodec/rv20enc.c b/libavcodec/rv20enc.c
index a10998450c..af7ef6bb72 100644
--- a/libavcodec/rv20enc.c
+++ b/libavcodec/rv20enc.c
@@ -58,13 +58,13 @@ void rv20_encode_picture_header(MpegEncContext *s, int picture_number){
 }
 
 AVCodec ff_rv20_encoder = {
-    "rv20",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RV20,
-    sizeof(MpegEncContext),
-    MPV_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "rv20",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RV20,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = MPV_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 };
diff --git a/libavcodec/rv30.c b/libavcodec/rv30.c
index cd11079d52..d2cc533d80 100644
--- a/libavcodec/rv30.c
+++ b/libavcodec/rv30.c
@@ -267,15 +267,14 @@ static av_cold int rv30_decode_init(AVCodecContext *avctx)
 }
 
 AVCodec ff_rv30_decoder = {
-    "rv30",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RV30,
-    sizeof(RV34DecContext),
-    rv30_decode_init,
-    NULL,
-    ff_rv34_decode_end,
-    ff_rv34_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
+    .name           = "rv30",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RV30,
+    .priv_data_size = sizeof(RV34DecContext),
+    .init           = rv30_decode_init,
+    .close          = ff_rv34_decode_end,
+    .decode         = ff_rv34_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
     .flush = ff_mpeg_flush,
     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 3.0"),
     .pix_fmts= ff_pixfmt_list_420,
diff --git a/libavcodec/rv40.c b/libavcodec/rv40.c
index 0683664548..67676c26cc 100644
--- a/libavcodec/rv40.c
+++ b/libavcodec/rv40.c
@@ -669,15 +669,14 @@ static av_cold int rv40_decode_init(AVCodecContext *avctx)
 }
 
 AVCodec ff_rv40_decoder = {
-    "rv40",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_RV40,
-    sizeof(RV34DecContext),
-    rv40_decode_init,
-    NULL,
-    ff_rv34_decode_end,
-    ff_rv34_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
+    .name           = "rv40",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_RV40,
+    .priv_data_size = sizeof(RV34DecContext),
+    .init           = rv40_decode_init,
+    .close          = ff_rv34_decode_end,
+    .decode         = ff_rv34_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
     .flush = ff_mpeg_flush,
     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
     .pix_fmts= ff_pixfmt_list_420,
diff --git a/libavcodec/s302m.c b/libavcodec/s302m.c
index 98a5e73a8c..4db18eb2d0 100644
--- a/libavcodec/s302m.c
+++ b/libavcodec/s302m.c
@@ -58,9 +58,9 @@ static int s302m_parse_frame_header(AVCodecContext *avctx, const uint8_t *buf,
     /* Set output properties */
     avctx->bits_per_coded_sample = bits;
     if (bits > 16)
-        avctx->sample_fmt = SAMPLE_FMT_S32;
+        avctx->sample_fmt = AV_SAMPLE_FMT_S32;
     else
-        avctx->sample_fmt = SAMPLE_FMT_S16;
+        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
     avctx->channels    = channels;
     switch(channels) {
diff --git a/libavcodec/sgidec.c b/libavcodec/sgidec.c
index 360a25ced2..b0a0b20a5e 100644
--- a/libavcodec/sgidec.c
+++ b/libavcodec/sgidec.c
@@ -260,14 +260,13 @@ static av_cold int sgi_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_sgi_decoder = {
-    "sgi",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SGI,
-    sizeof(SgiState),
-    sgi_init,
-    NULL,
-    sgi_end,
-    decode_frame,
+    .name           = "sgi",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SGI,
+    .priv_data_size = sizeof(SgiState),
+    .init           = sgi_init,
+    .close          = sgi_end,
+    .decode         = decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("SGI image"),
 };
 
diff --git a/libavcodec/sgienc.c b/libavcodec/sgienc.c
index 1e2af8e7ae..1fc6dcb244 100644
--- a/libavcodec/sgienc.c
+++ b/libavcodec/sgienc.c
@@ -160,13 +160,12 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf,
 }
 
 AVCodec ff_sgi_encoder = {
-    "sgi",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SGI,
-    sizeof(SgiContext),
-    encode_init,
-    encode_frame,
-    NULL,
+    .name           = "sgi",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SGI,
+    .priv_data_size = sizeof(SgiContext),
+    .init           = encode_init,
+    .encode         = encode_frame,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGBA, PIX_FMT_GRAY8, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("SGI image"),
 };
diff --git a/libavcodec/shorten.c b/libavcodec/shorten.c
index 37ba8261c4..b39fcbd0ef 100644
--- a/libavcodec/shorten.c
+++ b/libavcodec/shorten.c
@@ -536,14 +536,13 @@ static void shorten_flush(AVCodecContext *avctx){
 }
 
 AVCodec ff_shorten_decoder = {
-    "shorten",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_SHORTEN,
-    sizeof(ShortenContext),
-    shorten_decode_init,
-    NULL,
-    shorten_decode_close,
-    shorten_decode_frame,
+    .name           = "shorten",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_SHORTEN,
+    .priv_data_size = sizeof(ShortenContext),
+    .init           = shorten_decode_init,
+    .close          = shorten_decode_close,
+    .decode         = shorten_decode_frame,
     .flush= shorten_flush,
     .long_name= NULL_IF_CONFIG_SMALL("Shorten"),
 };
diff --git a/libavcodec/sipr.c b/libavcodec/sipr.c
index 9befe8a158..d6179a8edf 100644
--- a/libavcodec/sipr.c
+++ b/libavcodec/sipr.c
@@ -549,13 +549,11 @@ static int sipr_decode_frame(AVCodecContext *avctx, void *datap,
 }
 
 AVCodec ff_sipr_decoder = {
-    "sipr",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_SIPR,
-    sizeof(SiprContext),
-    sipr_decoder_init,
-    NULL,
-    NULL,
-    sipr_decode_frame,
+    .name           = "sipr",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_SIPR,
+    .priv_data_size = sizeof(SiprContext),
+    .init           = sipr_decoder_init,
+    .decode         = sipr_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("RealAudio SIPR / ACELP.NET"),
 };
diff --git a/libavcodec/smacker.c b/libavcodec/smacker.c
index b8eab837ff..bcfde4c8ba 100644
--- a/libavcodec/smacker.c
+++ b/libavcodec/smacker.c
@@ -687,27 +687,23 @@ static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 }
 
 AVCodec ff_smacker_decoder = {
-    "smackvid",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SMACKVIDEO,
-    sizeof(SmackVContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "smackvid",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SMACKVIDEO,
+    .priv_data_size = sizeof(SmackVContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
 };
 
 AVCodec ff_smackaud_decoder = {
-    "smackaud",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_SMACKAUDIO,
-    0,
-    smka_decode_init,
-    NULL,
-    NULL,
-    smka_decode_frame,
+    .name           = "smackaud",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_SMACKAUDIO,
+    .init           = smka_decode_init,
+    .decode         = smka_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
 };
 
diff --git a/libavcodec/smc.c b/libavcodec/smc.c
index ce5b72a2a3..86f4282d54 100644
--- a/libavcodec/smc.c
+++ b/libavcodec/smc.c
@@ -476,14 +476,13 @@ static av_cold int smc_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_smc_decoder = {
-    "smc",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SMC,
-    sizeof(SmcContext),
-    smc_decode_init,
-    NULL,
-    smc_decode_end,
-    smc_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "smc",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SMC,
+    .priv_data_size = sizeof(SmcContext),
+    .init           = smc_decode_init,
+    .close          = smc_decode_end,
+    .decode         = smc_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("QuickTime Graphics (SMC)"),
 };
diff --git a/libavcodec/snow.c b/libavcodec/snow.c
index 22b7fc6ae2..734ff44735 100644
--- a/libavcodec/snow.c
+++ b/libavcodec/snow.c
@@ -1930,16 +1930,14 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_snow_decoder = {
-    "snow",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SNOW,
-    sizeof(SnowContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
-    NULL,
+    .name           = "snow",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SNOW,
+    .priv_data_size = sizeof(SnowContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
     .long_name = NULL_IF_CONFIG_SMALL("Snow"),
 };
 
@@ -3679,13 +3677,13 @@ static av_cold int encode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_snow_encoder = {
-    "snow",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SNOW,
-    sizeof(SnowContext),
-    encode_init,
-    encode_frame,
-    encode_end,
+    .name           = "snow",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SNOW,
+    .priv_data_size = sizeof(SnowContext),
+    .init           = encode_init,
+    .encode         = encode_frame,
+    .close          = encode_end,
     .long_name = NULL_IF_CONFIG_SMALL("Snow"),
 };
 #endif
diff --git a/libavcodec/sp5xdec.c b/libavcodec/sp5xdec.c
index 0b56c101db..4bf45f5454 100644
--- a/libavcodec/sp5xdec.c
+++ b/libavcodec/sp5xdec.c
@@ -94,29 +94,25 @@ static int sp5x_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_sp5x_decoder = {
-    "sp5x",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SP5X,
-    sizeof(MJpegDecodeContext),
-    ff_mjpeg_decode_init,
-    NULL,
-    ff_mjpeg_decode_end,
-    sp5x_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "sp5x",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SP5X,
+    .priv_data_size = sizeof(MJpegDecodeContext),
+    .init           = ff_mjpeg_decode_init,
+    .close          = ff_mjpeg_decode_end,
+    .decode         = sp5x_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .max_lowres = 3,
     .long_name = NULL_IF_CONFIG_SMALL("Sunplus JPEG (SP5X)"),
 };
 
 AVCodec ff_amv_decoder = {
-    "amv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_AMV,
-    sizeof(MJpegDecodeContext),
-    ff_mjpeg_decode_init,
-    NULL,
-    ff_mjpeg_decode_end,
-    sp5x_decode_frame,
-    0,
+    .name           = "amv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_AMV,
+    .priv_data_size = sizeof(MJpegDecodeContext),
+    .init           = ff_mjpeg_decode_init,
+    .close          = ff_mjpeg_decode_end,
+    .decode         = sp5x_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("AMV Video"),
 };
diff --git a/libavcodec/sunrast.c b/libavcodec/sunrast.c
index 558b0edd8f..58bd2a2ab8 100644
--- a/libavcodec/sunrast.c
+++ b/libavcodec/sunrast.c
@@ -185,15 +185,13 @@ static av_cold int sunrast_end(AVCodecContext *avctx) {
 }
 
 AVCodec ff_sunrast_decoder = {
-    "sunrast",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SUNRAST,
-    sizeof(SUNRASTContext),
-    sunrast_init,
-    NULL,
-    sunrast_end,
-    sunrast_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "sunrast",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SUNRAST,
+    .priv_data_size = sizeof(SUNRASTContext),
+    .init           = sunrast_init,
+    .close          = sunrast_end,
+    .decode         = sunrast_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Sun Rasterfile image"),
 };
diff --git a/libavcodec/svq1dec.c b/libavcodec/svq1dec.c
index 40e4c43d9c..cb8a622f26 100644
--- a/libavcodec/svq1dec.c
+++ b/libavcodec/svq1dec.c
@@ -808,15 +808,14 @@ static av_cold int svq1_decode_end(AVCodecContext *avctx)
 
 
 AVCodec ff_svq1_decoder = {
-    "svq1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SVQ1,
-    sizeof(MpegEncContext),
-    svq1_decode_init,
-    NULL,
-    svq1_decode_end,
-    svq1_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "svq1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SVQ1,
+    .priv_data_size = sizeof(MpegEncContext),
+    .init           = svq1_decode_init,
+    .close          = svq1_decode_end,
+    .decode         = svq1_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .flush= ff_mpeg_flush,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
diff --git a/libavcodec/svq1enc.c b/libavcodec/svq1enc.c
index c3a1c60388..25053e47e9 100644
--- a/libavcodec/svq1enc.c
+++ b/libavcodec/svq1enc.c
@@ -573,13 +573,13 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
 
 
 AVCodec ff_svq1_encoder = {
-    "svq1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SVQ1,
-    sizeof(SVQ1Context),
-    svq1_encode_init,
-    svq1_encode_frame,
-    svq1_encode_end,
+    .name           = "svq1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SVQ1,
+    .priv_data_size = sizeof(SVQ1Context),
+    .init           = svq1_encode_init,
+    .encode         = svq1_encode_frame,
+    .close          = svq1_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
 };
diff --git a/libavcodec/svq3.c b/libavcodec/svq3.c
index f8b6c5f07a..54c1231511 100644
--- a/libavcodec/svq3.c
+++ b/libavcodec/svq3.c
@@ -1120,15 +1120,14 @@ static int svq3_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_svq3_decoder = {
-    "svq3",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_SVQ3,
-    sizeof(SVQ3Context),
-    svq3_decode_init,
-    NULL,
-    svq3_decode_end,
-    svq3_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
+    .name           = "svq3",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_SVQ3,
+    .priv_data_size = sizeof(SVQ3Context),
+    .init           = svq3_decode_init,
+    .close          = svq3_decode_end,
+    .decode         = svq3_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
     .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
 };
diff --git a/libavcodec/targa.c b/libavcodec/targa.c
index 88b34f3bf4..884bae6cc9 100644
--- a/libavcodec/targa.c
+++ b/libavcodec/targa.c
@@ -257,15 +257,13 @@ static av_cold int targa_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_targa_decoder = {
-    "targa",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TARGA,
-    sizeof(TargaContext),
-    targa_init,
-    NULL,
-    targa_end,
-    decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "targa",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TARGA,
+    .priv_data_size = sizeof(TargaContext),
+    .init           = targa_init,
+    .close          = targa_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Truevision Targa image"),
 };
diff --git a/libavcodec/tiertexseqv.c b/libavcodec/tiertexseqv.c
index f3a044882e..8f299be666 100644
--- a/libavcodec/tiertexseqv.c
+++ b/libavcodec/tiertexseqv.c
@@ -221,14 +221,13 @@ static av_cold int seqvideo_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_tiertexseqvideo_decoder = {
-    "tiertexseqvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TIERTEXSEQVIDEO,
-    sizeof(SeqVideoContext),
-    seqvideo_decode_init,
-    NULL,
-    seqvideo_decode_end,
-    seqvideo_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "tiertexseqvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TIERTEXSEQVIDEO,
+    .priv_data_size = sizeof(SeqVideoContext),
+    .init           = seqvideo_decode_init,
+    .close          = seqvideo_decode_end,
+    .decode         = seqvideo_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Tiertex Limited SEQ video"),
 };
diff --git a/libavcodec/tiff.c b/libavcodec/tiff.c
index f371dc60c3..a42b27ffb1 100644
--- a/libavcodec/tiff.c
+++ b/libavcodec/tiff.c
@@ -621,15 +621,13 @@ static av_cold int tiff_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_tiff_decoder = {
-    "tiff",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TIFF,
-    sizeof(TiffContext),
-    tiff_init,
-    NULL,
-    tiff_end,
-    decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "tiff",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TIFF,
+    .priv_data_size = sizeof(TiffContext),
+    .init           = tiff_init,
+    .close          = tiff_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
 };
diff --git a/libavcodec/tiffenc.c b/libavcodec/tiffenc.c
index 48b3d3f769..d635e17aad 100644
--- a/libavcodec/tiffenc.c
+++ b/libavcodec/tiffenc.c
@@ -442,16 +442,11 @@ fail:
 }
 
 AVCodec ff_tiff_encoder = {
-    "tiff",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TIFF,
-    sizeof(TiffEncoderContext),
-    NULL,
-    encode_frame,
-    NULL,
-    NULL,
-    0,
-    NULL,
+    .name           = "tiff",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TIFF,
+    .priv_data_size = sizeof(TiffEncoderContext),
+    .encode         = encode_frame,
     .pix_fmts =
         (const enum PixelFormat[]) {PIX_FMT_RGB24, PIX_FMT_PAL8, PIX_FMT_GRAY8,
                               PIX_FMT_MONOBLACK, PIX_FMT_MONOWHITE,
diff --git a/libavcodec/truemotion1.c b/libavcodec/truemotion1.c
index 284dbd8e12..9c2a273f1c 100644
--- a/libavcodec/truemotion1.c
+++ b/libavcodec/truemotion1.c
@@ -893,14 +893,13 @@ static av_cold int truemotion1_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_truemotion1_decoder = {
-    "truemotion1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TRUEMOTION1,
-    sizeof(TrueMotion1Context),
-    truemotion1_decode_init,
-    NULL,
-    truemotion1_decode_end,
-    truemotion1_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "truemotion1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TRUEMOTION1,
+    .priv_data_size = sizeof(TrueMotion1Context),
+    .init           = truemotion1_decode_init,
+    .close          = truemotion1_decode_end,
+    .decode         = truemotion1_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Duck TrueMotion 1.0"),
 };
diff --git a/libavcodec/truemotion2.c b/libavcodec/truemotion2.c
index 2b9a0cba72..4967e29d93 100644
--- a/libavcodec/truemotion2.c
+++ b/libavcodec/truemotion2.c
@@ -865,14 +865,13 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_truemotion2_decoder = {
-    "truemotion2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TRUEMOTION2,
-    sizeof(TM2Context),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "truemotion2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TRUEMOTION2,
+    .priv_data_size = sizeof(TM2Context),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Duck TrueMotion 2.0"),
 };
diff --git a/libavcodec/truespeech.c b/libavcodec/truespeech.c
index d903a0119e..3aa3444568 100644
--- a/libavcodec/truespeech.c
+++ b/libavcodec/truespeech.c
@@ -382,13 +382,11 @@ static int truespeech_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_truespeech_decoder = {
-    "truespeech",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_TRUESPEECH,
-    sizeof(TSContext),
-    truespeech_decode_init,
-    NULL,
-    NULL,
-    truespeech_decode_frame,
+    .name           = "truespeech",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_TRUESPEECH,
+    .priv_data_size = sizeof(TSContext),
+    .init           = truespeech_decode_init,
+    .decode         = truespeech_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("DSP Group TrueSpeech"),
 };
diff --git a/libavcodec/tscc.c b/libavcodec/tscc.c
index bc57ec74cb..00638007d2 100644
--- a/libavcodec/tscc.c
+++ b/libavcodec/tscc.c
@@ -200,15 +200,14 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_tscc_decoder = {
-        "camtasia",
-        AVMEDIA_TYPE_VIDEO,
-        CODEC_ID_TSCC,
-        sizeof(CamtasiaContext),
-        decode_init,
-        NULL,
-        decode_end,
-        decode_frame,
-        CODEC_CAP_DR1,
+    .name           = "camtasia",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TSCC,
+    .priv_data_size = sizeof(CamtasiaContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
         .long_name = NULL_IF_CONFIG_SMALL("TechSmith Screen Capture Codec"),
 };
 
diff --git a/libavcodec/tta.c b/libavcodec/tta.c
index 00974d7cbe..1ce1946333 100644
--- a/libavcodec/tta.c
+++ b/libavcodec/tta.c
@@ -454,13 +454,12 @@ static av_cold int tta_decode_close(AVCodecContext *avctx) {
 }
 
 AVCodec ff_tta_decoder = {
-    "tta",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_TTA,
-    sizeof(TTAContext),
-    tta_decode_init,
-    NULL,
-    tta_decode_close,
-    tta_decode_frame,
+    .name           = "tta",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_TTA,
+    .priv_data_size = sizeof(TTAContext),
+    .init           = tta_decode_init,
+    .close          = tta_decode_close,
+    .decode         = tta_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
 };
diff --git a/libavcodec/txd.c b/libavcodec/txd.c
index 0e25458c86..4299636f7b 100644
--- a/libavcodec/txd.c
+++ b/libavcodec/txd.c
@@ -156,15 +156,13 @@ static av_cold int txd_end(AVCodecContext *avctx) {
 }
 
 AVCodec ff_txd_decoder = {
-    "txd",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_TXD,
-    sizeof(TXDContext),
-    txd_init,
-    NULL,
-    txd_end,
-    txd_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "txd",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_TXD,
+    .priv_data_size = sizeof(TXDContext),
+    .init           = txd_init,
+    .close          = txd_end,
+    .decode         = txd_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Renderware TXD (TeXture Dictionary) image"),
 };
diff --git a/libavcodec/ulti.c b/libavcodec/ulti.c
index 9033cee98f..6d41cd9d06 100644
--- a/libavcodec/ulti.c
+++ b/libavcodec/ulti.c
@@ -403,16 +403,14 @@ static int ulti_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_ulti_decoder = {
-    "ultimotion",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ULTI,
-    sizeof(UltimotionDecodeContext),
-    ulti_decode_init,
-    NULL,
-    ulti_decode_end,
-    ulti_decode_frame,
-    CODEC_CAP_DR1,
-    NULL,
+    .name           = "ultimotion",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ULTI,
+    .priv_data_size = sizeof(UltimotionDecodeContext),
+    .init           = ulti_decode_init,
+    .close          = ulti_decode_end,
+    .decode         = ulti_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("IBM UltiMotion"),
 };
 
diff --git a/libavcodec/v210dec.c b/libavcodec/v210dec.c
index 94c5b5bb26..ecd88be22b 100644
--- a/libavcodec/v210dec.c
+++ b/libavcodec/v210dec.c
@@ -121,14 +121,12 @@ static av_cold int decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_v210_decoder = {
-    "v210",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_V210,
-    0,
-    decode_init,
-    NULL,
-    decode_close,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "v210",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_V210,
+    .init           = decode_init,
+    .close          = decode_close,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
 };
diff --git a/libavcodec/v210enc.c b/libavcodec/v210enc.c
index fd47d7a5e7..1991c8ccfe 100644
--- a/libavcodec/v210enc.c
+++ b/libavcodec/v210enc.c
@@ -118,13 +118,12 @@ static av_cold int encode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_v210_encoder = {
-    "v210",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_V210,
-    0,
-    encode_init,
-    encode_frame,
-    encode_close,
+    .name           = "v210",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_V210,
+    .init           = encode_init,
+    .encode         = encode_frame,
+    .close          = encode_close,
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV422P10, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
 };
diff --git a/libavcodec/v210x.c b/libavcodec/v210x.c
index 64954cb6bb..ec74a3384f 100644
--- a/libavcodec/v210x.c
+++ b/libavcodec/v210x.c
@@ -133,14 +133,12 @@ static av_cold int decode_close(AVCodecContext *avctx)
 }
 
 AVCodec ff_v210x_decoder = {
-    "v210x",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_V210X,
-    0,
-    decode_init,
-    NULL,
-    decode_close,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "v210x",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_V210X,
+    .init           = decode_init,
+    .close          = decode_close,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
 };
diff --git a/libavcodec/vb.c b/libavcodec/vb.c
index 3fb59cf377..622ea89790 100644
--- a/libavcodec/vb.c
+++ b/libavcodec/vb.c
@@ -289,14 +289,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_vb_decoder = {
-    "vb",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VB,
-    sizeof(VBDecContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
+    .name           = "vb",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VB,
+    .priv_data_size = sizeof(VBDecContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Beam Software VB"),
 };
 
diff --git a/libavcodec/vc1dec.c b/libavcodec/vc1dec.c
index a6fc9412f4..228a02a255 100644
--- a/libavcodec/vc1dec.c
+++ b/libavcodec/vc1dec.c
@@ -3829,16 +3829,14 @@ static const AVProfile profiles[] = {
 };
 
 AVCodec ff_vc1_decoder = {
-    "vc1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VC1,
-    sizeof(VC1Context),
-    vc1_decode_init,
-    NULL,
-    vc1_decode_end,
-    vc1_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
-    NULL,
+    .name           = "vc1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VC1,
+    .priv_data_size = sizeof(VC1Context),
+    .init           = vc1_decode_init,
+    .close          = vc1_decode_end,
+    .decode         = vc1_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
     .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
     .pix_fmts = ff_hwaccel_pixfmt_list_420,
     .profiles = NULL_IF_CONFIG_SMALL(profiles)
@@ -3846,16 +3844,14 @@ AVCodec ff_vc1_decoder = {
 
 #if CONFIG_WMV3_DECODER
 AVCodec ff_wmv3_decoder = {
-    "wmv3",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_WMV3,
-    sizeof(VC1Context),
-    vc1_decode_init,
-    NULL,
-    vc1_decode_end,
-    vc1_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
-    NULL,
+    .name           = "wmv3",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_WMV3,
+    .priv_data_size = sizeof(VC1Context),
+    .init           = vc1_decode_init,
+    .close          = vc1_decode_end,
+    .decode         = vc1_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
     .pix_fmts = ff_hwaccel_pixfmt_list_420,
     .profiles = NULL_IF_CONFIG_SMALL(profiles)
@@ -3864,16 +3860,14 @@ AVCodec ff_wmv3_decoder = {
 
 #if CONFIG_WMV3_VDPAU_DECODER
 AVCodec ff_wmv3_vdpau_decoder = {
-    "wmv3_vdpau",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_WMV3,
-    sizeof(VC1Context),
-    vc1_decode_init,
-    NULL,
-    vc1_decode_end,
-    vc1_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
-    NULL,
+    .name           = "wmv3_vdpau",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_WMV3,
+    .priv_data_size = sizeof(VC1Context),
+    .init           = vc1_decode_init,
+    .close          = vc1_decode_end,
+    .decode         = vc1_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
     .profiles = NULL_IF_CONFIG_SMALL(profiles)
@@ -3882,16 +3876,14 @@ AVCodec ff_wmv3_vdpau_decoder = {
 
 #if CONFIG_VC1_VDPAU_DECODER
 AVCodec ff_vc1_vdpau_decoder = {
-    "vc1_vdpau",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VC1,
-    sizeof(VC1Context),
-    vc1_decode_init,
-    NULL,
-    vc1_decode_end,
-    vc1_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
-    NULL,
+    .name           = "vc1_vdpau",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VC1,
+    .priv_data_size = sizeof(VC1Context),
+    .init           = vc1_decode_init,
+    .close          = vc1_decode_end,
+    .decode         = vc1_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
     .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
     .profiles = NULL_IF_CONFIG_SMALL(profiles)
diff --git a/libavcodec/vcr1.c b/libavcodec/vcr1.c
index 0d59b7e7ec..38b6d70d00 100644
--- a/libavcodec/vcr1.c
+++ b/libavcodec/vcr1.c
@@ -178,26 +178,25 @@ static av_cold int encode_init(AVCodecContext *avctx){
 #endif
 
 AVCodec ff_vcr1_decoder = {
-    "vcr1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VCR1,
-    sizeof(VCR1Context),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "vcr1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VCR1,
+    .priv_data_size = sizeof(VCR1Context),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("ATI VCR1"),
 };
 
 #if CONFIG_VCR1_ENCODER
 AVCodec ff_vcr1_encoder = {
-    "vcr1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VCR1,
-    sizeof(VCR1Context),
-    encode_init,
-    encode_frame,
+    .name           = "vcr1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VCR1,
+    .priv_data_size = sizeof(VCR1Context),
+    .init           = encode_init,
+    .encode         = encode_frame,
     //encode_end,
     .long_name = NULL_IF_CONFIG_SMALL("ATI VCR1"),
 };
diff --git a/libavcodec/vmdav.c b/libavcodec/vmdav.c
index b9acfe921c..919789168e 100644
--- a/libavcodec/vmdav.c
+++ b/libavcodec/vmdav.c
@@ -547,26 +547,23 @@ static int vmdaudio_decode_frame(AVCodecContext *avctx,
  */
 
 AVCodec ff_vmdvideo_decoder = {
-    "vmdvideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VMDVIDEO,
-    sizeof(VmdVideoContext),
-    vmdvideo_decode_init,
-    NULL,
-    vmdvideo_decode_end,
-    vmdvideo_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "vmdvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VMDVIDEO,
+    .priv_data_size = sizeof(VmdVideoContext),
+    .init           = vmdvideo_decode_init,
+    .close          = vmdvideo_decode_end,
+    .decode         = vmdvideo_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
 };
 
 AVCodec ff_vmdaudio_decoder = {
-    "vmdaudio",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_VMDAUDIO,
-    sizeof(VmdAudioContext),
-    vmdaudio_decode_init,
-    NULL,
-    NULL,
-    vmdaudio_decode_frame,
+    .name           = "vmdaudio",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_VMDAUDIO,
+    .priv_data_size = sizeof(VmdAudioContext),
+    .init           = vmdaudio_decode_init,
+    .decode         = vmdaudio_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
 };
diff --git a/libavcodec/vmnc.c b/libavcodec/vmnc.c
index 6455d86f77..4c9b26c6f8 100644
--- a/libavcodec/vmnc.c
+++ b/libavcodec/vmnc.c
@@ -510,15 +510,14 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_vmnc_decoder = {
-    "vmnc",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VMNC,
-    sizeof(VmncContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "vmnc",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VMNC,
+    .priv_data_size = sizeof(VmncContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("VMware Screen Codec / VMware Video"),
 };
 
diff --git a/libavcodec/vorbisdec.c b/libavcodec/vorbisdec.c
index 2d91ca1317..a29481d1b9 100644
--- a/libavcodec/vorbisdec.c
+++ b/libavcodec/vorbisdec.c
@@ -1669,14 +1669,13 @@ static av_cold int vorbis_decode_close(AVCodecContext *avccontext)
 }
 
 AVCodec ff_vorbis_decoder = {
-    "vorbis",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_VORBIS,
-    sizeof(vorbis_context),
-    vorbis_decode_init,
-    NULL,
-    vorbis_decode_close,
-    vorbis_decode_frame,
+    .name           = "vorbis",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_VORBIS,
+    .priv_data_size = sizeof(vorbis_context),
+    .init           = vorbis_decode_init,
+    .close          = vorbis_decode_close,
+    .decode         = vorbis_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
     .channel_layouts = ff_vorbis_channel_layouts,
     .sample_fmts = (const enum AVSampleFormat[]) {
diff --git a/libavcodec/vorbisenc.c b/libavcodec/vorbisenc.c
index 617e2b7cc4..80d722db4c 100644
--- a/libavcodec/vorbisenc.c
+++ b/libavcodec/vorbisenc.c
@@ -1103,13 +1103,13 @@ static av_cold int vorbis_encode_close(AVCodecContext *avccontext)
 }
 
 AVCodec ff_vorbis_encoder = {
-    "vorbis",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_VORBIS,
-    sizeof(vorbis_enc_context),
-    vorbis_encode_init,
-    vorbis_encode_frame,
-    vorbis_encode_close,
+    .name           = "vorbis",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_VORBIS,
+    .priv_data_size = sizeof(vorbis_enc_context),
+    .init           = vorbis_encode_init,
+    .encode         = vorbis_encode_frame,
+    .close          = vorbis_encode_close,
     .capabilities= CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
diff --git a/libavcodec/vp3.c b/libavcodec/vp3.c
index b9af998bc5..7dcd14718b 100644
--- a/libavcodec/vp3.c
+++ b/libavcodec/vp3.c
@@ -2342,16 +2342,14 @@ static void vp3_decode_flush(AVCodecContext *avctx)
 }
 
 AVCodec ff_theora_decoder = {
-    "theora",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_THEORA,
-    sizeof(Vp3DecodeContext),
-    theora_decode_init,
-    NULL,
-    vp3_decode_end,
-    vp3_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
-    NULL,
+    .name           = "theora",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_THEORA,
+    .priv_data_size = sizeof(Vp3DecodeContext),
+    .init           = theora_decode_init,
+    .close          = vp3_decode_end,
+    .decode         = vp3_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
     .flush = vp3_decode_flush,
     .long_name = NULL_IF_CONFIG_SMALL("Theora"),
     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context)
@@ -2359,16 +2357,14 @@ AVCodec ff_theora_decoder = {
 #endif
 
 AVCodec ff_vp3_decoder = {
-    "vp3",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VP3,
-    sizeof(Vp3DecodeContext),
-    vp3_decode_init,
-    NULL,
-    vp3_decode_end,
-    vp3_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
-    NULL,
+    .name           = "vp3",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VP3,
+    .priv_data_size = sizeof(Vp3DecodeContext),
+    .init           = vp3_decode_init,
+    .close          = vp3_decode_end,
+    .decode         = vp3_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
     .flush = vp3_decode_flush,
     .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"),
     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context)
diff --git a/libavcodec/vp5.c b/libavcodec/vp5.c
index fc17e4386c..04df3e29a5 100644
--- a/libavcodec/vp5.c
+++ b/libavcodec/vp5.c
@@ -269,14 +269,13 @@ static av_cold int vp5_decode_init(AVCodecContext *avctx)
 }
 
 AVCodec ff_vp5_decoder = {
-    "vp5",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VP5,
-    sizeof(VP56Context),
-    vp5_decode_init,
-    NULL,
-    ff_vp56_free,
-    ff_vp56_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "vp5",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VP5,
+    .priv_data_size = sizeof(VP56Context),
+    .init           = vp5_decode_init,
+    .close          = ff_vp56_free,
+    .decode         = ff_vp56_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("On2 VP5"),
 };
diff --git a/libavcodec/vp6.c b/libavcodec/vp6.c
index 9f350a942d..e6132abeb6 100644
--- a/libavcodec/vp6.c
+++ b/libavcodec/vp6.c
@@ -609,42 +609,39 @@ static av_cold int vp6_decode_free(AVCodecContext *avctx)
 }
 
 AVCodec ff_vp6_decoder = {
-    "vp6",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VP6,
-    sizeof(VP56Context),
-    vp6_decode_init,
-    NULL,
-    vp6_decode_free,
-    ff_vp56_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "vp6",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VP6,
+    .priv_data_size = sizeof(VP56Context),
+    .init           = vp6_decode_init,
+    .close          = vp6_decode_free,
+    .decode         = ff_vp56_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("On2 VP6"),
 };
 
 /* flash version, not flipped upside-down */
 AVCodec ff_vp6f_decoder = {
-    "vp6f",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VP6F,
-    sizeof(VP56Context),
-    vp6_decode_init,
-    NULL,
-    vp6_decode_free,
-    ff_vp56_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "vp6f",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VP6F,
+    .priv_data_size = sizeof(VP56Context),
+    .init           = vp6_decode_init,
+    .close          = vp6_decode_free,
+    .decode         = ff_vp56_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version)"),
 };
 
 /* flash version, not flipped upside-down, with alpha channel */
 AVCodec ff_vp6a_decoder = {
-    "vp6a",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VP6A,
-    sizeof(VP56Context),
-    vp6_decode_init,
-    NULL,
-    vp6_decode_free,
-    ff_vp56_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "vp6a",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VP6A,
+    .priv_data_size = sizeof(VP56Context),
+    .init           = vp6_decode_init,
+    .close          = vp6_decode_free,
+    .decode         = ff_vp56_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version, with alpha channel)"),
 };
diff --git a/libavcodec/vp8.c b/libavcodec/vp8.c
index beb4de3185..fb3f7f733a 100644
--- a/libavcodec/vp8.c
+++ b/libavcodec/vp8.c
@@ -1764,15 +1764,14 @@ static int vp8_decode_update_thread_context(AVCodecContext *dst, const AVCodecCo
 }
 
 AVCodec ff_vp8_decoder = {
-    "vp8",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VP8,
-    sizeof(VP8Context),
-    vp8_decode_init,
-    NULL,
-    vp8_decode_free,
-    vp8_decode_frame,
-    CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
+    .name           = "vp8",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VP8,
+    .priv_data_size = sizeof(VP8Context),
+    .init           = vp8_decode_init,
+    .close          = vp8_decode_free,
+    .decode         = vp8_decode_frame,
+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
     .flush = vp8_decode_flush,
     .long_name = NULL_IF_CONFIG_SMALL("On2 VP8"),
     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp8_decode_init_thread_copy),
diff --git a/libavcodec/vqavideo.c b/libavcodec/vqavideo.c
index 91ae687d06..67721097ef 100644
--- a/libavcodec/vqavideo.c
+++ b/libavcodec/vqavideo.c
@@ -601,14 +601,13 @@ static av_cold int vqa_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_vqa_decoder = {
-    "vqavideo",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_WS_VQA,
-    sizeof(VqaContext),
-    vqa_decode_init,
-    NULL,
-    vqa_decode_end,
-    vqa_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "vqavideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_WS_VQA,
+    .priv_data_size = sizeof(VqaContext),
+    .init           = vqa_decode_init,
+    .close          = vqa_decode_end,
+    .decode         = vqa_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Westwood Studios VQA (Vector Quantized Animation) video"),
 };
diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c
index d5102320fd..ba974bd089 100644
--- a/libavcodec/wavpack.c
+++ b/libavcodec/wavpack.c
@@ -1190,14 +1190,13 @@ static int wavpack_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_wavpack_decoder = {
-    "wavpack",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_WAVPACK,
-    sizeof(WavpackContext),
-    wavpack_decode_init,
-    NULL,
-    wavpack_decode_end,
-    wavpack_decode_frame,
+    .name           = "wavpack",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_WAVPACK,
+    .priv_data_size = sizeof(WavpackContext),
+    .init           = wavpack_decode_init,
+    .close          = wavpack_decode_end,
+    .decode         = wavpack_decode_frame,
     .capabilities = CODEC_CAP_SUBFRAMES,
     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
 };
diff --git a/libavcodec/wmaprodec.c b/libavcodec/wmaprodec.c
index e1d942dca2..d4ec0c02af 100644
--- a/libavcodec/wmaprodec.c
+++ b/libavcodec/wmaprodec.c
@@ -1605,14 +1605,13 @@ static void flush(AVCodecContext *avctx)
  *@brief wmapro decoder
  */
 AVCodec ff_wmapro_decoder = {
-    "wmapro",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_WMAPRO,
-    sizeof(WMAProDecodeCtx),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_packet,
+    .name           = "wmapro",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_WMAPRO,
+    .priv_data_size = sizeof(WMAProDecodeCtx),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_packet,
     .capabilities = CODEC_CAP_SUBFRAMES,
     .flush= flush,
     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
diff --git a/libavcodec/wmavoice.c b/libavcodec/wmavoice.c
index 002c529a30..400d96386b 100644
--- a/libavcodec/wmavoice.c
+++ b/libavcodec/wmavoice.c
@@ -2022,15 +2022,14 @@ static av_cold void wmavoice_flush(AVCodecContext *ctx)
 }
 
 AVCodec ff_wmavoice_decoder = {
-    "wmavoice",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_WMAVOICE,
-    sizeof(WMAVoiceContext),
-    wmavoice_decode_init,
-    NULL,
-    wmavoice_decode_end,
-    wmavoice_decode_packet,
-    CODEC_CAP_SUBFRAMES,
+    .name           = "wmavoice",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_WMAVOICE,
+    .priv_data_size = sizeof(WMAVoiceContext),
+    .init           = wmavoice_decode_init,
+    .close          = wmavoice_decode_end,
+    .decode         = wmavoice_decode_packet,
+    .capabilities   = CODEC_CAP_SUBFRAMES,
     .flush     = wmavoice_flush,
     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Voice"),
 };
diff --git a/libavcodec/wmv2dec.c b/libavcodec/wmv2dec.c
index 502f9dc750..519ae61b93 100644
--- a/libavcodec/wmv2dec.c
+++ b/libavcodec/wmv2dec.c
@@ -471,15 +471,14 @@ static av_cold int wmv2_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_wmv2_decoder = {
-    "wmv2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_WMV2,
-    sizeof(Wmv2Context),
-    wmv2_decode_init,
-    NULL,
-    wmv2_decode_end,
-    ff_h263_decode_frame,
-    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
+    .name           = "wmv2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_WMV2,
+    .priv_data_size = sizeof(Wmv2Context),
+    .init           = wmv2_decode_init,
+    .close          = wmv2_decode_end,
+    .decode         = ff_h263_decode_frame,
+    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 8"),
     .pix_fmts= ff_pixfmt_list_420,
 };
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index 4a074e674c..bc9e4fa0ab 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -212,13 +212,13 @@ void ff_wmv2_encode_mb(MpegEncContext * s,
 }
 
 AVCodec ff_wmv2_encoder = {
-    "wmv2",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_WMV2,
-    sizeof(Wmv2Context),
-    wmv2_encode_init,
-    MPV_encode_picture,
-    MPV_encode_end,
+    .name           = "wmv2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_WMV2,
+    .priv_data_size = sizeof(Wmv2Context),
+    .init           = wmv2_encode_init,
+    .encode         = MPV_encode_picture,
+    .close          = MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 8"),
 };
diff --git a/libavcodec/wnv1.c b/libavcodec/wnv1.c
index 197cf7985d..6429a5b748 100644
--- a/libavcodec/wnv1.c
+++ b/libavcodec/wnv1.c
@@ -158,14 +158,13 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_wnv1_decoder = {
-    "wnv1",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_WNV1,
-    sizeof(WNV1Context),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "wnv1",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_WNV1,
+    .priv_data_size = sizeof(WNV1Context),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Winnov WNV1"),
 };
diff --git a/libavcodec/ws-snd1.c b/libavcodec/ws-snd1.c
index d6a60d441f..8e2e8ced99 100644
--- a/libavcodec/ws-snd1.c
+++ b/libavcodec/ws-snd1.c
@@ -147,13 +147,10 @@ static int ws_snd_decode_frame(AVCodecContext *avctx,
 }
 
 AVCodec ff_ws_snd1_decoder = {
-    "ws_snd1",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_WESTWOOD_SND1,
-    0,
-    ws_snd_decode_init,
-    NULL,
-    NULL,
-    ws_snd_decode_frame,
+    .name           = "ws_snd1",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_WESTWOOD_SND1,
+    .init           = ws_snd_decode_init,
+    .decode         = ws_snd_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Westwood Audio (SND1)"),
 };
diff --git a/libavcodec/x86/cabac.h b/libavcodec/x86/cabac.h
index ae3f4b6e9e..545cf7c464 100644
--- a/libavcodec/x86/cabac.h
+++ b/libavcodec/x86/cabac.h
@@ -67,7 +67,7 @@
         "test   "lowword"   , "lowword"                                 \n\t"\
         " jnz   1f                                                      \n\t"\
         "mov "byte"("cabac"), %%"REG_c"                                 \n\t"\
-        "add    $2          , "byte    "("cabac")                       \n\t"\
+        "add"OPSIZE" $2     , "byte    "("cabac")                       \n\t"\
         "movzwl (%%"REG_c")     , "tmp"                                 \n\t"\
         "lea    -1("low")   , %%ecx                                     \n\t"\
         "xor    "low"       , %%ecx                                     \n\t"\
diff --git a/libavcodec/x86/dsputil_mmx.c b/libavcodec/x86/dsputil_mmx.c
index 6d96ab30a2..5276053bb9 100644
--- a/libavcodec/x86/dsputil_mmx.c
+++ b/libavcodec/x86/dsputil_mmx.c
@@ -456,12 +456,12 @@ static void put_pixels16_sse2(uint8_t *block, const uint8_t *pixels, int line_si
          "movdqu (%1,%3), %%xmm1        \n\t"
          "movdqu (%1,%3,2), %%xmm2      \n\t"
          "movdqu (%1,%4), %%xmm3        \n\t"
+         "lea (%1,%3,4), %1             \n\t"
          "movdqa %%xmm0, (%2)           \n\t"
          "movdqa %%xmm1, (%2,%3)        \n\t"
          "movdqa %%xmm2, (%2,%3,2)      \n\t"
          "movdqa %%xmm3, (%2,%4)        \n\t"
          "subl $4, %0                   \n\t"
-         "lea (%1,%3,4), %1             \n\t"
          "lea (%2,%3,4), %2             \n\t"
          "jnz 1b                        \n\t"
          : "+g"(h), "+r" (pixels),  "+r" (block)
@@ -478,6 +478,7 @@ static void avg_pixels16_sse2(uint8_t *block, const uint8_t *pixels, int line_si
          "movdqu (%1,%3), %%xmm1        \n\t"
          "movdqu (%1,%3,2), %%xmm2      \n\t"
          "movdqu (%1,%4), %%xmm3        \n\t"
+         "lea (%1,%3,4), %1             \n\t"
          "pavgb  (%2), %%xmm0           \n\t"
          "pavgb  (%2,%3), %%xmm1        \n\t"
          "pavgb  (%2,%3,2), %%xmm2      \n\t"
@@ -487,7 +488,6 @@ static void avg_pixels16_sse2(uint8_t *block, const uint8_t *pixels, int line_si
          "movdqa %%xmm2, (%2,%3,2)      \n\t"
          "movdqa %%xmm3, (%2,%4)        \n\t"
          "subl $4, %0                   \n\t"
-         "lea (%1,%3,4), %1             \n\t"
          "lea (%2,%3,4), %2             \n\t"
          "jnz 1b                        \n\t"
          : "+g"(h), "+r" (pixels),  "+r" (block)
diff --git a/libavcodec/x86/h264_chromamc.asm b/libavcodec/x86/h264_chromamc.asm
index 5dae1cca85..e9091f7059 100644
--- a/libavcodec/x86/h264_chromamc.asm
+++ b/libavcodec/x86/h264_chromamc.asm
@@ -72,17 +72,17 @@ SECTION .text
 .next4rows
     movq         mm0, [r1   ]
     movq         mm1, [r1+r2]
+    add           r1, r4
     CHROMAMC_AVG mm0, [r0   ]
     CHROMAMC_AVG mm1, [r0+r2]
     movq     [r0   ], mm0
     movq     [r0+r2], mm1
     add           r0, r4
-    add           r1, r4
     movq         mm0, [r1   ]
     movq         mm1, [r1+r2]
+    add           r1, r4
     CHROMAMC_AVG mm0, [r0   ]
     CHROMAMC_AVG mm1, [r0+r2]
-    add           r1, r4
     movq     [r0   ], mm0
     movq     [r0+r2], mm1
     add           r0, r4
@@ -472,8 +472,8 @@ cglobal %1_%2_chroma_mc8_%3, 6, 7, 8
     mov          r6d, r4d
     shl          r4d, 8
     sub           r4, r6
-    add           r4, 8           ; x*288+8 = x<<8 | (8-x)
     mov           r6, 8
+    add           r4, 8           ; x*288+8 = x<<8 | (8-x)
     sub          r6d, r5d
     imul          r6, r4          ; (8-y)*(x*255+8) = (8-y)*x<<8 | (8-y)*(8-x)
     imul         r4d, r5d         ;    y *(x*255+8) =    y *x<<8 |    y *(8-x)
@@ -481,24 +481,23 @@ cglobal %1_%2_chroma_mc8_%3, 6, 7, 8
     movd          m7, r6d
     movd          m6, r4d
     movdqa        m5, [rnd_2d_%2]
+    movq          m0, [r1  ]
+    movq          m1, [r1+1]
     pshuflw       m7, m7, 0
     pshuflw       m6, m6, 0
+    punpcklbw     m0, m1
     movlhps       m7, m7
     movlhps       m6, m6
 
-    movq          m0, [r1     ]
-    movq          m1, [r1   +1]
-    punpcklbw     m0, m1
-    add           r1, r2
 .next2rows
-    movq          m1, [r1     ]
-    movq          m2, [r1   +1]
-    movq          m3, [r1+r2  ]
-    movq          m4, [r1+r2+1]
+    movq          m1, [r1+r2*1   ]
+    movq          m2, [r1+r2*1+1]
+    movq          m3, [r1+r2*2  ]
+    movq          m4, [r1+r2*2+1]
     lea           r1, [r1+r2*2]
     punpcklbw     m1, m2
-    punpcklbw     m3, m4
     movdqa        m2, m1
+    punpcklbw     m3, m4
     movdqa        m4, m3
     pmaddubsw     m0, m7
     pmaddubsw     m1, m6
@@ -508,8 +507,8 @@ cglobal %1_%2_chroma_mc8_%3, 6, 7, 8
     paddw         m2, m5
     paddw         m1, m0
     paddw         m3, m2
-    movdqa        m0, m4
     psrlw         m1, 6
+    movdqa        m0, m4
     psrlw         m3, 6
 %ifidn %1, avg
     movq          m2, [r0   ]
@@ -576,6 +575,7 @@ cglobal %1_%2_chroma_mc8_%3, 6, 7, 8
     movq          m1, [r1+r2  ]
     movdqa        m2, m1
     movq          m3, [r1+r2*2]
+    lea           r1, [r1+r2*2]
     punpcklbw     m0, m1
     punpcklbw     m2, m3
     pmaddubsw     m0, m7
@@ -594,7 +594,6 @@ cglobal %1_%2_chroma_mc8_%3, 6, 7, 8
     movhps   [r0+r2], m0
     sub          r3d, 2
     lea           r0, [r0+r2*2]
-    lea           r1, [r1+r2*2]
     jg .next2yrows
     REP_RET
 %endmacro
@@ -607,8 +606,8 @@ cglobal %1_%2_chroma_mc4_%3, 6, 7, 0
     mov           r6, r4
     shl          r4d, 8
     sub          r4d, r6d
-    add          r4d, 8           ; x*288+8
     mov           r6, 8
+    add          r4d, 8           ; x*288+8
     sub          r6d, r5d
     imul         r6d, r4d         ; (8-y)*(x*255+8) = (8-y)*x<<8 | (8-y)*(8-x)
     imul         r4d, r5d         ;    y *(x*255+8) =    y *x<<8 |    y *(8-x)
@@ -616,17 +615,16 @@ cglobal %1_%2_chroma_mc4_%3, 6, 7, 0
     movd          m7, r6d
     movd          m6, r4d
     movq          m5, [pw_32]
+    movd          m0, [r1  ]
     pshufw        m7, m7, 0
+    punpcklbw     m0, [r1+1]
     pshufw        m6, m6, 0
 
-    movd          m0, [r1     ]
-    punpcklbw     m0, [r1   +1]
-    add           r1, r2
 .next2rows
-    movd          m1, [r1     ]
-    movd          m3, [r1+r2  ]
-    punpcklbw     m1, [r1   +1]
-    punpcklbw     m3, [r1+r2+1]
+    movd          m1, [r1+r2*1  ]
+    movd          m3, [r1+r2*2  ]
+    punpcklbw     m1, [r1+r2*1+1]
+    punpcklbw     m3, [r1+r2*2+1]
     lea           r1, [r1+r2*2]
     movq          m2, m1
     movq          m4, m3
@@ -638,8 +636,8 @@ cglobal %1_%2_chroma_mc4_%3, 6, 7, 0
     paddw         m2, m5
     paddw         m1, m0
     paddw         m3, m2
-    movq          m0, m4
     psrlw         m1, 6
+    movq          m0, m4
     psrlw         m3, 6
     packuswb      m1, m1
     packuswb      m3, m3
diff --git a/libavcodec/x86/h264_deblock.asm b/libavcodec/x86/h264_deblock.asm
index 6c2ef18bc2..ca90f3f4c2 100644
--- a/libavcodec/x86/h264_deblock.asm
+++ b/libavcodec/x86/h264_deblock.asm
@@ -240,17 +240,17 @@ cextern pb_A1
 ; out: m1=p0' m2=q0'
 ; clobbers: m0,3-6
 %macro DEBLOCK_P0_Q0 0
-    pxor    m5, m1, m2   ; p0^q0
-    pand    m5, [pb_1]   ; (p0^q0)&1
     pcmpeqb m4, m4
+    pxor    m5, m1, m2   ; p0^q0
     pxor    m3, m4
+    pand    m5, [pb_1]   ; (p0^q0)&1
     pavgb   m3, m0       ; (p1 - q1 + 256)>>1
-    pavgb   m3, [pb_3]   ; (((p1 - q1 + 256)>>1)+4)>>1 = 64+2+(p1-q1)>>2
     pxor    m4, m1
+    pavgb   m3, [pb_3]   ; (((p1 - q1 + 256)>>1)+4)>>1 = 64+2+(p1-q1)>>2
     pavgb   m4, m2       ; (q0 - p0 + 256)>>1
     pavgb   m3, m5
-    paddusb m3, m4       ; d+128+33
     mova    m6, [pb_A1]
+    paddusb m3, m4       ; d+128+33
     psubusb m6, m3
     psubusb m3, [pb_A1]
     pminub  m6, m7
@@ -413,16 +413,16 @@ cglobal deblock_%2_luma_8_%1, 5,5
     LOAD_MASK r2, r3
 
     mov     r3, r4mp
+    pcmpeqb m3, m3
     movd    m4, [r3] ; tc0
     punpcklbw m4, m4
     punpcklbw m4, m4 ; tc = 4x tc0[3], 4x tc0[2], 4x tc0[1], 4x tc0[0]
     mova   [esp+%3], m4 ; tc
-    pcmpeqb m3, m3
     pcmpgtb m4, m3
+    mova    m3, [r4] ; p2
     pand    m4, m7
     mova   [esp], m4 ; mask
 
-    mova    m3, [r4] ; p2
     DIFF_GT2 m1, m3, m5, m6, m7 ; |p2-p0| > beta-1
     pand    m6, m4
     pand    m4, [esp+%3] ; tc
@@ -432,11 +432,10 @@ cglobal deblock_%2_luma_8_%1, 5,5
 
     mova    m4, [r0+2*r1] ; q2
     DIFF_GT2 m2, m4, m5, m6, m3 ; |q2-q0| > beta-1
-    mova    m5, [esp] ; mask
-    pand    m6, m5
+    pand    m6, [esp] ; mask
     mova    m5, [esp+%3] ; tc
-    pand    m5, m6
     psubb   m7, m6
+    pand    m5, m6
     mova    m3, [r0+r1]
     LUMA_Q1 m3, m4, [r0+2*r1], [r0+r1], m5, m6
 
@@ -484,10 +483,10 @@ cglobal deblock_h_luma_8_%1, 0,5
     ; transpose 16x4 -> original space  (only the middle 4 rows were changed by the filter)
     mov    r0, r0mp
     sub    r0, 2
-    lea    r1, [r0+r4]
 
     movq   m0, [pix_tmp+0x10]
     movq   m1, [pix_tmp+0x20]
+    lea    r1, [r0+r4]
     movq   m2, [pix_tmp+0x30]
     movq   m3, [pix_tmp+0x40]
     TRANSPOSE8x4B_STORE  PASS8ROWS(r0, r1, r3, r4)
diff --git a/libavcodec/x86/h264_i386.h b/libavcodec/x86/h264_i386.h
index 38908a42e2..8ea430a82a 100644
--- a/libavcodec/x86/h264_i386.h
+++ b/libavcodec/x86/h264_i386.h
@@ -67,7 +67,7 @@ static int decode_significance_x86(CABACContext *c, int max_coeff,
         "test $1, %4                            \n\t"
         " jnz 4f                                \n\t"
 
-        "add  $4, %2                            \n\t"
+        "add"OPSIZE"  $4, %2                    \n\t"
 
         "3:                                     \n\t"
         "add  $1, %1                            \n\t"
@@ -125,7 +125,7 @@ static int decode_significance_8x8_x86(CABACContext *c,
         "test $1, %4                            \n\t"
         " jnz 4f                                \n\t"
 
-        "add  $4, %2                            \n\t"
+        "add"OPSIZE"  $4, %2                    \n\t"
 
         "3:                                     \n\t"
         "addl $1, %k6                           \n\t"
diff --git a/libavcodec/x86/h264_idct.asm b/libavcodec/x86/h264_idct.asm
index 04dabc3a2d..3b3dabe601 100644
--- a/libavcodec/x86/h264_idct.asm
+++ b/libavcodec/x86/h264_idct.asm
@@ -82,10 +82,10 @@ cglobal h264_idct_add_8_mmx, 3, 3, 0
     RET
 
 %macro IDCT8_1D 2
-    mova         m4, m5
     mova         m0, m1
-    psraw        m4, 1
     psraw        m1, 1
+    mova         m4, m5
+    psraw        m4, 1
     paddw        m4, m5
     paddw        m1, m0
     paddw        m4, m7
@@ -95,16 +95,16 @@ cglobal h264_idct_add_8_mmx, 3, 3, 0
 
     psubw        m0, m3
     psubw        m5, m3
+    psraw        m3, 1
     paddw        m0, m7
     psubw        m5, m7
-    psraw        m3, 1
     psraw        m7, 1
     psubw        m0, m3
     psubw        m5, m7
 
-    mova         m3, m4
     mova         m7, m1
     psraw        m1, 2
+    mova         m3, m4
     psraw        m3, 2
     paddw        m3, m0
     psraw        m0, 2
@@ -113,12 +113,12 @@ cglobal h264_idct_add_8_mmx, 3, 3, 0
     psubw        m0, m4
     psubw        m7, m5
 
-    mova         m4, m2
     mova         m5, m6
-    psraw        m4, 1
     psraw        m6, 1
-    psubw        m4, m5
+    mova         m4, m2
+    psraw        m4, 1
     paddw        m6, m2
+    psubw        m4, m5
 
     mova         m2, %1
     mova         m5, %2
@@ -337,7 +337,7 @@ cglobal h264_idct8_add4_8_mmx, 5, 7, 0
     test         r6, r6
     jz .skipblock
     mov         r6d, dword [r1+r5*4]
-    lea          r6, [r0+r6]
+    add          r6, r0
     add   word [r2], 32
     IDCT8_ADD_MMX_START r2  , rsp
     IDCT8_ADD_MMX_START r2+8, rsp+64
@@ -391,7 +391,7 @@ cglobal h264_idct_add16_8_mmx2, 5, 7, 0
     REP_RET
 .no_dc
     mov         r6d, dword [r1+r5*4]
-    lea          r6, [r0+r6]
+    add          r6, r0
     IDCT4_ADD    r6, r2, r3
 .skipblock
     inc          r5
@@ -414,7 +414,7 @@ cglobal h264_idct_add16intra_8_mmx, 5, 7, 0
     test         r6, r6
     jz .skipblock
     mov         r6d, dword [r1+r5*4]
-    lea          r6, [r0+r6]
+    add          r6, r0
     IDCT4_ADD    r6, r2, r3
 .skipblock
     inc          r5
@@ -456,7 +456,7 @@ cglobal h264_idct_add16intra_8_mmx2, 5, 7, 0
 %define dst_regd r1d
 %endif
     mov    dst_regd, dword [r1+r5*4]
-    lea     dst_reg, [r0+dst_reg]
+    add     dst_reg, r0
     DC_ADD_MMX2_OP movh, dst_reg, r3, r6
 %ifndef ARCH_X86_64
     mov          r1, r1m
@@ -513,7 +513,7 @@ cglobal h264_idct8_add4_8_mmx2, 5, 7, 0
     RET
 .no_dc
     mov         r6d, dword [r1+r5*4]
-    lea          r6, [r0+r6]
+    add          r6, r0
     add   word [r2], 32
     IDCT8_ADD_MMX_START r2  , rsp
     IDCT8_ADD_MMX_START r2+8, rsp+64
@@ -558,7 +558,7 @@ INIT_MMX
 %define dst_regd r1d
 %endif
     mov    dst_regd, dword [r1+r5*4]
-    lea     dst_reg, [r0+dst_reg]
+    add     dst_reg, r0
     DC_ADD_MMX2_OP mova, dst_reg, r3, r6
     lea     dst_reg, [dst_reg+r3*4]
     DC_ADD_MMX2_OP mova, dst_reg, r3, r6
@@ -573,7 +573,7 @@ INIT_MMX
 .no_dc
 INIT_XMM
     mov    dst_regd, dword [r1+r5*4]
-    lea     dst_reg, [r0+dst_reg]
+    add     dst_reg, r0
     IDCT8_ADD_SSE dst_reg, r2, r3, r6
 %ifndef ARCH_X86_64
     mov          r1, r1m
diff --git a/libavcodec/x86/x86util.asm b/libavcodec/x86/x86util.asm
index 09c2d54f87..1cede4d336 100644
--- a/libavcodec/x86/x86util.asm
+++ b/libavcodec/x86/x86util.asm
@@ -497,10 +497,10 @@
 %macro STORE_DIFFx2 8 ; add1, add2, reg1, reg2, zero, shift, source, stride
     movh       %3, [%7]
     movh       %4, [%7+%8]
-    punpcklbw  %3, %5
-    punpcklbw  %4, %5
     psraw      %1, %6
     psraw      %2, %6
+    punpcklbw  %3, %5
+    punpcklbw  %4, %5
     paddw      %3, %1
     paddw      %4, %2
     packuswb   %3, %5
diff --git a/libavcodec/xan.c b/libavcodec/xan.c
index f5d1812aec..598d1e1423 100644
--- a/libavcodec/xan.c
+++ b/libavcodec/xan.c
@@ -553,15 +553,14 @@ static av_cold int xan_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_xan_wc3_decoder = {
-    "xan_wc3",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_XAN_WC3,
-    sizeof(XanContext),
-    xan_decode_init,
-    NULL,
-    xan_decode_end,
-    xan_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "xan_wc3",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_XAN_WC3,
+    .priv_data_size = sizeof(XanContext),
+    .init           = xan_decode_init,
+    .close          = xan_decode_end,
+    .decode         = xan_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Wing Commander III / Xan"),
 };
 
diff --git a/libavcodec/xl.c b/libavcodec/xl.c
index 7f3b0775c0..c29e8b3190 100644
--- a/libavcodec/xl.c
+++ b/libavcodec/xl.c
@@ -140,14 +140,13 @@ static av_cold int decode_end(AVCodecContext *avctx){
 }
 
 AVCodec ff_xl_decoder = {
-    "xl",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_VIXL,
-    sizeof(VideoXLContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "xl",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_VIXL,
+    .priv_data_size = sizeof(VideoXLContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Miro VideoXL"),
 };
diff --git a/libavcodec/xsubdec.c b/libavcodec/xsubdec.c
index eaf2953172..448c3dd823 100644
--- a/libavcodec/xsubdec.c
+++ b/libavcodec/xsubdec.c
@@ -136,13 +136,10 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 }
 
 AVCodec ff_xsub_decoder = {
-    "xsub",
-    AVMEDIA_TYPE_SUBTITLE,
-    CODEC_ID_XSUB,
-    0,
-    decode_init,
-    NULL,
-    NULL,
-    decode_frame,
+    .name           = "xsub",
+    .type           = AVMEDIA_TYPE_SUBTITLE,
+    .id             = CODEC_ID_XSUB,
+    .init           = decode_init,
+    .decode         = decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("XSUB"),
 };
diff --git a/libavcodec/xsubenc.c b/libavcodec/xsubenc.c
index 0e950d1856..9a8f7ef1e1 100644
--- a/libavcodec/xsubenc.c
+++ b/libavcodec/xsubenc.c
@@ -211,12 +211,10 @@ static av_cold int xsub_encoder_init(AVCodecContext *avctx)
 }
 
 AVCodec ff_xsub_encoder = {
-    "xsub",
-    AVMEDIA_TYPE_SUBTITLE,
-    CODEC_ID_XSUB,
-    0,
-    xsub_encoder_init,
-    xsub_encode,
-    NULL,
+    .name           = "xsub",
+    .type           = AVMEDIA_TYPE_SUBTITLE,
+    .id             = CODEC_ID_XSUB,
+    .init           = xsub_encoder_init,
+    .encode         = xsub_encode,
     .long_name = NULL_IF_CONFIG_SMALL("DivX subtitles (XSUB)"),
 };
diff --git a/libavcodec/xxan.c b/libavcodec/xxan.c
index 10ec53f467..e96e1ddbfe 100644
--- a/libavcodec/xxan.c
+++ b/libavcodec/xxan.c
@@ -415,15 +415,14 @@ static av_cold int xan_decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_xan_wc4_decoder = {
-    "xan_wc4",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_XAN_WC4,
-    sizeof(XanContext),
-    xan_decode_init,
-    NULL,
-    xan_decode_end,
-    xan_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "xan_wc4",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_XAN_WC4,
+    .priv_data_size = sizeof(XanContext),
+    .init           = xan_decode_init,
+    .close          = xan_decode_end,
+    .decode         = xan_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Wing Commander IV / Xxan"),
 };
 
diff --git a/libavcodec/yop.c b/libavcodec/yop.c
index dbd0217ce5..87a91f28d7 100644
--- a/libavcodec/yop.c
+++ b/libavcodec/yop.c
@@ -249,13 +249,12 @@ static int yop_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 }
 
 AVCodec ff_yop_decoder = {
-    "yop",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_YOP,
-    sizeof(YopDecContext),
-    yop_decode_init,
-    NULL,
-    yop_decode_close,
-    yop_decode_frame,
+    .name           = "yop",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_YOP,
+    .priv_data_size = sizeof(YopDecContext),
+    .init           = yop_decode_init,
+    .close          = yop_decode_close,
+    .decode         = yop_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Psygnosis YOP Video"),
 };
diff --git a/libavcodec/zmbv.c b/libavcodec/zmbv.c
index 4bd159cc44..054c84231f 100644
--- a/libavcodec/zmbv.c
+++ b/libavcodec/zmbv.c
@@ -652,15 +652,14 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_zmbv_decoder = {
-    "zmbv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ZMBV,
-    sizeof(ZmbvContext),
-    decode_init,
-    NULL,
-    decode_end,
-    decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "zmbv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ZMBV,
+    .priv_data_size = sizeof(ZmbvContext),
+    .init           = decode_init,
+    .close          = decode_end,
+    .decode         = decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"),
 };
 
diff --git a/libavcodec/zmbvenc.c b/libavcodec/zmbvenc.c
index 4c98987fea..ce65ce4dc0 100644
--- a/libavcodec/zmbvenc.c
+++ b/libavcodec/zmbvenc.c
@@ -324,13 +324,13 @@ static av_cold int encode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_zmbv_encoder = {
-    "zmbv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_ZMBV,
-    sizeof(ZmbvEncContext),
-    encode_init,
-    encode_frame,
-    encode_end,
+    .name           = "zmbv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_ZMBV,
+    .priv_data_size = sizeof(ZmbvEncContext),
+    .init           = encode_init,
+    .encode         = encode_frame,
+    .close          = encode_end,
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_PAL8, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"),
 };
diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c
index a404031d00..630a42ab00 100644
--- a/libavformat/mpegts.c
+++ b/libavformat/mpegts.c
@@ -1491,10 +1491,6 @@ static int mpegts_read_header(AVFormatContext *s,
     if (ap) {
         if (ap->mpeg2ts_compute_pcr)
             ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr;
-        if(ap->mpeg2ts_raw){
-            av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n");
-            return -1;
-        }
     }
 #endif
 
diff --git a/libavformat/mxfdec.c b/libavformat/mxfdec.c
index 4fa908bba7..c27fbfcd62 100644
--- a/libavformat/mxfdec.c
+++ b/libavformat/mxfdec.c
@@ -600,7 +600,7 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int
     default:
         /* Private uid used by SONY C0023S01.mxf */
         if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
-            descriptor->extradata = av_malloc(size);
+            descriptor->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
             if (!descriptor->extradata)
                 return -1;
             descriptor->extradata_size = size;
diff --git a/libavformat/utils.c b/libavformat/utils.c
index 74891049ae..81577c9158 100644
--- a/libavformat/utils.c
+++ b/libavformat/utils.c
@@ -522,9 +522,9 @@ int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
         return AVERROR(EINVAL);
     }
 
-    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
+    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
-        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
+        int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
         int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
 
         if (probe_size < offset) {