diff --git a/libavcodec/012v.c b/libavcodec/012v.c
index b5a4066656..f8aea0d04f 100644
--- a/libavcodec/012v.c
+++ b/libavcodec/012v.c
@@ -144,7 +144,7 @@ static int zero12v_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_zero12v_decoder = {
+const AVCodec ff_zero12v_decoder = {
     .name           = "012v",
     .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/4xm.c b/libavcodec/4xm.c
index cbd8637763..e628edde43 100644
--- a/libavcodec/4xm.c
+++ b/libavcodec/4xm.c
@@ -1025,7 +1025,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_fourxm_decoder = {
+const AVCodec ff_fourxm_decoder = {
     .name           = "4xm",
     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/8bps.c b/libavcodec/8bps.c
index dda8b8b1c9..6865b9b12e 100644
--- a/libavcodec/8bps.c
+++ b/libavcodec/8bps.c
@@ -173,7 +173,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_eightbps_decoder = {
+const AVCodec ff_eightbps_decoder = {
     .name           = "8bps",
     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime 8BPS video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/8svx.c b/libavcodec/8svx.c
index 092dbaae04..54ad806ec9 100644
--- a/libavcodec/8svx.c
+++ b/libavcodec/8svx.c
@@ -184,7 +184,7 @@ static av_cold int eightsvx_decode_close(AVCodecContext *avctx)
 }
 
 #if CONFIG_EIGHTSVX_FIB_DECODER
-AVCodec ff_eightsvx_fib_decoder = {
+const AVCodec ff_eightsvx_fib_decoder = {
   .name           = "8svx_fib",
   .long_name      = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),
   .type           = AVMEDIA_TYPE_AUDIO,
@@ -199,7 +199,7 @@ AVCodec ff_eightsvx_fib_decoder = {
 };
 #endif
 #if CONFIG_EIGHTSVX_EXP_DECODER
-AVCodec ff_eightsvx_exp_decoder = {
+const AVCodec ff_eightsvx_exp_decoder = {
   .name           = "8svx_exp",
   .long_name      = NULL_IF_CONFIG_SMALL("8SVX exponential"),
   .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/a64multienc.c b/libavcodec/a64multienc.c
index 91c89c87eb..9dc859b271 100644
--- a/libavcodec/a64multienc.c
+++ b/libavcodec/a64multienc.c
@@ -399,7 +399,7 @@ static int a64multi_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 }
 
 #if CONFIG_A64MULTI_ENCODER
-AVCodec ff_a64multi_encoder = {
+const AVCodec ff_a64multi_encoder = {
     .name           = "a64multi",
     .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -414,7 +414,7 @@ AVCodec ff_a64multi_encoder = {
 };
 #endif
 #if CONFIG_A64MULTI5_ENCODER
-AVCodec ff_a64multi5_encoder = {
+const AVCodec ff_a64multi5_encoder = {
     .name           = "a64multi5",
     .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64, extended with 5th color (colram)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/aacdec.c b/libavcodec/aacdec.c
index 0174bf8d5b..3ce5330c06 100644
--- a/libavcodec/aacdec.c
+++ b/libavcodec/aacdec.c
@@ -553,7 +553,7 @@ static av_cold int latm_decode_init(AVCodecContext *avctx)
     return ret;
 }
 
-AVCodec ff_aac_decoder = {
+const AVCodec ff_aac_decoder = {
     .name            = "aac",
     .long_name       = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
     .type            = AVMEDIA_TYPE_AUDIO,
@@ -578,7 +578,7 @@ AVCodec ff_aac_decoder = {
     in MPEG transport streams which only contain one program.
     To do a more complex LATM demuxing a separate LATM demuxer should be used.
 */
-AVCodec ff_aac_latm_decoder = {
+const AVCodec ff_aac_latm_decoder = {
     .name            = "aac_latm",
     .long_name       = NULL_IF_CONFIG_SMALL("AAC LATM (Advanced Audio Coding LATM syntax)"),
     .type            = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/aacdec_fixed.c b/libavcodec/aacdec_fixed.c
index c5d923a8b4..00257a5478 100644
--- a/libavcodec/aacdec_fixed.c
+++ b/libavcodec/aacdec_fixed.c
@@ -451,7 +451,7 @@ static void apply_independent_coupling_fixed(AACContext *ac,
 
 #include "aacdec_template.c"
 
-AVCodec ff_aac_fixed_decoder = {
+const AVCodec ff_aac_fixed_decoder = {
     .name            = "aac_fixed",
     .long_name       = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
     .type            = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/aacenc.c b/libavcodec/aacenc.c
index 6dc68eb9b0..219bf02163 100644
--- a/libavcodec/aacenc.c
+++ b/libavcodec/aacenc.c
@@ -1130,7 +1130,7 @@ static const AVCodecDefault aac_encode_defaults[] = {
     { NULL }
 };
 
-AVCodec ff_aac_encoder = {
+const AVCodec ff_aac_encoder = {
     .name           = "aac",
     .long_name      = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/aasc.c b/libavcodec/aasc.c
index 26570f49e5..2177aa8f56 100644
--- a/libavcodec/aasc.c
+++ b/libavcodec/aasc.c
@@ -149,7 +149,7 @@ static av_cold int aasc_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_aasc_decoder = {
+const AVCodec ff_aasc_decoder = {
     .name           = "aasc",
     .long_name      = NULL_IF_CONFIG_SMALL("Autodesk RLE"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ac3dec_fixed.c b/libavcodec/ac3dec_fixed.c
index daab433295..f6c2810ce5 100644
--- a/libavcodec/ac3dec_fixed.c
+++ b/libavcodec/ac3dec_fixed.c
@@ -168,7 +168,7 @@ static const AVClass ac3_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_ac3_fixed_decoder = {
+const AVCodec ff_ac3_fixed_decoder = {
     .name           = "ac3_fixed",
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_AC3,
diff --git a/libavcodec/ac3dec_float.c b/libavcodec/ac3dec_float.c
index b18317f8b3..3aa6482b1a 100644
--- a/libavcodec/ac3dec_float.c
+++ b/libavcodec/ac3dec_float.c
@@ -53,7 +53,7 @@ static const AVClass ac3_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_ac3_decoder = {
+const AVCodec ff_ac3_decoder = {
     .name           = "ac3",
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_AC3,
@@ -78,7 +78,7 @@ static const AVClass eac3_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_eac3_decoder = {
+const AVCodec ff_eac3_decoder = {
     .name           = "eac3",
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_EAC3,
diff --git a/libavcodec/ac3enc_fixed.c b/libavcodec/ac3enc_fixed.c
index 8b1a062c66..fe8607988b 100644
--- a/libavcodec/ac3enc_fixed.c
+++ b/libavcodec/ac3enc_fixed.c
@@ -127,7 +127,7 @@ static av_cold int ac3_fixed_encode_init(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_ac3_fixed_encoder = {
+const AVCodec ff_ac3_fixed_encoder = {
     .name            = "ac3_fixed",
     .long_name       = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
     .type            = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/ac3enc_float.c b/libavcodec/ac3enc_float.c
index 223874907f..e5c2cbd42c 100644
--- a/libavcodec/ac3enc_float.c
+++ b/libavcodec/ac3enc_float.c
@@ -131,7 +131,7 @@ av_cold int ff_ac3_float_encode_init(AVCodecContext *avctx)
     return ff_ac3_encode_init(avctx);
 }
 
-AVCodec ff_ac3_encoder = {
+const AVCodec ff_ac3_encoder = {
     .name            = "ac3",
     .long_name       = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
     .type            = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/adpcm.c b/libavcodec/adpcm.c
index be14607eac..b58a5848cf 100644
--- a/libavcodec/adpcm.c
+++ b/libavcodec/adpcm.c
@@ -2139,7 +2139,7 @@ static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
                                                         AV_SAMPLE_FMT_NONE };
 
 #define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
-AVCodec ff_ ## name_ ## _decoder = {                        \
+const AVCodec ff_ ## name_ ## _decoder = {                  \
     .name           = #name_,                               \
     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
     .type           = AVMEDIA_TYPE_AUDIO,                   \
diff --git a/libavcodec/adpcmenc.c b/libavcodec/adpcmenc.c
index 9dc77d519a..a8ba41d9c0 100644
--- a/libavcodec/adpcmenc.c
+++ b/libavcodec/adpcmenc.c
@@ -968,7 +968,7 @@ static const AVClass name_ ## _encoder_class = {                           \
     .version    = LIBAVUTIL_VERSION_INT,                                   \
 };                                                                         \
                                                                            \
-AVCodec ff_ ## name_ ## _encoder = {                                       \
+const AVCodec ff_ ## name_ ## _encoder = {                                 \
     .name           = #name_,                                              \
     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),                    \
     .type           = AVMEDIA_TYPE_AUDIO,                                  \
diff --git a/libavcodec/adxdec.c b/libavcodec/adxdec.c
index eb05145da9..bff15d826c 100644
--- a/libavcodec/adxdec.c
+++ b/libavcodec/adxdec.c
@@ -190,7 +190,7 @@ static void adx_decode_flush(AVCodecContext *avctx)
     c->eof = 0;
 }
 
-AVCodec ff_adpcm_adx_decoder = {
+const AVCodec ff_adpcm_adx_decoder = {
     .name           = "adpcm_adx",
     .long_name      = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/adxenc.c b/libavcodec/adxenc.c
index 93b902b0e1..f507840a1a 100644
--- a/libavcodec/adxenc.c
+++ b/libavcodec/adxenc.c
@@ -187,7 +187,7 @@ static int adx_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_adpcm_adx_encoder = {
+const AVCodec ff_adpcm_adx_encoder = {
     .name           = "adpcm_adx",
     .long_name      = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/agm.c b/libavcodec/agm.c
index f39383140f..7579d9765d 100644
--- a/libavcodec/agm.c
+++ b/libavcodec/agm.c
@@ -1285,7 +1285,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_agm_decoder = {
+const AVCodec ff_agm_decoder = {
     .name             = "agm",
     .long_name        = NULL_IF_CONFIG_SMALL("Amuse Graphics Movie"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/aic.c b/libavcodec/aic.c
index cf5b0782be..c95bdae1ed 100644
--- a/libavcodec/aic.c
+++ b/libavcodec/aic.c
@@ -496,7 +496,7 @@ static av_cold int aic_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_aic_decoder = {
+const AVCodec ff_aic_decoder = {
     .name           = "aic",
     .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/alac.c b/libavcodec/alac.c
index 7edbb06a3e..67c02ab6af 100644
--- a/libavcodec/alac.c
+++ b/libavcodec/alac.c
@@ -616,7 +616,7 @@ static const AVClass alac_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_alac_decoder = {
+const AVCodec ff_alac_decoder = {
     .name           = "alac",
     .long_name      = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/alacenc.c b/libavcodec/alacenc.c
index 7c7a35c002..d6b2e1c991 100644
--- a/libavcodec/alacenc.c
+++ b/libavcodec/alacenc.c
@@ -631,7 +631,7 @@ static const AVClass alacenc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_alac_encoder = {
+const AVCodec ff_alac_encoder = {
     .name           = "alac",
     .long_name      = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/aliaspixdec.c b/libavcodec/aliaspixdec.c
index def7e17c0f..e08891ec1b 100644
--- a/libavcodec/aliaspixdec.c
+++ b/libavcodec/aliaspixdec.c
@@ -121,7 +121,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 }
 
-AVCodec ff_alias_pix_decoder = {
+const AVCodec ff_alias_pix_decoder = {
     .name         = "alias_pix",
     .long_name    = NULL_IF_CONFIG_SMALL("Alias/Wavefront PIX image"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/aliaspixenc.c b/libavcodec/aliaspixenc.c
index 7c881d2e0a..01e9b3ab96 100644
--- a/libavcodec/aliaspixenc.c
+++ b/libavcodec/aliaspixenc.c
@@ -103,7 +103,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_alias_pix_encoder = {
+const AVCodec ff_alias_pix_encoder = {
     .name      = "alias_pix",
     .long_name = NULL_IF_CONFIG_SMALL("Alias/Wavefront PIX image"),
     .type      = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index e60ac5ce78..35e51c1397 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -28,811 +28,818 @@
 #include "libavutil/thread.h"
 #include "avcodec.h"
 
-extern AVCodec ff_a64multi_encoder;
-extern AVCodec ff_a64multi5_encoder;
-extern AVCodec ff_aasc_decoder;
-extern AVCodec ff_aic_decoder;
-extern AVCodec ff_alias_pix_encoder;
-extern AVCodec ff_alias_pix_decoder;
-extern AVCodec ff_agm_decoder;
-extern AVCodec ff_amv_encoder;
-extern AVCodec ff_amv_decoder;
-extern AVCodec ff_anm_decoder;
-extern AVCodec ff_ansi_decoder;
-extern AVCodec ff_apng_encoder;
-extern AVCodec ff_apng_decoder;
-extern AVCodec ff_arbc_decoder;
-extern AVCodec ff_argo_decoder;
-extern AVCodec ff_asv1_encoder;
-extern AVCodec ff_asv1_decoder;
-extern AVCodec ff_asv2_encoder;
-extern AVCodec ff_asv2_decoder;
-extern AVCodec ff_aura_decoder;
-extern AVCodec ff_aura2_decoder;
-extern AVCodec ff_avrp_encoder;
-extern AVCodec ff_avrp_decoder;
-extern AVCodec ff_avrn_decoder;
-extern AVCodec ff_avs_decoder;
-extern AVCodec ff_avui_encoder;
-extern AVCodec ff_avui_decoder;
-extern AVCodec ff_ayuv_encoder;
-extern AVCodec ff_ayuv_decoder;
-extern AVCodec ff_bethsoftvid_decoder;
-extern AVCodec ff_bfi_decoder;
-extern AVCodec ff_bink_decoder;
-extern AVCodec ff_bitpacked_decoder;
-extern AVCodec ff_bmp_encoder;
-extern AVCodec ff_bmp_decoder;
-extern AVCodec ff_bmv_video_decoder;
-extern AVCodec ff_brender_pix_decoder;
-extern AVCodec ff_c93_decoder;
-extern AVCodec ff_cavs_decoder;
-extern AVCodec ff_cdgraphics_decoder;
-extern AVCodec ff_cdtoons_decoder;
-extern AVCodec ff_cdxl_decoder;
-extern AVCodec ff_cfhd_encoder;
-extern AVCodec ff_cfhd_decoder;
-extern AVCodec ff_cinepak_encoder;
-extern AVCodec ff_cinepak_decoder;
-extern AVCodec ff_clearvideo_decoder;
-extern AVCodec ff_cljr_encoder;
-extern AVCodec ff_cljr_decoder;
-extern AVCodec ff_cllc_decoder;
-extern AVCodec ff_comfortnoise_encoder;
-extern AVCodec ff_comfortnoise_decoder;
-extern AVCodec ff_cpia_decoder;
-extern AVCodec ff_cri_decoder;
-extern AVCodec ff_cscd_decoder;
-extern AVCodec ff_cyuv_decoder;
-extern AVCodec ff_dds_decoder;
-extern AVCodec ff_dfa_decoder;
-extern AVCodec ff_dirac_decoder;
-extern AVCodec ff_dnxhd_encoder;
-extern AVCodec ff_dnxhd_decoder;
-extern AVCodec ff_dpx_encoder;
-extern AVCodec ff_dpx_decoder;
-extern AVCodec ff_dsicinvideo_decoder;
-extern AVCodec ff_dvaudio_decoder;
-extern AVCodec ff_dvvideo_encoder;
-extern AVCodec ff_dvvideo_decoder;
-extern AVCodec ff_dxa_decoder;
-extern AVCodec ff_dxtory_decoder;
-extern AVCodec ff_dxv_decoder;
-extern AVCodec ff_eacmv_decoder;
-extern AVCodec ff_eamad_decoder;
-extern AVCodec ff_eatgq_decoder;
-extern AVCodec ff_eatgv_decoder;
-extern AVCodec ff_eatqi_decoder;
-extern AVCodec ff_eightbps_decoder;
-extern AVCodec ff_eightsvx_exp_decoder;
-extern AVCodec ff_eightsvx_fib_decoder;
-extern AVCodec ff_escape124_decoder;
-extern AVCodec ff_escape130_decoder;
-extern AVCodec ff_exr_encoder;
-extern AVCodec ff_exr_decoder;
-extern AVCodec ff_ffv1_encoder;
-extern AVCodec ff_ffv1_decoder;
-extern AVCodec ff_ffvhuff_encoder;
-extern AVCodec ff_ffvhuff_decoder;
-extern AVCodec ff_fic_decoder;
-extern AVCodec ff_fits_encoder;
-extern AVCodec ff_fits_decoder;
-extern AVCodec ff_flashsv_encoder;
-extern AVCodec ff_flashsv_decoder;
-extern AVCodec ff_flashsv2_encoder;
-extern AVCodec ff_flashsv2_decoder;
-extern AVCodec ff_flic_decoder;
-extern AVCodec ff_flv_encoder;
-extern AVCodec ff_flv_decoder;
-extern AVCodec ff_fmvc_decoder;
-extern AVCodec ff_fourxm_decoder;
-extern AVCodec ff_fraps_decoder;
-extern AVCodec ff_frwu_decoder;
-extern AVCodec ff_g2m_decoder;
-extern AVCodec ff_gdv_decoder;
-extern AVCodec ff_gif_encoder;
-extern AVCodec ff_gif_decoder;
-extern AVCodec ff_h261_encoder;
-extern AVCodec ff_h261_decoder;
-extern AVCodec ff_h263_encoder;
-extern AVCodec ff_h263_decoder;
-extern AVCodec ff_h263i_decoder;
-extern AVCodec ff_h263p_encoder;
-extern AVCodec ff_h263p_decoder;
-extern AVCodec ff_h263_v4l2m2m_decoder;
-extern AVCodec ff_h264_decoder;
-extern AVCodec ff_h264_crystalhd_decoder;
-extern AVCodec ff_h264_v4l2m2m_decoder;
-extern AVCodec ff_h264_mediacodec_decoder;
-extern AVCodec ff_h264_mmal_decoder;
-extern AVCodec ff_h264_qsv_decoder;
-extern AVCodec ff_h264_rkmpp_decoder;
-extern AVCodec ff_hap_encoder;
-extern AVCodec ff_hap_decoder;
-extern AVCodec ff_hevc_decoder;
-extern AVCodec ff_hevc_qsv_decoder;
-extern AVCodec ff_hevc_rkmpp_decoder;
-extern AVCodec ff_hevc_v4l2m2m_decoder;
-extern AVCodec ff_hnm4_video_decoder;
-extern AVCodec ff_hq_hqa_decoder;
-extern AVCodec ff_hqx_decoder;
-extern AVCodec ff_huffyuv_encoder;
-extern AVCodec ff_huffyuv_decoder;
-extern AVCodec ff_hymt_decoder;
-extern AVCodec ff_idcin_decoder;
-extern AVCodec ff_iff_ilbm_decoder;
-extern AVCodec ff_imm4_decoder;
-extern AVCodec ff_imm5_decoder;
-extern AVCodec ff_indeo2_decoder;
-extern AVCodec ff_indeo3_decoder;
-extern AVCodec ff_indeo4_decoder;
-extern AVCodec ff_indeo5_decoder;
-extern AVCodec ff_interplay_video_decoder;
-extern AVCodec ff_ipu_decoder;
-extern AVCodec ff_jpeg2000_encoder;
-extern AVCodec ff_jpeg2000_decoder;
-extern AVCodec ff_jpegls_encoder;
-extern AVCodec ff_jpegls_decoder;
-extern AVCodec ff_jv_decoder;
-extern AVCodec ff_kgv1_decoder;
-extern AVCodec ff_kmvc_decoder;
-extern AVCodec ff_lagarith_decoder;
-extern AVCodec ff_ljpeg_encoder;
-extern AVCodec ff_loco_decoder;
-extern AVCodec ff_lscr_decoder;
-extern AVCodec ff_m101_decoder;
-extern AVCodec ff_magicyuv_encoder;
-extern AVCodec ff_magicyuv_decoder;
-extern AVCodec ff_mdec_decoder;
-extern AVCodec ff_mimic_decoder;
-extern AVCodec ff_mjpeg_encoder;
-extern AVCodec ff_mjpeg_decoder;
-extern AVCodec ff_mjpegb_decoder;
-extern AVCodec ff_mmvideo_decoder;
-extern AVCodec ff_mobiclip_decoder;
-extern AVCodec ff_motionpixels_decoder;
-extern AVCodec ff_mpeg1video_encoder;
-extern AVCodec ff_mpeg1video_decoder;
-extern AVCodec ff_mpeg2video_encoder;
-extern AVCodec ff_mpeg2video_decoder;
-extern AVCodec ff_mpeg4_encoder;
-extern AVCodec ff_mpeg4_decoder;
-extern AVCodec ff_mpeg4_crystalhd_decoder;
-extern AVCodec ff_mpeg4_v4l2m2m_decoder;
-extern AVCodec ff_mpeg4_mmal_decoder;
-extern AVCodec ff_mpegvideo_decoder;
-extern AVCodec ff_mpeg1_v4l2m2m_decoder;
-extern AVCodec ff_mpeg2_mmal_decoder;
-extern AVCodec ff_mpeg2_crystalhd_decoder;
-extern AVCodec ff_mpeg2_v4l2m2m_decoder;
-extern AVCodec ff_mpeg2_qsv_decoder;
-extern AVCodec ff_mpeg2_mediacodec_decoder;
-extern AVCodec ff_msa1_decoder;
-extern AVCodec ff_mscc_decoder;
-extern AVCodec ff_msmpeg4v1_decoder;
-extern AVCodec ff_msmpeg4v2_encoder;
-extern AVCodec ff_msmpeg4v2_decoder;
-extern AVCodec ff_msmpeg4v3_encoder;
-extern AVCodec ff_msmpeg4v3_decoder;
-extern AVCodec ff_msmpeg4_crystalhd_decoder;
-extern AVCodec ff_msp2_decoder;
-extern AVCodec ff_msrle_decoder;
-extern AVCodec ff_mss1_decoder;
-extern AVCodec ff_mss2_decoder;
-extern AVCodec ff_msvideo1_encoder;
-extern AVCodec ff_msvideo1_decoder;
-extern AVCodec ff_mszh_decoder;
-extern AVCodec ff_mts2_decoder;
-extern AVCodec ff_mv30_decoder;
-extern AVCodec ff_mvc1_decoder;
-extern AVCodec ff_mvc2_decoder;
-extern AVCodec ff_mvdv_decoder;
-extern AVCodec ff_mvha_decoder;
-extern AVCodec ff_mwsc_decoder;
-extern AVCodec ff_mxpeg_decoder;
-extern AVCodec ff_notchlc_decoder;
-extern AVCodec ff_nuv_decoder;
-extern AVCodec ff_paf_video_decoder;
-extern AVCodec ff_pam_encoder;
-extern AVCodec ff_pam_decoder;
-extern AVCodec ff_pbm_encoder;
-extern AVCodec ff_pbm_decoder;
-extern AVCodec ff_pcx_encoder;
-extern AVCodec ff_pcx_decoder;
-extern AVCodec ff_pfm_encoder;
-extern AVCodec ff_pfm_decoder;
-extern AVCodec ff_pgm_encoder;
-extern AVCodec ff_pgm_decoder;
-extern AVCodec ff_pgmyuv_encoder;
-extern AVCodec ff_pgmyuv_decoder;
-extern AVCodec ff_pgx_decoder;
-extern AVCodec ff_photocd_decoder;
-extern AVCodec ff_pictor_decoder;
-extern AVCodec ff_pixlet_decoder;
-extern AVCodec ff_png_encoder;
-extern AVCodec ff_png_decoder;
-extern AVCodec ff_ppm_encoder;
-extern AVCodec ff_ppm_decoder;
-extern AVCodec ff_prores_encoder;
-extern AVCodec ff_prores_decoder;
-extern AVCodec ff_prores_aw_encoder;
-extern AVCodec ff_prores_ks_encoder;
-extern AVCodec ff_prosumer_decoder;
-extern AVCodec ff_psd_decoder;
-extern AVCodec ff_ptx_decoder;
-extern AVCodec ff_qdraw_decoder;
-extern AVCodec ff_qpeg_decoder;
-extern AVCodec ff_qtrle_encoder;
-extern AVCodec ff_qtrle_decoder;
-extern AVCodec ff_r10k_encoder;
-extern AVCodec ff_r10k_decoder;
-extern AVCodec ff_r210_encoder;
-extern AVCodec ff_r210_decoder;
-extern AVCodec ff_rasc_decoder;
-extern AVCodec ff_rawvideo_encoder;
-extern AVCodec ff_rawvideo_decoder;
-extern AVCodec ff_rl2_decoder;
-extern AVCodec ff_roq_encoder;
-extern AVCodec ff_roq_decoder;
-extern AVCodec ff_rpza_encoder;
-extern AVCodec ff_rpza_decoder;
-extern AVCodec ff_rscc_decoder;
-extern AVCodec ff_rv10_encoder;
-extern AVCodec ff_rv10_decoder;
-extern AVCodec ff_rv20_encoder;
-extern AVCodec ff_rv20_decoder;
-extern AVCodec ff_rv30_decoder;
-extern AVCodec ff_rv40_decoder;
-extern AVCodec ff_s302m_encoder;
-extern AVCodec ff_s302m_decoder;
-extern AVCodec ff_sanm_decoder;
-extern AVCodec ff_scpr_decoder;
-extern AVCodec ff_screenpresso_decoder;
-extern AVCodec ff_sga_decoder;
-extern AVCodec ff_sgi_encoder;
-extern AVCodec ff_sgi_decoder;
-extern AVCodec ff_sgirle_decoder;
-extern AVCodec ff_sheervideo_decoder;
-extern AVCodec ff_simbiosis_imx_decoder;
-extern AVCodec ff_smacker_decoder;
-extern AVCodec ff_smc_decoder;
-extern AVCodec ff_smvjpeg_decoder;
-extern AVCodec ff_snow_encoder;
-extern AVCodec ff_snow_decoder;
-extern AVCodec ff_sp5x_decoder;
-extern AVCodec ff_speedhq_decoder;
-extern AVCodec ff_speedhq_encoder;
-extern AVCodec ff_srgc_decoder;
-extern AVCodec ff_sunrast_encoder;
-extern AVCodec ff_sunrast_decoder;
-extern AVCodec ff_svq1_encoder;
-extern AVCodec ff_svq1_decoder;
-extern AVCodec ff_svq3_decoder;
-extern AVCodec ff_targa_encoder;
-extern AVCodec ff_targa_decoder;
-extern AVCodec ff_targa_y216_decoder;
-extern AVCodec ff_tdsc_decoder;
-extern AVCodec ff_theora_decoder;
-extern AVCodec ff_thp_decoder;
-extern AVCodec ff_tiertexseqvideo_decoder;
-extern AVCodec ff_tiff_encoder;
-extern AVCodec ff_tiff_decoder;
-extern AVCodec ff_tmv_decoder;
-extern AVCodec ff_truemotion1_decoder;
-extern AVCodec ff_truemotion2_decoder;
-extern AVCodec ff_truemotion2rt_decoder;
-extern AVCodec ff_tscc_decoder;
-extern AVCodec ff_tscc2_decoder;
-extern AVCodec ff_txd_decoder;
-extern AVCodec ff_ulti_decoder;
-extern AVCodec ff_utvideo_encoder;
-extern AVCodec ff_utvideo_decoder;
-extern AVCodec ff_v210_encoder;
-extern AVCodec ff_v210_decoder;
-extern AVCodec ff_v210x_decoder;
-extern AVCodec ff_v308_encoder;
-extern AVCodec ff_v308_decoder;
-extern AVCodec ff_v408_encoder;
-extern AVCodec ff_v408_decoder;
-extern AVCodec ff_v410_encoder;
-extern AVCodec ff_v410_decoder;
-extern AVCodec ff_vb_decoder;
-extern AVCodec ff_vble_decoder;
-extern AVCodec ff_vc1_decoder;
-extern AVCodec ff_vc1_crystalhd_decoder;
-extern AVCodec ff_vc1image_decoder;
-extern AVCodec ff_vc1_mmal_decoder;
-extern AVCodec ff_vc1_qsv_decoder;
-extern AVCodec ff_vc1_v4l2m2m_decoder;
-extern AVCodec ff_vc2_encoder;
-extern AVCodec ff_vcr1_decoder;
-extern AVCodec ff_vmdvideo_decoder;
-extern AVCodec ff_vmnc_decoder;
-extern AVCodec ff_vp3_decoder;
-extern AVCodec ff_vp4_decoder;
-extern AVCodec ff_vp5_decoder;
-extern AVCodec ff_vp6_decoder;
-extern AVCodec ff_vp6a_decoder;
-extern AVCodec ff_vp6f_decoder;
-extern AVCodec ff_vp7_decoder;
-extern AVCodec ff_vp8_decoder;
-extern AVCodec ff_vp8_rkmpp_decoder;
-extern AVCodec ff_vp8_v4l2m2m_decoder;
-extern AVCodec ff_vp9_decoder;
-extern AVCodec ff_vp9_rkmpp_decoder;
-extern AVCodec ff_vp9_v4l2m2m_decoder;
-extern AVCodec ff_vqa_decoder;
-extern AVCodec ff_webp_decoder;
-extern AVCodec ff_wcmv_decoder;
-extern AVCodec ff_wrapped_avframe_encoder;
-extern AVCodec ff_wrapped_avframe_decoder;
-extern AVCodec ff_wmv1_encoder;
-extern AVCodec ff_wmv1_decoder;
-extern AVCodec ff_wmv2_encoder;
-extern AVCodec ff_wmv2_decoder;
-extern AVCodec ff_wmv3_decoder;
-extern AVCodec ff_wmv3_crystalhd_decoder;
-extern AVCodec ff_wmv3image_decoder;
-extern AVCodec ff_wnv1_decoder;
-extern AVCodec ff_xan_wc3_decoder;
-extern AVCodec ff_xan_wc4_decoder;
-extern AVCodec ff_xbm_encoder;
-extern AVCodec ff_xbm_decoder;
-extern AVCodec ff_xface_encoder;
-extern AVCodec ff_xface_decoder;
-extern AVCodec ff_xl_decoder;
-extern AVCodec ff_xpm_decoder;
-extern AVCodec ff_xwd_encoder;
-extern AVCodec ff_xwd_decoder;
-extern AVCodec ff_y41p_encoder;
-extern AVCodec ff_y41p_decoder;
-extern AVCodec ff_ylc_decoder;
-extern AVCodec ff_yop_decoder;
-extern AVCodec ff_yuv4_encoder;
-extern AVCodec ff_yuv4_decoder;
-extern AVCodec ff_zero12v_decoder;
-extern AVCodec ff_zerocodec_decoder;
-extern AVCodec ff_zlib_encoder;
-extern AVCodec ff_zlib_decoder;
-extern AVCodec ff_zmbv_encoder;
-extern AVCodec ff_zmbv_decoder;
+extern const AVCodec ff_a64multi_encoder;
+extern const AVCodec ff_a64multi5_encoder;
+extern const AVCodec ff_aasc_decoder;
+extern const AVCodec ff_aic_decoder;
+extern const AVCodec ff_alias_pix_encoder;
+extern const AVCodec ff_alias_pix_decoder;
+extern const AVCodec ff_agm_decoder;
+extern const AVCodec ff_amv_encoder;
+extern const AVCodec ff_amv_decoder;
+extern const AVCodec ff_anm_decoder;
+extern const AVCodec ff_ansi_decoder;
+extern const AVCodec ff_apng_encoder;
+extern const AVCodec ff_apng_decoder;
+extern const AVCodec ff_arbc_decoder;
+extern const AVCodec ff_argo_decoder;
+extern const AVCodec ff_asv1_encoder;
+extern const AVCodec ff_asv1_decoder;
+extern const AVCodec ff_asv2_encoder;
+extern const AVCodec ff_asv2_decoder;
+extern const AVCodec ff_aura_decoder;
+extern const AVCodec ff_aura2_decoder;
+extern const AVCodec ff_avrp_encoder;
+extern const AVCodec ff_avrp_decoder;
+extern const AVCodec ff_avrn_decoder;
+extern const AVCodec ff_avs_decoder;
+extern const AVCodec ff_avui_encoder;
+extern const AVCodec ff_avui_decoder;
+extern const AVCodec ff_ayuv_encoder;
+extern const AVCodec ff_ayuv_decoder;
+extern const AVCodec ff_bethsoftvid_decoder;
+extern const AVCodec ff_bfi_decoder;
+extern const AVCodec ff_bink_decoder;
+extern const AVCodec ff_bitpacked_decoder;
+extern const AVCodec ff_bmp_encoder;
+extern const AVCodec ff_bmp_decoder;
+extern const AVCodec ff_bmv_video_decoder;
+extern const AVCodec ff_brender_pix_decoder;
+extern const AVCodec ff_c93_decoder;
+extern const AVCodec ff_cavs_decoder;
+extern const AVCodec ff_cdgraphics_decoder;
+extern const AVCodec ff_cdtoons_decoder;
+extern const AVCodec ff_cdxl_decoder;
+extern const AVCodec ff_cfhd_encoder;
+extern const AVCodec ff_cfhd_decoder;
+extern const AVCodec ff_cinepak_encoder;
+extern const AVCodec ff_cinepak_decoder;
+extern const AVCodec ff_clearvideo_decoder;
+extern const AVCodec ff_cljr_encoder;
+extern const AVCodec ff_cljr_decoder;
+extern const AVCodec ff_cllc_decoder;
+extern const AVCodec ff_comfortnoise_encoder;
+extern const AVCodec ff_comfortnoise_decoder;
+extern const AVCodec ff_cpia_decoder;
+extern const AVCodec ff_cri_decoder;
+extern const AVCodec ff_cscd_decoder;
+extern const AVCodec ff_cyuv_decoder;
+extern const AVCodec ff_dds_decoder;
+extern const AVCodec ff_dfa_decoder;
+extern const AVCodec ff_dirac_decoder;
+extern const AVCodec ff_dnxhd_encoder;
+extern const AVCodec ff_dnxhd_decoder;
+extern const AVCodec ff_dpx_encoder;
+extern const AVCodec ff_dpx_decoder;
+extern const AVCodec ff_dsicinvideo_decoder;
+extern const AVCodec ff_dvaudio_decoder;
+extern const AVCodec ff_dvvideo_encoder;
+extern const AVCodec ff_dvvideo_decoder;
+extern const AVCodec ff_dxa_decoder;
+extern const AVCodec ff_dxtory_decoder;
+extern const AVCodec ff_dxv_decoder;
+extern const AVCodec ff_eacmv_decoder;
+extern const AVCodec ff_eamad_decoder;
+extern const AVCodec ff_eatgq_decoder;
+extern const AVCodec ff_eatgv_decoder;
+extern const AVCodec ff_eatqi_decoder;
+extern const AVCodec ff_eightbps_decoder;
+extern const AVCodec ff_eightsvx_exp_decoder;
+extern const AVCodec ff_eightsvx_fib_decoder;
+extern const AVCodec ff_escape124_decoder;
+extern const AVCodec ff_escape130_decoder;
+extern const AVCodec ff_exr_encoder;
+extern const AVCodec ff_exr_decoder;
+extern const AVCodec ff_ffv1_encoder;
+extern const AVCodec ff_ffv1_decoder;
+extern const AVCodec ff_ffvhuff_encoder;
+extern const AVCodec ff_ffvhuff_decoder;
+extern const AVCodec ff_fic_decoder;
+extern const AVCodec ff_fits_encoder;
+extern const AVCodec ff_fits_decoder;
+extern const AVCodec ff_flashsv_encoder;
+extern const AVCodec ff_flashsv_decoder;
+extern const AVCodec ff_flashsv2_encoder;
+extern const AVCodec ff_flashsv2_decoder;
+extern const AVCodec ff_flic_decoder;
+extern const AVCodec ff_flv_encoder;
+extern const AVCodec ff_flv_decoder;
+extern const AVCodec ff_fmvc_decoder;
+extern const AVCodec ff_fourxm_decoder;
+extern const AVCodec ff_fraps_decoder;
+extern const AVCodec ff_frwu_decoder;
+extern const AVCodec ff_g2m_decoder;
+extern const AVCodec ff_gdv_decoder;
+extern const AVCodec ff_gif_encoder;
+extern const AVCodec ff_gif_decoder;
+extern const AVCodec ff_h261_encoder;
+extern const AVCodec ff_h261_decoder;
+extern const AVCodec ff_h263_encoder;
+extern const AVCodec ff_h263_decoder;
+extern const AVCodec ff_h263i_decoder;
+extern const AVCodec ff_h263p_encoder;
+extern const AVCodec ff_h263p_decoder;
+extern const AVCodec ff_h263_v4l2m2m_decoder;
+extern const AVCodec ff_h264_decoder;
+extern const AVCodec ff_h264_crystalhd_decoder;
+extern const AVCodec ff_h264_v4l2m2m_decoder;
+extern const AVCodec ff_h264_mediacodec_decoder;
+extern const AVCodec ff_h264_mmal_decoder;
+extern const AVCodec ff_h264_qsv_decoder;
+extern const AVCodec ff_h264_rkmpp_decoder;
+extern const AVCodec ff_hap_encoder;
+extern const AVCodec ff_hap_decoder;
+extern const AVCodec ff_hevc_decoder;
+extern const AVCodec ff_hevc_qsv_decoder;
+extern const AVCodec ff_hevc_rkmpp_decoder;
+extern const AVCodec ff_hevc_v4l2m2m_decoder;
+extern const AVCodec ff_hnm4_video_decoder;
+extern const AVCodec ff_hq_hqa_decoder;
+extern const AVCodec ff_hqx_decoder;
+extern const AVCodec ff_huffyuv_encoder;
+extern const AVCodec ff_huffyuv_decoder;
+extern const AVCodec ff_hymt_decoder;
+extern const AVCodec ff_idcin_decoder;
+extern const AVCodec ff_iff_ilbm_decoder;
+extern const AVCodec ff_imm4_decoder;
+extern const AVCodec ff_imm5_decoder;
+extern const AVCodec ff_indeo2_decoder;
+extern const AVCodec ff_indeo3_decoder;
+extern const AVCodec ff_indeo4_decoder;
+extern const AVCodec ff_indeo5_decoder;
+extern const AVCodec ff_interplay_video_decoder;
+extern const AVCodec ff_ipu_decoder;
+extern const AVCodec ff_jpeg2000_encoder;
+extern const AVCodec ff_jpeg2000_decoder;
+extern const AVCodec ff_jpegls_encoder;
+extern const AVCodec ff_jpegls_decoder;
+extern const AVCodec ff_jv_decoder;
+extern const AVCodec ff_kgv1_decoder;
+extern const AVCodec ff_kmvc_decoder;
+extern const AVCodec ff_lagarith_decoder;
+extern const AVCodec ff_ljpeg_encoder;
+extern const AVCodec ff_loco_decoder;
+extern const AVCodec ff_lscr_decoder;
+extern const AVCodec ff_m101_decoder;
+extern const AVCodec ff_magicyuv_encoder;
+extern const AVCodec ff_magicyuv_decoder;
+extern const AVCodec ff_mdec_decoder;
+extern const AVCodec ff_mimic_decoder;
+extern const AVCodec ff_mjpeg_encoder;
+extern const AVCodec ff_mjpeg_decoder;
+extern const AVCodec ff_mjpegb_decoder;
+extern const AVCodec ff_mmvideo_decoder;
+extern const AVCodec ff_mobiclip_decoder;
+extern const AVCodec ff_motionpixels_decoder;
+extern const AVCodec ff_mpeg1video_encoder;
+extern const AVCodec ff_mpeg1video_decoder;
+extern const AVCodec ff_mpeg2video_encoder;
+extern const AVCodec ff_mpeg2video_decoder;
+extern const AVCodec ff_mpeg4_encoder;
+extern const AVCodec ff_mpeg4_decoder;
+extern const AVCodec ff_mpeg4_crystalhd_decoder;
+extern const AVCodec ff_mpeg4_v4l2m2m_decoder;
+extern const AVCodec ff_mpeg4_mmal_decoder;
+extern const AVCodec ff_mpegvideo_decoder;
+extern const AVCodec ff_mpeg1_v4l2m2m_decoder;
+extern const AVCodec ff_mpeg2_mmal_decoder;
+extern const AVCodec ff_mpeg2_crystalhd_decoder;
+extern const AVCodec ff_mpeg2_v4l2m2m_decoder;
+extern const AVCodec ff_mpeg2_qsv_decoder;
+extern const AVCodec ff_mpeg2_mediacodec_decoder;
+extern const AVCodec ff_msa1_decoder;
+extern const AVCodec ff_mscc_decoder;
+extern const AVCodec ff_msmpeg4v1_decoder;
+extern const AVCodec ff_msmpeg4v2_encoder;
+extern const AVCodec ff_msmpeg4v2_decoder;
+extern const AVCodec ff_msmpeg4v3_encoder;
+extern const AVCodec ff_msmpeg4v3_decoder;
+extern const AVCodec ff_msmpeg4_crystalhd_decoder;
+extern const AVCodec ff_msp2_decoder;
+extern const AVCodec ff_msrle_decoder;
+extern const AVCodec ff_mss1_decoder;
+extern const AVCodec ff_mss2_decoder;
+extern const AVCodec ff_msvideo1_encoder;
+extern const AVCodec ff_msvideo1_decoder;
+extern const AVCodec ff_mszh_decoder;
+extern const AVCodec ff_mts2_decoder;
+extern const AVCodec ff_mv30_decoder;
+extern const AVCodec ff_mvc1_decoder;
+extern const AVCodec ff_mvc2_decoder;
+extern const AVCodec ff_mvdv_decoder;
+extern const AVCodec ff_mvha_decoder;
+extern const AVCodec ff_mwsc_decoder;
+extern const AVCodec ff_mxpeg_decoder;
+extern const AVCodec ff_notchlc_decoder;
+extern const AVCodec ff_nuv_decoder;
+extern const AVCodec ff_paf_video_decoder;
+extern const AVCodec ff_pam_encoder;
+extern const AVCodec ff_pam_decoder;
+extern const AVCodec ff_pbm_encoder;
+extern const AVCodec ff_pbm_decoder;
+extern const AVCodec ff_pcx_encoder;
+extern const AVCodec ff_pcx_decoder;
+extern const AVCodec ff_pfm_encoder;
+extern const AVCodec ff_pfm_decoder;
+extern const AVCodec ff_pgm_encoder;
+extern const AVCodec ff_pgm_decoder;
+extern const AVCodec ff_pgmyuv_encoder;
+extern const AVCodec ff_pgmyuv_decoder;
+extern const AVCodec ff_pgx_decoder;
+extern const AVCodec ff_photocd_decoder;
+extern const AVCodec ff_pictor_decoder;
+extern const AVCodec ff_pixlet_decoder;
+extern const AVCodec ff_png_encoder;
+extern const AVCodec ff_png_decoder;
+extern const AVCodec ff_ppm_encoder;
+extern const AVCodec ff_ppm_decoder;
+extern const AVCodec ff_prores_encoder;
+extern const AVCodec ff_prores_decoder;
+extern const AVCodec ff_prores_aw_encoder;
+extern const AVCodec ff_prores_ks_encoder;
+extern const AVCodec ff_prosumer_decoder;
+extern const AVCodec ff_psd_decoder;
+extern const AVCodec ff_ptx_decoder;
+extern const AVCodec ff_qdraw_decoder;
+extern const AVCodec ff_qpeg_decoder;
+extern const AVCodec ff_qtrle_encoder;
+extern const AVCodec ff_qtrle_decoder;
+extern const AVCodec ff_r10k_encoder;
+extern const AVCodec ff_r10k_decoder;
+extern const AVCodec ff_r210_encoder;
+extern const AVCodec ff_r210_decoder;
+extern const AVCodec ff_rasc_decoder;
+extern const AVCodec ff_rawvideo_encoder;
+extern const AVCodec ff_rawvideo_decoder;
+extern const AVCodec ff_rl2_decoder;
+extern const AVCodec ff_roq_encoder;
+extern const AVCodec ff_roq_decoder;
+extern const AVCodec ff_rpza_encoder;
+extern const AVCodec ff_rpza_decoder;
+extern const AVCodec ff_rscc_decoder;
+extern const AVCodec ff_rv10_encoder;
+extern const AVCodec ff_rv10_decoder;
+extern const AVCodec ff_rv20_encoder;
+extern const AVCodec ff_rv20_decoder;
+extern const AVCodec ff_rv30_decoder;
+extern const AVCodec ff_rv40_decoder;
+extern const AVCodec ff_s302m_encoder;
+extern const AVCodec ff_s302m_decoder;
+extern const AVCodec ff_sanm_decoder;
+extern const AVCodec ff_scpr_decoder;
+extern const AVCodec ff_screenpresso_decoder;
+extern const AVCodec ff_sga_decoder;
+extern const AVCodec ff_sgi_encoder;
+extern const AVCodec ff_sgi_decoder;
+extern const AVCodec ff_sgirle_decoder;
+extern const AVCodec ff_sheervideo_decoder;
+extern const AVCodec ff_simbiosis_imx_decoder;
+extern const AVCodec ff_smacker_decoder;
+extern const AVCodec ff_smc_decoder;
+extern const AVCodec ff_smvjpeg_decoder;
+extern const AVCodec ff_snow_encoder;
+extern const AVCodec ff_snow_decoder;
+extern const AVCodec ff_sp5x_decoder;
+extern const AVCodec ff_speedhq_decoder;
+extern const AVCodec ff_speedhq_encoder;
+extern const AVCodec ff_srgc_decoder;
+extern const AVCodec ff_sunrast_encoder;
+extern const AVCodec ff_sunrast_decoder;
+extern const AVCodec ff_svq1_encoder;
+extern const AVCodec ff_svq1_decoder;
+extern const AVCodec ff_svq3_decoder;
+extern const AVCodec ff_targa_encoder;
+extern const AVCodec ff_targa_decoder;
+extern const AVCodec ff_targa_y216_decoder;
+extern const AVCodec ff_tdsc_decoder;
+extern const AVCodec ff_theora_decoder;
+extern const AVCodec ff_thp_decoder;
+extern const AVCodec ff_tiertexseqvideo_decoder;
+extern const AVCodec ff_tiff_encoder;
+extern const AVCodec ff_tiff_decoder;
+extern const AVCodec ff_tmv_decoder;
+extern const AVCodec ff_truemotion1_decoder;
+extern const AVCodec ff_truemotion2_decoder;
+extern const AVCodec ff_truemotion2rt_decoder;
+extern const AVCodec ff_tscc_decoder;
+extern const AVCodec ff_tscc2_decoder;
+extern const AVCodec ff_txd_decoder;
+extern const AVCodec ff_ulti_decoder;
+extern const AVCodec ff_utvideo_encoder;
+extern const AVCodec ff_utvideo_decoder;
+extern const AVCodec ff_v210_encoder;
+extern const AVCodec ff_v210_decoder;
+extern const AVCodec ff_v210x_decoder;
+extern const AVCodec ff_v308_encoder;
+extern const AVCodec ff_v308_decoder;
+extern const AVCodec ff_v408_encoder;
+extern const AVCodec ff_v408_decoder;
+extern const AVCodec ff_v410_encoder;
+extern const AVCodec ff_v410_decoder;
+extern const AVCodec ff_vb_decoder;
+extern const AVCodec ff_vble_decoder;
+extern const AVCodec ff_vc1_decoder;
+extern const AVCodec ff_vc1_crystalhd_decoder;
+extern const AVCodec ff_vc1image_decoder;
+extern const AVCodec ff_vc1_mmal_decoder;
+extern const AVCodec ff_vc1_qsv_decoder;
+extern const AVCodec ff_vc1_v4l2m2m_decoder;
+extern const AVCodec ff_vc2_encoder;
+extern const AVCodec ff_vcr1_decoder;
+extern const AVCodec ff_vmdvideo_decoder;
+extern const AVCodec ff_vmnc_decoder;
+extern const AVCodec ff_vp3_decoder;
+extern const AVCodec ff_vp4_decoder;
+extern const AVCodec ff_vp5_decoder;
+extern const AVCodec ff_vp6_decoder;
+extern const AVCodec ff_vp6a_decoder;
+extern const AVCodec ff_vp6f_decoder;
+extern const AVCodec ff_vp7_decoder;
+extern const AVCodec ff_vp8_decoder;
+extern const AVCodec ff_vp8_rkmpp_decoder;
+extern const AVCodec ff_vp8_v4l2m2m_decoder;
+extern const AVCodec ff_vp9_decoder;
+extern const AVCodec ff_vp9_rkmpp_decoder;
+extern const AVCodec ff_vp9_v4l2m2m_decoder;
+extern const AVCodec ff_vqa_decoder;
+extern const AVCodec ff_webp_decoder;
+extern const AVCodec ff_wcmv_decoder;
+extern const AVCodec ff_wrapped_avframe_encoder;
+extern const AVCodec ff_wrapped_avframe_decoder;
+extern const AVCodec ff_wmv1_encoder;
+extern const AVCodec ff_wmv1_decoder;
+extern const AVCodec ff_wmv2_encoder;
+extern const AVCodec ff_wmv2_decoder;
+extern const AVCodec ff_wmv3_decoder;
+extern const AVCodec ff_wmv3_crystalhd_decoder;
+extern const AVCodec ff_wmv3image_decoder;
+extern const AVCodec ff_wnv1_decoder;
+extern const AVCodec ff_xan_wc3_decoder;
+extern const AVCodec ff_xan_wc4_decoder;
+extern const AVCodec ff_xbm_encoder;
+extern const AVCodec ff_xbm_decoder;
+extern const AVCodec ff_xface_encoder;
+extern const AVCodec ff_xface_decoder;
+extern const AVCodec ff_xl_decoder;
+extern const AVCodec ff_xpm_decoder;
+extern const AVCodec ff_xwd_encoder;
+extern const AVCodec ff_xwd_decoder;
+extern const AVCodec ff_y41p_encoder;
+extern const AVCodec ff_y41p_decoder;
+extern const AVCodec ff_ylc_decoder;
+extern const AVCodec ff_yop_decoder;
+extern const AVCodec ff_yuv4_encoder;
+extern const AVCodec ff_yuv4_decoder;
+extern const AVCodec ff_zero12v_decoder;
+extern const AVCodec ff_zerocodec_decoder;
+extern const AVCodec ff_zlib_encoder;
+extern const AVCodec ff_zlib_decoder;
+extern const AVCodec ff_zmbv_encoder;
+extern const AVCodec ff_zmbv_decoder;
 
 /* audio codecs */
-extern AVCodec ff_aac_encoder;
-extern AVCodec ff_aac_decoder;
-extern AVCodec ff_aac_fixed_decoder;
-extern AVCodec ff_aac_latm_decoder;
-extern AVCodec ff_ac3_encoder;
-extern AVCodec ff_ac3_decoder;
-extern AVCodec ff_ac3_fixed_encoder;
-extern AVCodec ff_ac3_fixed_decoder;
-extern AVCodec ff_acelp_kelvin_decoder;
-extern AVCodec ff_alac_encoder;
-extern AVCodec ff_alac_decoder;
-extern AVCodec ff_als_decoder;
-extern AVCodec ff_amrnb_decoder;
-extern AVCodec ff_amrwb_decoder;
-extern AVCodec ff_ape_decoder;
-extern AVCodec ff_aptx_encoder;
-extern AVCodec ff_aptx_decoder;
-extern AVCodec ff_aptx_hd_encoder;
-extern AVCodec ff_aptx_hd_decoder;
-extern AVCodec ff_atrac1_decoder;
-extern AVCodec ff_atrac3_decoder;
-extern AVCodec ff_atrac3al_decoder;
-extern AVCodec ff_atrac3p_decoder;
-extern AVCodec ff_atrac3pal_decoder;
-extern AVCodec ff_atrac9_decoder;
-extern AVCodec ff_binkaudio_dct_decoder;
-extern AVCodec ff_binkaudio_rdft_decoder;
-extern AVCodec ff_bmv_audio_decoder;
-extern AVCodec ff_cook_decoder;
-extern AVCodec ff_dca_encoder;
-extern AVCodec ff_dca_decoder;
-extern AVCodec ff_dolby_e_decoder;
-extern AVCodec ff_dsd_lsbf_decoder;
-extern AVCodec ff_dsd_msbf_decoder;
-extern AVCodec ff_dsd_lsbf_planar_decoder;
-extern AVCodec ff_dsd_msbf_planar_decoder;
-extern AVCodec ff_dsicinaudio_decoder;
-extern AVCodec ff_dss_sp_decoder;
-extern AVCodec ff_dst_decoder;
-extern AVCodec ff_eac3_encoder;
-extern AVCodec ff_eac3_decoder;
-extern AVCodec ff_evrc_decoder;
-extern AVCodec ff_fastaudio_decoder;
-extern AVCodec ff_ffwavesynth_decoder;
-extern AVCodec ff_flac_encoder;
-extern AVCodec ff_flac_decoder;
-extern AVCodec ff_g723_1_encoder;
-extern AVCodec ff_g723_1_decoder;
-extern AVCodec ff_g729_decoder;
-extern AVCodec ff_gsm_decoder;
-extern AVCodec ff_gsm_ms_decoder;
-extern AVCodec ff_hca_decoder;
-extern AVCodec ff_hcom_decoder;
-extern AVCodec ff_iac_decoder;
-extern AVCodec ff_ilbc_decoder;
-extern AVCodec ff_imc_decoder;
-extern AVCodec ff_interplay_acm_decoder;
-extern AVCodec ff_mace3_decoder;
-extern AVCodec ff_mace6_decoder;
-extern AVCodec ff_metasound_decoder;
-extern AVCodec ff_mlp_encoder;
-extern AVCodec ff_mlp_decoder;
-extern AVCodec ff_mp1_decoder;
-extern AVCodec ff_mp1float_decoder;
-extern AVCodec ff_mp2_encoder;
-extern AVCodec ff_mp2_decoder;
-extern AVCodec ff_mp2float_decoder;
-extern AVCodec ff_mp2fixed_encoder;
-extern AVCodec ff_mp3float_decoder;
-extern AVCodec ff_mp3_decoder;
-extern AVCodec ff_mp3adufloat_decoder;
-extern AVCodec ff_mp3adu_decoder;
-extern AVCodec ff_mp3on4float_decoder;
-extern AVCodec ff_mp3on4_decoder;
-extern AVCodec ff_mpc7_decoder;
-extern AVCodec ff_mpc8_decoder;
-extern AVCodec ff_nellymoser_encoder;
-extern AVCodec ff_nellymoser_decoder;
-extern AVCodec ff_on2avc_decoder;
-extern AVCodec ff_opus_encoder;
-extern AVCodec ff_opus_decoder;
-extern AVCodec ff_paf_audio_decoder;
-extern AVCodec ff_qcelp_decoder;
-extern AVCodec ff_qdm2_decoder;
-extern AVCodec ff_qdmc_decoder;
-extern AVCodec ff_ra_144_encoder;
-extern AVCodec ff_ra_144_decoder;
-extern AVCodec ff_ra_288_decoder;
-extern AVCodec ff_ralf_decoder;
-extern AVCodec ff_sbc_encoder;
-extern AVCodec ff_sbc_decoder;
-extern AVCodec ff_shorten_decoder;
-extern AVCodec ff_sipr_decoder;
-extern AVCodec ff_siren_decoder;
-extern AVCodec ff_smackaud_decoder;
-extern AVCodec ff_sonic_encoder;
-extern AVCodec ff_sonic_decoder;
-extern AVCodec ff_sonic_ls_encoder;
-extern AVCodec ff_tak_decoder;
-extern AVCodec ff_truehd_encoder;
-extern AVCodec ff_truehd_decoder;
-extern AVCodec ff_truespeech_decoder;
-extern AVCodec ff_tta_encoder;
-extern AVCodec ff_tta_decoder;
-extern AVCodec ff_twinvq_decoder;
-extern AVCodec ff_vmdaudio_decoder;
-extern AVCodec ff_vorbis_encoder;
-extern AVCodec ff_vorbis_decoder;
-extern AVCodec ff_wavpack_encoder;
-extern AVCodec ff_wavpack_decoder;
-extern AVCodec ff_wmalossless_decoder;
-extern AVCodec ff_wmapro_decoder;
-extern AVCodec ff_wmav1_encoder;
-extern AVCodec ff_wmav1_decoder;
-extern AVCodec ff_wmav2_encoder;
-extern AVCodec ff_wmav2_decoder;
-extern AVCodec ff_wmavoice_decoder;
-extern AVCodec ff_ws_snd1_decoder;
-extern AVCodec ff_xma1_decoder;
-extern AVCodec ff_xma2_decoder;
+extern const AVCodec ff_aac_encoder;
+extern const AVCodec ff_aac_decoder;
+extern const AVCodec ff_aac_fixed_decoder;
+extern const AVCodec ff_aac_latm_decoder;
+extern const AVCodec ff_ac3_encoder;
+extern const AVCodec ff_ac3_decoder;
+extern const AVCodec ff_ac3_fixed_encoder;
+extern const AVCodec ff_ac3_fixed_decoder;
+extern const AVCodec ff_acelp_kelvin_decoder;
+extern const AVCodec ff_alac_encoder;
+extern const AVCodec ff_alac_decoder;
+extern const AVCodec ff_als_decoder;
+extern const AVCodec ff_amrnb_decoder;
+extern const AVCodec ff_amrwb_decoder;
+extern const AVCodec ff_ape_decoder;
+extern const AVCodec ff_aptx_encoder;
+extern const AVCodec ff_aptx_decoder;
+extern const AVCodec ff_aptx_hd_encoder;
+extern const AVCodec ff_aptx_hd_decoder;
+extern const AVCodec ff_atrac1_decoder;
+extern const AVCodec ff_atrac3_decoder;
+extern const AVCodec ff_atrac3al_decoder;
+extern const AVCodec ff_atrac3p_decoder;
+extern const AVCodec ff_atrac3pal_decoder;
+extern const AVCodec ff_atrac9_decoder;
+extern const AVCodec ff_binkaudio_dct_decoder;
+extern const AVCodec ff_binkaudio_rdft_decoder;
+extern const AVCodec ff_bmv_audio_decoder;
+extern const AVCodec ff_cook_decoder;
+extern const AVCodec ff_dca_encoder;
+extern const AVCodec ff_dca_decoder;
+extern const AVCodec ff_dolby_e_decoder;
+extern const AVCodec ff_dsd_lsbf_decoder;
+extern const AVCodec ff_dsd_msbf_decoder;
+extern const AVCodec ff_dsd_lsbf_planar_decoder;
+extern const AVCodec ff_dsd_msbf_planar_decoder;
+extern const AVCodec ff_dsicinaudio_decoder;
+extern const AVCodec ff_dss_sp_decoder;
+extern const AVCodec ff_dst_decoder;
+extern const AVCodec ff_eac3_encoder;
+extern const AVCodec ff_eac3_decoder;
+extern const AVCodec ff_evrc_decoder;
+extern const AVCodec ff_fastaudio_decoder;
+extern const AVCodec ff_ffwavesynth_decoder;
+extern const AVCodec ff_flac_encoder;
+extern const AVCodec ff_flac_decoder;
+extern const AVCodec ff_g723_1_encoder;
+extern const AVCodec ff_g723_1_decoder;
+extern const AVCodec ff_g729_decoder;
+extern const AVCodec ff_gsm_decoder;
+extern const AVCodec ff_gsm_ms_decoder;
+extern const AVCodec ff_hca_decoder;
+extern const AVCodec ff_hcom_decoder;
+extern const AVCodec ff_iac_decoder;
+extern const AVCodec ff_ilbc_decoder;
+extern const AVCodec ff_imc_decoder;
+extern const AVCodec ff_interplay_acm_decoder;
+extern const AVCodec ff_mace3_decoder;
+extern const AVCodec ff_mace6_decoder;
+extern const AVCodec ff_metasound_decoder;
+extern const AVCodec ff_mlp_encoder;
+extern const AVCodec ff_mlp_decoder;
+extern const AVCodec ff_mp1_decoder;
+extern const AVCodec ff_mp1float_decoder;
+extern const AVCodec ff_mp2_encoder;
+extern const AVCodec ff_mp2_decoder;
+extern const AVCodec ff_mp2float_decoder;
+extern const AVCodec ff_mp2fixed_encoder;
+extern const AVCodec ff_mp3float_decoder;
+extern const AVCodec ff_mp3_decoder;
+extern const AVCodec ff_mp3adufloat_decoder;
+extern const AVCodec ff_mp3adu_decoder;
+extern const AVCodec ff_mp3on4float_decoder;
+extern const AVCodec ff_mp3on4_decoder;
+extern const AVCodec ff_mpc7_decoder;
+extern const AVCodec ff_mpc8_decoder;
+extern const AVCodec ff_nellymoser_encoder;
+extern const AVCodec ff_nellymoser_decoder;
+extern const AVCodec ff_on2avc_decoder;
+extern const AVCodec ff_opus_encoder;
+extern const AVCodec ff_opus_decoder;
+extern const AVCodec ff_paf_audio_decoder;
+extern const AVCodec ff_qcelp_decoder;
+extern const AVCodec ff_qdm2_decoder;
+extern const AVCodec ff_qdmc_decoder;
+extern const AVCodec ff_ra_144_encoder;
+extern const AVCodec ff_ra_144_decoder;
+extern const AVCodec ff_ra_288_decoder;
+extern const AVCodec ff_ralf_decoder;
+extern const AVCodec ff_sbc_encoder;
+extern const AVCodec ff_sbc_decoder;
+extern const AVCodec ff_shorten_decoder;
+extern const AVCodec ff_sipr_decoder;
+extern const AVCodec ff_siren_decoder;
+extern const AVCodec ff_smackaud_decoder;
+extern const AVCodec ff_sonic_encoder;
+extern const AVCodec ff_sonic_decoder;
+extern const AVCodec ff_sonic_ls_encoder;
+extern const AVCodec ff_tak_decoder;
+extern const AVCodec ff_truehd_encoder;
+extern const AVCodec ff_truehd_decoder;
+extern const AVCodec ff_truespeech_decoder;
+extern const AVCodec ff_tta_encoder;
+extern const AVCodec ff_tta_decoder;
+extern const AVCodec ff_twinvq_decoder;
+extern const AVCodec ff_vmdaudio_decoder;
+extern const AVCodec ff_vorbis_encoder;
+extern const AVCodec ff_vorbis_decoder;
+extern const AVCodec ff_wavpack_encoder;
+extern const AVCodec ff_wavpack_decoder;
+extern const AVCodec ff_wmalossless_decoder;
+extern const AVCodec ff_wmapro_decoder;
+extern const AVCodec ff_wmav1_encoder;
+extern const AVCodec ff_wmav1_decoder;
+extern const AVCodec ff_wmav2_encoder;
+extern const AVCodec ff_wmav2_decoder;
+extern const AVCodec ff_wmavoice_decoder;
+extern const AVCodec ff_ws_snd1_decoder;
+extern const AVCodec ff_xma1_decoder;
+extern const AVCodec ff_xma2_decoder;
 
 /* PCM codecs */
-extern AVCodec ff_pcm_alaw_encoder;
-extern AVCodec ff_pcm_alaw_decoder;
-extern AVCodec ff_pcm_bluray_decoder;
-extern AVCodec ff_pcm_dvd_encoder;
-extern AVCodec ff_pcm_dvd_decoder;
-extern AVCodec ff_pcm_f16le_decoder;
-extern AVCodec ff_pcm_f24le_decoder;
-extern AVCodec ff_pcm_f32be_encoder;
-extern AVCodec ff_pcm_f32be_decoder;
-extern AVCodec ff_pcm_f32le_encoder;
-extern AVCodec ff_pcm_f32le_decoder;
-extern AVCodec ff_pcm_f64be_encoder;
-extern AVCodec ff_pcm_f64be_decoder;
-extern AVCodec ff_pcm_f64le_encoder;
-extern AVCodec ff_pcm_f64le_decoder;
-extern AVCodec ff_pcm_lxf_decoder;
-extern AVCodec ff_pcm_mulaw_encoder;
-extern AVCodec ff_pcm_mulaw_decoder;
-extern AVCodec ff_pcm_s8_encoder;
-extern AVCodec ff_pcm_s8_decoder;
-extern AVCodec ff_pcm_s8_planar_encoder;
-extern AVCodec ff_pcm_s8_planar_decoder;
-extern AVCodec ff_pcm_s16be_encoder;
-extern AVCodec ff_pcm_s16be_decoder;
-extern AVCodec ff_pcm_s16be_planar_encoder;
-extern AVCodec ff_pcm_s16be_planar_decoder;
-extern AVCodec ff_pcm_s16le_encoder;
-extern AVCodec ff_pcm_s16le_decoder;
-extern AVCodec ff_pcm_s16le_planar_encoder;
-extern AVCodec ff_pcm_s16le_planar_decoder;
-extern AVCodec ff_pcm_s24be_encoder;
-extern AVCodec ff_pcm_s24be_decoder;
-extern AVCodec ff_pcm_s24daud_encoder;
-extern AVCodec ff_pcm_s24daud_decoder;
-extern AVCodec ff_pcm_s24le_encoder;
-extern AVCodec ff_pcm_s24le_decoder;
-extern AVCodec ff_pcm_s24le_planar_encoder;
-extern AVCodec ff_pcm_s24le_planar_decoder;
-extern AVCodec ff_pcm_s32be_encoder;
-extern AVCodec ff_pcm_s32be_decoder;
-extern AVCodec ff_pcm_s32le_encoder;
-extern AVCodec ff_pcm_s32le_decoder;
-extern AVCodec ff_pcm_s32le_planar_encoder;
-extern AVCodec ff_pcm_s32le_planar_decoder;
-extern AVCodec ff_pcm_s64be_encoder;
-extern AVCodec ff_pcm_s64be_decoder;
-extern AVCodec ff_pcm_s64le_encoder;
-extern AVCodec ff_pcm_s64le_decoder;
-extern AVCodec ff_pcm_sga_decoder;
-extern AVCodec ff_pcm_u8_encoder;
-extern AVCodec ff_pcm_u8_decoder;
-extern AVCodec ff_pcm_u16be_encoder;
-extern AVCodec ff_pcm_u16be_decoder;
-extern AVCodec ff_pcm_u16le_encoder;
-extern AVCodec ff_pcm_u16le_decoder;
-extern AVCodec ff_pcm_u24be_encoder;
-extern AVCodec ff_pcm_u24be_decoder;
-extern AVCodec ff_pcm_u24le_encoder;
-extern AVCodec ff_pcm_u24le_decoder;
-extern AVCodec ff_pcm_u32be_encoder;
-extern AVCodec ff_pcm_u32be_decoder;
-extern AVCodec ff_pcm_u32le_encoder;
-extern AVCodec ff_pcm_u32le_decoder;
-extern AVCodec ff_pcm_vidc_encoder;
-extern AVCodec ff_pcm_vidc_decoder;
+extern const AVCodec ff_pcm_alaw_encoder;
+extern const AVCodec ff_pcm_alaw_decoder;
+extern const AVCodec ff_pcm_bluray_decoder;
+extern const AVCodec ff_pcm_dvd_encoder;
+extern const AVCodec ff_pcm_dvd_decoder;
+extern const AVCodec ff_pcm_f16le_decoder;
+extern const AVCodec ff_pcm_f24le_decoder;
+extern const AVCodec ff_pcm_f32be_encoder;
+extern const AVCodec ff_pcm_f32be_decoder;
+extern const AVCodec ff_pcm_f32le_encoder;
+extern const AVCodec ff_pcm_f32le_decoder;
+extern const AVCodec ff_pcm_f64be_encoder;
+extern const AVCodec ff_pcm_f64be_decoder;
+extern const AVCodec ff_pcm_f64le_encoder;
+extern const AVCodec ff_pcm_f64le_decoder;
+extern const AVCodec ff_pcm_lxf_decoder;
+extern const AVCodec ff_pcm_mulaw_encoder;
+extern const AVCodec ff_pcm_mulaw_decoder;
+extern const AVCodec ff_pcm_s8_encoder;
+extern const AVCodec ff_pcm_s8_decoder;
+extern const AVCodec ff_pcm_s8_planar_encoder;
+extern const AVCodec ff_pcm_s8_planar_decoder;
+extern const AVCodec ff_pcm_s16be_encoder;
+extern const AVCodec ff_pcm_s16be_decoder;
+extern const AVCodec ff_pcm_s16be_planar_encoder;
+extern const AVCodec ff_pcm_s16be_planar_decoder;
+extern const AVCodec ff_pcm_s16le_encoder;
+extern const AVCodec ff_pcm_s16le_decoder;
+extern const AVCodec ff_pcm_s16le_planar_encoder;
+extern const AVCodec ff_pcm_s16le_planar_decoder;
+extern const AVCodec ff_pcm_s24be_encoder;
+extern const AVCodec ff_pcm_s24be_decoder;
+extern const AVCodec ff_pcm_s24daud_encoder;
+extern const AVCodec ff_pcm_s24daud_decoder;
+extern const AVCodec ff_pcm_s24le_encoder;
+extern const AVCodec ff_pcm_s24le_decoder;
+extern const AVCodec ff_pcm_s24le_planar_encoder;
+extern const AVCodec ff_pcm_s24le_planar_decoder;
+extern const AVCodec ff_pcm_s32be_encoder;
+extern const AVCodec ff_pcm_s32be_decoder;
+extern const AVCodec ff_pcm_s32le_encoder;
+extern const AVCodec ff_pcm_s32le_decoder;
+extern const AVCodec ff_pcm_s32le_planar_encoder;
+extern const AVCodec ff_pcm_s32le_planar_decoder;
+extern const AVCodec ff_pcm_s64be_encoder;
+extern const AVCodec ff_pcm_s64be_decoder;
+extern const AVCodec ff_pcm_s64le_encoder;
+extern const AVCodec ff_pcm_s64le_decoder;
+extern const AVCodec ff_pcm_sga_decoder;
+extern const AVCodec ff_pcm_u8_encoder;
+extern const AVCodec ff_pcm_u8_decoder;
+extern const AVCodec ff_pcm_u16be_encoder;
+extern const AVCodec ff_pcm_u16be_decoder;
+extern const AVCodec ff_pcm_u16le_encoder;
+extern const AVCodec ff_pcm_u16le_decoder;
+extern const AVCodec ff_pcm_u24be_encoder;
+extern const AVCodec ff_pcm_u24be_decoder;
+extern const AVCodec ff_pcm_u24le_encoder;
+extern const AVCodec ff_pcm_u24le_decoder;
+extern const AVCodec ff_pcm_u32be_encoder;
+extern const AVCodec ff_pcm_u32be_decoder;
+extern const AVCodec ff_pcm_u32le_encoder;
+extern const AVCodec ff_pcm_u32le_decoder;
+extern const AVCodec ff_pcm_vidc_encoder;
+extern const AVCodec ff_pcm_vidc_decoder;
 
 /* DPCM codecs */
-extern AVCodec ff_derf_dpcm_decoder;
-extern AVCodec ff_gremlin_dpcm_decoder;
-extern AVCodec ff_interplay_dpcm_decoder;
-extern AVCodec ff_roq_dpcm_encoder;
-extern AVCodec ff_roq_dpcm_decoder;
-extern AVCodec ff_sdx2_dpcm_decoder;
-extern AVCodec ff_sol_dpcm_decoder;
-extern AVCodec ff_xan_dpcm_decoder;
+extern const AVCodec ff_derf_dpcm_decoder;
+extern const AVCodec ff_gremlin_dpcm_decoder;
+extern const AVCodec ff_interplay_dpcm_decoder;
+extern const AVCodec ff_roq_dpcm_encoder;
+extern const AVCodec ff_roq_dpcm_decoder;
+extern const AVCodec ff_sdx2_dpcm_decoder;
+extern const AVCodec ff_sol_dpcm_decoder;
+extern const AVCodec ff_xan_dpcm_decoder;
 
 /* ADPCM codecs */
-extern AVCodec ff_adpcm_4xm_decoder;
-extern AVCodec ff_adpcm_adx_encoder;
-extern AVCodec ff_adpcm_adx_decoder;
-extern AVCodec ff_adpcm_afc_decoder;
-extern AVCodec ff_adpcm_agm_decoder;
-extern AVCodec ff_adpcm_aica_decoder;
-extern AVCodec ff_adpcm_argo_decoder;
-extern AVCodec ff_adpcm_argo_encoder;
-extern AVCodec ff_adpcm_ct_decoder;
-extern AVCodec ff_adpcm_dtk_decoder;
-extern AVCodec ff_adpcm_ea_decoder;
-extern AVCodec ff_adpcm_ea_maxis_xa_decoder;
-extern AVCodec ff_adpcm_ea_r1_decoder;
-extern AVCodec ff_adpcm_ea_r2_decoder;
-extern AVCodec ff_adpcm_ea_r3_decoder;
-extern AVCodec ff_adpcm_ea_xas_decoder;
-extern AVCodec ff_adpcm_g722_encoder;
-extern AVCodec ff_adpcm_g722_decoder;
-extern AVCodec ff_adpcm_g726_encoder;
-extern AVCodec ff_adpcm_g726_decoder;
-extern AVCodec ff_adpcm_g726le_encoder;
-extern AVCodec ff_adpcm_g726le_decoder;
-extern AVCodec ff_adpcm_ima_amv_decoder;
-extern AVCodec ff_adpcm_ima_amv_encoder;
-extern AVCodec ff_adpcm_ima_alp_decoder;
-extern AVCodec ff_adpcm_ima_alp_encoder;
-extern AVCodec ff_adpcm_ima_apc_decoder;
-extern AVCodec ff_adpcm_ima_apm_decoder;
-extern AVCodec ff_adpcm_ima_apm_encoder;
-extern AVCodec ff_adpcm_ima_cunning_decoder;
-extern AVCodec ff_adpcm_ima_dat4_decoder;
-extern AVCodec ff_adpcm_ima_dk3_decoder;
-extern AVCodec ff_adpcm_ima_dk4_decoder;
-extern AVCodec ff_adpcm_ima_ea_eacs_decoder;
-extern AVCodec ff_adpcm_ima_ea_sead_decoder;
-extern AVCodec ff_adpcm_ima_iss_decoder;
-extern AVCodec ff_adpcm_ima_moflex_decoder;
-extern AVCodec ff_adpcm_ima_mtf_decoder;
-extern AVCodec ff_adpcm_ima_oki_decoder;
-extern AVCodec ff_adpcm_ima_qt_encoder;
-extern AVCodec ff_adpcm_ima_qt_decoder;
-extern AVCodec ff_adpcm_ima_rad_decoder;
-extern AVCodec ff_adpcm_ima_ssi_decoder;
-extern AVCodec ff_adpcm_ima_ssi_encoder;
-extern AVCodec ff_adpcm_ima_smjpeg_decoder;
-extern AVCodec ff_adpcm_ima_wav_encoder;
-extern AVCodec ff_adpcm_ima_wav_decoder;
-extern AVCodec ff_adpcm_ima_ws_decoder;
-extern AVCodec ff_adpcm_ms_encoder;
-extern AVCodec ff_adpcm_ms_decoder;
-extern AVCodec ff_adpcm_mtaf_decoder;
-extern AVCodec ff_adpcm_psx_decoder;
-extern AVCodec ff_adpcm_sbpro_2_decoder;
-extern AVCodec ff_adpcm_sbpro_3_decoder;
-extern AVCodec ff_adpcm_sbpro_4_decoder;
-extern AVCodec ff_adpcm_swf_encoder;
-extern AVCodec ff_adpcm_swf_decoder;
-extern AVCodec ff_adpcm_thp_decoder;
-extern AVCodec ff_adpcm_thp_le_decoder;
-extern AVCodec ff_adpcm_vima_decoder;
-extern AVCodec ff_adpcm_xa_decoder;
-extern AVCodec ff_adpcm_yamaha_encoder;
-extern AVCodec ff_adpcm_yamaha_decoder;
-extern AVCodec ff_adpcm_zork_decoder;
+extern const AVCodec ff_adpcm_4xm_decoder;
+extern const AVCodec ff_adpcm_adx_encoder;
+extern const AVCodec ff_adpcm_adx_decoder;
+extern const AVCodec ff_adpcm_afc_decoder;
+extern const AVCodec ff_adpcm_agm_decoder;
+extern const AVCodec ff_adpcm_aica_decoder;
+extern const AVCodec ff_adpcm_argo_decoder;
+extern const AVCodec ff_adpcm_argo_encoder;
+extern const AVCodec ff_adpcm_ct_decoder;
+extern const AVCodec ff_adpcm_dtk_decoder;
+extern const AVCodec ff_adpcm_ea_decoder;
+extern const AVCodec ff_adpcm_ea_maxis_xa_decoder;
+extern const AVCodec ff_adpcm_ea_r1_decoder;
+extern const AVCodec ff_adpcm_ea_r2_decoder;
+extern const AVCodec ff_adpcm_ea_r3_decoder;
+extern const AVCodec ff_adpcm_ea_xas_decoder;
+extern const AVCodec ff_adpcm_g722_encoder;
+extern const AVCodec ff_adpcm_g722_decoder;
+extern const AVCodec ff_adpcm_g726_encoder;
+extern const AVCodec ff_adpcm_g726_decoder;
+extern const AVCodec ff_adpcm_g726le_encoder;
+extern const AVCodec ff_adpcm_g726le_decoder;
+extern const AVCodec ff_adpcm_ima_amv_decoder;
+extern const AVCodec ff_adpcm_ima_amv_encoder;
+extern const AVCodec ff_adpcm_ima_alp_decoder;
+extern const AVCodec ff_adpcm_ima_alp_encoder;
+extern const AVCodec ff_adpcm_ima_apc_decoder;
+extern const AVCodec ff_adpcm_ima_apm_decoder;
+extern const AVCodec ff_adpcm_ima_apm_encoder;
+extern const AVCodec ff_adpcm_ima_cunning_decoder;
+extern const AVCodec ff_adpcm_ima_dat4_decoder;
+extern const AVCodec ff_adpcm_ima_dk3_decoder;
+extern const AVCodec ff_adpcm_ima_dk4_decoder;
+extern const AVCodec ff_adpcm_ima_ea_eacs_decoder;
+extern const AVCodec ff_adpcm_ima_ea_sead_decoder;
+extern const AVCodec ff_adpcm_ima_iss_decoder;
+extern const AVCodec ff_adpcm_ima_moflex_decoder;
+extern const AVCodec ff_adpcm_ima_mtf_decoder;
+extern const AVCodec ff_adpcm_ima_oki_decoder;
+extern const AVCodec ff_adpcm_ima_qt_encoder;
+extern const AVCodec ff_adpcm_ima_qt_decoder;
+extern const AVCodec ff_adpcm_ima_rad_decoder;
+extern const AVCodec ff_adpcm_ima_ssi_decoder;
+extern const AVCodec ff_adpcm_ima_ssi_encoder;
+extern const AVCodec ff_adpcm_ima_smjpeg_decoder;
+extern const AVCodec ff_adpcm_ima_wav_encoder;
+extern const AVCodec ff_adpcm_ima_wav_decoder;
+extern const AVCodec ff_adpcm_ima_ws_decoder;
+extern const AVCodec ff_adpcm_ms_encoder;
+extern const AVCodec ff_adpcm_ms_decoder;
+extern const AVCodec ff_adpcm_mtaf_decoder;
+extern const AVCodec ff_adpcm_psx_decoder;
+extern const AVCodec ff_adpcm_sbpro_2_decoder;
+extern const AVCodec ff_adpcm_sbpro_3_decoder;
+extern const AVCodec ff_adpcm_sbpro_4_decoder;
+extern const AVCodec ff_adpcm_swf_encoder;
+extern const AVCodec ff_adpcm_swf_decoder;
+extern const AVCodec ff_adpcm_thp_decoder;
+extern const AVCodec ff_adpcm_thp_le_decoder;
+extern const AVCodec ff_adpcm_vima_decoder;
+extern const AVCodec ff_adpcm_xa_decoder;
+extern const AVCodec ff_adpcm_yamaha_encoder;
+extern const AVCodec ff_adpcm_yamaha_decoder;
+extern const AVCodec ff_adpcm_zork_decoder;
 
 /* subtitles */
-extern AVCodec ff_ssa_encoder;
-extern AVCodec ff_ssa_decoder;
-extern AVCodec ff_ass_encoder;
-extern AVCodec ff_ass_decoder;
-extern AVCodec ff_ccaption_decoder;
-extern AVCodec ff_dvbsub_encoder;
-extern AVCodec ff_dvbsub_decoder;
-extern AVCodec ff_dvdsub_encoder;
-extern AVCodec ff_dvdsub_decoder;
-extern AVCodec ff_jacosub_decoder;
-extern AVCodec ff_microdvd_decoder;
-extern AVCodec ff_movtext_encoder;
-extern AVCodec ff_movtext_decoder;
-extern AVCodec ff_mpl2_decoder;
-extern AVCodec ff_pgssub_decoder;
-extern AVCodec ff_pjs_decoder;
-extern AVCodec ff_realtext_decoder;
-extern AVCodec ff_sami_decoder;
-extern AVCodec ff_srt_encoder;
-extern AVCodec ff_srt_decoder;
-extern AVCodec ff_stl_decoder;
-extern AVCodec ff_subrip_encoder;
-extern AVCodec ff_subrip_decoder;
-extern AVCodec ff_subviewer_decoder;
-extern AVCodec ff_subviewer1_decoder;
-extern AVCodec ff_text_encoder;
-extern AVCodec ff_text_decoder;
-extern AVCodec ff_ttml_encoder;
-extern AVCodec ff_vplayer_decoder;
-extern AVCodec ff_webvtt_encoder;
-extern AVCodec ff_webvtt_decoder;
-extern AVCodec ff_xsub_encoder;
-extern AVCodec ff_xsub_decoder;
+extern const AVCodec ff_ssa_encoder;
+extern const AVCodec ff_ssa_decoder;
+extern const AVCodec ff_ass_encoder;
+extern const AVCodec ff_ass_decoder;
+extern const AVCodec ff_ccaption_decoder;
+extern const AVCodec ff_dvbsub_encoder;
+extern const AVCodec ff_dvbsub_decoder;
+extern const AVCodec ff_dvdsub_encoder;
+extern const AVCodec ff_dvdsub_decoder;
+extern const AVCodec ff_jacosub_decoder;
+extern const AVCodec ff_microdvd_decoder;
+extern const AVCodec ff_movtext_encoder;
+extern const AVCodec ff_movtext_decoder;
+extern const AVCodec ff_mpl2_decoder;
+extern const AVCodec ff_pgssub_decoder;
+extern const AVCodec ff_pjs_decoder;
+extern const AVCodec ff_realtext_decoder;
+extern const AVCodec ff_sami_decoder;
+extern const AVCodec ff_srt_encoder;
+extern const AVCodec ff_srt_decoder;
+extern const AVCodec ff_stl_decoder;
+extern const AVCodec ff_subrip_encoder;
+extern const AVCodec ff_subrip_decoder;
+extern const AVCodec ff_subviewer_decoder;
+extern const AVCodec ff_subviewer1_decoder;
+extern const AVCodec ff_text_encoder;
+extern const AVCodec ff_text_decoder;
+extern const AVCodec ff_ttml_encoder;
+extern const AVCodec ff_vplayer_decoder;
+extern const AVCodec ff_webvtt_encoder;
+extern const AVCodec ff_webvtt_decoder;
+extern const AVCodec ff_xsub_encoder;
+extern const AVCodec ff_xsub_decoder;
 
 /* external libraries */
-extern AVCodec ff_aac_at_encoder;
-extern AVCodec ff_aac_at_decoder;
-extern AVCodec ff_ac3_at_decoder;
-extern AVCodec ff_adpcm_ima_qt_at_decoder;
-extern AVCodec ff_alac_at_encoder;
-extern AVCodec ff_alac_at_decoder;
-extern AVCodec ff_amr_nb_at_decoder;
-extern AVCodec ff_eac3_at_decoder;
-extern AVCodec ff_gsm_ms_at_decoder;
-extern AVCodec ff_ilbc_at_encoder;
-extern AVCodec ff_ilbc_at_decoder;
-extern AVCodec ff_mp1_at_decoder;
-extern AVCodec ff_mp2_at_decoder;
-extern AVCodec ff_mp3_at_decoder;
-extern AVCodec ff_pcm_alaw_at_encoder;
-extern AVCodec ff_pcm_alaw_at_decoder;
-extern AVCodec ff_pcm_mulaw_at_encoder;
-extern AVCodec ff_pcm_mulaw_at_decoder;
-extern AVCodec ff_qdmc_at_decoder;
-extern AVCodec ff_qdm2_at_decoder;
+extern const AVCodec ff_aac_at_encoder;
+extern const AVCodec ff_aac_at_decoder;
+extern const AVCodec ff_ac3_at_decoder;
+extern const AVCodec ff_adpcm_ima_qt_at_decoder;
+extern const AVCodec ff_alac_at_encoder;
+extern const AVCodec ff_alac_at_decoder;
+extern const AVCodec ff_amr_nb_at_decoder;
+extern const AVCodec ff_eac3_at_decoder;
+extern const AVCodec ff_gsm_ms_at_decoder;
+extern const AVCodec ff_ilbc_at_encoder;
+extern const AVCodec ff_ilbc_at_decoder;
+extern const AVCodec ff_mp1_at_decoder;
+extern const AVCodec ff_mp2_at_decoder;
+extern const AVCodec ff_mp3_at_decoder;
+extern const AVCodec ff_pcm_alaw_at_encoder;
+extern const AVCodec ff_pcm_alaw_at_decoder;
+extern const AVCodec ff_pcm_mulaw_at_encoder;
+extern const AVCodec ff_pcm_mulaw_at_decoder;
+extern const AVCodec ff_qdmc_at_decoder;
+extern const AVCodec ff_qdm2_at_decoder;
 extern AVCodec ff_libaom_av1_encoder;
-extern AVCodec ff_libaribb24_decoder;
-extern AVCodec ff_libcelt_decoder;
-extern AVCodec ff_libcodec2_encoder;
-extern AVCodec ff_libcodec2_decoder;
-extern AVCodec ff_libdav1d_decoder;
-extern AVCodec ff_libdavs2_decoder;
-extern AVCodec ff_libfdk_aac_encoder;
-extern AVCodec ff_libfdk_aac_decoder;
-extern AVCodec ff_libgsm_encoder;
-extern AVCodec ff_libgsm_decoder;
-extern AVCodec ff_libgsm_ms_encoder;
-extern AVCodec ff_libgsm_ms_decoder;
-extern AVCodec ff_libilbc_encoder;
-extern AVCodec ff_libilbc_decoder;
-extern AVCodec ff_libmp3lame_encoder;
-extern AVCodec ff_libopencore_amrnb_encoder;
-extern AVCodec ff_libopencore_amrnb_decoder;
-extern AVCodec ff_libopencore_amrwb_decoder;
-extern AVCodec ff_libopenjpeg_encoder;
-extern AVCodec ff_libopenjpeg_decoder;
-extern AVCodec ff_libopus_encoder;
-extern AVCodec ff_libopus_decoder;
-extern AVCodec ff_librav1e_encoder;
-extern AVCodec ff_librsvg_decoder;
-extern AVCodec ff_libshine_encoder;
-extern AVCodec ff_libspeex_encoder;
-extern AVCodec ff_libspeex_decoder;
-extern AVCodec ff_libsvtav1_encoder;
-extern AVCodec ff_libtheora_encoder;
-extern AVCodec ff_libtwolame_encoder;
-extern AVCodec ff_libuavs3d_decoder;
-extern AVCodec ff_libvo_amrwbenc_encoder;
-extern AVCodec ff_libvorbis_encoder;
-extern AVCodec ff_libvorbis_decoder;
-extern AVCodec ff_libvpx_vp8_encoder;
-extern AVCodec ff_libvpx_vp8_decoder;
+extern const AVCodec ff_libaribb24_decoder;
+extern const AVCodec ff_libcelt_decoder;
+extern const AVCodec ff_libcodec2_encoder;
+extern const AVCodec ff_libcodec2_decoder;
+extern const AVCodec ff_libdav1d_decoder;
+extern const AVCodec ff_libdavs2_decoder;
+extern const AVCodec ff_libfdk_aac_encoder;
+extern const AVCodec ff_libfdk_aac_decoder;
+extern const AVCodec ff_libgsm_encoder;
+extern const AVCodec ff_libgsm_decoder;
+extern const AVCodec ff_libgsm_ms_encoder;
+extern const AVCodec ff_libgsm_ms_decoder;
+extern const AVCodec ff_libilbc_encoder;
+extern const AVCodec ff_libilbc_decoder;
+extern const AVCodec ff_libmp3lame_encoder;
+extern const AVCodec ff_libopencore_amrnb_encoder;
+extern const AVCodec ff_libopencore_amrnb_decoder;
+extern const AVCodec ff_libopencore_amrwb_decoder;
+extern const AVCodec ff_libopenjpeg_encoder;
+extern const AVCodec ff_libopenjpeg_decoder;
+extern const AVCodec ff_libopus_encoder;
+extern const AVCodec ff_libopus_decoder;
+extern const AVCodec ff_librav1e_encoder;
+extern const AVCodec ff_librsvg_decoder;
+extern const AVCodec ff_libshine_encoder;
+extern const AVCodec ff_libspeex_encoder;
+extern const AVCodec ff_libspeex_decoder;
+extern const AVCodec ff_libsvtav1_encoder;
+extern const AVCodec ff_libtheora_encoder;
+extern const AVCodec ff_libtwolame_encoder;
+extern const AVCodec ff_libuavs3d_decoder;
+extern const AVCodec ff_libvo_amrwbenc_encoder;
+extern const AVCodec ff_libvorbis_encoder;
+extern const AVCodec ff_libvorbis_decoder;
+extern const AVCodec ff_libvpx_vp8_encoder;
+extern const AVCodec ff_libvpx_vp8_decoder;
 extern AVCodec ff_libvpx_vp9_encoder;
 extern AVCodec ff_libvpx_vp9_decoder;
 /* preferred over libwebp */
-extern AVCodec ff_libwebp_anim_encoder;
-extern AVCodec ff_libwebp_encoder;
-extern AVCodec ff_libx262_encoder;
+extern const AVCodec ff_libwebp_anim_encoder;
+extern const AVCodec ff_libwebp_encoder;
+extern const AVCodec ff_libx262_encoder;
+#if CONFIG_LIBX264_ENCODER
+#include <x264.h>
+#if X264_BUILD < 153
 extern AVCodec ff_libx264_encoder;
-extern AVCodec ff_libx264rgb_encoder;
+#else
+extern const AVCodec ff_libx264_encoder;
+#endif
+#endif
+extern const AVCodec ff_libx264rgb_encoder;
 extern AVCodec ff_libx265_encoder;
-extern AVCodec ff_libxavs_encoder;
-extern AVCodec ff_libxavs2_encoder;
-extern AVCodec ff_libxvid_encoder;
-extern AVCodec ff_libzvbi_teletext_decoder;
+extern const AVCodec ff_libxavs_encoder;
+extern const AVCodec ff_libxavs2_encoder;
+extern const AVCodec ff_libxvid_encoder;
+extern const AVCodec ff_libzvbi_teletext_decoder;
 
 /* text */
-extern AVCodec ff_bintext_decoder;
-extern AVCodec ff_xbin_decoder;
-extern AVCodec ff_idf_decoder;
+extern const AVCodec ff_bintext_decoder;
+extern const AVCodec ff_xbin_decoder;
+extern const AVCodec ff_idf_decoder;
 
 /* external libraries, that shouldn't be used by default if one of the
  * above is available */
-extern AVCodec ff_aac_mf_encoder;
-extern AVCodec ff_ac3_mf_encoder;
-extern AVCodec ff_h263_v4l2m2m_encoder;
-extern AVCodec ff_libaom_av1_decoder;
+extern const AVCodec ff_aac_mf_encoder;
+extern const AVCodec ff_ac3_mf_encoder;
+extern const AVCodec ff_h263_v4l2m2m_encoder;
+extern const AVCodec ff_libaom_av1_decoder;
 /* hwaccel hooks only, so prefer external decoders */
-extern AVCodec ff_av1_decoder;
-extern AVCodec ff_av1_cuvid_decoder;
-extern AVCodec ff_av1_qsv_decoder;
-extern AVCodec ff_libopenh264_encoder;
-extern AVCodec ff_libopenh264_decoder;
-extern AVCodec ff_h264_amf_encoder;
-extern AVCodec ff_h264_cuvid_decoder;
-extern AVCodec ff_h264_mf_encoder;
-extern AVCodec ff_h264_nvenc_encoder;
-extern AVCodec ff_h264_omx_encoder;
-extern AVCodec ff_h264_qsv_encoder;
-extern AVCodec ff_h264_v4l2m2m_encoder;
-extern AVCodec ff_h264_vaapi_encoder;
-extern AVCodec ff_h264_videotoolbox_encoder;
-extern AVCodec ff_hevc_amf_encoder;
-extern AVCodec ff_hevc_cuvid_decoder;
-extern AVCodec ff_hevc_mediacodec_decoder;
-extern AVCodec ff_hevc_mf_encoder;
-extern AVCodec ff_hevc_nvenc_encoder;
-extern AVCodec ff_hevc_qsv_encoder;
-extern AVCodec ff_hevc_v4l2m2m_encoder;
-extern AVCodec ff_hevc_vaapi_encoder;
-extern AVCodec ff_hevc_videotoolbox_encoder;
-extern AVCodec ff_libkvazaar_encoder;
-extern AVCodec ff_mjpeg_cuvid_decoder;
-extern AVCodec ff_mjpeg_qsv_encoder;
-extern AVCodec ff_mjpeg_qsv_decoder;
-extern AVCodec ff_mjpeg_vaapi_encoder;
-extern AVCodec ff_mp3_mf_encoder;
-extern AVCodec ff_mpeg1_cuvid_decoder;
-extern AVCodec ff_mpeg2_cuvid_decoder;
-extern AVCodec ff_mpeg2_qsv_encoder;
-extern AVCodec ff_mpeg2_vaapi_encoder;
-extern AVCodec ff_mpeg4_cuvid_decoder;
-extern AVCodec ff_mpeg4_mediacodec_decoder;
-extern AVCodec ff_mpeg4_omx_encoder;
-extern AVCodec ff_mpeg4_v4l2m2m_encoder;
-extern AVCodec ff_vc1_cuvid_decoder;
-extern AVCodec ff_vp8_cuvid_decoder;
-extern AVCodec ff_vp8_mediacodec_decoder;
-extern AVCodec ff_vp8_qsv_decoder;
-extern AVCodec ff_vp8_v4l2m2m_encoder;
-extern AVCodec ff_vp8_vaapi_encoder;
-extern AVCodec ff_vp9_cuvid_decoder;
-extern AVCodec ff_vp9_mediacodec_decoder;
-extern AVCodec ff_vp9_qsv_decoder;
-extern AVCodec ff_vp9_vaapi_encoder;
-extern AVCodec ff_vp9_qsv_encoder;
+extern const AVCodec ff_av1_decoder;
+extern const AVCodec ff_av1_cuvid_decoder;
+extern const AVCodec ff_av1_qsv_decoder;
+extern const AVCodec ff_libopenh264_encoder;
+extern const AVCodec ff_libopenh264_decoder;
+extern const AVCodec ff_h264_amf_encoder;
+extern const AVCodec ff_h264_cuvid_decoder;
+extern const AVCodec ff_h264_mf_encoder;
+extern const AVCodec ff_h264_nvenc_encoder;
+extern const AVCodec ff_h264_omx_encoder;
+extern const AVCodec ff_h264_qsv_encoder;
+extern const AVCodec ff_h264_v4l2m2m_encoder;
+extern const AVCodec ff_h264_vaapi_encoder;
+extern const AVCodec ff_h264_videotoolbox_encoder;
+extern const AVCodec ff_hevc_amf_encoder;
+extern const AVCodec ff_hevc_cuvid_decoder;
+extern const AVCodec ff_hevc_mediacodec_decoder;
+extern const AVCodec ff_hevc_mf_encoder;
+extern const AVCodec ff_hevc_nvenc_encoder;
+extern const AVCodec ff_hevc_qsv_encoder;
+extern const AVCodec ff_hevc_v4l2m2m_encoder;
+extern const AVCodec ff_hevc_vaapi_encoder;
+extern const AVCodec ff_hevc_videotoolbox_encoder;
+extern const AVCodec ff_libkvazaar_encoder;
+extern const AVCodec ff_mjpeg_cuvid_decoder;
+extern const AVCodec ff_mjpeg_qsv_encoder;
+extern const AVCodec ff_mjpeg_qsv_decoder;
+extern const AVCodec ff_mjpeg_vaapi_encoder;
+extern const AVCodec ff_mp3_mf_encoder;
+extern const AVCodec ff_mpeg1_cuvid_decoder;
+extern const AVCodec ff_mpeg2_cuvid_decoder;
+extern const AVCodec ff_mpeg2_qsv_encoder;
+extern const AVCodec ff_mpeg2_vaapi_encoder;
+extern const AVCodec ff_mpeg4_cuvid_decoder;
+extern const AVCodec ff_mpeg4_mediacodec_decoder;
+extern const AVCodec ff_mpeg4_omx_encoder;
+extern const AVCodec ff_mpeg4_v4l2m2m_encoder;
+extern const AVCodec ff_vc1_cuvid_decoder;
+extern const AVCodec ff_vp8_cuvid_decoder;
+extern const AVCodec ff_vp8_mediacodec_decoder;
+extern const AVCodec ff_vp8_qsv_decoder;
+extern const AVCodec ff_vp8_v4l2m2m_encoder;
+extern const AVCodec ff_vp8_vaapi_encoder;
+extern const AVCodec ff_vp9_cuvid_decoder;
+extern const AVCodec ff_vp9_mediacodec_decoder;
+extern const AVCodec ff_vp9_qsv_decoder;
+extern const AVCodec ff_vp9_vaapi_encoder;
+extern const AVCodec ff_vp9_qsv_encoder;
 
 // The iterate API is not usable with ossfuzz due to the excessive size of binaries created
 #if CONFIG_OSSFUZZ
-AVCodec * codec_list[] = {
+const AVCodec * codec_list[] = {
     NULL,
     NULL,
     NULL
diff --git a/libavcodec/alsdec.c b/libavcodec/alsdec.c
index a8c3433fa8..0aada77450 100644
--- a/libavcodec/alsdec.c
+++ b/libavcodec/alsdec.c
@@ -2173,7 +2173,7 @@ static av_cold void flush(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_als_decoder = {
+const AVCodec ff_als_decoder = {
     .name           = "als",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/amfenc_h264.c b/libavcodec/amfenc_h264.c
index fe30d7f11d..aeca99f7c6 100644
--- a/libavcodec/amfenc_h264.c
+++ b/libavcodec/amfenc_h264.c
@@ -377,7 +377,7 @@ static const AVClass h264_amf_class = {
     .version = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_h264_amf_encoder = {
+const AVCodec ff_h264_amf_encoder = {
     .name           = "h264_amf",
     .long_name      = NULL_IF_CONFIG_SMALL("AMD AMF H.264 Encoder"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/amfenc_hevc.c b/libavcodec/amfenc_hevc.c
index b5c840e5f3..79541b9b2f 100644
--- a/libavcodec/amfenc_hevc.c
+++ b/libavcodec/amfenc_hevc.c
@@ -309,7 +309,7 @@ static const AVClass hevc_amf_class = {
     .version = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_hevc_amf_encoder = {
+const AVCodec ff_hevc_amf_encoder = {
     .name           = "hevc_amf",
     .long_name      = NULL_IF_CONFIG_SMALL("AMD AMF HEVC encoder"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/amrnbdec.c b/libavcodec/amrnbdec.c
index 8e02d4cb20..e366a09976 100644
--- a/libavcodec/amrnbdec.c
+++ b/libavcodec/amrnbdec.c
@@ -1080,7 +1080,7 @@ static int amrnb_decode_frame(AVCodecContext *avctx, void *data,
 }
 
 
-AVCodec ff_amrnb_decoder = {
+const AVCodec ff_amrnb_decoder = {
     .name           = "amrnb",
     .long_name      = NULL_IF_CONFIG_SMALL("AMR-NB (Adaptive Multi-Rate NarrowBand)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/amrwbdec.c b/libavcodec/amrwbdec.c
index 070f276904..a6c1d894d7 100644
--- a/libavcodec/amrwbdec.c
+++ b/libavcodec/amrwbdec.c
@@ -1275,7 +1275,7 @@ static int amrwb_decode_frame(AVCodecContext *avctx, void *data,
     return expected_fr_size;
 }
 
-AVCodec ff_amrwb_decoder = {
+const AVCodec ff_amrwb_decoder = {
     .name           = "amrwb",
     .long_name      = NULL_IF_CONFIG_SMALL("AMR-WB (Adaptive Multi-Rate WideBand)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/anm.c b/libavcodec/anm.c
index 134640ee36..494903235d 100644
--- a/libavcodec/anm.c
+++ b/libavcodec/anm.c
@@ -189,7 +189,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_anm_decoder = {
+const AVCodec ff_anm_decoder = {
     .name           = "anm",
     .long_name      = NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ansi.c b/libavcodec/ansi.c
index 3a461eec26..0965f8cd56 100644
--- a/libavcodec/ansi.c
+++ b/libavcodec/ansi.c
@@ -480,7 +480,7 @@ static const AVCodecDefault ansi_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_ansi_decoder = {
+const AVCodec ff_ansi_decoder = {
     .name           = "ansi",
     .long_name      = NULL_IF_CONFIG_SMALL("ASCII/ANSI art"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/apedec.c b/libavcodec/apedec.c
index e0c6b6bb8b..022a6f9398 100644
--- a/libavcodec/apedec.c
+++ b/libavcodec/apedec.c
@@ -1655,7 +1655,7 @@ static const AVClass ape_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_ape_decoder = {
+const AVCodec ff_ape_decoder = {
     .name           = "ape",
     .long_name      = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/aptxdec.c b/libavcodec/aptxdec.c
index 3bbf0104df..e7e5459bbf 100644
--- a/libavcodec/aptxdec.c
+++ b/libavcodec/aptxdec.c
@@ -170,7 +170,7 @@ static int aptx_decode_frame(AVCodecContext *avctx, void *data,
 }
 
 #if CONFIG_APTX_DECODER
-AVCodec ff_aptx_decoder = {
+const AVCodec ff_aptx_decoder = {
     .name                  = "aptx",
     .long_name             = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
@@ -187,7 +187,7 @@ AVCodec ff_aptx_decoder = {
 #endif
 
 #if CONFIG_APTX_HD_DECODER
-AVCodec ff_aptx_hd_decoder = {
+const AVCodec ff_aptx_hd_decoder = {
     .name                  = "aptx_hd",
     .long_name             = NULL_IF_CONFIG_SMALL("aptX HD (Audio Processing Technology for Bluetooth)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/aptxenc.c b/libavcodec/aptxenc.c
index 60de73ec28..f432a123d0 100644
--- a/libavcodec/aptxenc.c
+++ b/libavcodec/aptxenc.c
@@ -240,7 +240,7 @@ static av_cold int aptx_close(AVCodecContext *avctx)
 }
 
 #if CONFIG_APTX_ENCODER
-AVCodec ff_aptx_encoder = {
+const AVCodec ff_aptx_encoder = {
     .name                  = "aptx",
     .long_name             = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
@@ -259,7 +259,7 @@ AVCodec ff_aptx_encoder = {
 #endif
 
 #if CONFIG_APTX_HD_ENCODER
-AVCodec ff_aptx_hd_encoder = {
+const AVCodec ff_aptx_hd_encoder = {
     .name                  = "aptx_hd",
     .long_name             = NULL_IF_CONFIG_SMALL("aptX HD (Audio Processing Technology for Bluetooth)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/arbc.c b/libavcodec/arbc.c
index 06970f140b..c4fc30e047 100644
--- a/libavcodec/arbc.c
+++ b/libavcodec/arbc.c
@@ -212,7 +212,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_arbc_decoder = {
+const AVCodec ff_arbc_decoder = {
     .name           = "arbc",
     .long_name      = NULL_IF_CONFIG_SMALL("Gryphon's Anim Compressor"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/argo.c b/libavcodec/argo.c
index 7358d102e3..0df66f1cee 100644
--- a/libavcodec/argo.c
+++ b/libavcodec/argo.c
@@ -725,7 +725,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_argo_decoder = {
+const AVCodec ff_argo_decoder = {
     .name           = "argo",
     .long_name      = NULL_IF_CONFIG_SMALL("Argonaut Games Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/assdec.c b/libavcodec/assdec.c
index f0b1069cd2..3b1a119496 100644
--- a/libavcodec/assdec.c
+++ b/libavcodec/assdec.c
@@ -62,7 +62,7 @@ static int ass_decode_frame(AVCodecContext *avctx, void *data, int *got_sub_ptr,
 }
 
 #if CONFIG_SSA_DECODER
-AVCodec ff_ssa_decoder = {
+const AVCodec ff_ssa_decoder = {
     .name         = "ssa",
     .long_name    = NULL_IF_CONFIG_SMALL("ASS (Advanced SubStation Alpha) subtitle"),
     .type         = AVMEDIA_TYPE_SUBTITLE,
@@ -73,7 +73,7 @@ AVCodec ff_ssa_decoder = {
 #endif
 
 #if CONFIG_ASS_DECODER
-AVCodec ff_ass_decoder = {
+const AVCodec ff_ass_decoder = {
     .name         = "ass",
     .long_name    = NULL_IF_CONFIG_SMALL("ASS (Advanced SubStation Alpha) subtitle"),
     .type         = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/assenc.c b/libavcodec/assenc.c
index 3decf670d7..c8fcf45bed 100644
--- a/libavcodec/assenc.c
+++ b/libavcodec/assenc.c
@@ -66,7 +66,7 @@ static int ass_encode_frame(AVCodecContext *avctx,
 }
 
 #if CONFIG_SSA_ENCODER
-AVCodec ff_ssa_encoder = {
+const AVCodec ff_ssa_encoder = {
     .name         = "ssa",
     .long_name    = NULL_IF_CONFIG_SMALL("ASS (Advanced SubStation Alpha) subtitle"),
     .type         = AVMEDIA_TYPE_SUBTITLE,
@@ -77,7 +77,7 @@ AVCodec ff_ssa_encoder = {
 #endif
 
 #if CONFIG_ASS_ENCODER
-AVCodec ff_ass_encoder = {
+const AVCodec ff_ass_encoder = {
     .name         = "ass",
     .long_name    = NULL_IF_CONFIG_SMALL("ASS (Advanced SubStation Alpha) subtitle"),
     .type         = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/asvdec.c b/libavcodec/asvdec.c
index a72e11b848..60a4e138c4 100644
--- a/libavcodec/asvdec.c
+++ b/libavcodec/asvdec.c
@@ -327,7 +327,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 #if CONFIG_ASV1_DECODER
-AVCodec ff_asv1_decoder = {
+const AVCodec ff_asv1_decoder = {
     .name           = "asv1",
     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V1"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -342,7 +342,7 @@ AVCodec ff_asv1_decoder = {
 #endif
 
 #if CONFIG_ASV2_DECODER
-AVCodec ff_asv2_decoder = {
+const AVCodec ff_asv2_decoder = {
     .name           = "asv2",
     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/asvenc.c b/libavcodec/asvenc.c
index c33a3b4681..bf11701d17 100644
--- a/libavcodec/asvenc.c
+++ b/libavcodec/asvenc.c
@@ -341,7 +341,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
 }
 
 #if CONFIG_ASV1_ENCODER
-AVCodec ff_asv1_encoder = {
+const AVCodec ff_asv1_encoder = {
     .name           = "asv1",
     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V1"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -356,7 +356,7 @@ AVCodec ff_asv1_encoder = {
 #endif
 
 #if CONFIG_ASV2_ENCODER
-AVCodec ff_asv2_encoder = {
+const AVCodec ff_asv2_encoder = {
     .name           = "asv2",
     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/atrac1.c b/libavcodec/atrac1.c
index 54f9b1c2d8..228477d778 100644
--- a/libavcodec/atrac1.c
+++ b/libavcodec/atrac1.c
@@ -382,7 +382,7 @@ static av_cold int atrac1_decode_init(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_atrac1_decoder = {
+const AVCodec ff_atrac1_decoder = {
     .name           = "atrac1",
     .long_name      = NULL_IF_CONFIG_SMALL("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/atrac3.c b/libavcodec/atrac3.c
index 37ccbcc946..b4809111f8 100644
--- a/libavcodec/atrac3.c
+++ b/libavcodec/atrac3.c
@@ -1013,7 +1013,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_atrac3_decoder = {
+const AVCodec ff_atrac3_decoder = {
     .name             = "atrac3",
     .long_name        = NULL_IF_CONFIG_SMALL("ATRAC3 (Adaptive TRansform Acoustic Coding 3)"),
     .type             = AVMEDIA_TYPE_AUDIO,
@@ -1028,7 +1028,7 @@ AVCodec ff_atrac3_decoder = {
     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 };
 
-AVCodec ff_atrac3al_decoder = {
+const AVCodec ff_atrac3al_decoder = {
     .name             = "atrac3al",
     .long_name        = NULL_IF_CONFIG_SMALL("ATRAC3 AL (Adaptive TRansform Acoustic Coding 3 Advanced Lossless)"),
     .type             = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/atrac3plusdec.c b/libavcodec/atrac3plusdec.c
index c024ab6bde..9917f2d819 100644
--- a/libavcodec/atrac3plusdec.c
+++ b/libavcodec/atrac3plusdec.c
@@ -393,7 +393,7 @@ static int atrac3p_decode_frame(AVCodecContext *avctx, void *data,
     return avctx->codec_id == AV_CODEC_ID_ATRAC3P ? FFMIN(avctx->block_align, avpkt->size) : avpkt->size;
 }
 
-AVCodec ff_atrac3p_decoder = {
+const AVCodec ff_atrac3p_decoder = {
     .name           = "atrac3plus",
     .long_name      = NULL_IF_CONFIG_SMALL("ATRAC3+ (Adaptive TRansform Acoustic Coding 3+)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -406,7 +406,7 @@ AVCodec ff_atrac3p_decoder = {
     .decode         = atrac3p_decode_frame,
 };
 
-AVCodec ff_atrac3pal_decoder = {
+const AVCodec ff_atrac3pal_decoder = {
     .name           = "atrac3plusal",
     .long_name      = NULL_IF_CONFIG_SMALL("ATRAC3+ AL (Adaptive TRansform Acoustic Coding 3+ Advanced Lossless)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/atrac9dec.c b/libavcodec/atrac9dec.c
index f88b25da48..eebb412145 100644
--- a/libavcodec/atrac9dec.c
+++ b/libavcodec/atrac9dec.c
@@ -986,7 +986,7 @@ static av_cold int atrac9_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_atrac9_decoder = {
+const AVCodec ff_atrac9_decoder = {
     .name           = "atrac9",
     .long_name      = NULL_IF_CONFIG_SMALL("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/audiotoolboxdec.c b/libavcodec/audiotoolboxdec.c
index a4fb8c9120..cbd381ef12 100644
--- a/libavcodec/audiotoolboxdec.c
+++ b/libavcodec/audiotoolboxdec.c
@@ -579,7 +579,7 @@ static av_cold int ffat_close_decoder(AVCodecContext *avctx)
 
 #define FFAT_DEC(NAME, ID, bsf_name) \
     FFAT_DEC_CLASS(NAME) \
-    AVCodec ff_##NAME##_at_decoder = { \
+    const AVCodec ff_##NAME##_at_decoder = { \
         .name           = #NAME "_at", \
         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \
         .type           = AVMEDIA_TYPE_AUDIO, \
diff --git a/libavcodec/audiotoolboxenc.c b/libavcodec/audiotoolboxenc.c
index b0a4340ae3..e3d056a79d 100644
--- a/libavcodec/audiotoolboxenc.c
+++ b/libavcodec/audiotoolboxenc.c
@@ -616,7 +616,7 @@ static const AVOption options[] = {
 
 #define FFAT_ENC(NAME, ID, PROFILES, ...) \
     FFAT_ENC_CLASS(NAME) \
-    AVCodec ff_##NAME##_at_encoder = { \
+    const AVCodec ff_##NAME##_at_encoder = { \
         .name           = #NAME "_at", \
         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \
         .type           = AVMEDIA_TYPE_AUDIO, \
diff --git a/libavcodec/aura.c b/libavcodec/aura.c
index 5ef9316632..585c710f5a 100644
--- a/libavcodec/aura.c
+++ b/libavcodec/aura.c
@@ -97,7 +97,7 @@ static int aura_decode_frame(AVCodecContext *avctx,
     return pkt->size;
 }
 
-AVCodec ff_aura2_decoder = {
+const AVCodec ff_aura2_decoder = {
     .name           = "aura2",
     .long_name      = NULL_IF_CONFIG_SMALL("Auravision Aura 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/av1dec.c b/libavcodec/av1dec.c
index a75d6744d3..1dda0f9160 100644
--- a/libavcodec/av1dec.c
+++ b/libavcodec/av1dec.c
@@ -1121,7 +1121,7 @@ static const AVClass av1_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_av1_decoder = {
+const AVCodec ff_av1_decoder = {
     .name                  = "av1",
     .long_name             = NULL_IF_CONFIG_SMALL("Alliance for Open Media AV1"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/avrndec.c b/libavcodec/avrndec.c
index 477afd8bf1..70e34c617d 100644
--- a/libavcodec/avrndec.c
+++ b/libavcodec/avrndec.c
@@ -89,7 +89,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_avrn_decoder = {
+const AVCodec ff_avrn_decoder = {
     .name           = "avrn",
     .long_name      = NULL_IF_CONFIG_SMALL("Avid AVI Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/avs.c b/libavcodec/avs.c
index 2f2361e5ea..28f5f0b137 100644
--- a/libavcodec/avs.c
+++ b/libavcodec/avs.c
@@ -176,7 +176,7 @@ static av_cold int avs_decode_end(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_avs_decoder = {
+const AVCodec ff_avs_decoder = {
     .name           = "avs",
     .long_name      = NULL_IF_CONFIG_SMALL("AVS (Audio Video Standard) video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/avuidec.c b/libavcodec/avuidec.c
index 4cf620d43a..f7172845c3 100644
--- a/libavcodec/avuidec.c
+++ b/libavcodec/avuidec.c
@@ -119,7 +119,7 @@ static int avui_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_avui_decoder = {
+const AVCodec ff_avui_decoder = {
     .name         = "avui",
     .long_name    = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/avuienc.c b/libavcodec/avuienc.c
index 2091309e7e..e9e30fe7f4 100644
--- a/libavcodec/avuienc.c
+++ b/libavcodec/avuienc.c
@@ -91,7 +91,7 @@ static int avui_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_avui_encoder = {
+const AVCodec ff_avui_encoder = {
     .name         = "avui",
     .long_name    = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/bethsoftvideo.c b/libavcodec/bethsoftvideo.c
index a931b54911..b529aba7e9 100644
--- a/libavcodec/bethsoftvideo.c
+++ b/libavcodec/bethsoftvideo.c
@@ -158,7 +158,7 @@ static av_cold int bethsoftvid_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_bethsoftvid_decoder = {
+const AVCodec ff_bethsoftvid_decoder = {
     .name           = "bethsoftvid",
     .long_name      = NULL_IF_CONFIG_SMALL("Bethesda VID video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/bfi.c b/libavcodec/bfi.c
index a4cb002053..78685e8777 100644
--- a/libavcodec/bfi.c
+++ b/libavcodec/bfi.c
@@ -175,7 +175,7 @@ static av_cold int bfi_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_bfi_decoder = {
+const AVCodec ff_bfi_decoder = {
     .name           = "bfi",
     .long_name      = NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/bink.c b/libavcodec/bink.c
index 5efd24e9c3..36d1ab6c0a 100644
--- a/libavcodec/bink.c
+++ b/libavcodec/bink.c
@@ -1415,7 +1415,7 @@ static void flush(AVCodecContext *avctx)
     c->frame_num = 0;
 }
 
-AVCodec ff_bink_decoder = {
+const AVCodec ff_bink_decoder = {
     .name           = "binkvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Bink video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/binkaudio.c b/libavcodec/binkaudio.c
index df15a0fd5b..e42ceb3673 100644
--- a/libavcodec/binkaudio.c
+++ b/libavcodec/binkaudio.c
@@ -337,7 +337,7 @@ fail:
     return ret;
 }
 
-AVCodec ff_binkaudio_rdft_decoder = {
+const AVCodec ff_binkaudio_rdft_decoder = {
     .name           = "binkaudio_rdft",
     .long_name      = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -350,7 +350,7 @@ AVCodec ff_binkaudio_rdft_decoder = {
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 
-AVCodec ff_binkaudio_dct_decoder = {
+const AVCodec ff_binkaudio_dct_decoder = {
     .name           = "binkaudio_dct",
     .long_name      = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/bintext.c b/libavcodec/bintext.c
index 1aeed21f51..520d68a7c0 100644
--- a/libavcodec/bintext.c
+++ b/libavcodec/bintext.c
@@ -215,7 +215,7 @@ static int decode_frame(AVCodecContext *avctx,
 }
 
 #if CONFIG_BINTEXT_DECODER
-AVCodec ff_bintext_decoder = {
+const AVCodec ff_bintext_decoder = {
     .name           = "bintext",
     .long_name      = NULL_IF_CONFIG_SMALL("Binary text"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -227,7 +227,7 @@ AVCodec ff_bintext_decoder = {
 };
 #endif
 #if CONFIG_XBIN_DECODER
-AVCodec ff_xbin_decoder = {
+const AVCodec ff_xbin_decoder = {
     .name           = "xbin",
     .long_name      = NULL_IF_CONFIG_SMALL("eXtended BINary text"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -239,7 +239,7 @@ AVCodec ff_xbin_decoder = {
 };
 #endif
 #if CONFIG_IDF_DECODER
-AVCodec ff_idf_decoder = {
+const AVCodec ff_idf_decoder = {
     .name           = "idf",
     .long_name      = NULL_IF_CONFIG_SMALL("iCEDraw text"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/bitpacked.c b/libavcodec/bitpacked.c
index 23e82c69b5..57ae93b6b4 100644
--- a/libavcodec/bitpacked.c
+++ b/libavcodec/bitpacked.c
@@ -137,7 +137,7 @@ static int bitpacked_decode(AVCodecContext *avctx, void *data, int *got_frame,
 
 }
 
-AVCodec ff_bitpacked_decoder = {
+const AVCodec ff_bitpacked_decoder = {
     .name   = "bitpacked",
     .long_name = NULL_IF_CONFIG_SMALL("Bitpacked"),
     .type = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/bmp.c b/libavcodec/bmp.c
index 40010ac46f..c4f6044cb4 100644
--- a/libavcodec/bmp.c
+++ b/libavcodec/bmp.c
@@ -365,7 +365,7 @@ static int bmp_decode_frame(AVCodecContext *avctx,
     return buf_size;
 }
 
-AVCodec ff_bmp_decoder = {
+const AVCodec ff_bmp_decoder = {
     .name           = "bmp",
     .long_name      = NULL_IF_CONFIG_SMALL("BMP (Windows and OS/2 bitmap)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/bmpenc.c b/libavcodec/bmpenc.c
index bab2558bc9..ee2a2d0ea9 100644
--- a/libavcodec/bmpenc.c
+++ b/libavcodec/bmpenc.c
@@ -157,7 +157,7 @@ static int bmp_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_bmp_encoder = {
+const AVCodec ff_bmp_encoder = {
     .name           = "bmp",
     .long_name      = NULL_IF_CONFIG_SMALL("BMP (Windows and OS/2 bitmap)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/bmvaudio.c b/libavcodec/bmvaudio.c
index 7c4dad7f8d..0c3aad0f2f 100644
--- a/libavcodec/bmvaudio.c
+++ b/libavcodec/bmvaudio.c
@@ -78,7 +78,7 @@ static int bmv_aud_decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_bmv_audio_decoder = {
+const AVCodec ff_bmv_audio_decoder = {
     .name           = "bmv_audio",
     .long_name      = NULL_IF_CONFIG_SMALL("Discworld II BMV audio"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/bmvvideo.c b/libavcodec/bmvvideo.c
index 679b14208a..d76ba442be 100644
--- a/libavcodec/bmvvideo.c
+++ b/libavcodec/bmvvideo.c
@@ -285,7 +285,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_bmv_video_decoder = {
+const AVCodec ff_bmv_video_decoder = {
     .name           = "bmv_video",
     .long_name      = NULL_IF_CONFIG_SMALL("Discworld II BMV video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/brenderpix.c b/libavcodec/brenderpix.c
index 46b7a59aa4..4726fd3d77 100644
--- a/libavcodec/brenderpix.c
+++ b/libavcodec/brenderpix.c
@@ -285,7 +285,7 @@ static int pix_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 }
 
-AVCodec ff_brender_pix_decoder = {
+const AVCodec ff_brender_pix_decoder = {
     .name         = "brender_pix",
     .long_name    = NULL_IF_CONFIG_SMALL("BRender PIX image"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/c93.c b/libavcodec/c93.c
index 7e3bfdbc72..3464c85e23 100644
--- a/libavcodec/c93.c
+++ b/libavcodec/c93.c
@@ -257,7 +257,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_c93_decoder = {
+const AVCodec ff_c93_decoder = {
     .name           = "c93",
     .long_name      = NULL_IF_CONFIG_SMALL("Interplay C93"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cavsdec.c b/libavcodec/cavsdec.c
index 9c3825df38..692c77eb39 100644
--- a/libavcodec/cavsdec.c
+++ b/libavcodec/cavsdec.c
@@ -1307,7 +1307,7 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     }
 }
 
-AVCodec ff_cavs_decoder = {
+const AVCodec ff_cavs_decoder = {
     .name           = "cavs",
     .long_name      = NULL_IF_CONFIG_SMALL("Chinese AVS (Audio Video Standard) (AVS1-P2, JiZhun profile)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ccaption_dec.c b/libavcodec/ccaption_dec.c
index a208e19b95..9ad00cb254 100644
--- a/libavcodec/ccaption_dec.c
+++ b/libavcodec/ccaption_dec.c
@@ -940,7 +940,7 @@ static const AVClass ccaption_dec_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_ccaption_decoder = {
+const AVCodec ff_ccaption_decoder = {
     .name           = "cc_dec",
     .long_name      = NULL_IF_CONFIG_SMALL("Closed Caption (EIA-608 / CEA-708)"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/cdgraphics.c b/libavcodec/cdgraphics.c
index 263459d0f2..faa43c1c83 100644
--- a/libavcodec/cdgraphics.c
+++ b/libavcodec/cdgraphics.c
@@ -386,7 +386,7 @@ static av_cold int cdg_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cdgraphics_decoder = {
+const AVCodec ff_cdgraphics_decoder = {
     .name           = "cdgraphics",
     .long_name      = NULL_IF_CONFIG_SMALL("CD Graphics video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cdtoons.c b/libavcodec/cdtoons.c
index 3530f81452..14c15c4579 100644
--- a/libavcodec/cdtoons.c
+++ b/libavcodec/cdtoons.c
@@ -442,7 +442,7 @@ static av_cold int cdtoons_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cdtoons_decoder = {
+const AVCodec ff_cdtoons_decoder = {
     .name           = "cdtoons",
     .long_name      = NULL_IF_CONFIG_SMALL("CDToons video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cdxl.c b/libavcodec/cdxl.c
index 056c3577ab..860dc639f6 100644
--- a/libavcodec/cdxl.c
+++ b/libavcodec/cdxl.c
@@ -336,7 +336,7 @@ static av_cold int cdxl_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cdxl_decoder = {
+const AVCodec ff_cdxl_decoder = {
     .name           = "cdxl",
     .long_name      = NULL_IF_CONFIG_SMALL("Commodore CDXL video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cfhd.c b/libavcodec/cfhd.c
index 6f13207cc1..66e1695ec9 100644
--- a/libavcodec/cfhd.c
+++ b/libavcodec/cfhd.c
@@ -1458,7 +1458,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 }
 #endif
 
-AVCodec ff_cfhd_decoder = {
+const AVCodec ff_cfhd_decoder = {
     .name             = "cfhd",
     .long_name        = NULL_IF_CONFIG_SMALL("GoPro CineForm HD"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cfhdenc.c b/libavcodec/cfhdenc.c
index 0369164fab..e0b1172ede 100644
--- a/libavcodec/cfhdenc.c
+++ b/libavcodec/cfhdenc.c
@@ -845,7 +845,7 @@ static const AVClass cfhd_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_cfhd_encoder = {
+const AVCodec ff_cfhd_encoder = {
     .name             = "cfhd",
     .long_name        = NULL_IF_CONFIG_SMALL("GoPro CineForm HD"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cinepak.c b/libavcodec/cinepak.c
index ccd6af3208..090ab9cea0 100644
--- a/libavcodec/cinepak.c
+++ b/libavcodec/cinepak.c
@@ -506,7 +506,7 @@ static av_cold int cinepak_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cinepak_decoder = {
+const AVCodec ff_cinepak_decoder = {
     .name           = "cinepak",
     .long_name      = NULL_IF_CONFIG_SMALL("Cinepak"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cinepakenc.c b/libavcodec/cinepakenc.c
index 4c9b961660..422cb3f8e9 100644
--- a/libavcodec/cinepakenc.c
+++ b/libavcodec/cinepakenc.c
@@ -1178,7 +1178,7 @@ static av_cold int cinepak_encode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cinepak_encoder = {
+const AVCodec ff_cinepak_encoder = {
     .name           = "cinepak",
     .long_name      = NULL_IF_CONFIG_SMALL("Cinepak"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/clearvideo.c b/libavcodec/clearvideo.c
index 79ba88857c..e5e33d3313 100644
--- a/libavcodec/clearvideo.c
+++ b/libavcodec/clearvideo.c
@@ -766,7 +766,7 @@ static av_cold int clv_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_clearvideo_decoder = {
+const AVCodec ff_clearvideo_decoder = {
     .name           = "clearvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cljrdec.c b/libavcodec/cljrdec.c
index c41df12d53..4a8c9d2ae1 100644
--- a/libavcodec/cljrdec.c
+++ b/libavcodec/cljrdec.c
@@ -82,7 +82,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cljr_decoder = {
+const AVCodec ff_cljr_decoder = {
     .name           = "cljr",
     .long_name      = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cljrenc.c b/libavcodec/cljrenc.c
index fe58f50f09..6f04c62cb0 100644
--- a/libavcodec/cljrenc.c
+++ b/libavcodec/cljrenc.c
@@ -109,7 +109,7 @@ static const AVClass cljr_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_cljr_encoder = {
+const AVCodec ff_cljr_encoder = {
     .name           = "cljr",
     .long_name      = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cllc.c b/libavcodec/cllc.c
index 837e04f173..41b3a4ef83 100644
--- a/libavcodec/cllc.c
+++ b/libavcodec/cllc.c
@@ -493,7 +493,7 @@ static av_cold int cllc_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cllc_decoder = {
+const AVCodec ff_cllc_decoder = {
     .name           = "cllc",
     .long_name      = NULL_IF_CONFIG_SMALL("Canopus Lossless Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cngdec.c b/libavcodec/cngdec.c
index ceee087c57..57cb620179 100644
--- a/libavcodec/cngdec.c
+++ b/libavcodec/cngdec.c
@@ -161,7 +161,7 @@ static int cng_decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_comfortnoise_decoder = {
+const AVCodec ff_comfortnoise_decoder = {
     .name           = "comfortnoise",
     .long_name      = NULL_IF_CONFIG_SMALL("RFC 3389 comfort noise generator"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/cngenc.c b/libavcodec/cngenc.c
index b622d7bbda..55826c75be 100644
--- a/libavcodec/cngenc.c
+++ b/libavcodec/cngenc.c
@@ -100,7 +100,7 @@ static int cng_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_comfortnoise_encoder = {
+const AVCodec ff_comfortnoise_encoder = {
     .name           = "comfortnoise",
     .long_name      = NULL_IF_CONFIG_SMALL("RFC 3389 comfort noise generator"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/cook.c b/libavcodec/cook.c
index a9de3c8b1a..361baeb3ac 100644
--- a/libavcodec/cook.c
+++ b/libavcodec/cook.c
@@ -1292,7 +1292,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cook_decoder = {
+const AVCodec ff_cook_decoder = {
     .name           = "cook",
     .long_name      = NULL_IF_CONFIG_SMALL("Cook / Cooker / Gecko (RealAudio G2)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/cpia.c b/libavcodec/cpia.c
index 5f12a99a83..d88bd1aae7 100644
--- a/libavcodec/cpia.c
+++ b/libavcodec/cpia.c
@@ -220,7 +220,7 @@ static av_cold int cpia_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cpia_decoder = {
+const AVCodec ff_cpia_decoder = {
     .name           = "cpia",
     .long_name      = NULL_IF_CONFIG_SMALL("CPiA video format"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cri.c b/libavcodec/cri.c
index 0558d0c8dd..dfea24d979 100644
--- a/libavcodec/cri.c
+++ b/libavcodec/cri.c
@@ -424,7 +424,7 @@ static av_cold int cri_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cri_decoder = {
+const AVCodec ff_cri_decoder = {
     .name           = "cri",
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_CRI,
diff --git a/libavcodec/crystalhd.c b/libavcodec/crystalhd.c
index fbfe5e8f62..f709cf74a7 100644
--- a/libavcodec/crystalhd.c
+++ b/libavcodec/crystalhd.c
@@ -767,7 +767,7 @@ static int crystalhd_receive_frame(AVCodecContext *avctx, AVFrame *frame)
         .option = options, \
         .version = LIBAVUTIL_VERSION_INT, \
     }; \
-    AVCodec ff_##x##_crystalhd_decoder = { \
+    const AVCodec ff_##x##_crystalhd_decoder = { \
         .name           = #x "_crystalhd", \
         .long_name      = NULL_IF_CONFIG_SMALL("CrystalHD " #X " decoder"), \
         .type           = AVMEDIA_TYPE_VIDEO, \
diff --git a/libavcodec/cscd.c b/libavcodec/cscd.c
index f5c93e9912..af12246281 100644
--- a/libavcodec/cscd.c
+++ b/libavcodec/cscd.c
@@ -166,7 +166,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_cscd_decoder = {
+const AVCodec ff_cscd_decoder = {
     .name           = "camstudio",
     .long_name      = NULL_IF_CONFIG_SMALL("CamStudio"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/cuviddec.c b/libavcodec/cuviddec.c
index 1e5e3ea9a6..a5f33e6fc1 100644
--- a/libavcodec/cuviddec.c
+++ b/libavcodec/cuviddec.c
@@ -1131,7 +1131,7 @@ static const AVCodecHWConfigInternal *const cuvid_hw_configs[] = {
         .option = options, \
         .version = LIBAVUTIL_VERSION_INT, \
     }; \
-    AVCodec ff_##x##_cuvid_decoder = { \
+    const AVCodec ff_##x##_cuvid_decoder = { \
         .name           = #x "_cuvid", \
         .long_name      = NULL_IF_CONFIG_SMALL("Nvidia CUVID " #X " decoder"), \
         .type           = AVMEDIA_TYPE_VIDEO, \
diff --git a/libavcodec/cyuv.c b/libavcodec/cyuv.c
index f2b0a7cbab..cfaa5cfa66 100644
--- a/libavcodec/cyuv.c
+++ b/libavcodec/cyuv.c
@@ -176,7 +176,7 @@ static int cyuv_decode_frame(AVCodecContext *avctx,
 }
 
 #if CONFIG_AURA_DECODER
-AVCodec ff_aura_decoder = {
+const AVCodec ff_aura_decoder = {
     .name           = "aura",
     .long_name      = NULL_IF_CONFIG_SMALL("Auravision AURA"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -190,7 +190,7 @@ AVCodec ff_aura_decoder = {
 #endif
 
 #if CONFIG_CYUV_DECODER
-AVCodec ff_cyuv_decoder = {
+const AVCodec ff_cyuv_decoder = {
     .name           = "cyuv",
     .long_name      = NULL_IF_CONFIG_SMALL("Creative YUV (CYUV)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dcadec.c b/libavcodec/dcadec.c
index 4146a85ec5..1aa1b4235b 100644
--- a/libavcodec/dcadec.c
+++ b/libavcodec/dcadec.c
@@ -381,7 +381,7 @@ static const AVClass dcadec_class = {
     .category   = AV_CLASS_CATEGORY_DECODER,
 };
 
-AVCodec ff_dca_decoder = {
+const AVCodec ff_dca_decoder = {
     .name           = "dca",
     .long_name      = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/dcaenc.c b/libavcodec/dcaenc.c
index 12aa7e0df2..bd08ccd331 100644
--- a/libavcodec/dcaenc.c
+++ b/libavcodec/dcaenc.c
@@ -1238,7 +1238,7 @@ static const AVCodecDefault defaults[] = {
     { NULL },
 };
 
-AVCodec ff_dca_encoder = {
+const AVCodec ff_dca_encoder = {
     .name                  = "dca",
     .long_name             = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/dds.c b/libavcodec/dds.c
index 9154f692fa..e5183cade1 100644
--- a/libavcodec/dds.c
+++ b/libavcodec/dds.c
@@ -748,7 +748,7 @@ static int dds_decode(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_dds_decoder = {
+const AVCodec ff_dds_decoder = {
     .name           = "dds",
     .long_name      = NULL_IF_CONFIG_SMALL("DirectDraw Surface image decoder"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dfa.c b/libavcodec/dfa.c
index 31c6c39089..13d1e71f82 100644
--- a/libavcodec/dfa.c
+++ b/libavcodec/dfa.c
@@ -414,7 +414,7 @@ static av_cold int dfa_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_dfa_decoder = {
+const AVCodec ff_dfa_decoder = {
     .name           = "dfa",
     .long_name      = NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/diracdec.c b/libavcodec/diracdec.c
index b9999cde01..30a5b1340b 100644
--- a/libavcodec/diracdec.c
+++ b/libavcodec/diracdec.c
@@ -2355,7 +2355,7 @@ static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return buf_idx;
 }
 
-AVCodec ff_dirac_decoder = {
+const AVCodec ff_dirac_decoder = {
     .name           = "dirac",
     .long_name      = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dnxhddec.c b/libavcodec/dnxhddec.c
index c78d55aee5..b9e07a8562 100644
--- a/libavcodec/dnxhddec.c
+++ b/libavcodec/dnxhddec.c
@@ -717,7 +717,7 @@ static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_dnxhd_decoder = {
+const AVCodec ff_dnxhd_decoder = {
     .name           = "dnxhd",
     .long_name      = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c
index 19e11b4214..23c3f6fdb9 100644
--- a/libavcodec/dnxhdenc.c
+++ b/libavcodec/dnxhdenc.c
@@ -1349,7 +1349,7 @@ static const AVCodecDefault dnxhd_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_dnxhd_encoder = {
+const AVCodec ff_dnxhd_encoder = {
     .name           = "dnxhd",
     .long_name      = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dolby_e.c b/libavcodec/dolby_e.c
index ecb2f4802a..cd4c8c2c3c 100644
--- a/libavcodec/dolby_e.c
+++ b/libavcodec/dolby_e.c
@@ -1256,7 +1256,7 @@ static av_cold int dolby_e_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_dolby_e_decoder = {
+const AVCodec ff_dolby_e_decoder = {
     .name           = "dolby_e",
     .long_name      = NULL_IF_CONFIG_SMALL("Dolby E"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/dpcm.c b/libavcodec/dpcm.c
index 7078419f08..3bd7a3e117 100644
--- a/libavcodec/dpcm.c
+++ b/libavcodec/dpcm.c
@@ -410,7 +410,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
 }
 
 #define DPCM_DECODER(id_, name_, long_name_)                \
-AVCodec ff_ ## name_ ## _decoder = {                        \
+const AVCodec ff_ ## name_ ## _decoder = {                        \
     .name           = #name_,                               \
     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
     .type           = AVMEDIA_TYPE_AUDIO,                   \
diff --git a/libavcodec/dpx.c b/libavcodec/dpx.c
index b02996f04c..8e77c09bb1 100644
--- a/libavcodec/dpx.c
+++ b/libavcodec/dpx.c
@@ -762,7 +762,7 @@ static int decode_frame(AVCodecContext *avctx,
     return buf_size;
 }
 
-AVCodec ff_dpx_decoder = {
+const AVCodec ff_dpx_decoder = {
     .name           = "dpx",
     .long_name      = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dpxenc.c b/libavcodec/dpxenc.c
index a5960334d5..615623bf94 100644
--- a/libavcodec/dpxenc.c
+++ b/libavcodec/dpxenc.c
@@ -276,7 +276,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_dpx_encoder = {
+const AVCodec ff_dpx_encoder = {
     .name           = "dpx",
     .long_name      = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dsddec.c b/libavcodec/dsddec.c
index 21d1d9f5de..19fb75ee85 100644
--- a/libavcodec/dsddec.c
+++ b/libavcodec/dsddec.c
@@ -115,7 +115,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
 }
 
 #define DSD_DECODER(id_, name_, long_name_) \
-AVCodec ff_##name_##_decoder = { \
+const AVCodec ff_ ## name_ ## _decoder = { \
     .name         = #name_, \
     .long_name    = NULL_IF_CONFIG_SMALL(long_name_), \
     .type         = AVMEDIA_TYPE_AUDIO, \
diff --git a/libavcodec/dsicinaudio.c b/libavcodec/dsicinaudio.c
index 3ee6c196d2..cb3fd22e46 100644
--- a/libavcodec/dsicinaudio.c
+++ b/libavcodec/dsicinaudio.c
@@ -121,7 +121,7 @@ static int cinaudio_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_dsicinaudio_decoder = {
+const AVCodec ff_dsicinaudio_decoder = {
     .name           = "dsicinaudio",
     .long_name      = NULL_IF_CONFIG_SMALL("Delphine Software International CIN audio"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/dsicinvideo.c b/libavcodec/dsicinvideo.c
index 52f660fb51..73eea9aeb7 100644
--- a/libavcodec/dsicinvideo.c
+++ b/libavcodec/dsicinvideo.c
@@ -321,7 +321,7 @@ static av_cold int cinvideo_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_dsicinvideo_decoder = {
+const AVCodec ff_dsicinvideo_decoder = {
     .name           = "dsicinvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dss_sp.c b/libavcodec/dss_sp.c
index 568757d212..26e196db14 100644
--- a/libavcodec/dss_sp.c
+++ b/libavcodec/dss_sp.c
@@ -774,7 +774,7 @@ static int dss_sp_decode_frame(AVCodecContext *avctx, void *data,
     return DSS_SP_FRAME_SIZE;
 }
 
-AVCodec ff_dss_sp_decoder = {
+const AVCodec ff_dss_sp_decoder = {
     .name           = "dss_sp",
     .long_name      = NULL_IF_CONFIG_SMALL("Digital Speech Standard - Standard Play mode (DSS SP)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/dstdec.c b/libavcodec/dstdec.c
index 84d19b91aa..7be97126ca 100644
--- a/libavcodec/dstdec.c
+++ b/libavcodec/dstdec.c
@@ -379,7 +379,7 @@ dsd:
     return avpkt->size;
 }
 
-AVCodec ff_dst_decoder = {
+const AVCodec ff_dst_decoder = {
     .name           = "dst",
     .long_name      = NULL_IF_CONFIG_SMALL("DST (Digital Stream Transfer)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/dvaudiodec.c b/libavcodec/dvaudiodec.c
index 5aa2a95553..64721c45b2 100644
--- a/libavcodec/dvaudiodec.c
+++ b/libavcodec/dvaudiodec.c
@@ -121,7 +121,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     return s->block_size;
 }
 
-AVCodec ff_dvaudio_decoder = {
+const AVCodec ff_dvaudio_decoder = {
     .name           = "dvaudio",
     .long_name      = NULL_IF_CONFIG_SMALL("Ulead DV Audio"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/dvbsubdec.c b/libavcodec/dvbsubdec.c
index 7db1fef216..f33744df0f 100644
--- a/libavcodec/dvbsubdec.c
+++ b/libavcodec/dvbsubdec.c
@@ -1737,7 +1737,7 @@ static const AVClass dvbsubdec_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_dvbsub_decoder = {
+const AVCodec ff_dvbsub_decoder = {
     .name           = "dvbsub",
     .long_name      = NULL_IF_CONFIG_SMALL("DVB subtitles"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/dvbsubenc.c b/libavcodec/dvbsubenc.c
index d1620e0c50..322fc27cb4 100644
--- a/libavcodec/dvbsubenc.c
+++ b/libavcodec/dvbsubenc.c
@@ -505,7 +505,7 @@ static int dvbsub_encode(AVCodecContext *avctx, uint8_t *outbuf, int buf_size,
     return q - outbuf;
 }
 
-AVCodec ff_dvbsub_encoder = {
+const AVCodec ff_dvbsub_encoder = {
     .name           = "dvbsub",
     .long_name      = NULL_IF_CONFIG_SMALL("DVB subtitles"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/dvdec.c b/libavcodec/dvdec.c
index a0647e58b4..d768326661 100644
--- a/libavcodec/dvdec.c
+++ b/libavcodec/dvdec.c
@@ -619,7 +619,7 @@ static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
     return s->sys->frame_size;
 }
 
-AVCodec ff_dvvideo_decoder = {
+const AVCodec ff_dvvideo_decoder = {
     .name           = "dvvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dvdsubdec.c b/libavcodec/dvdsubdec.c
index 91906b9df4..b0127951c5 100644
--- a/libavcodec/dvdsubdec.c
+++ b/libavcodec/dvdsubdec.c
@@ -760,7 +760,7 @@ static const AVClass dvdsub_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_dvdsub_decoder = {
+const AVCodec ff_dvdsub_decoder = {
     .name           = "dvdsub",
     .long_name      = NULL_IF_CONFIG_SMALL("DVD subtitles"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/dvdsubenc.c b/libavcodec/dvdsubenc.c
index e55e2eab4f..cbea4e372c 100644
--- a/libavcodec/dvdsubenc.c
+++ b/libavcodec/dvdsubenc.c
@@ -493,7 +493,7 @@ static const AVClass dvdsubenc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_dvdsub_encoder = {
+const AVCodec ff_dvdsub_encoder = {
     .name           = "dvdsub",
     .long_name      = NULL_IF_CONFIG_SMALL("DVD subtitles"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/dvenc.c b/libavcodec/dvenc.c
index f1be3e43f6..458f39b558 100644
--- a/libavcodec/dvenc.c
+++ b/libavcodec/dvenc.c
@@ -1198,7 +1198,7 @@ static const AVClass dvvideo_encode_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_dvvideo_encoder = {
+const AVCodec ff_dvvideo_encoder = {
     .name           = "dvvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dxa.c b/libavcodec/dxa.c
index 3f62eac252..cddb13fea5 100644
--- a/libavcodec/dxa.c
+++ b/libavcodec/dxa.c
@@ -360,7 +360,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_dxa_decoder = {
+const AVCodec ff_dxa_decoder = {
     .name           = "dxa",
     .long_name      = NULL_IF_CONFIG_SMALL("Feeble Files/ScummVM DXA"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dxtory.c b/libavcodec/dxtory.c
index f314bcec75..914131e742 100644
--- a/libavcodec/dxtory.c
+++ b/libavcodec/dxtory.c
@@ -876,7 +876,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 }
 
-AVCodec ff_dxtory_decoder = {
+const AVCodec ff_dxtory_decoder = {
     .name           = "dxtory",
     .long_name      = NULL_IF_CONFIG_SMALL("Dxtory"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/dxv.c b/libavcodec/dxv.c
index 71d85208d8..5f17347913 100644
--- a/libavcodec/dxv.c
+++ b/libavcodec/dxv.c
@@ -1262,7 +1262,7 @@ static int dxv_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_dxv_decoder = {
+const AVCodec ff_dxv_decoder = {
     .name           = "dxv",
     .long_name      = NULL_IF_CONFIG_SMALL("Resolume DXV"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/eac3enc.c b/libavcodec/eac3enc.c
index 06d4df8f56..38ca31a219 100644
--- a/libavcodec/eac3enc.c
+++ b/libavcodec/eac3enc.c
@@ -248,7 +248,7 @@ void ff_eac3_output_frame_header(AC3EncodeContext *s)
 }
 
 
-AVCodec ff_eac3_encoder = {
+const AVCodec ff_eac3_encoder = {
     .name            = "eac3",
     .long_name       = NULL_IF_CONFIG_SMALL("ATSC A/52 E-AC-3"),
     .type            = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/eacmv.c b/libavcodec/eacmv.c
index b239acffda..6c4a85214f 100644
--- a/libavcodec/eacmv.c
+++ b/libavcodec/eacmv.c
@@ -230,7 +230,7 @@ static av_cold int cmv_decode_end(AVCodecContext *avctx){
     return 0;
 }
 
-AVCodec ff_eacmv_decoder = {
+const AVCodec ff_eacmv_decoder = {
     .name           = "eacmv",
     .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts CMV video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/eamad.c b/libavcodec/eamad.c
index 2c03aa5a1c..896f940735 100644
--- a/libavcodec/eamad.c
+++ b/libavcodec/eamad.c
@@ -341,7 +341,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_eamad_decoder = {
+const AVCodec ff_eamad_decoder = {
     .name           = "eamad",
     .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/eatgq.c b/libavcodec/eatgq.c
index 197ba6fc6e..f390fb3f41 100644
--- a/libavcodec/eatgq.c
+++ b/libavcodec/eatgq.c
@@ -247,7 +247,7 @@ static int tgq_decode_frame(AVCodecContext *avctx,
     return avpkt->size;
 }
 
-AVCodec ff_eatgq_decoder = {
+const AVCodec ff_eatgq_decoder = {
     .name           = "eatgq",
     .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts TGQ video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/eatgv.c b/libavcodec/eatgv.c
index f82f7b9cca..42cd07a60f 100644
--- a/libavcodec/eatgv.c
+++ b/libavcodec/eatgv.c
@@ -359,7 +359,7 @@ static av_cold int tgv_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_eatgv_decoder = {
+const AVCodec ff_eatgv_decoder = {
     .name           = "eatgv",
     .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts TGV video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/eatqi.c b/libavcodec/eatqi.c
index 2be2737fd6..9beab58a83 100644
--- a/libavcodec/eatqi.c
+++ b/libavcodec/eatqi.c
@@ -181,7 +181,7 @@ static av_cold int tqi_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_eatqi_decoder = {
+const AVCodec ff_eatqi_decoder = {
     .name           = "eatqi",
     .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts TQI Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/escape124.c b/libavcodec/escape124.c
index 94c2a961e6..3b514e7eb0 100644
--- a/libavcodec/escape124.c
+++ b/libavcodec/escape124.c
@@ -376,7 +376,7 @@ static int escape124_decode_frame(AVCodecContext *avctx,
 }
 
 
-AVCodec ff_escape124_decoder = {
+const AVCodec ff_escape124_decoder = {
     .name           = "escape124",
     .long_name      = NULL_IF_CONFIG_SMALL("Escape 124"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/escape130.c b/libavcodec/escape130.c
index a6fda901de..67373c3470 100644
--- a/libavcodec/escape130.c
+++ b/libavcodec/escape130.c
@@ -345,7 +345,7 @@ static int escape130_decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_escape130_decoder = {
+const AVCodec ff_escape130_decoder = {
     .name           = "escape130",
     .long_name      = NULL_IF_CONFIG_SMALL("Escape 130"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/evrcdec.c b/libavcodec/evrcdec.c
index 00e342a1f6..436c9d1373 100644
--- a/libavcodec/evrcdec.c
+++ b/libavcodec/evrcdec.c
@@ -928,7 +928,7 @@ static const AVClass evrcdec_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_evrc_decoder = {
+const AVCodec ff_evrc_decoder = {
     .name           = "evrc",
     .long_name      = NULL_IF_CONFIG_SMALL("EVRC (Enhanced Variable Rate Codec)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/exr.c b/libavcodec/exr.c
index 49c4774145..fc4822e0a3 100644
--- a/libavcodec/exr.c
+++ b/libavcodec/exr.c
@@ -2331,7 +2331,7 @@ static const AVClass exr_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_exr_decoder = {
+const AVCodec ff_exr_decoder = {
     .name             = "exr",
     .long_name        = NULL_IF_CONFIG_SMALL("OpenEXR image"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/exrenc.c b/libavcodec/exrenc.c
index db9000a85c..b2cb9c4205 100644
--- a/libavcodec/exrenc.c
+++ b/libavcodec/exrenc.c
@@ -534,7 +534,7 @@ static const AVClass exr_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_exr_encoder = {
+const AVCodec ff_exr_encoder = {
     .name           = "exr",
     .long_name      = NULL_IF_CONFIG_SMALL("OpenEXR image"),
     .priv_data_size = sizeof(EXRContext),
diff --git a/libavcodec/fastaudio.c b/libavcodec/fastaudio.c
index 9de42d2134..e771534e9f 100644
--- a/libavcodec/fastaudio.c
+++ b/libavcodec/fastaudio.c
@@ -187,7 +187,7 @@ static av_cold int fastaudio_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_fastaudio_decoder = {
+const AVCodec ff_fastaudio_decoder = {
     .name           = "fastaudio",
     .long_name      = NULL_IF_CONFIG_SMALL("MobiClip FastAudio"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/ffv1dec.c b/libavcodec/ffv1dec.c
index 14879779fa..7430bea960 100644
--- a/libavcodec/ffv1dec.c
+++ b/libavcodec/ffv1dec.c
@@ -1052,7 +1052,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 }
 #endif
 
-AVCodec ff_ffv1_decoder = {
+const AVCodec ff_ffv1_decoder = {
     .name           = "ffv1",
     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ffv1enc.c b/libavcodec/ffv1enc.c
index 749f6265f3..98abd936cd 100644
--- a/libavcodec/ffv1enc.c
+++ b/libavcodec/ffv1enc.c
@@ -1276,7 +1276,7 @@ static const AVClass ffv1_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_ffv1_encoder = {
+const AVCodec ff_ffv1_encoder = {
     .name           = "ffv1",
     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ffwavesynth.c b/libavcodec/ffwavesynth.c
index 3f982d07cf..a1211facb9 100644
--- a/libavcodec/ffwavesynth.c
+++ b/libavcodec/ffwavesynth.c
@@ -459,7 +459,7 @@ static av_cold int wavesynth_close(AVCodecContext *avc)
     return 0;
 }
 
-AVCodec ff_ffwavesynth_decoder = {
+const AVCodec ff_ffwavesynth_decoder = {
     .name           = "wavesynth",
     .long_name      = NULL_IF_CONFIG_SMALL("Wave synthesis pseudo-codec"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/fic.c b/libavcodec/fic.c
index ef5f3f44d1..457d74d7cd 100644
--- a/libavcodec/fic.c
+++ b/libavcodec/fic.c
@@ -483,7 +483,7 @@ static const AVClass fic_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_fic_decoder = {
+const AVCodec ff_fic_decoder = {
     .name           = "fic",
     .long_name      = NULL_IF_CONFIG_SMALL("Mirillis FIC"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/fitsdec.c b/libavcodec/fitsdec.c
index 802aa5b509..af60217a8a 100644
--- a/libavcodec/fitsdec.c
+++ b/libavcodec/fitsdec.c
@@ -320,7 +320,7 @@ static const AVClass fits_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_fits_decoder = {
+const AVCodec ff_fits_decoder = {
     .name           = "fits",
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_FITS,
diff --git a/libavcodec/fitsenc.c b/libavcodec/fitsenc.c
index b44507e436..80d0d71d1d 100644
--- a/libavcodec/fitsenc.c
+++ b/libavcodec/fitsenc.c
@@ -113,7 +113,7 @@ static int fits_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_fits_encoder = {
+const AVCodec ff_fits_encoder = {
     .name           = "fits",
     .long_name      = NULL_IF_CONFIG_SMALL("Flexible Image Transport System"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/flacdec.c b/libavcodec/flacdec.c
index 9e55bc1361..c62661a353 100644
--- a/libavcodec/flacdec.c
+++ b/libavcodec/flacdec.c
@@ -660,7 +660,7 @@ static const AVClass flac_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_flac_decoder = {
+const AVCodec ff_flac_decoder = {
     .name           = "flac",
     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/flacenc.c b/libavcodec/flacenc.c
index 9460b1afc8..caa9092314 100644
--- a/libavcodec/flacenc.c
+++ b/libavcodec/flacenc.c
@@ -1457,7 +1457,7 @@ static const AVClass flac_encoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_flac_encoder = {
+const AVCodec ff_flac_encoder = {
     .name           = "flac",
     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/flashsv.c b/libavcodec/flashsv.c
index 9481f80f0b..4240091d92 100644
--- a/libavcodec/flashsv.c
+++ b/libavcodec/flashsv.c
@@ -507,7 +507,7 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
 }
 
 #if CONFIG_FLASHSV_DECODER
-AVCodec ff_flashsv_decoder = {
+const AVCodec ff_flashsv_decoder = {
     .name           = "flashsv",
     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -575,7 +575,7 @@ static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_flashsv2_decoder = {
+const AVCodec ff_flashsv2_decoder = {
     .name           = "flashsv2",
     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/flashsv2enc.c b/libavcodec/flashsv2enc.c
index 00aedf0795..5e91367796 100644
--- a/libavcodec/flashsv2enc.c
+++ b/libavcodec/flashsv2enc.c
@@ -897,7 +897,7 @@ static av_cold int flashsv2_encode_end(AVCodecContext * avctx)
     return 0;
 }
 
-AVCodec ff_flashsv2_encoder = {
+const AVCodec ff_flashsv2_encoder = {
     .name           = "flashsv2",
     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/flashsvenc.c b/libavcodec/flashsvenc.c
index d365ff3999..0b01550c1e 100644
--- a/libavcodec/flashsvenc.c
+++ b/libavcodec/flashsvenc.c
@@ -256,7 +256,7 @@ static int flashsv_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_flashsv_encoder = {
+const AVCodec ff_flashsv_encoder = {
     .name           = "flashsv",
     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/flicvideo.c b/libavcodec/flicvideo.c
index 276c2ff2a6..db35d917a9 100644
--- a/libavcodec/flicvideo.c
+++ b/libavcodec/flicvideo.c
@@ -1102,7 +1102,7 @@ static av_cold int flic_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_flic_decoder = {
+const AVCodec ff_flic_decoder = {
     .name           = "flic",
     .long_name      = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/flvdec.c b/libavcodec/flvdec.c
index c19f07fe05..6258c1c0a7 100644
--- a/libavcodec/flvdec.c
+++ b/libavcodec/flvdec.c
@@ -113,7 +113,7 @@ int ff_flv_decode_picture_header(MpegEncContext *s)
     return 0;
 }
 
-AVCodec ff_flv_decoder = {
+const AVCodec ff_flv_decoder = {
     .name           = "flv",
     .long_name      = NULL_IF_CONFIG_SMALL("FLV / Sorenson Spark / Sorenson H.263 (Flash Video)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/flvenc.c b/libavcodec/flvenc.c
index b85e4667c4..8a4ae392ee 100644
--- a/libavcodec/flvenc.c
+++ b/libavcodec/flvenc.c
@@ -98,7 +98,7 @@ static const AVClass flv_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_flv_encoder = {
+const AVCodec ff_flv_encoder = {
     .name           = "flv",
     .long_name      = NULL_IF_CONFIG_SMALL("FLV / Sorenson Spark / Sorenson H.263 (Flash Video)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/fmvc.c b/libavcodec/fmvc.c
index 3701b0849b..aab46da9cf 100644
--- a/libavcodec/fmvc.c
+++ b/libavcodec/fmvc.c
@@ -626,7 +626,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_fmvc_decoder = {
+const AVCodec ff_fmvc_decoder = {
     .name             = "fmvc",
     .long_name        = NULL_IF_CONFIG_SMALL("FM Screen Capture Codec"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/fraps.c b/libavcodec/fraps.c
index 8d01b44f11..b3262a4b23 100644
--- a/libavcodec/fraps.c
+++ b/libavcodec/fraps.c
@@ -342,7 +342,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_fraps_decoder = {
+const AVCodec ff_fraps_decoder = {
     .name           = "fraps",
     .long_name      = NULL_IF_CONFIG_SMALL("Fraps"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/frwu.c b/libavcodec/frwu.c
index e68fda967f..d0a9102fe3 100644
--- a/libavcodec/frwu.c
+++ b/libavcodec/frwu.c
@@ -115,7 +115,7 @@ static const AVClass frwu_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_frwu_decoder = {
+const AVCodec ff_frwu_decoder = {
     .name           = "frwu",
     .long_name      = NULL_IF_CONFIG_SMALL("Forward Uncompressed"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/g2meet.c b/libavcodec/g2meet.c
index da910c1e59..66f4557f06 100644
--- a/libavcodec/g2meet.c
+++ b/libavcodec/g2meet.c
@@ -1623,7 +1623,7 @@ static av_cold int g2m_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_g2m_decoder = {
+const AVCodec ff_g2m_decoder = {
     .name           = "g2m",
     .long_name      = NULL_IF_CONFIG_SMALL("Go2Meeting"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/g722dec.c b/libavcodec/g722dec.c
index 8444d9a4bc..96cf1a86f1 100644
--- a/libavcodec/g722dec.c
+++ b/libavcodec/g722dec.c
@@ -139,7 +139,7 @@ static int g722_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_adpcm_g722_decoder = {
+const AVCodec ff_adpcm_g722_decoder = {
     .name           = "g722",
     .long_name      = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/g722enc.c b/libavcodec/g722enc.c
index 9e2ebf67c5..24880f9550 100644
--- a/libavcodec/g722enc.c
+++ b/libavcodec/g722enc.c
@@ -368,7 +368,7 @@ static int g722_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_adpcm_g722_encoder = {
+const AVCodec ff_adpcm_g722_encoder = {
     .name            = "g722",
     .long_name       = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
     .type            = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/g723_1dec.c b/libavcodec/g723_1dec.c
index fddd4b03c0..3b052f3801 100644
--- a/libavcodec/g723_1dec.c
+++ b/libavcodec/g723_1dec.c
@@ -1110,7 +1110,7 @@ static const AVClass g723_1dec_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_g723_1_decoder = {
+const AVCodec ff_g723_1_decoder = {
     .name           = "g723_1",
     .long_name      = NULL_IF_CONFIG_SMALL("G.723.1"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/g723_1enc.c b/libavcodec/g723_1enc.c
index 11b0c7f71e..2fb4b7fc82 100644
--- a/libavcodec/g723_1enc.c
+++ b/libavcodec/g723_1enc.c
@@ -1244,7 +1244,7 @@ static const AVCodecDefault defaults[] = {
     { NULL },
 };
 
-AVCodec ff_g723_1_encoder = {
+const AVCodec ff_g723_1_encoder = {
     .name           = "g723_1",
     .long_name      = NULL_IF_CONFIG_SMALL("G.723.1"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/g726.c b/libavcodec/g726.c
index 71f5791416..d643fbf968 100644
--- a/libavcodec/g726.c
+++ b/libavcodec/g726.c
@@ -396,7 +396,7 @@ static const AVClass g726_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_adpcm_g726_encoder = {
+const AVCodec ff_adpcm_g726_encoder = {
     .name           = "g726",
     .long_name      = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -420,7 +420,7 @@ static const AVClass g726le_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_adpcm_g726le_encoder = {
+const AVCodec ff_adpcm_g726le_encoder = {
     .name           = "g726le",
     .long_name      = NULL_IF_CONFIG_SMALL("G.726 little endian ADPCM (\"right-justified\")"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -504,7 +504,7 @@ static void g726_decode_flush(AVCodecContext *avctx)
 #endif
 
 #if CONFIG_ADPCM_G726_DECODER
-AVCodec ff_adpcm_g726_decoder = {
+const AVCodec ff_adpcm_g726_decoder = {
     .name           = "g726",
     .long_name      = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -518,7 +518,7 @@ AVCodec ff_adpcm_g726_decoder = {
 #endif
 
 #if CONFIG_ADPCM_G726LE_DECODER
-AVCodec ff_adpcm_g726le_decoder = {
+const AVCodec ff_adpcm_g726le_decoder = {
     .name           = "g726le",
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_ADPCM_G726LE,
diff --git a/libavcodec/g729dec.c b/libavcodec/g729dec.c
index c181f23452..eca69026c0 100644
--- a/libavcodec/g729dec.c
+++ b/libavcodec/g729dec.c
@@ -750,7 +750,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_g729_decoder = {
+const AVCodec ff_g729_decoder = {
     .name           = "g729",
     .long_name      = NULL_IF_CONFIG_SMALL("G.729"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -762,7 +762,7 @@ AVCodec ff_g729_decoder = {
     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
 };
 
-AVCodec ff_acelp_kelvin_decoder = {
+const AVCodec ff_acelp_kelvin_decoder = {
     .name           = "acelp.kelvin",
     .long_name      = NULL_IF_CONFIG_SMALL("Sipro ACELP.KELVIN"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/gdv.c b/libavcodec/gdv.c
index 406d79df01..222e604c8b 100644
--- a/libavcodec/gdv.c
+++ b/libavcodec/gdv.c
@@ -560,7 +560,7 @@ static av_cold int gdv_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_gdv_decoder = {
+const AVCodec ff_gdv_decoder = {
     .name           = "gdv",
     .long_name      = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/gif.c b/libavcodec/gif.c
index cafd93e190..f3ee15c2ac 100644
--- a/libavcodec/gif.c
+++ b/libavcodec/gif.c
@@ -551,7 +551,7 @@ static const AVClass gif_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_gif_encoder = {
+const AVCodec ff_gif_encoder = {
     .name           = "gif",
     .long_name      = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/gifdec.c b/libavcodec/gifdec.c
index dffc860bbc..80f1ba0cce 100644
--- a/libavcodec/gifdec.c
+++ b/libavcodec/gifdec.c
@@ -554,7 +554,7 @@ static const AVClass decoder_class = {
     .category   = AV_CLASS_CATEGORY_DECODER,
 };
 
-AVCodec ff_gif_decoder = {
+const AVCodec ff_gif_decoder = {
     .name           = "gif",
     .long_name      = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/gsmdec.c b/libavcodec/gsmdec.c
index bf3740aa5d..373ed087ef 100644
--- a/libavcodec/gsmdec.c
+++ b/libavcodec/gsmdec.c
@@ -111,7 +111,7 @@ static void gsm_flush(AVCodecContext *avctx)
 }
 
 #if CONFIG_GSM_DECODER
-AVCodec ff_gsm_decoder = {
+const AVCodec ff_gsm_decoder = {
     .name           = "gsm",
     .long_name      = NULL_IF_CONFIG_SMALL("GSM"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -124,7 +124,7 @@ AVCodec ff_gsm_decoder = {
 };
 #endif
 #if CONFIG_GSM_MS_DECODER
-AVCodec ff_gsm_ms_decoder = {
+const AVCodec ff_gsm_ms_decoder = {
     .name           = "gsm_ms",
     .long_name      = NULL_IF_CONFIG_SMALL("GSM Microsoft variant"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/h261dec.c b/libavcodec/h261dec.c
index 0d8cd8c20d..80ec1c8814 100644
--- a/libavcodec/h261dec.c
+++ b/libavcodec/h261dec.c
@@ -665,7 +665,7 @@ static av_cold int h261_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_h261_decoder = {
+const AVCodec ff_h261_decoder = {
     .name           = "h261",
     .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index eec526c500..da681f140a 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -392,7 +392,7 @@ static const AVClass h261_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_h261_encoder = {
+const AVCodec ff_h261_encoder = {
     .name           = "h261",
     .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/h263dec.c b/libavcodec/h263dec.c
index 192cc487da..f05dfbf25e 100644
--- a/libavcodec/h263dec.c
+++ b/libavcodec/h263dec.c
@@ -759,7 +759,7 @@ const AVCodecHWConfigInternal *const ff_h263_hw_config_list[] = {
     NULL
 };
 
-AVCodec ff_h263_decoder = {
+const AVCodec ff_h263_decoder = {
     .name           = "h263",
     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -777,7 +777,7 @@ AVCodec ff_h263_decoder = {
     .hw_configs     = ff_h263_hw_config_list,
 };
 
-AVCodec ff_h263p_decoder = {
+const AVCodec ff_h263p_decoder = {
     .name           = "h263p",
     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c
index 536020095c..38f8967265 100644
--- a/libavcodec/h264dec.c
+++ b/libavcodec/h264dec.c
@@ -1043,7 +1043,7 @@ static const AVClass h264_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_h264_decoder = {
+const AVCodec ff_h264_decoder = {
     .name                  = "h264",
     .long_name             = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/hapdec.c b/libavcodec/hapdec.c
index 692bb6e750..2c8c5c36ba 100644
--- a/libavcodec/hapdec.c
+++ b/libavcodec/hapdec.c
@@ -478,7 +478,7 @@ static av_cold int hap_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_hap_decoder = {
+const AVCodec ff_hap_decoder = {
     .name           = "hap",
     .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/hapenc.c b/libavcodec/hapenc.c
index 3a1bc870b1..7801111e15 100644
--- a/libavcodec/hapenc.c
+++ b/libavcodec/hapenc.c
@@ -349,7 +349,7 @@ static const AVClass hapenc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_hap_encoder = {
+const AVCodec ff_hap_encoder = {
     .name           = "hap",
     .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/hcadec.c b/libavcodec/hcadec.c
index 9c3eda21af..c98f8eb379 100644
--- a/libavcodec/hcadec.c
+++ b/libavcodec/hcadec.c
@@ -445,7 +445,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_hca_decoder = {
+const AVCodec ff_hca_decoder = {
     .name           = "hca",
     .long_name      = NULL_IF_CONFIG_SMALL("CRI HCA"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/hcom.c b/libavcodec/hcom.c
index 06fa25fcd2..1c49988b3a 100644
--- a/libavcodec/hcom.c
+++ b/libavcodec/hcom.c
@@ -134,7 +134,7 @@ static av_cold int hcom_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_hcom_decoder = {
+const AVCodec ff_hcom_decoder = {
     .name           = "hcom",
     .long_name      = NULL_IF_CONFIG_SMALL("HCOM Audio"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/hevcdec.c b/libavcodec/hevcdec.c
index ad38f37187..2d35b0b182 100644
--- a/libavcodec/hevcdec.c
+++ b/libavcodec/hevcdec.c
@@ -3667,7 +3667,7 @@ static const AVClass hevc_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_hevc_decoder = {
+const AVCodec ff_hevc_decoder = {
     .name                  = "hevc",
     .long_name             = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/hnm4video.c b/libavcodec/hnm4video.c
index 43baa9c572..0d3fa7d1e8 100644
--- a/libavcodec/hnm4video.c
+++ b/libavcodec/hnm4video.c
@@ -497,7 +497,7 @@ static av_cold int hnm_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_hnm4_video_decoder = {
+const AVCodec ff_hnm4_video_decoder = {
     .name           = "hnm4video",
     .long_name      = NULL_IF_CONFIG_SMALL("HNM 4 video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/hq_hqa.c b/libavcodec/hq_hqa.c
index 8404e80ec8..71753e7cc2 100644
--- a/libavcodec/hq_hqa.c
+++ b/libavcodec/hq_hqa.c
@@ -381,7 +381,7 @@ static av_cold int hq_hqa_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_hq_hqa_decoder = {
+const AVCodec ff_hq_hqa_decoder = {
     .name           = "hq_hqa",
     .long_name      = NULL_IF_CONFIG_SMALL("Canopus HQ/HQA"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/hqx.c b/libavcodec/hqx.c
index aa4ff22a8f..3a4db1b6c3 100644
--- a/libavcodec/hqx.c
+++ b/libavcodec/hqx.c
@@ -535,7 +535,7 @@ static av_cold int hqx_decode_init(AVCodecContext *avctx)
     return ff_hqx_init_vlcs(ctx);
 }
 
-AVCodec ff_hqx_decoder = {
+const AVCodec ff_hqx_decoder = {
     .name           = "hqx",
     .long_name      = NULL_IF_CONFIG_SMALL("Canopus HQX"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/huffyuvdec.c b/libavcodec/huffyuvdec.c
index e713b91e4d..62907ecb5e 100644
--- a/libavcodec/huffyuvdec.c
+++ b/libavcodec/huffyuvdec.c
@@ -1270,7 +1270,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
 }
 
-AVCodec ff_huffyuv_decoder = {
+const AVCodec ff_huffyuv_decoder = {
     .name             = "huffyuv",
     .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
     .type             = AVMEDIA_TYPE_VIDEO,
@@ -1284,7 +1284,7 @@ AVCodec ff_huffyuv_decoder = {
 };
 
 #if CONFIG_FFVHUFF_DECODER
-AVCodec ff_ffvhuff_decoder = {
+const AVCodec ff_ffvhuff_decoder = {
     .name             = "ffvhuff",
     .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
     .type             = AVMEDIA_TYPE_VIDEO,
@@ -1299,7 +1299,7 @@ AVCodec ff_ffvhuff_decoder = {
 #endif /* CONFIG_FFVHUFF_DECODER */
 
 #if CONFIG_HYMT_DECODER
-AVCodec ff_hymt_decoder = {
+const AVCodec ff_hymt_decoder = {
     .name             = "hymt",
     .long_name        = NULL_IF_CONFIG_SMALL("HuffYUV MT"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/huffyuvenc.c b/libavcodec/huffyuvenc.c
index f1b42c8499..6e08a94d41 100644
--- a/libavcodec/huffyuvenc.c
+++ b/libavcodec/huffyuvenc.c
@@ -1048,7 +1048,7 @@ static const AVClass ff_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_huffyuv_encoder = {
+const AVCodec ff_huffyuv_encoder = {
     .name           = "huffyuv",
     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -1068,7 +1068,7 @@ AVCodec ff_huffyuv_encoder = {
 };
 
 #if CONFIG_FFVHUFF_ENCODER
-AVCodec ff_ffvhuff_encoder = {
+const AVCodec ff_ffvhuff_encoder = {
     .name           = "ffvhuff",
     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/idcinvideo.c b/libavcodec/idcinvideo.c
index b79ec93108..41df545542 100644
--- a/libavcodec/idcinvideo.c
+++ b/libavcodec/idcinvideo.c
@@ -242,7 +242,7 @@ static const AVCodecDefault idcin_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_idcin_decoder = {
+const AVCodec ff_idcin_decoder = {
     .name           = "idcinvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("id Quake II CIN video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/iff.c b/libavcodec/iff.c
index 79f6215c77..fe1baf3a0c 100644
--- a/libavcodec/iff.c
+++ b/libavcodec/iff.c
@@ -1903,7 +1903,7 @@ static int decode_frame(AVCodecContext *avctx,
 }
 
 #if CONFIG_IFF_ILBM_DECODER
-AVCodec ff_iff_ilbm_decoder = {
+const AVCodec ff_iff_ilbm_decoder = {
     .name           = "iff",
     .long_name      = NULL_IF_CONFIG_SMALL("IFF ACBM/ANIM/DEEP/ILBM/PBM/RGB8/RGBN"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ilbcdec.c b/libavcodec/ilbcdec.c
index 33f4e2c1eb..a23b697806 100644
--- a/libavcodec/ilbcdec.c
+++ b/libavcodec/ilbcdec.c
@@ -1477,7 +1477,7 @@ static av_cold int ilbc_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_ilbc_decoder = {
+const AVCodec ff_ilbc_decoder = {
     .name           = "ilbc",
     .long_name      = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/imc.c b/libavcodec/imc.c
index 51e7c1b2e1..cbe3edeeec 100644
--- a/libavcodec/imc.c
+++ b/libavcodec/imc.c
@@ -1084,7 +1084,7 @@ static av_cold void flush(AVCodecContext *avctx)
 }
 
 #if CONFIG_IMC_DECODER
-AVCodec ff_imc_decoder = {
+const AVCodec ff_imc_decoder = {
     .name           = "imc",
     .long_name      = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -1101,7 +1101,7 @@ AVCodec ff_imc_decoder = {
 };
 #endif
 #if CONFIG_IAC_DECODER
-AVCodec ff_iac_decoder = {
+const AVCodec ff_iac_decoder = {
     .name           = "iac",
     .long_name      = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/imm4.c b/libavcodec/imm4.c
index 636130dd54..a47c1e1ed8 100644
--- a/libavcodec/imm4.c
+++ b/libavcodec/imm4.c
@@ -532,7 +532,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_imm4_decoder = {
+const AVCodec ff_imm4_decoder = {
     .name             = "imm4",
     .long_name        = NULL_IF_CONFIG_SMALL("Infinity IMM4"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/imm5.c b/libavcodec/imm5.c
index 5f8faa4dd0..cb8a619a4a 100644
--- a/libavcodec/imm5.c
+++ b/libavcodec/imm5.c
@@ -178,7 +178,7 @@ static av_cold int imm5_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_imm5_decoder = {
+const AVCodec ff_imm5_decoder = {
     .name           = "imm5",
     .long_name      = NULL_IF_CONFIG_SMALL("Infinity IMM5"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/imx.c b/libavcodec/imx.c
index d86c747c6d..d81a0de7be 100644
--- a/libavcodec/imx.c
+++ b/libavcodec/imx.c
@@ -179,7 +179,7 @@ static int imx_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_simbiosis_imx_decoder = {
+const AVCodec ff_simbiosis_imx_decoder = {
     .name           = "simbiosis_imx",
     .long_name      = NULL_IF_CONFIG_SMALL("Simbiosis Interactive IMX Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/indeo2.c b/libavcodec/indeo2.c
index 5721308267..02fc7fefa1 100644
--- a/libavcodec/indeo2.c
+++ b/libavcodec/indeo2.c
@@ -260,7 +260,7 @@ static av_cold int ir2_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_indeo2_decoder = {
+const AVCodec ff_indeo2_decoder = {
     .name           = "indeo2",
     .long_name      = NULL_IF_CONFIG_SMALL("Intel Indeo 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/indeo3.c b/libavcodec/indeo3.c
index 5257d983c2..3a8b8712bc 100644
--- a/libavcodec/indeo3.c
+++ b/libavcodec/indeo3.c
@@ -1131,7 +1131,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_indeo3_decoder = {
+const AVCodec ff_indeo3_decoder = {
     .name           = "indeo3",
     .long_name      = NULL_IF_CONFIG_SMALL("Intel Indeo 3"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/indeo4.c b/libavcodec/indeo4.c
index e2778af6ca..3d3579d76b 100644
--- a/libavcodec/indeo4.c
+++ b/libavcodec/indeo4.c
@@ -703,7 +703,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_indeo4_decoder = {
+const AVCodec ff_indeo4_decoder = {
     .name           = "indeo4",
     .long_name      = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 4"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/indeo5.c b/libavcodec/indeo5.c
index 3de4a30ee2..fbf0c004d8 100644
--- a/libavcodec/indeo5.c
+++ b/libavcodec/indeo5.c
@@ -683,7 +683,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_indeo5_decoder = {
+const AVCodec ff_indeo5_decoder = {
     .name           = "indeo5",
     .long_name      = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 5"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/intelh263dec.c b/libavcodec/intelh263dec.c
index 283fb1cb0a..7c794dc5e3 100644
--- a/libavcodec/intelh263dec.c
+++ b/libavcodec/intelh263dec.c
@@ -128,7 +128,7 @@ int ff_intel_h263_decode_picture_header(MpegEncContext *s)
     return 0;
 }
 
-AVCodec ff_h263i_decoder = {
+const AVCodec ff_h263i_decoder = {
     .name           = "h263i",
     .long_name      = NULL_IF_CONFIG_SMALL("Intel H.263"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/interplayacm.c b/libavcodec/interplayacm.c
index 3704d1a2f2..9838411cdc 100644
--- a/libavcodec/interplayacm.c
+++ b/libavcodec/interplayacm.c
@@ -621,7 +621,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_interplay_acm_decoder = {
+const AVCodec ff_interplay_acm_decoder = {
     .name           = "interplayacm",
     .long_name      = NULL_IF_CONFIG_SMALL("Interplay ACM"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/interplayvideo.c b/libavcodec/interplayvideo.c
index 388fe2665e..bd1d7c74ba 100644
--- a/libavcodec/interplayvideo.c
+++ b/libavcodec/interplayvideo.c
@@ -1357,7 +1357,7 @@ static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_interplay_video_decoder = {
+const AVCodec ff_interplay_video_decoder = {
     .name           = "interplayvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/j2kenc.c b/libavcodec/j2kenc.c
index 40ba965cdb..c51adadd13 100644
--- a/libavcodec/j2kenc.c
+++ b/libavcodec/j2kenc.c
@@ -1832,7 +1832,7 @@ static const AVClass j2k_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_jpeg2000_encoder = {
+const AVCodec ff_jpeg2000_encoder = {
     .name           = "jpeg2000",
     .long_name      = NULL_IF_CONFIG_SMALL("JPEG 2000"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/jacosubdec.c b/libavcodec/jacosubdec.c
index cdb372af58..4054612a3d 100644
--- a/libavcodec/jacosubdec.c
+++ b/libavcodec/jacosubdec.c
@@ -193,7 +193,7 @@ end:
     return avpkt->size;
 }
 
-AVCodec ff_jacosub_decoder = {
+const AVCodec ff_jacosub_decoder = {
     .name           = "jacosub",
     .long_name      = NULL_IF_CONFIG_SMALL("JACOsub subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c
index 63edbcda09..5364631432 100644
--- a/libavcodec/jpeg2000dec.c
+++ b/libavcodec/jpeg2000dec.c
@@ -2578,7 +2578,7 @@ static const AVClass jpeg2000_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_jpeg2000_decoder = {
+const AVCodec ff_jpeg2000_decoder = {
     .name             = "jpeg2000",
     .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/jpeglsdec.c b/libavcodec/jpeglsdec.c
index 92df81600b..bb9ece8d54 100644
--- a/libavcodec/jpeglsdec.c
+++ b/libavcodec/jpeglsdec.c
@@ -543,7 +543,7 @@ end:
     return ret;
 }
 
-AVCodec ff_jpegls_decoder = {
+const AVCodec ff_jpegls_decoder = {
     .name           = "jpegls",
     .long_name      = NULL_IF_CONFIG_SMALL("JPEG-LS"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/jpeglsenc.c b/libavcodec/jpeglsenc.c
index bc64288c95..3e73b04c0e 100644
--- a/libavcodec/jpeglsenc.c
+++ b/libavcodec/jpeglsenc.c
@@ -431,7 +431,7 @@ static const AVClass jpegls_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_jpegls_encoder = {
+const AVCodec ff_jpegls_encoder = {
     .name           = "jpegls",
     .long_name      = NULL_IF_CONFIG_SMALL("JPEG-LS"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/jvdec.c b/libavcodec/jvdec.c
index 6f10157b0d..584b4a717c 100644
--- a/libavcodec/jvdec.c
+++ b/libavcodec/jvdec.c
@@ -233,7 +233,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_jv_decoder = {
+const AVCodec ff_jv_decoder = {
     .name           = "jv",
     .long_name      = NULL_IF_CONFIG_SMALL("Bitmap Brothers JV video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/kgv1dec.c b/libavcodec/kgv1dec.c
index a6bd9400ac..427f57f416 100644
--- a/libavcodec/kgv1dec.c
+++ b/libavcodec/kgv1dec.c
@@ -176,7 +176,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_kgv1_decoder = {
+const AVCodec ff_kgv1_decoder = {
     .name           = "kgv1",
     .long_name      = NULL_IF_CONFIG_SMALL("Kega Game Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/kmvc.c b/libavcodec/kmvc.c
index 56c1977254..5d3dd4ce63 100644
--- a/libavcodec/kmvc.c
+++ b/libavcodec/kmvc.c
@@ -404,7 +404,7 @@ static av_cold int decode_init(AVCodecContext * avctx)
     return 0;
 }
 
-AVCodec ff_kmvc_decoder = {
+const AVCodec ff_kmvc_decoder = {
     .name           = "kmvc",
     .long_name      = NULL_IF_CONFIG_SMALL("Karl Morton's video codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/lagarith.c b/libavcodec/lagarith.c
index d81e55cf4c..69899e423e 100644
--- a/libavcodec/lagarith.c
+++ b/libavcodec/lagarith.c
@@ -712,7 +712,7 @@ static av_cold int lag_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_lagarith_decoder = {
+const AVCodec ff_lagarith_decoder = {
     .name           = "lagarith",
     .long_name      = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/lcldec.c b/libavcodec/lcldec.c
index d281733fdd..a47e3bd780 100644
--- a/libavcodec/lcldec.c
+++ b/libavcodec/lcldec.c
@@ -638,7 +638,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
 }
 
 #if CONFIG_MSZH_DECODER
-AVCodec ff_mszh_decoder = {
+const AVCodec ff_mszh_decoder = {
     .name           = "mszh",
     .long_name      = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) MSZH"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -653,7 +653,7 @@ AVCodec ff_mszh_decoder = {
 #endif
 
 #if CONFIG_ZLIB_DECODER
-AVCodec ff_zlib_decoder = {
+const AVCodec ff_zlib_decoder = {
     .name           = "zlib",
     .long_name      = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/lclenc.c b/libavcodec/lclenc.c
index 250cb5625c..9484279771 100644
--- a/libavcodec/lclenc.c
+++ b/libavcodec/lclenc.c
@@ -160,7 +160,7 @@ static av_cold int encode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_zlib_encoder = {
+const AVCodec ff_zlib_encoder = {
     .name           = "zlib",
     .long_name      = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libaomdec.c b/libavcodec/libaomdec.c
index 4b9125a32c..6e7324a832 100644
--- a/libavcodec/libaomdec.c
+++ b/libavcodec/libaomdec.c
@@ -243,7 +243,7 @@ static av_cold int av1_init(AVCodecContext *avctx)
     return aom_init(avctx, &aom_codec_av1_dx_algo);
 }
 
-AVCodec ff_libaom_av1_decoder = {
+const AVCodec ff_libaom_av1_decoder = {
     .name           = "libaom-av1",
     .long_name      = NULL_IF_CONFIG_SMALL("libaom AV1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libaribb24.c b/libavcodec/libaribb24.c
index 3a59938451..0766c0079d 100644
--- a/libavcodec/libaribb24.c
+++ b/libavcodec/libaribb24.c
@@ -380,7 +380,7 @@ static const AVClass aribb24_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libaribb24_decoder = {
+const AVCodec ff_libaribb24_decoder = {
     .name      = "libaribb24",
     .long_name = NULL_IF_CONFIG_SMALL("libaribb24 ARIB STD-B24 caption decoder"),
     .type      = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/libcelt_dec.c b/libavcodec/libcelt_dec.c
index 75b438b285..c0fb4013c9 100644
--- a/libavcodec/libcelt_dec.c
+++ b/libavcodec/libcelt_dec.c
@@ -127,7 +127,7 @@ static int libcelt_dec_decode(AVCodecContext *c, void *data,
     return pkt->size;
 }
 
-AVCodec ff_libcelt_decoder = {
+const AVCodec ff_libcelt_decoder = {
     .name           = "libcelt",
     .long_name      = NULL_IF_CONFIG_SMALL("Xiph CELT decoder using libcelt"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libcodec2.c b/libavcodec/libcodec2.c
index 2164f36051..562a616f59 100644
--- a/libavcodec/libcodec2.c
+++ b/libavcodec/libcodec2.c
@@ -180,7 +180,7 @@ static int libcodec2_encode(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_libcodec2_decoder = {
+const AVCodec ff_libcodec2_decoder = {
     .name                   = "libcodec2",
     .long_name              = NULL_IF_CONFIG_SMALL("codec2 decoder using libcodec2"),
     .type                   = AVMEDIA_TYPE_AUDIO,
@@ -196,7 +196,7 @@ AVCodec ff_libcodec2_decoder = {
     .priv_class             = &libcodec2_dec_class,
 };
 
-AVCodec ff_libcodec2_encoder = {
+const AVCodec ff_libcodec2_encoder = {
     .name                   = "libcodec2",
     .long_name              = NULL_IF_CONFIG_SMALL("codec2 encoder using libcodec2"),
     .type                   = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libdav1d.c b/libavcodec/libdav1d.c
index 90c531fb91..50e6200f5d 100644
--- a/libavcodec/libdav1d.c
+++ b/libavcodec/libdav1d.c
@@ -469,7 +469,7 @@ static const AVClass libdav1d_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libdav1d_decoder = {
+const AVCodec ff_libdav1d_decoder = {
     .name           = "libdav1d",
     .long_name      = NULL_IF_CONFIG_SMALL("dav1d AV1 decoder by VideoLAN"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libdavs2.c b/libavcodec/libdavs2.c
index 0f18353c93..28cad9c5f7 100644
--- a/libavcodec/libdavs2.c
+++ b/libavcodec/libdavs2.c
@@ -212,7 +212,7 @@ static int davs2_decode_frame(AVCodecContext *avctx, void *data,
     return ret == 0 ? buf_size : ret;
 }
 
-AVCodec ff_libdavs2_decoder = {
+const AVCodec ff_libdavs2_decoder = {
     .name           = "libdavs2",
     .long_name      = NULL_IF_CONFIG_SMALL("libdavs2 AVS2-P2/IEEE1857.4"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libfdk-aacdec.c b/libavcodec/libfdk-aacdec.c
index 1a86dffe4b..ffa1fdcce3 100644
--- a/libavcodec/libfdk-aacdec.c
+++ b/libavcodec/libfdk-aacdec.c
@@ -408,7 +408,7 @@ static av_cold void fdk_aac_decode_flush(AVCodecContext *avctx)
         av_log(avctx, AV_LOG_WARNING, "failed to clear buffer when flushing\n");
 }
 
-AVCodec ff_libfdk_aac_decoder = {
+const AVCodec ff_libfdk_aac_decoder = {
     .name           = "libfdk_aac",
     .long_name      = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libfdk-aacenc.c b/libavcodec/libfdk-aacenc.c
index 6494c11ddc..b848cd8851 100644
--- a/libavcodec/libfdk-aacenc.c
+++ b/libavcodec/libfdk-aacenc.c
@@ -458,7 +458,7 @@ static const int aac_sample_rates[] = {
     24000, 22050, 16000, 12000, 11025, 8000, 0
 };
 
-AVCodec ff_libfdk_aac_encoder = {
+const AVCodec ff_libfdk_aac_encoder = {
     .name                  = "libfdk_aac",
     .long_name             = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libgsmdec.c b/libavcodec/libgsmdec.c
index 1182afae6b..ae4a952d99 100644
--- a/libavcodec/libgsmdec.c
+++ b/libavcodec/libgsmdec.c
@@ -124,7 +124,7 @@ static void libgsm_flush(AVCodecContext *avctx) {
 }
 
 #if CONFIG_LIBGSM_DECODER
-AVCodec ff_libgsm_decoder = {
+const AVCodec ff_libgsm_decoder = {
     .name           = "libgsm",
     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -139,7 +139,7 @@ AVCodec ff_libgsm_decoder = {
 };
 #endif
 #if CONFIG_LIBGSM_MS_DECODER
-AVCodec ff_libgsm_ms_decoder = {
+const AVCodec ff_libgsm_ms_decoder = {
     .name           = "libgsm_ms",
     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libgsmenc.c b/libavcodec/libgsmenc.c
index fdb11c705e..850963e8f6 100644
--- a/libavcodec/libgsmenc.c
+++ b/libavcodec/libgsmenc.c
@@ -120,7 +120,7 @@ static const AVCodecDefault libgsm_defaults[] = {
 };
 
 #if CONFIG_LIBGSM_ENCODER
-AVCodec ff_libgsm_encoder = {
+const AVCodec ff_libgsm_encoder = {
     .name           = "libgsm",
     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -136,7 +136,7 @@ AVCodec ff_libgsm_encoder = {
 };
 #endif
 #if CONFIG_LIBGSM_MS_ENCODER
-AVCodec ff_libgsm_ms_encoder = {
+const AVCodec ff_libgsm_ms_encoder = {
     .name           = "libgsm_ms",
     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libilbc.c b/libavcodec/libilbc.c
index 9c82589918..20a2951850 100644
--- a/libavcodec/libilbc.c
+++ b/libavcodec/libilbc.c
@@ -116,7 +116,7 @@ static int ilbc_decode_frame(AVCodecContext *avctx, void *data,
     return s->decoder.no_of_bytes;
 }
 
-AVCodec ff_libilbc_decoder = {
+const AVCodec ff_libilbc_decoder = {
     .name           = "libilbc",
     .long_name      = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -198,7 +198,7 @@ static const AVCodecDefault ilbc_encode_defaults[] = {
     { NULL }
 };
 
-AVCodec ff_libilbc_encoder = {
+const AVCodec ff_libilbc_encoder = {
     .name           = "libilbc",
     .long_name      = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libkvazaar.c b/libavcodec/libkvazaar.c
index 7dca605059..54788e154b 100644
--- a/libavcodec/libkvazaar.c
+++ b/libavcodec/libkvazaar.c
@@ -314,7 +314,7 @@ static const AVCodecDefault defaults[] = {
     { NULL },
 };
 
-AVCodec ff_libkvazaar_encoder = {
+const AVCodec ff_libkvazaar_encoder = {
     .name             = "libkvazaar",
     .long_name        = NULL_IF_CONFIG_SMALL("libkvazaar H.265 / HEVC"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libmp3lame.c b/libavcodec/libmp3lame.c
index 2beb28e569..fe4b50257f 100644
--- a/libavcodec/libmp3lame.c
+++ b/libavcodec/libmp3lame.c
@@ -327,7 +327,7 @@ static const int libmp3lame_sample_rates[] = {
     44100, 48000,  32000, 22050, 24000, 16000, 11025, 12000, 8000, 0
 };
 
-AVCodec ff_libmp3lame_encoder = {
+const AVCodec ff_libmp3lame_encoder = {
     .name                  = "libmp3lame",
     .long_name             = NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libopencore-amr.c b/libavcodec/libopencore-amr.c
index f23bb48d5b..e88431ba9f 100644
--- a/libavcodec/libopencore-amr.c
+++ b/libavcodec/libopencore-amr.c
@@ -130,7 +130,7 @@ static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
     return packet_size;
 }
 
-AVCodec ff_libopencore_amrnb_decoder = {
+const AVCodec ff_libopencore_amrnb_decoder = {
     .name           = "libopencore_amrnb",
     .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -285,7 +285,7 @@ static int amr_nb_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_libopencore_amrnb_encoder = {
+const AVCodec ff_libopencore_amrnb_encoder = {
     .name           = "libopencore_amrnb",
     .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -370,7 +370,7 @@ static int amr_wb_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_libopencore_amrwb_decoder = {
+const AVCodec ff_libopencore_amrwb_decoder = {
     .name           = "libopencore_amrwb",
     .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-WB (Adaptive Multi-Rate Wide-Band)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libopenh264dec.c b/libavcodec/libopenh264dec.c
index 832bfc49ef..ea70a8e143 100644
--- a/libavcodec/libopenh264dec.c
+++ b/libavcodec/libopenh264dec.c
@@ -155,7 +155,7 @@ static int svc_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_libopenh264_decoder = {
+const AVCodec ff_libopenh264_decoder = {
     .name           = "libopenh264",
     .long_name      = NULL_IF_CONFIG_SMALL("OpenH264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libopenh264enc.c b/libavcodec/libopenh264enc.c
index 608fa59cdd..54babc3e97 100644
--- a/libavcodec/libopenh264enc.c
+++ b/libavcodec/libopenh264enc.c
@@ -428,7 +428,7 @@ static const AVCodecDefault svc_enc_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_libopenh264_encoder = {
+const AVCodec ff_libopenh264_encoder = {
     .name           = "libopenh264",
     .long_name      = NULL_IF_CONFIG_SMALL("OpenH264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libopenjpegdec.c b/libavcodec/libopenjpegdec.c
index 344c5ba5a3..8982d21be4 100644
--- a/libavcodec/libopenjpegdec.c
+++ b/libavcodec/libopenjpegdec.c
@@ -502,7 +502,7 @@ static const AVClass openjpeg_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libopenjpeg_decoder = {
+const AVCodec ff_libopenjpeg_decoder = {
     .name           = "libopenjpeg",
     .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libopenjpegenc.c b/libavcodec/libopenjpegenc.c
index e4641235f5..14808a7591 100644
--- a/libavcodec/libopenjpegenc.c
+++ b/libavcodec/libopenjpegenc.c
@@ -755,7 +755,7 @@ static const AVClass openjpeg_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libopenjpeg_encoder = {
+const AVCodec ff_libopenjpeg_encoder = {
     .name           = "libopenjpeg",
     .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libopusdec.c b/libavcodec/libopusdec.c
index 082a431c6c..86ef715205 100644
--- a/libavcodec/libopusdec.c
+++ b/libavcodec/libopusdec.c
@@ -225,7 +225,7 @@ static const AVClass libopusdec_class = {
 };
 
 
-AVCodec ff_libopus_decoder = {
+const AVCodec ff_libopus_decoder = {
     .name           = "libopus",
     .long_name      = NULL_IF_CONFIG_SMALL("libopus Opus"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libopusenc.c b/libavcodec/libopusenc.c
index 70d17f802b..8c99b26ddf 100644
--- a/libavcodec/libopusenc.c
+++ b/libavcodec/libopusenc.c
@@ -581,7 +581,7 @@ static const int libopus_sample_rates[] = {
     48000, 24000, 16000, 12000, 8000, 0,
 };
 
-AVCodec ff_libopus_encoder = {
+const AVCodec ff_libopus_encoder = {
     .name            = "libopus",
     .long_name       = NULL_IF_CONFIG_SMALL("libopus Opus"),
     .type            = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/librav1e.c b/libavcodec/librav1e.c
index 37c3007d81..619a4d0b36 100644
--- a/libavcodec/librav1e.c
+++ b/libavcodec/librav1e.c
@@ -612,7 +612,7 @@ static const AVClass class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_librav1e_encoder = {
+const AVCodec ff_librav1e_encoder = {
     .name           = "librav1e",
     .long_name      = NULL_IF_CONFIG_SMALL("librav1e AV1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/librsvgdec.c b/libavcodec/librsvgdec.c
index e9a181d092..2895bbf28b 100644
--- a/libavcodec/librsvgdec.c
+++ b/libavcodec/librsvgdec.c
@@ -117,7 +117,7 @@ static const AVClass librsvg_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_librsvg_decoder = {
+const AVCodec ff_librsvg_decoder = {
     .name           = "librsvg",
     .long_name      = NULL_IF_CONFIG_SMALL("Librsvg rasterizer"),
     .priv_class     = &librsvg_decoder_class,
diff --git a/libavcodec/libshine.c b/libavcodec/libshine.c
index 7056fcd2e3..4a9fc617f0 100644
--- a/libavcodec/libshine.c
+++ b/libavcodec/libshine.c
@@ -130,7 +130,7 @@ static const int libshine_sample_rates[] = {
     44100, 48000, 32000, 0
 };
 
-AVCodec ff_libshine_encoder = {
+const AVCodec ff_libshine_encoder = {
     .name                  = "libshine",
     .long_name             = NULL_IF_CONFIG_SMALL("libshine MP3 (MPEG audio layer 3)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libspeexdec.c b/libavcodec/libspeexdec.c
index b02582b380..6f032907fc 100644
--- a/libavcodec/libspeexdec.c
+++ b/libavcodec/libspeexdec.c
@@ -189,7 +189,7 @@ static av_cold void libspeex_decode_flush(AVCodecContext *avctx)
     speex_bits_reset(&s->bits);
 }
 
-AVCodec ff_libspeex_decoder = {
+const AVCodec ff_libspeex_decoder = {
     .name           = "libspeex",
     .long_name      = NULL_IF_CONFIG_SMALL("libspeex Speex"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libspeexenc.c b/libavcodec/libspeexenc.c
index 6a37dbc76c..c96e2d87fd 100644
--- a/libavcodec/libspeexenc.c
+++ b/libavcodec/libspeexenc.c
@@ -347,7 +347,7 @@ static const AVCodecDefault defaults[] = {
     { NULL },
 };
 
-AVCodec ff_libspeex_encoder = {
+const AVCodec ff_libspeex_encoder = {
     .name           = "libspeex",
     .long_name      = NULL_IF_CONFIG_SMALL("libspeex Speex"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libsvtav1.c b/libavcodec/libsvtav1.c
index cfd93a2484..fabc4e6428 100644
--- a/libavcodec/libsvtav1.c
+++ b/libavcodec/libsvtav1.c
@@ -551,7 +551,7 @@ static const AVCodecDefault eb_enc_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_libsvtav1_encoder = {
+const AVCodec ff_libsvtav1_encoder = {
     .name           = "libsvtav1",
     .long_name      = NULL_IF_CONFIG_SMALL("SVT-AV1(Scalable Video Technology for AV1) encoder"),
     .priv_data_size = sizeof(SvtContext),
diff --git a/libavcodec/libtheoraenc.c b/libavcodec/libtheoraenc.c
index a067fa3344..f26ab501f4 100644
--- a/libavcodec/libtheoraenc.c
+++ b/libavcodec/libtheoraenc.c
@@ -367,7 +367,7 @@ static av_cold int encode_close(AVCodecContext* avc_context)
 }
 
 /** AVCodec struct exposed to libavcodec */
-AVCodec ff_libtheora_encoder = {
+const AVCodec ff_libtheora_encoder = {
     .name           = "libtheora",
     .long_name      = NULL_IF_CONFIG_SMALL("libtheora Theora"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libtwolame.c b/libavcodec/libtwolame.c
index 5ceb3d9f3f..e28141022d 100644
--- a/libavcodec/libtwolame.c
+++ b/libavcodec/libtwolame.c
@@ -206,7 +206,7 @@ static const int twolame_samplerates[] = {
     16000, 22050, 24000, 32000, 44100, 48000, 0
 };
 
-AVCodec ff_libtwolame_encoder = {
+const AVCodec ff_libtwolame_encoder = {
     .name           = "libtwolame",
     .long_name      = NULL_IF_CONFIG_SMALL("libtwolame MP2 (MPEG audio layer 2)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libuavs3d.c b/libavcodec/libuavs3d.c
index be03da39e2..f7e458b356 100644
--- a/libavcodec/libuavs3d.c
+++ b/libavcodec/libuavs3d.c
@@ -244,7 +244,7 @@ static int libuavs3d_decode_frame(AVCodecContext *avctx, void *data, int *got_fr
     return buf_ptr - buf;
 }
 
-AVCodec ff_libuavs3d_decoder = {
+const AVCodec ff_libuavs3d_decoder = {
     .name           = "libuavs3d",
     .long_name      = NULL_IF_CONFIG_SMALL("libuavs3d AVS3-P2/IEEE1857.10"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libvo-amrwbenc.c b/libavcodec/libvo-amrwbenc.c
index 77d0ccef15..e48dc8a5b7 100644
--- a/libavcodec/libvo-amrwbenc.c
+++ b/libavcodec/libvo-amrwbenc.c
@@ -139,7 +139,7 @@ static int amr_wb_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_libvo_amrwbenc_encoder = {
+const AVCodec ff_libvo_amrwbenc_encoder = {
     .name           = "libvo_amrwbenc",
     .long_name      = NULL_IF_CONFIG_SMALL("Android VisualOn AMR-WB "
                                            "(Adaptive Multi-Rate Wide-Band)"),
diff --git a/libavcodec/libvorbisdec.c b/libavcodec/libvorbisdec.c
index ebb0fcdd86..5686aaf096 100644
--- a/libavcodec/libvorbisdec.c
+++ b/libavcodec/libvorbisdec.c
@@ -208,7 +208,7 @@ static int oggvorbis_decode_close(AVCodecContext *avccontext) {
 }
 
 
-AVCodec ff_libvorbis_decoder = {
+const AVCodec ff_libvorbis_decoder = {
     .name           = "libvorbis",
     .long_name      = NULL_IF_CONFIG_SMALL("libvorbis"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libvorbisenc.c b/libavcodec/libvorbisenc.c
index bf94764954..8999a18bf4 100644
--- a/libavcodec/libvorbisenc.c
+++ b/libavcodec/libvorbisenc.c
@@ -374,7 +374,7 @@ static int libvorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_libvorbis_encoder = {
+const AVCodec ff_libvorbis_encoder = {
     .name           = "libvorbis",
     .long_name      = NULL_IF_CONFIG_SMALL("libvorbis"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/libvpxdec.c b/libavcodec/libvpxdec.c
index 67d56fb05e..f9b4c9f427 100644
--- a/libavcodec/libvpxdec.c
+++ b/libavcodec/libvpxdec.c
@@ -352,7 +352,7 @@ static av_cold int vp8_init(AVCodecContext *avctx)
     return vpx_init(avctx, &ctx->decoder, &vpx_codec_vp8_dx_algo);
 }
 
-AVCodec ff_libvpx_vp8_decoder = {
+const AVCodec ff_libvpx_vp8_decoder = {
     .name           = "libvpx",
     .long_name      = NULL_IF_CONFIG_SMALL("libvpx VP8"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libvpxenc.c b/libavcodec/libvpxenc.c
index bcfbbf3e76..8173af5dce 100644
--- a/libavcodec/libvpxenc.c
+++ b/libavcodec/libvpxenc.c
@@ -1825,7 +1825,7 @@ static const AVClass class_vp8 = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libvpx_vp8_encoder = {
+const AVCodec ff_libvpx_vp8_encoder = {
     .name           = "libvpx",
     .long_name      = NULL_IF_CONFIG_SMALL("libvpx VP8"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libwebpenc.c b/libavcodec/libwebpenc.c
index 48f45b6320..2e5b811455 100644
--- a/libavcodec/libwebpenc.c
+++ b/libavcodec/libwebpenc.c
@@ -93,7 +93,7 @@ static const AVClass class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libwebp_encoder = {
+const AVCodec ff_libwebp_encoder = {
     .name           = "libwebp",
     .long_name      = NULL_IF_CONFIG_SMALL("libwebp WebP image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libwebpenc_animencoder.c b/libavcodec/libwebpenc_animencoder.c
index 835891d890..5f0c6ba194 100644
--- a/libavcodec/libwebpenc_animencoder.c
+++ b/libavcodec/libwebpenc_animencoder.c
@@ -131,7 +131,7 @@ static const AVClass class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libwebp_anim_encoder = {
+const AVCodec ff_libwebp_anim_encoder = {
     .name           = "libwebp_anim",
     .long_name      = NULL_IF_CONFIG_SMALL("libwebp WebP image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libx264.c b/libavcodec/libx264.c
index 23f7ad897b..2bed61f91e 100644
--- a/libavcodec/libx264.c
+++ b/libavcodec/libx264.c
@@ -1140,6 +1140,9 @@ static const AVClass x264_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
+#if X264_BUILD >= 153
+const
+#endif
 AVCodec ff_libx264_encoder = {
     .name             = "libx264",
     .long_name        = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
@@ -1176,7 +1179,7 @@ static const AVClass rgbclass = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libx264rgb_encoder = {
+const AVCodec ff_libx264rgb_encoder = {
     .name           = "libx264rgb",
     .long_name      = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -1207,7 +1210,7 @@ static const AVClass X262_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libx262_encoder = {
+const AVCodec ff_libx262_encoder = {
     .name             = "libx262",
     .long_name        = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libxavs.c b/libavcodec/libxavs.c
index b0b6b247b6..3135e221c7 100644
--- a/libavcodec/libxavs.c
+++ b/libavcodec/libxavs.c
@@ -417,7 +417,7 @@ static const AVCodecDefault xavs_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_libxavs_encoder = {
+const AVCodec ff_libxavs_encoder = {
     .name           = "libxavs",
     .long_name      = NULL_IF_CONFIG_SMALL("libxavs Chinese AVS (Audio Video Standard)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libxavs2.c b/libavcodec/libxavs2.c
index 2a4a3e36bd..99fe0e3286 100644
--- a/libavcodec/libxavs2.c
+++ b/libavcodec/libxavs2.c
@@ -285,7 +285,7 @@ static const AVCodecDefault xavs2_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_libxavs2_encoder = {
+const AVCodec ff_libxavs2_encoder = {
     .name           = "libxavs2",
     .long_name      = NULL_IF_CONFIG_SMALL("libxavs2 AVS2-P2/IEEE1857.4"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libxvid.c b/libavcodec/libxvid.c
index 2bc32bddb1..7ba709b1bc 100644
--- a/libavcodec/libxvid.c
+++ b/libavcodec/libxvid.c
@@ -899,7 +899,7 @@ static const AVClass xvid_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libxvid_encoder = {
+const AVCodec ff_libxvid_encoder = {
     .name           = "libxvid",
     .long_name      = NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/libzvbi-teletextdec.c b/libavcodec/libzvbi-teletextdec.c
index e056ea5ef0..1073d6a0bd 100644
--- a/libavcodec/libzvbi-teletextdec.c
+++ b/libavcodec/libzvbi-teletextdec.c
@@ -810,7 +810,7 @@ static const AVClass teletext_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_libzvbi_teletext_decoder = {
+const AVCodec ff_libzvbi_teletext_decoder = {
     .name      = "libzvbi_teletextdec",
     .long_name = NULL_IF_CONFIG_SMALL("Libzvbi DVB teletext decoder"),
     .type      = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/ljpegenc.c b/libavcodec/ljpegenc.c
index 788fd4260b..80b5e799ed 100644
--- a/libavcodec/ljpegenc.c
+++ b/libavcodec/ljpegenc.c
@@ -321,7 +321,7 @@ static const AVClass ljpeg_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_ljpeg_encoder = {
+const AVCodec ff_ljpeg_encoder = {
     .name           = "ljpeg",
     .long_name      = NULL_IF_CONFIG_SMALL("Lossless JPEG"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/loco.c b/libavcodec/loco.c
index 99e3a1d021..ebd81f43f2 100644
--- a/libavcodec/loco.c
+++ b/libavcodec/loco.c
@@ -337,7 +337,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_loco_decoder = {
+const AVCodec ff_loco_decoder = {
     .name           = "loco",
     .long_name      = NULL_IF_CONFIG_SMALL("LOCO"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/lscrdec.c b/libavcodec/lscrdec.c
index 042da84bf9..18f46bd27c 100644
--- a/libavcodec/lscrdec.c
+++ b/libavcodec/lscrdec.c
@@ -264,7 +264,7 @@ static void lscr_decode_flush(AVCodecContext *avctx)
     av_frame_unref(s->last_picture);
 }
 
-AVCodec ff_lscr_decoder = {
+const AVCodec ff_lscr_decoder = {
     .name           = "lscr",
     .long_name      = NULL_IF_CONFIG_SMALL("LEAD Screen Capture"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/m101.c b/libavcodec/m101.c
index 70f1da4f45..795a4fba63 100644
--- a/libavcodec/m101.c
+++ b/libavcodec/m101.c
@@ -105,7 +105,7 @@ static int m101_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 }
 
-AVCodec ff_m101_decoder = {
+const AVCodec ff_m101_decoder = {
     .name           = "m101",
     .long_name      = NULL_IF_CONFIG_SMALL("Matrox Uncompressed SD"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mace.c b/libavcodec/mace.c
index e332a72d6d..aa1f8e2de5 100644
--- a/libavcodec/mace.c
+++ b/libavcodec/mace.c
@@ -284,7 +284,7 @@ static int mace_decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_mace3_decoder = {
+const AVCodec ff_mace3_decoder = {
     .name           = "mace3",
     .long_name      = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 3:1"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -297,7 +297,7 @@ AVCodec ff_mace3_decoder = {
                                                       AV_SAMPLE_FMT_NONE },
 };
 
-AVCodec ff_mace6_decoder = {
+const AVCodec ff_mace6_decoder = {
     .name           = "mace6",
     .long_name      = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 6:1"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/magicyuv.c b/libavcodec/magicyuv.c
index 13cb346119..594196063b 100644
--- a/libavcodec/magicyuv.c
+++ b/libavcodec/magicyuv.c
@@ -694,7 +694,7 @@ static av_cold int magy_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_magicyuv_decoder = {
+const AVCodec ff_magicyuv_decoder = {
     .name             = "magicyuv",
     .long_name        = NULL_IF_CONFIG_SMALL("MagicYUV video"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/magicyuvenc.c b/libavcodec/magicyuvenc.c
index 7ec3c963bf..7edaf1b45e 100644
--- a/libavcodec/magicyuvenc.c
+++ b/libavcodec/magicyuvenc.c
@@ -556,7 +556,7 @@ static const AVClass magicyuv_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_magicyuv_encoder = {
+const AVCodec ff_magicyuv_encoder = {
     .name             = "magicyuv",
     .long_name        = NULL_IF_CONFIG_SMALL("MagicYUV video"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mdec.c b/libavcodec/mdec.c
index 101e558336..39efed69b1 100644
--- a/libavcodec/mdec.c
+++ b/libavcodec/mdec.c
@@ -250,7 +250,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mdec_decoder = {
+const AVCodec ff_mdec_decoder = {
     .name             = "mdec",
     .long_name        = NULL_IF_CONFIG_SMALL("Sony PlayStation MDEC (Motion DECoder)"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mediacodecdec.c b/libavcodec/mediacodecdec.c
index ad592d14a3..1cebb3d76d 100644
--- a/libavcodec/mediacodecdec.c
+++ b/libavcodec/mediacodecdec.c
@@ -522,7 +522,7 @@ static const AVClass ff_##short_name##_mediacodec_dec_class = { \
 
 #define DECLARE_MEDIACODEC_VDEC(short_name, full_name, codec_id, bsf)                          \
 DECLARE_MEDIACODEC_VCLASS(short_name)                                                          \
-AVCodec ff_##short_name##_mediacodec_decoder = {                                               \
+const AVCodec ff_ ## short_name ## _mediacodec_decoder = {                                     \
     .name           = #short_name "_mediacodec",                                               \
     .long_name      = NULL_IF_CONFIG_SMALL(full_name " Android MediaCodec decoder"),           \
     .type           = AVMEDIA_TYPE_VIDEO,                                                      \
diff --git a/libavcodec/metasound.c b/libavcodec/metasound.c
index 27cf1dd83f..be47510d7a 100644
--- a/libavcodec/metasound.c
+++ b/libavcodec/metasound.c
@@ -370,7 +370,7 @@ static av_cold int metasound_decode_init(AVCodecContext *avctx)
     return ff_twinvq_decode_init(avctx);
 }
 
-AVCodec ff_metasound_decoder = {
+const AVCodec ff_metasound_decoder = {
     .name           = "metasound",
     .long_name      = NULL_IF_CONFIG_SMALL("Voxware MetaSound"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mfenc.c b/libavcodec/mfenc.c
index d70e49351a..26f1c8057f 100644
--- a/libavcodec/mfenc.c
+++ b/libavcodec/mfenc.c
@@ -1152,7 +1152,7 @@ static int mf_close(AVCodecContext *avctx)
         .option     = OPTS,                                                    \
         .version    = LIBAVUTIL_VERSION_INT,                                   \
     };                                                                         \
-    AVCodec ff_ ## NAME ## _mf_encoder = {                                     \
+    const AVCodec ff_ ## NAME ## _mf_encoder = {                               \
         .priv_class     = &ff_ ## NAME ## _mf_encoder_class,                   \
         .name           = #NAME "_mf",                                         \
         .long_name      = NULL_IF_CONFIG_SMALL(#ID " via MediaFoundation"),    \
diff --git a/libavcodec/microdvddec.c b/libavcodec/microdvddec.c
index dad0ec8a22..777445997b 100644
--- a/libavcodec/microdvddec.c
+++ b/libavcodec/microdvddec.c
@@ -368,7 +368,7 @@ static int microdvd_init(AVCodecContext *avctx)
                                   alignment);
 }
 
-AVCodec ff_microdvd_decoder = {
+const AVCodec ff_microdvd_decoder = {
     .name         = "microdvd",
     .long_name    = NULL_IF_CONFIG_SMALL("MicroDVD subtitle"),
     .type         = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/midivid.c b/libavcodec/midivid.c
index 2200440e2c..69f9f4d0ec 100644
--- a/libavcodec/midivid.c
+++ b/libavcodec/midivid.c
@@ -277,7 +277,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mvdv_decoder = {
+const AVCodec ff_mvdv_decoder = {
     .name           = "mvdv",
     .long_name      = NULL_IF_CONFIG_SMALL("MidiVid VQ"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mimic.c b/libavcodec/mimic.c
index 407faa02da..ade973d860 100644
--- a/libavcodec/mimic.c
+++ b/libavcodec/mimic.c
@@ -435,7 +435,7 @@ static int mimic_decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_mimic_decoder = {
+const AVCodec ff_mimic_decoder = {
     .name                  = "mimic",
     .long_name             = NULL_IF_CONFIG_SMALL("Mimic"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mjpegbdec.c b/libavcodec/mjpegbdec.c
index 7666674908..87eebb8771 100644
--- a/libavcodec/mjpegbdec.c
+++ b/libavcodec/mjpegbdec.c
@@ -152,7 +152,7 @@ read_header:
     return buf_size;
 }
 
-AVCodec ff_mjpegb_decoder = {
+const AVCodec ff_mjpegb_decoder = {
     .name           = "mjpegb",
     .long_name      = NULL_IF_CONFIG_SMALL("Apple MJPEG-B"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mjpegdec.c b/libavcodec/mjpegdec.c
index f3d9e99aab..d53e72dc72 100644
--- a/libavcodec/mjpegdec.c
+++ b/libavcodec/mjpegdec.c
@@ -2945,7 +2945,7 @@ static const AVClass mjpegdec_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_mjpeg_decoder = {
+const AVCodec ff_mjpeg_decoder = {
     .name           = "mjpeg",
     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -2973,7 +2973,7 @@ AVCodec ff_mjpeg_decoder = {
 };
 #endif
 #if CONFIG_THP_DECODER
-AVCodec ff_thp_decoder = {
+const AVCodec ff_thp_decoder = {
     .name           = "thp",
     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -2991,7 +2991,7 @@ AVCodec ff_thp_decoder = {
 #endif
 
 #if CONFIG_SMVJPEG_DECODER
-AVCodec ff_smvjpeg_decoder = {
+const AVCodec ff_smvjpeg_decoder = {
     .name           = "smvjpeg",
     .long_name      = NULL_IF_CONFIG_SMALL("SMV JPEG"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index b355f97f14..0ade66bc5f 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -610,7 +610,7 @@ static const AVClass mjpeg_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_mjpeg_encoder = {
+const AVCodec ff_mjpeg_encoder = {
     .name           = "mjpeg",
     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -639,7 +639,7 @@ static const AVClass amv_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_amv_encoder = {
+const AVCodec ff_amv_encoder = {
     .name           = "amv",
     .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mlpdec.c b/libavcodec/mlpdec.c
index 0c30034dd4..e4992550ee 100644
--- a/libavcodec/mlpdec.c
+++ b/libavcodec/mlpdec.c
@@ -1331,7 +1331,7 @@ error:
 }
 
 #if CONFIG_MLP_DECODER
-AVCodec ff_mlp_decoder = {
+const AVCodec ff_mlp_decoder = {
     .name           = "mlp",
     .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -1344,7 +1344,7 @@ AVCodec ff_mlp_decoder = {
 };
 #endif
 #if CONFIG_TRUEHD_DECODER
-AVCodec ff_truehd_decoder = {
+const AVCodec ff_truehd_decoder = {
     .name           = "truehd",
     .long_name      = NULL_IF_CONFIG_SMALL("TrueHD"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mlpenc.c b/libavcodec/mlpenc.c
index 8684056cab..a66965f2bf 100644
--- a/libavcodec/mlpenc.c
+++ b/libavcodec/mlpenc.c
@@ -2364,7 +2364,7 @@ static av_cold int mlp_encode_close(AVCodecContext *avctx)
 }
 
 #if CONFIG_MLP_ENCODER
-AVCodec ff_mlp_encoder = {
+const AVCodec ff_mlp_encoder = {
     .name                   ="mlp",
     .long_name              = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
     .type                   = AVMEDIA_TYPE_AUDIO,
@@ -2381,7 +2381,7 @@ AVCodec ff_mlp_encoder = {
 };
 #endif
 #if CONFIG_TRUEHD_ENCODER
-AVCodec ff_truehd_encoder = {
+const AVCodec ff_truehd_encoder = {
     .name                   ="truehd",
     .long_name              = NULL_IF_CONFIG_SMALL("TrueHD"),
     .type                   = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mmaldec.c b/libavcodec/mmaldec.c
index db9e4f9589..8c7d749742 100644
--- a/libavcodec/mmaldec.c
+++ b/libavcodec/mmaldec.c
@@ -825,7 +825,7 @@ static const AVOption options[]={
 
 #define FFMMAL_DEC(NAME, ID) \
     FFMMAL_DEC_CLASS(NAME) \
-    AVCodec ff_##NAME##_mmal_decoder = { \
+    const AVCodec ff_##NAME##_mmal_decoder = { \
         .name           = #NAME "_mmal", \
         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (mmal)"), \
         .type           = AVMEDIA_TYPE_VIDEO, \
diff --git a/libavcodec/mmvideo.c b/libavcodec/mmvideo.c
index 7f650be80e..11a819dc6d 100644
--- a/libavcodec/mmvideo.c
+++ b/libavcodec/mmvideo.c
@@ -238,7 +238,7 @@ static av_cold int mm_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mmvideo_decoder = {
+const AVCodec ff_mmvideo_decoder = {
     .name           = "mmvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("American Laser Games MM Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mobiclip.c b/libavcodec/mobiclip.c
index bf47a5bc41..6ea1c3eefa 100644
--- a/libavcodec/mobiclip.c
+++ b/libavcodec/mobiclip.c
@@ -1340,7 +1340,7 @@ static av_cold int mobiclip_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mobiclip_decoder = {
+const AVCodec ff_mobiclip_decoder = {
     .name           = "mobiclip",
     .long_name      = NULL_IF_CONFIG_SMALL("MobiClip Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/motionpixels.c b/libavcodec/motionpixels.c
index b08a2f624b..1896330fe1 100644
--- a/libavcodec/motionpixels.c
+++ b/libavcodec/motionpixels.c
@@ -345,7 +345,7 @@ end:
     return buf_size;
 }
 
-AVCodec ff_motionpixels_decoder = {
+const AVCodec ff_motionpixels_decoder = {
     .name           = "motionpixels",
     .long_name      = NULL_IF_CONFIG_SMALL("Motion Pixels video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/movtextdec.c b/libavcodec/movtextdec.c
index 7adc16d262..873c1350a4 100644
--- a/libavcodec/movtextdec.c
+++ b/libavcodec/movtextdec.c
@@ -582,7 +582,7 @@ static const AVClass mov_text_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_movtext_decoder = {
+const AVCodec ff_movtext_decoder = {
     .name         = "mov_text",
     .long_name    = NULL_IF_CONFIG_SMALL("3GPP Timed Text subtitle"),
     .type         = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/movtextenc.c b/libavcodec/movtextenc.c
index 3c166639ba..4e782c7856 100644
--- a/libavcodec/movtextenc.c
+++ b/libavcodec/movtextenc.c
@@ -708,7 +708,7 @@ static const AVClass mov_text_encoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_movtext_encoder = {
+const AVCodec ff_movtext_encoder = {
     .name           = "mov_text",
     .long_name      = NULL_IF_CONFIG_SMALL("3GPP Timed Text subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/mpc7.c b/libavcodec/mpc7.c
index af12a6fd8e..c1a63203d6 100644
--- a/libavcodec/mpc7.c
+++ b/libavcodec/mpc7.c
@@ -308,7 +308,7 @@ static av_cold int mpc7_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mpc7_decoder = {
+const AVCodec ff_mpc7_decoder = {
     .name           = "mpc7",
     .long_name      = NULL_IF_CONFIG_SMALL("Musepack SV7"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mpc8.c b/libavcodec/mpc8.c
index e9919aea62..ae07093338 100644
--- a/libavcodec/mpc8.c
+++ b/libavcodec/mpc8.c
@@ -383,7 +383,7 @@ static av_cold void mpc8_decode_flush(AVCodecContext *avctx)
     c->cur_frame = 0;
 }
 
-AVCodec ff_mpc8_decoder = {
+const AVCodec ff_mpc8_decoder = {
     .name           = "mpc8",
     .long_name      = NULL_IF_CONFIG_SMALL("Musepack SV8"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mpeg12dec.c b/libavcodec/mpeg12dec.c
index c4d89e10ce..b27ed5bd6d 100644
--- a/libavcodec/mpeg12dec.c
+++ b/libavcodec/mpeg12dec.c
@@ -2878,7 +2878,7 @@ static av_cold int mpeg_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mpeg1video_decoder = {
+const AVCodec ff_mpeg1video_decoder = {
     .name                  = "mpeg1video",
     .long_name             = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
     .type                  = AVMEDIA_TYPE_VIDEO,
@@ -2912,7 +2912,7 @@ AVCodec ff_mpeg1video_decoder = {
                            },
 };
 
-AVCodec ff_mpeg2video_decoder = {
+const AVCodec ff_mpeg2video_decoder = {
     .name           = "mpeg2video",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -2959,7 +2959,7 @@ AVCodec ff_mpeg2video_decoder = {
 };
 
 //legacy decoder
-AVCodec ff_mpegvideo_decoder = {
+const AVCodec ff_mpegvideo_decoder = {
     .name           = "mpegvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -3121,7 +3121,7 @@ static av_cold int ipu_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_ipu_decoder = {
+const AVCodec ff_ipu_decoder = {
     .name           = "ipu",
     .long_name      = NULL_IF_CONFIG_SMALL("IPU Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mpeg12enc.c b/libavcodec/mpeg12enc.c
index 432d27e1f6..2fb2232f3c 100644
--- a/libavcodec/mpeg12enc.c
+++ b/libavcodec/mpeg12enc.c
@@ -1199,7 +1199,7 @@ static const AVClass mpeg ## x ## _class = {            \
 mpeg12_class(1)
 mpeg12_class(2)
 
-AVCodec ff_mpeg1video_encoder = {
+const AVCodec ff_mpeg1video_encoder = {
     .name                 = "mpeg1video",
     .long_name            = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
     .type                 = AVMEDIA_TYPE_VIDEO,
@@ -1216,7 +1216,7 @@ AVCodec ff_mpeg1video_encoder = {
     .priv_class           = &mpeg1_class,
 };
 
-AVCodec ff_mpeg2video_encoder = {
+const AVCodec ff_mpeg2video_encoder = {
     .name                 = "mpeg2video",
     .long_name            = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
     .type                 = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c
index de66fe8b83..6543750d85 100644
--- a/libavcodec/mpeg4videodec.c
+++ b/libavcodec/mpeg4videodec.c
@@ -3578,7 +3578,7 @@ static const AVClass mpeg4_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_mpeg4_decoder = {
+const AVCodec ff_mpeg4_decoder = {
     .name                  = "mpeg4",
     .long_name             = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index 7145bfe8ce..f9aa3b2c5e 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -1394,7 +1394,7 @@ static const AVClass mpeg4enc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_mpeg4_encoder = {
+const AVCodec ff_mpeg4_encoder = {
     .name           = "mpeg4",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mpegaudiodec_fixed.c b/libavcodec/mpegaudiodec_fixed.c
index a3c8ddc21e..f9f24330fd 100644
--- a/libavcodec/mpegaudiodec_fixed.c
+++ b/libavcodec/mpegaudiodec_fixed.c
@@ -59,7 +59,7 @@ static const int32_t csa_table[8][4] = {
 #include "mpegaudiodec_template.c"
 
 #if CONFIG_MP1_DECODER
-AVCodec ff_mp1_decoder = {
+const AVCodec ff_mp1_decoder = {
     .name           = "mp1",
     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -77,7 +77,7 @@ AVCodec ff_mp1_decoder = {
 };
 #endif
 #if CONFIG_MP2_DECODER
-AVCodec ff_mp2_decoder = {
+const AVCodec ff_mp2_decoder = {
     .name           = "mp2",
     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -95,7 +95,7 @@ AVCodec ff_mp2_decoder = {
 };
 #endif
 #if CONFIG_MP3_DECODER
-AVCodec ff_mp3_decoder = {
+const AVCodec ff_mp3_decoder = {
     .name           = "mp3",
     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -113,7 +113,7 @@ AVCodec ff_mp3_decoder = {
 };
 #endif
 #if CONFIG_MP3ADU_DECODER
-AVCodec ff_mp3adu_decoder = {
+const AVCodec ff_mp3adu_decoder = {
     .name           = "mp3adu",
     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -131,7 +131,7 @@ AVCodec ff_mp3adu_decoder = {
 };
 #endif
 #if CONFIG_MP3ON4_DECODER
-AVCodec ff_mp3on4_decoder = {
+const AVCodec ff_mp3on4_decoder = {
     .name           = "mp3on4",
     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mpegaudiodec_float.c b/libavcodec/mpegaudiodec_float.c
index 3ab7651d5b..c7b7839997 100644
--- a/libavcodec/mpegaudiodec_float.c
+++ b/libavcodec/mpegaudiodec_float.c
@@ -72,7 +72,7 @@ static const float csa_table[8][4] = {
 #include "mpegaudiodec_template.c"
 
 #if CONFIG_MP1FLOAT_DECODER
-AVCodec ff_mp1float_decoder = {
+const AVCodec ff_mp1float_decoder = {
     .name           = "mp1float",
     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -90,7 +90,7 @@ AVCodec ff_mp1float_decoder = {
 };
 #endif
 #if CONFIG_MP2FLOAT_DECODER
-AVCodec ff_mp2float_decoder = {
+const AVCodec ff_mp2float_decoder = {
     .name           = "mp2float",
     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -108,7 +108,7 @@ AVCodec ff_mp2float_decoder = {
 };
 #endif
 #if CONFIG_MP3FLOAT_DECODER
-AVCodec ff_mp3float_decoder = {
+const AVCodec ff_mp3float_decoder = {
     .name           = "mp3float",
     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -126,7 +126,7 @@ AVCodec ff_mp3float_decoder = {
 };
 #endif
 #if CONFIG_MP3ADUFLOAT_DECODER
-AVCodec ff_mp3adufloat_decoder = {
+const AVCodec ff_mp3adufloat_decoder = {
     .name           = "mp3adufloat",
     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -144,7 +144,7 @@ AVCodec ff_mp3adufloat_decoder = {
 };
 #endif
 #if CONFIG_MP3ON4FLOAT_DECODER
-AVCodec ff_mp3on4float_decoder = {
+const AVCodec ff_mp3on4float_decoder = {
     .name           = "mp3on4float",
     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mpegaudioenc_fixed.c b/libavcodec/mpegaudioenc_fixed.c
index 022b6fedd3..1504834925 100644
--- a/libavcodec/mpegaudioenc_fixed.c
+++ b/libavcodec/mpegaudioenc_fixed.c
@@ -21,7 +21,7 @@
 
 #include "mpegaudioenc_template.c"
 
-AVCodec ff_mp2fixed_encoder = {
+const AVCodec ff_mp2fixed_encoder = {
     .name                  = "mp2fixed",
     .long_name             = NULL_IF_CONFIG_SMALL("MP2 fixed point (MPEG audio layer 2)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mpegaudioenc_float.c b/libavcodec/mpegaudioenc_float.c
index 4d4ab2d7fa..22c5f916b2 100644
--- a/libavcodec/mpegaudioenc_float.c
+++ b/libavcodec/mpegaudioenc_float.c
@@ -22,7 +22,7 @@
 #define USE_FLOATS 1
 #include "mpegaudioenc_template.c"
 
-AVCodec ff_mp2_encoder = {
+const AVCodec ff_mp2_encoder = {
     .name                  = "mp2",
     .long_name             = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index f50f6cdeff..0f31d7be96 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -4598,7 +4598,7 @@ static const AVClass h263_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_h263_encoder = {
+const AVCodec ff_h263_encoder = {
     .name           = "h263",
     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -4633,7 +4633,7 @@ static const AVClass h263p_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_h263p_encoder = {
+const AVCodec ff_h263p_encoder = {
     .name           = "h263p",
     .long_name      = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -4655,7 +4655,7 @@ static const AVClass msmpeg4v2_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_msmpeg4v2_encoder = {
+const AVCodec ff_msmpeg4v2_encoder = {
     .name           = "msmpeg4v2",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -4676,7 +4676,7 @@ static const AVClass msmpeg4v3_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_msmpeg4v3_encoder = {
+const AVCodec ff_msmpeg4v3_encoder = {
     .name           = "msmpeg4",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -4697,7 +4697,7 @@ static const AVClass wmv1_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_wmv1_encoder = {
+const AVCodec ff_wmv1_encoder = {
     .name           = "wmv1",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mpl2dec.c b/libavcodec/mpl2dec.c
index 409e4b3708..3ad094b97a 100644
--- a/libavcodec/mpl2dec.c
+++ b/libavcodec/mpl2dec.c
@@ -81,7 +81,7 @@ static int mpl2_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_mpl2_decoder = {
+const AVCodec ff_mpl2_decoder = {
     .name           = "mpl2",
     .long_name      = NULL_IF_CONFIG_SMALL("MPL2 subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/mscc.c b/libavcodec/mscc.c
index e685b2a32b..027eb16085 100644
--- a/libavcodec/mscc.c
+++ b/libavcodec/mscc.c
@@ -252,7 +252,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mscc_decoder = {
+const AVCodec ff_mscc_decoder = {
     .name             = "mscc",
     .long_name        = NULL_IF_CONFIG_SMALL("Mandsoft Screen Capture Codec"),
     .type             = AVMEDIA_TYPE_VIDEO,
@@ -265,7 +265,7 @@ AVCodec ff_mscc_decoder = {
     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
 };
 
-AVCodec ff_srgc_decoder = {
+const AVCodec ff_srgc_decoder = {
     .name             = "srgc",
     .long_name        = NULL_IF_CONFIG_SMALL("Screen Recorder Gold Codec"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/msmpeg4dec.c b/libavcodec/msmpeg4dec.c
index 8fcd5b94cd..5c893a0141 100644
--- a/libavcodec/msmpeg4dec.c
+++ b/libavcodec/msmpeg4dec.c
@@ -858,7 +858,7 @@ void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
     *my_ptr = my;
 }
 
-AVCodec ff_msmpeg4v1_decoder = {
+const AVCodec ff_msmpeg4v1_decoder = {
     .name           = "msmpeg4v1",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -876,7 +876,7 @@ AVCodec ff_msmpeg4v1_decoder = {
     },
 };
 
-AVCodec ff_msmpeg4v2_decoder = {
+const AVCodec ff_msmpeg4v2_decoder = {
     .name           = "msmpeg4v2",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -894,7 +894,7 @@ AVCodec ff_msmpeg4v2_decoder = {
     },
 };
 
-AVCodec ff_msmpeg4v3_decoder = {
+const AVCodec ff_msmpeg4v3_decoder = {
     .name           = "msmpeg4",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -912,7 +912,7 @@ AVCodec ff_msmpeg4v3_decoder = {
     },
 };
 
-AVCodec ff_wmv1_decoder = {
+const AVCodec ff_wmv1_decoder = {
     .name           = "wmv1",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/msp2dec.c b/libavcodec/msp2dec.c
index 16c5ac6f02..8772bff6bc 100644
--- a/libavcodec/msp2dec.c
+++ b/libavcodec/msp2dec.c
@@ -93,7 +93,7 @@ static int msp2_decode_frame(AVCodecContext *avctx,
     return buf_size;
 }
 
-AVCodec ff_msp2_decoder = {
+const AVCodec ff_msp2_decoder = {
     .name           = "msp2",
     .long_name      = NULL_IF_CONFIG_SMALL("Microsoft Paint (MSP) version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/msrle.c b/libavcodec/msrle.c
index 42c8f48373..bbac2a3ffb 100644
--- a/libavcodec/msrle.c
+++ b/libavcodec/msrle.c
@@ -159,7 +159,7 @@ static av_cold int msrle_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_msrle_decoder = {
+const AVCodec ff_msrle_decoder = {
     .name           = "msrle",
     .long_name      = NULL_IF_CONFIG_SMALL("Microsoft RLE"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mss1.c b/libavcodec/mss1.c
index 7af8024d63..10c2c34eb4 100644
--- a/libavcodec/mss1.c
+++ b/libavcodec/mss1.c
@@ -218,7 +218,7 @@ static av_cold int mss1_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mss1_decoder = {
+const AVCodec ff_mss1_decoder = {
     .name           = "mss1",
     .long_name      = NULL_IF_CONFIG_SMALL("MS Screen 1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mss2.c b/libavcodec/mss2.c
index a27fae7559..d7a19f6ad2 100644
--- a/libavcodec/mss2.c
+++ b/libavcodec/mss2.c
@@ -845,7 +845,7 @@ static av_cold int mss2_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mss2_decoder = {
+const AVCodec ff_mss2_decoder = {
     .name           = "mss2",
     .long_name      = NULL_IF_CONFIG_SMALL("MS Windows Media Video V9 Screen"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mss3.c b/libavcodec/mss3.c
index 74f4b5e671..0ce7c96121 100644
--- a/libavcodec/mss3.c
+++ b/libavcodec/mss3.c
@@ -859,7 +859,7 @@ static av_cold int mss3_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_msa1_decoder = {
+const AVCodec ff_msa1_decoder = {
     .name           = "msa1",
     .long_name      = NULL_IF_CONFIG_SMALL("MS ATC Screen"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mss4.c b/libavcodec/mss4.c
index 7f11f30dc8..6c44c76c50 100644
--- a/libavcodec/mss4.c
+++ b/libavcodec/mss4.c
@@ -604,7 +604,7 @@ static av_cold int mss4_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mts2_decoder = {
+const AVCodec ff_mts2_decoder = {
     .name           = "mts2",
     .long_name      = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/msvideo1.c b/libavcodec/msvideo1.c
index cfd51cfd67..99965b04a2 100644
--- a/libavcodec/msvideo1.c
+++ b/libavcodec/msvideo1.c
@@ -341,7 +341,7 @@ static av_cold int msvideo1_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_msvideo1_decoder = {
+const AVCodec ff_msvideo1_decoder = {
     .name           = "msvideo1",
     .long_name      = NULL_IF_CONFIG_SMALL("Microsoft Video 1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/msvideo1enc.c b/libavcodec/msvideo1enc.c
index b6ae92b2ac..34c8d47c2b 100644
--- a/libavcodec/msvideo1enc.c
+++ b/libavcodec/msvideo1enc.c
@@ -292,7 +292,7 @@ static av_cold int encode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_msvideo1_encoder = {
+const AVCodec ff_msvideo1_encoder = {
     .name           = "msvideo1",
     .long_name = NULL_IF_CONFIG_SMALL("Microsoft Video-1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mv30.c b/libavcodec/mv30.c
index 7ae264e0f0..21f52679c0 100644
--- a/libavcodec/mv30.c
+++ b/libavcodec/mv30.c
@@ -702,7 +702,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mv30_decoder = {
+const AVCodec ff_mv30_decoder = {
     .name             = "mv30",
     .long_name        = NULL_IF_CONFIG_SMALL("MidiVid 3.0"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mvcdec.c b/libavcodec/mvcdec.c
index e507674c22..84cdae2123 100644
--- a/libavcodec/mvcdec.c
+++ b/libavcodec/mvcdec.c
@@ -253,7 +253,7 @@ static int mvc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 }
 
 #if CONFIG_MVC1_DECODER
-AVCodec ff_mvc1_decoder = {
+const AVCodec ff_mvc1_decoder = {
     .name           = "mvc1",
     .long_name      = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 1"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -266,7 +266,7 @@ AVCodec ff_mvc1_decoder = {
 #endif
 
 #if CONFIG_MVC2_DECODER
-AVCodec ff_mvc2_decoder = {
+const AVCodec ff_mvc2_decoder = {
     .name           = "mvc2",
     .long_name      = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mvha.c b/libavcodec/mvha.c
index c603ef6975..4048e4625c 100644
--- a/libavcodec/mvha.c
+++ b/libavcodec/mvha.c
@@ -307,7 +307,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mvha_decoder = {
+const AVCodec ff_mvha_decoder = {
     .name             = "mvha",
     .long_name        = NULL_IF_CONFIG_SMALL("MidiVid Archive Codec"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mwsc.c b/libavcodec/mwsc.c
index 4db7642e85..b62db67ff5 100644
--- a/libavcodec/mwsc.c
+++ b/libavcodec/mwsc.c
@@ -177,7 +177,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_mwsc_decoder = {
+const AVCodec ff_mwsc_decoder = {
     .name             = "mwsc",
     .long_name        = NULL_IF_CONFIG_SMALL("MatchWare Screen Capture Codec"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/mxpegdec.c b/libavcodec/mxpegdec.c
index 763ce5871d..7c97a9340e 100644
--- a/libavcodec/mxpegdec.c
+++ b/libavcodec/mxpegdec.c
@@ -339,7 +339,7 @@ the_end:
     return buf_ptr - buf;
 }
 
-AVCodec ff_mxpeg_decoder = {
+const AVCodec ff_mxpeg_decoder = {
     .name           = "mxpeg",
     .long_name      = NULL_IF_CONFIG_SMALL("Mobotix MxPEG video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/nellymoserdec.c b/libavcodec/nellymoserdec.c
index e091ec94bd..ccfe881790 100644
--- a/libavcodec/nellymoserdec.c
+++ b/libavcodec/nellymoserdec.c
@@ -186,7 +186,7 @@ static av_cold int decode_end(AVCodecContext * avctx) {
     return 0;
 }
 
-AVCodec ff_nellymoser_decoder = {
+const AVCodec ff_nellymoser_decoder = {
     .name           = "nellymoser",
     .long_name      = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/nellymoserenc.c b/libavcodec/nellymoserenc.c
index 8670431dcc..2e13e6af08 100644
--- a/libavcodec/nellymoserenc.c
+++ b/libavcodec/nellymoserenc.c
@@ -417,7 +417,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_nellymoser_encoder = {
+const AVCodec ff_nellymoser_encoder = {
     .name           = "nellymoser",
     .long_name      = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/notchlc.c b/libavcodec/notchlc.c
index 9a53cad9cb..c109c5f6f3 100644
--- a/libavcodec/notchlc.c
+++ b/libavcodec/notchlc.c
@@ -537,7 +537,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_notchlc_decoder = {
+const AVCodec ff_notchlc_decoder = {
     .name             = "notchlc",
     .long_name        = NULL_IF_CONFIG_SMALL("NotchLC"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/nuv.c b/libavcodec/nuv.c
index 3ceaaac4e9..3ba12fd8e6 100644
--- a/libavcodec/nuv.c
+++ b/libavcodec/nuv.c
@@ -362,7 +362,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_nuv_decoder = {
+const AVCodec ff_nuv_decoder = {
     .name           = "nuv",
     .long_name      = NULL_IF_CONFIG_SMALL("NuppelVideo/RTJPEG"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/nvenc_h264.c b/libavcodec/nvenc_h264.c
index ea7390cbf1..5ad6b35836 100644
--- a/libavcodec/nvenc_h264.c
+++ b/libavcodec/nvenc_h264.c
@@ -205,7 +205,7 @@ static const AVClass h264_nvenc_class = {
     .version = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_h264_nvenc_encoder = {
+const AVCodec ff_h264_nvenc_encoder = {
     .name           = "h264_nvenc",
     .long_name      = NULL_IF_CONFIG_SMALL("NVIDIA NVENC H.264 encoder"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/nvenc_hevc.c b/libavcodec/nvenc_hevc.c
index 1aacec5f9c..007099242a 100644
--- a/libavcodec/nvenc_hevc.c
+++ b/libavcodec/nvenc_hevc.c
@@ -186,7 +186,7 @@ static const AVClass hevc_nvenc_class = {
     .version = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_hevc_nvenc_encoder = {
+const AVCodec ff_hevc_nvenc_encoder = {
     .name           = "hevc_nvenc",
     .long_name      = NULL_IF_CONFIG_SMALL("NVIDIA NVENC hevc encoder"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/omx.c b/libavcodec/omx.c
index 0a6a308309..3a113723d3 100644
--- a/libavcodec/omx.c
+++ b/libavcodec/omx.c
@@ -951,7 +951,7 @@ static const AVClass omx_mpeg4enc_class = {
     .option     = options,
     .version    = LIBAVUTIL_VERSION_INT,
 };
-AVCodec ff_mpeg4_omx_encoder = {
+const AVCodec ff_mpeg4_omx_encoder = {
     .name             = "mpeg4_omx",
     .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL MPEG-4 video encoder"),
     .type             = AVMEDIA_TYPE_VIDEO,
@@ -972,7 +972,7 @@ static const AVClass omx_h264enc_class = {
     .option     = options,
     .version    = LIBAVUTIL_VERSION_INT,
 };
-AVCodec ff_h264_omx_encoder = {
+const AVCodec ff_h264_omx_encoder = {
     .name             = "h264_omx",
     .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL H.264 video encoder"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/on2avc.c b/libavcodec/on2avc.c
index d7a3e4945a..2ab67350ca 100644
--- a/libavcodec/on2avc.c
+++ b/libavcodec/on2avc.c
@@ -1002,7 +1002,7 @@ static av_cold int on2avc_decode_close(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_on2avc_decoder = {
+const AVCodec ff_on2avc_decoder = {
     .name           = "on2avc",
     .long_name      = NULL_IF_CONFIG_SMALL("On2 Audio for Video Codec"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/opusdec.c b/libavcodec/opusdec.c
index f0d7ed62a1..3ebf199219 100644
--- a/libavcodec/opusdec.c
+++ b/libavcodec/opusdec.c
@@ -704,7 +704,7 @@ static const AVClass opus_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_opus_decoder = {
+const AVCodec ff_opus_decoder = {
     .name            = "opus",
     .long_name       = NULL_IF_CONFIG_SMALL("Opus"),
     .priv_class      = &opus_class,
diff --git a/libavcodec/opusenc.c b/libavcodec/opusenc.c
index 8bc9e9dc4a..da83ef4d32 100644
--- a/libavcodec/opusenc.c
+++ b/libavcodec/opusenc.c
@@ -719,7 +719,7 @@ static const AVCodecDefault opusenc_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_opus_encoder = {
+const AVCodec ff_opus_encoder = {
     .name           = "opus",
     .long_name      = NULL_IF_CONFIG_SMALL("Opus"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/pafaudio.c b/libavcodec/pafaudio.c
index f306e3b96c..cb80f3a186 100644
--- a/libavcodec/pafaudio.c
+++ b/libavcodec/pafaudio.c
@@ -71,7 +71,7 @@ static int paf_audio_decode(AVCodecContext *avctx, void *data,
     return pkt->size;
 }
 
-AVCodec ff_paf_audio_decoder = {
+const AVCodec ff_paf_audio_decoder = {
     .name         = "paf_audio",
     .long_name    = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Audio"),
     .type         = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/pafvideo.c b/libavcodec/pafvideo.c
index 1e5d891332..bb5c17b6a1 100644
--- a/libavcodec/pafvideo.c
+++ b/libavcodec/pafvideo.c
@@ -407,7 +407,7 @@ static int paf_video_decode(AVCodecContext *avctx, void *data,
     return pkt->size;
 }
 
-AVCodec ff_paf_video_decoder = {
+const AVCodec ff_paf_video_decoder = {
     .name           = "paf_video",
     .long_name      = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pamenc.c b/libavcodec/pamenc.c
index ef3bc3bf16..10dbdf5589 100644
--- a/libavcodec/pamenc.c
+++ b/libavcodec/pamenc.c
@@ -127,7 +127,7 @@ static int pam_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_pam_encoder = {
+const AVCodec ff_pam_encoder = {
     .name           = "pam",
     .long_name      = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pcm-bluray.c b/libavcodec/pcm-bluray.c
index 8e6f562b52..c2a6e82b1d 100644
--- a/libavcodec/pcm-bluray.c
+++ b/libavcodec/pcm-bluray.c
@@ -301,7 +301,7 @@ static int pcm_bluray_decode_frame(AVCodecContext *avctx, void *data,
     return retval + 4;
 }
 
-AVCodec ff_pcm_bluray_decoder = {
+const AVCodec ff_pcm_bluray_decoder = {
     .name           = "pcm_bluray",
     .long_name      = NULL_IF_CONFIG_SMALL("PCM signed 16|20|24-bit big-endian for Blu-ray media"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/pcm-dvd.c b/libavcodec/pcm-dvd.c
index 3dda218bf4..775d342eaa 100644
--- a/libavcodec/pcm-dvd.c
+++ b/libavcodec/pcm-dvd.c
@@ -291,7 +291,7 @@ static int pcm_dvd_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_pcm_dvd_decoder = {
+const AVCodec ff_pcm_dvd_decoder = {
     .name           = "pcm_dvd",
     .long_name      = NULL_IF_CONFIG_SMALL("PCM signed 16|20|24-bit big-endian for DVD media"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/pcm-dvdenc.c b/libavcodec/pcm-dvdenc.c
index 97ac778334..e644f30f5d 100644
--- a/libavcodec/pcm-dvdenc.c
+++ b/libavcodec/pcm-dvdenc.c
@@ -170,7 +170,7 @@ static int pcm_dvd_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_pcm_dvd_encoder = {
+const AVCodec ff_pcm_dvd_encoder = {
     .name           = "pcm_dvd",
     .long_name      = NULL_IF_CONFIG_SMALL("PCM signed 16|20|24-bit big-endian for DVD media"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/pcm.c b/libavcodec/pcm.c
index 19d04e9181..79b33b935c 100644
--- a/libavcodec/pcm.c
+++ b/libavcodec/pcm.c
@@ -550,7 +550,7 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
 
 #define PCM_ENCODER_0(id_, sample_fmt_, name_, long_name_)
 #define PCM_ENCODER_1(id_, sample_fmt_, name_, long_name_)                  \
-AVCodec ff_ ## name_ ## _encoder = {                                        \
+const AVCodec ff_ ## name_ ## _encoder = {                                  \
     .name         = #name_,                                                 \
     .long_name    = NULL_IF_CONFIG_SMALL(long_name_),                       \
     .type         = AVMEDIA_TYPE_AUDIO,                                     \
@@ -572,7 +572,7 @@ AVCodec ff_ ## name_ ## _encoder = {                                        \
 
 #define PCM_DECODER_0(id, sample_fmt, name, long_name)
 #define PCM_DECODER_1(id_, sample_fmt_, name_, long_name_)                  \
-AVCodec ff_ ## name_ ## _decoder = {                                        \
+const AVCodec ff_ ## name_ ## _decoder = {                                  \
     .name           = #name_,                                               \
     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),                     \
     .type           = AVMEDIA_TYPE_AUDIO,                                   \
diff --git a/libavcodec/pcx.c b/libavcodec/pcx.c
index 4505db75b8..b8d911be6b 100644
--- a/libavcodec/pcx.c
+++ b/libavcodec/pcx.c
@@ -249,7 +249,7 @@ end:
     return ret;
 }
 
-AVCodec ff_pcx_decoder = {
+const AVCodec ff_pcx_decoder = {
     .name         = "pcx",
     .long_name    = NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pcxenc.c b/libavcodec/pcxenc.c
index 709bf84d12..4cba1019e6 100644
--- a/libavcodec/pcxenc.c
+++ b/libavcodec/pcxenc.c
@@ -192,7 +192,7 @@ static int pcx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_pcx_encoder = {
+const AVCodec ff_pcx_encoder = {
     .name           = "pcx",
     .long_name      = NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pgssubdec.c b/libavcodec/pgssubdec.c
index eaf069017a..8b088bda8f 100644
--- a/libavcodec/pgssubdec.c
+++ b/libavcodec/pgssubdec.c
@@ -703,7 +703,7 @@ static const AVClass pgsdec_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_pgssub_decoder = {
+const AVCodec ff_pgssub_decoder = {
     .name           = "pgssub",
     .long_name      = NULL_IF_CONFIG_SMALL("HDMV Presentation Graphic Stream subtitles"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/pgxdec.c b/libavcodec/pgxdec.c
index 65b2929283..1d659e82c2 100644
--- a/libavcodec/pgxdec.c
+++ b/libavcodec/pgxdec.c
@@ -158,7 +158,7 @@ static int pgx_decode_frame(AVCodecContext *avctx, void *data,
     return 0;
 }
 
-AVCodec ff_pgx_decoder = {
+const AVCodec ff_pgx_decoder = {
     .name           = "pgx",
     .long_name      = NULL_IF_CONFIG_SMALL("PGX (JPEG2000 Test Format)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/photocd.c b/libavcodec/photocd.c
index 408ddeaac8..f95d5a8eb8 100644
--- a/libavcodec/photocd.c
+++ b/libavcodec/photocd.c
@@ -458,7 +458,7 @@ static const AVClass photocd_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_photocd_decoder = {
+const AVCodec ff_photocd_decoder = {
     .name           = "photocd",
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_PHOTOCD,
diff --git a/libavcodec/pictordec.c b/libavcodec/pictordec.c
index 6340902526..c37c5e7106 100644
--- a/libavcodec/pictordec.c
+++ b/libavcodec/pictordec.c
@@ -281,7 +281,7 @@ finish:
     return avpkt->size;
 }
 
-AVCodec ff_pictor_decoder = {
+const AVCodec ff_pictor_decoder = {
     .name           = "pictor",
     .long_name      = NULL_IF_CONFIG_SMALL("Pictor/PC Paint"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pixlet.c b/libavcodec/pixlet.c
index ad9d830af7..5361bc42bf 100644
--- a/libavcodec/pixlet.c
+++ b/libavcodec/pixlet.c
@@ -693,7 +693,7 @@ static int pixlet_decode_frame(AVCodecContext *avctx, void *data,
     return pktsize;
 }
 
-AVCodec ff_pixlet_decoder = {
+const AVCodec ff_pixlet_decoder = {
     .name             = "pixlet",
     .long_name        = NULL_IF_CONFIG_SMALL("Apple Pixlet"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pngdec.c b/libavcodec/pngdec.c
index 3e509e8ae0..f2e6f689b0 100644
--- a/libavcodec/pngdec.c
+++ b/libavcodec/pngdec.c
@@ -1728,7 +1728,7 @@ static av_cold int png_dec_end(AVCodecContext *avctx)
 }
 
 #if CONFIG_APNG_DECODER
-AVCodec ff_apng_decoder = {
+const AVCodec ff_apng_decoder = {
     .name           = "apng",
     .long_name      = NULL_IF_CONFIG_SMALL("APNG (Animated Portable Network Graphics) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -1745,7 +1745,7 @@ AVCodec ff_apng_decoder = {
 #endif
 
 #if CONFIG_PNG_DECODER
-AVCodec ff_png_decoder = {
+const AVCodec ff_png_decoder = {
     .name           = "png",
     .long_name      = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pngenc.c b/libavcodec/pngenc.c
index 374d7c9cf7..831223be63 100644
--- a/libavcodec/pngenc.c
+++ b/libavcodec/pngenc.c
@@ -1121,7 +1121,7 @@ static const AVClass apngenc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_png_encoder = {
+const AVCodec ff_png_encoder = {
     .name           = "png",
     .long_name      = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -1142,7 +1142,7 @@ AVCodec ff_png_encoder = {
     .priv_class     = &pngenc_class,
 };
 
-AVCodec ff_apng_encoder = {
+const AVCodec ff_apng_encoder = {
     .name           = "apng",
     .long_name      = NULL_IF_CONFIG_SMALL("APNG (Animated Portable Network Graphics) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pnmdec.c b/libavcodec/pnmdec.c
index 4d5ce0bcb5..01f9dade1a 100644
--- a/libavcodec/pnmdec.c
+++ b/libavcodec/pnmdec.c
@@ -329,7 +329,7 @@ static int pnm_decode_frame(AVCodecContext *avctx, void *data,
 
 
 #if CONFIG_PGM_DECODER
-AVCodec ff_pgm_decoder = {
+const AVCodec ff_pgm_decoder = {
     .name           = "pgm",
     .long_name      = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -341,7 +341,7 @@ AVCodec ff_pgm_decoder = {
 #endif
 
 #if CONFIG_PGMYUV_DECODER
-AVCodec ff_pgmyuv_decoder = {
+const AVCodec ff_pgmyuv_decoder = {
     .name           = "pgmyuv",
     .long_name      = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -353,7 +353,7 @@ AVCodec ff_pgmyuv_decoder = {
 #endif
 
 #if CONFIG_PPM_DECODER
-AVCodec ff_ppm_decoder = {
+const AVCodec ff_ppm_decoder = {
     .name           = "ppm",
     .long_name      = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -365,7 +365,7 @@ AVCodec ff_ppm_decoder = {
 #endif
 
 #if CONFIG_PBM_DECODER
-AVCodec ff_pbm_decoder = {
+const AVCodec ff_pbm_decoder = {
     .name           = "pbm",
     .long_name      = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -377,7 +377,7 @@ AVCodec ff_pbm_decoder = {
 #endif
 
 #if CONFIG_PAM_DECODER
-AVCodec ff_pam_decoder = {
+const AVCodec ff_pam_decoder = {
     .name           = "pam",
     .long_name      = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -389,7 +389,7 @@ AVCodec ff_pam_decoder = {
 #endif
 
 #if CONFIG_PFM_DECODER
-AVCodec ff_pfm_decoder = {
+const AVCodec ff_pfm_decoder = {
     .name           = "pfm",
     .long_name      = NULL_IF_CONFIG_SMALL("PFM (Portable FloatMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/pnmenc.c b/libavcodec/pnmenc.c
index 56e929a5f0..80c7b66332 100644
--- a/libavcodec/pnmenc.c
+++ b/libavcodec/pnmenc.c
@@ -149,7 +149,7 @@ static int pnm_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 }
 
 #if CONFIG_PGM_ENCODER
-AVCodec ff_pgm_encoder = {
+const AVCodec ff_pgm_encoder = {
     .name           = "pgm",
     .long_name      = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -163,7 +163,7 @@ AVCodec ff_pgm_encoder = {
 #endif
 
 #if CONFIG_PGMYUV_ENCODER
-AVCodec ff_pgmyuv_encoder = {
+const AVCodec ff_pgmyuv_encoder = {
     .name           = "pgmyuv",
     .long_name      = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -177,7 +177,7 @@ AVCodec ff_pgmyuv_encoder = {
 #endif
 
 #if CONFIG_PPM_ENCODER
-AVCodec ff_ppm_encoder = {
+const AVCodec ff_ppm_encoder = {
     .name           = "ppm",
     .long_name      = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -191,7 +191,7 @@ AVCodec ff_ppm_encoder = {
 #endif
 
 #if CONFIG_PBM_ENCODER
-AVCodec ff_pbm_encoder = {
+const AVCodec ff_pbm_encoder = {
     .name           = "pbm",
     .long_name      = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -204,7 +204,7 @@ AVCodec ff_pbm_encoder = {
 #endif
 
 #if CONFIG_PFM_ENCODER
-AVCodec ff_pfm_encoder = {
+const AVCodec ff_pfm_encoder = {
     .name           = "pfm",
     .long_name      = NULL_IF_CONFIG_SMALL("PFM (Portable FloatMap) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/proresdec2.c b/libavcodec/proresdec2.c
index 5a01c89c48..a57cece99b 100644
--- a/libavcodec/proresdec2.c
+++ b/libavcodec/proresdec2.c
@@ -820,7 +820,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_prores_decoder = {
+const AVCodec ff_prores_decoder = {
     .name           = "prores",
     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/proresenc_anatoliy.c b/libavcodec/proresenc_anatoliy.c
index a4197870ec..2eda471f0c 100644
--- a/libavcodec/proresenc_anatoliy.c
+++ b/libavcodec/proresenc_anatoliy.c
@@ -944,7 +944,7 @@ static const AVClass prores_enc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_prores_aw_encoder = {
+const AVCodec ff_prores_aw_encoder = {
     .name           = "prores_aw",
     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -960,7 +960,7 @@ AVCodec ff_prores_aw_encoder = {
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 
-AVCodec ff_prores_encoder = {
+const AVCodec ff_prores_encoder = {
     .name           = "prores",
     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/proresenc_kostya.c b/libavcodec/proresenc_kostya.c
index 81a8cd73e7..d140ef053a 100644
--- a/libavcodec/proresenc_kostya.c
+++ b/libavcodec/proresenc_kostya.c
@@ -1399,7 +1399,7 @@ static const AVClass proresenc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_prores_ks_encoder = {
+const AVCodec ff_prores_ks_encoder = {
     .name           = "prores_ks",
     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/prosumer.c b/libavcodec/prosumer.c
index 9950519604..f57d8dda41 100644
--- a/libavcodec/prosumer.c
+++ b/libavcodec/prosumer.c
@@ -365,7 +365,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_prosumer_decoder = {
+const AVCodec ff_prosumer_decoder = {
     .name           = "prosumer",
     .long_name      = NULL_IF_CONFIG_SMALL("Brooktree ProSumer Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/psd.c b/libavcodec/psd.c
index ae7ad4e559..681d8a83c9 100644
--- a/libavcodec/psd.c
+++ b/libavcodec/psd.c
@@ -545,7 +545,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_psd_decoder = {
+const AVCodec ff_psd_decoder = {
     .name             = "psd",
     .long_name        = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ptx.c b/libavcodec/ptx.c
index 19f9305cda..47b8926f73 100644
--- a/libavcodec/ptx.c
+++ b/libavcodec/ptx.c
@@ -85,7 +85,7 @@ static int ptx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return offset + w*h*bytes_per_pixel;
 }
 
-AVCodec ff_ptx_decoder = {
+const AVCodec ff_ptx_decoder = {
     .name           = "ptx",
     .long_name      = NULL_IF_CONFIG_SMALL("V.Flash PTX image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/qcelpdec.c b/libavcodec/qcelpdec.c
index 4878af5a2c..6663d8588b 100644
--- a/libavcodec/qcelpdec.c
+++ b/libavcodec/qcelpdec.c
@@ -790,7 +790,7 @@ erasure:
     return buf_size;
 }
 
-AVCodec ff_qcelp_decoder = {
+const AVCodec ff_qcelp_decoder = {
     .name           = "qcelp",
     .long_name      = NULL_IF_CONFIG_SMALL("QCELP / PureVoice"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/qdm2.c b/libavcodec/qdm2.c
index 07dea55a76..5e4e741e59 100644
--- a/libavcodec/qdm2.c
+++ b/libavcodec/qdm2.c
@@ -1869,7 +1869,7 @@ static int qdm2_decode_frame(AVCodecContext *avctx, void *data,
     return s->checksum_size;
 }
 
-AVCodec ff_qdm2_decoder = {
+const AVCodec ff_qdm2_decoder = {
     .name             = "qdm2",
     .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),
     .type             = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/qdmc.c b/libavcodec/qdmc.c
index a8c930f0e7..ae75ca524a 100644
--- a/libavcodec/qdmc.c
+++ b/libavcodec/qdmc.c
@@ -725,7 +725,7 @@ static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
     return ret;
 }
 
-AVCodec ff_qdmc_decoder = {
+const AVCodec ff_qdmc_decoder = {
     .name             = "qdmc",
     .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
     .type             = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/qdrw.c b/libavcodec/qdrw.c
index 65279c9805..fcc1de0c62 100644
--- a/libavcodec/qdrw.c
+++ b/libavcodec/qdrw.c
@@ -514,7 +514,7 @@ static int decode_frame(AVCodecContext *avctx,
     }
 }
 
-AVCodec ff_qdraw_decoder = {
+const AVCodec ff_qdraw_decoder = {
     .name           = "qdraw",
     .long_name      = NULL_IF_CONFIG_SMALL("Apple QuickDraw"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/qpeg.c b/libavcodec/qpeg.c
index 2e66d3bf8a..829e08aba1 100644
--- a/libavcodec/qpeg.c
+++ b/libavcodec/qpeg.c
@@ -352,7 +352,7 @@ static av_cold int decode_init(AVCodecContext *avctx){
     return 0;
 }
 
-AVCodec ff_qpeg_decoder = {
+const AVCodec ff_qpeg_decoder = {
     .name           = "qpeg",
     .long_name      = NULL_IF_CONFIG_SMALL("Q-team QPEG"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/qsvdec.c b/libavcodec/qsvdec.c
index bf843c8ca2..f543defb18 100644
--- a/libavcodec/qsvdec.c
+++ b/libavcodec/qsvdec.c
@@ -829,7 +829,7 @@ static const AVClass x##_qsv_class = { \
     .option     = opt, \
     .version    = LIBAVUTIL_VERSION_INT, \
 }; \
-AVCodec ff_##x##_qsv_decoder = { \
+const AVCodec ff_##x##_qsv_decoder = { \
     .name           = #x "_qsv", \
     .long_name      = NULL_IF_CONFIG_SMALL(#X " video (Intel Quick Sync Video acceleration)"), \
     .priv_data_size = sizeof(QSVDecContext), \
diff --git a/libavcodec/qsvenc_h264.c b/libavcodec/qsvenc_h264.c
index 06b49c46ee..80fe3cc280 100644
--- a/libavcodec/qsvenc_h264.c
+++ b/libavcodec/qsvenc_h264.c
@@ -174,7 +174,7 @@ static const AVCodecDefault qsv_enc_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_h264_qsv_encoder = {
+const AVCodec ff_h264_qsv_encoder = {
     .name           = "h264_qsv",
     .long_name      = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (Intel Quick Sync Video acceleration)"),
     .priv_data_size = sizeof(QSVH264EncContext),
diff --git a/libavcodec/qsvenc_hevc.c b/libavcodec/qsvenc_hevc.c
index fc10459628..a5671ebbca 100644
--- a/libavcodec/qsvenc_hevc.c
+++ b/libavcodec/qsvenc_hevc.c
@@ -270,7 +270,7 @@ static const AVCodecDefault qsv_enc_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_hevc_qsv_encoder = {
+const AVCodec ff_hevc_qsv_encoder = {
     .name           = "hevc_qsv",
     .long_name      = NULL_IF_CONFIG_SMALL("HEVC (Intel Quick Sync Video acceleration)"),
     .priv_data_size = sizeof(QSVHEVCEncContext),
diff --git a/libavcodec/qsvenc_jpeg.c b/libavcodec/qsvenc_jpeg.c
index f76af9486b..dd082692be 100644
--- a/libavcodec/qsvenc_jpeg.c
+++ b/libavcodec/qsvenc_jpeg.c
@@ -79,7 +79,7 @@ static const AVCodecDefault qsv_enc_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_mjpeg_qsv_encoder = {
+const AVCodec ff_mjpeg_qsv_encoder = {
     .name           = "mjpeg_qsv",
     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Intel Quick Sync Video acceleration)"),
     .priv_data_size = sizeof(QSVMJPEGEncContext),
diff --git a/libavcodec/qsvenc_mpeg2.c b/libavcodec/qsvenc_mpeg2.c
index 538b937f74..525df99e50 100644
--- a/libavcodec/qsvenc_mpeg2.c
+++ b/libavcodec/qsvenc_mpeg2.c
@@ -92,7 +92,7 @@ static const AVCodecDefault qsv_enc_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_mpeg2_qsv_encoder = {
+const AVCodec ff_mpeg2_qsv_encoder = {
     .name           = "mpeg2_qsv",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 video (Intel Quick Sync Video acceleration)"),
     .priv_data_size = sizeof(QSVMpeg2EncContext),
diff --git a/libavcodec/qsvenc_vp9.c b/libavcodec/qsvenc_vp9.c
index ce44c09397..9329990d11 100644
--- a/libavcodec/qsvenc_vp9.c
+++ b/libavcodec/qsvenc_vp9.c
@@ -92,7 +92,7 @@ static const AVCodecDefault qsv_enc_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_vp9_qsv_encoder = {
+const AVCodec ff_vp9_qsv_encoder = {
     .name           = "vp9_qsv",
     .long_name      = NULL_IF_CONFIG_SMALL("VP9 video (Intel Quick Sync Video acceleration)"),
     .priv_data_size = sizeof(QSVVP9EncContext),
diff --git a/libavcodec/qtrle.c b/libavcodec/qtrle.c
index 33da393bd1..4ad224e37d 100644
--- a/libavcodec/qtrle.c
+++ b/libavcodec/qtrle.c
@@ -581,7 +581,7 @@ static av_cold int qtrle_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_qtrle_decoder = {
+const AVCodec ff_qtrle_decoder = {
     .name           = "qtrle",
     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/qtrleenc.c b/libavcodec/qtrleenc.c
index 9340563084..1ff288456a 100644
--- a/libavcodec/qtrleenc.c
+++ b/libavcodec/qtrleenc.c
@@ -398,7 +398,7 @@ static int qtrle_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_qtrle_encoder = {
+const AVCodec ff_qtrle_encoder = {
     .name           = "qtrle",
     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/r210dec.c b/libavcodec/r210dec.c
index 407684c7fc..476f1c0680 100644
--- a/libavcodec/r210dec.c
+++ b/libavcodec/r210dec.c
@@ -102,7 +102,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 }
 
 #if CONFIG_R210_DECODER
-AVCodec ff_r210_decoder = {
+const AVCodec ff_r210_decoder = {
     .name           = "r210",
     .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed RGB 10-bit"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -114,7 +114,7 @@ AVCodec ff_r210_decoder = {
 };
 #endif
 #if CONFIG_R10K_DECODER
-AVCodec ff_r10k_decoder = {
+const AVCodec ff_r10k_decoder = {
     .name           = "r10k",
     .long_name      = NULL_IF_CONFIG_SMALL("AJA Kona 10-bit RGB Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -126,7 +126,7 @@ AVCodec ff_r10k_decoder = {
 };
 #endif
 #if CONFIG_AVRP_DECODER
-AVCodec ff_avrp_decoder = {
+const AVCodec ff_avrp_decoder = {
     .name           = "avrp",
     .long_name      = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/r210enc.c b/libavcodec/r210enc.c
index be1943f5f9..89518bce29 100644
--- a/libavcodec/r210enc.c
+++ b/libavcodec/r210enc.c
@@ -86,7 +86,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 
 
 #if CONFIG_R210_ENCODER
-AVCodec ff_r210_encoder = {
+const AVCodec ff_r210_encoder = {
     .name           = "r210",
     .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed RGB 10-bit"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -97,7 +97,7 @@ AVCodec ff_r210_encoder = {
 };
 #endif
 #if CONFIG_R10K_ENCODER
-AVCodec ff_r10k_encoder = {
+const AVCodec ff_r10k_encoder = {
     .name           = "r10k",
     .long_name      = NULL_IF_CONFIG_SMALL("AJA Kona 10-bit RGB Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -108,7 +108,7 @@ AVCodec ff_r10k_encoder = {
 };
 #endif
 #if CONFIG_AVRP_ENCODER
-AVCodec ff_avrp_encoder = {
+const AVCodec ff_avrp_encoder = {
     .name           = "avrp",
     .long_name      = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ra144dec.c b/libavcodec/ra144dec.c
index 40b278895f..e5e3def15e 100644
--- a/libavcodec/ra144dec.c
+++ b/libavcodec/ra144dec.c
@@ -126,7 +126,7 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *data,
     return FRAME_SIZE;
 }
 
-AVCodec ff_ra_144_decoder = {
+const AVCodec ff_ra_144_decoder = {
     .name           = "real_144",
     .long_name      = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/ra144enc.c b/libavcodec/ra144enc.c
index c6965c5c47..0eb151a49e 100644
--- a/libavcodec/ra144enc.c
+++ b/libavcodec/ra144enc.c
@@ -539,7 +539,7 @@ static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 }
 
 
-AVCodec ff_ra_144_encoder = {
+const AVCodec ff_ra_144_encoder = {
     .name           = "real_144",
     .long_name      = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/ra288.c b/libavcodec/ra288.c
index 0eb2a661cb..05f322c40a 100644
--- a/libavcodec/ra288.c
+++ b/libavcodec/ra288.c
@@ -237,7 +237,7 @@ static int ra288_decode_frame(AVCodecContext * avctx, void *data,
     return avctx->block_align;
 }
 
-AVCodec ff_ra_288_decoder = {
+const AVCodec ff_ra_288_decoder = {
     .name           = "real_288",
     .long_name      = NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/ralf.c b/libavcodec/ralf.c
index dc012d71b1..2b253c5711 100644
--- a/libavcodec/ralf.c
+++ b/libavcodec/ralf.c
@@ -525,7 +525,7 @@ static void decode_flush(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_ralf_decoder = {
+const AVCodec ff_ralf_decoder = {
     .name           = "ralf",
     .long_name      = NULL_IF_CONFIG_SMALL("RealAudio Lossless"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/rasc.c b/libavcodec/rasc.c
index 207d50c452..c1e9185192 100644
--- a/libavcodec/rasc.c
+++ b/libavcodec/rasc.c
@@ -805,7 +805,7 @@ static const AVClass rasc_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_rasc_decoder = {
+const AVCodec ff_rasc_decoder = {
     .name             = "rasc",
     .long_name        = NULL_IF_CONFIG_SMALL("RemotelyAnywhere Screen Capture"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rawdec.c b/libavcodec/rawdec.c
index a13f88b148..96abf6a48c 100644
--- a/libavcodec/rawdec.c
+++ b/libavcodec/rawdec.c
@@ -481,7 +481,7 @@ static av_cold int raw_close_decoder(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_rawvideo_decoder = {
+const AVCodec ff_rawvideo_decoder = {
     .name           = "rawvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("raw video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rawenc.c b/libavcodec/rawenc.c
index a7dd162d55..baaab749fd 100644
--- a/libavcodec/rawenc.c
+++ b/libavcodec/rawenc.c
@@ -80,7 +80,7 @@ static int raw_encode(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_rawvideo_encoder = {
+const AVCodec ff_rawvideo_encoder = {
     .name           = "rawvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("raw video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/realtextdec.c b/libavcodec/realtextdec.c
index 5084781123..d469a1981b 100644
--- a/libavcodec/realtextdec.c
+++ b/libavcodec/realtextdec.c
@@ -74,7 +74,7 @@ static int realtext_decode_frame(AVCodecContext *avctx,
     return avpkt->size;
 }
 
-AVCodec ff_realtext_decoder = {
+const AVCodec ff_realtext_decoder = {
     .name           = "realtext",
     .long_name      = NULL_IF_CONFIG_SMALL("RealText subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/rkmppdec.c b/libavcodec/rkmppdec.c
index a60962dc86..19ef108832 100644
--- a/libavcodec/rkmppdec.c
+++ b/libavcodec/rkmppdec.c
@@ -561,7 +561,7 @@ static const AVCodecHWConfigInternal *const rkmpp_hw_configs[] = {
 
 #define RKMPP_DEC(NAME, ID, BSFS) \
     RKMPP_DEC_CLASS(NAME) \
-    AVCodec ff_##NAME##_rkmpp_decoder = { \
+    const AVCodec ff_##NAME##_rkmpp_decoder = { \
         .name           = #NAME "_rkmpp", \
         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (rkmpp)"), \
         .type           = AVMEDIA_TYPE_VIDEO, \
diff --git a/libavcodec/rl2.c b/libavcodec/rl2.c
index 2d336a61e5..d75802cc12 100644
--- a/libavcodec/rl2.c
+++ b/libavcodec/rl2.c
@@ -218,7 +218,7 @@ static av_cold int rl2_decode_end(AVCodecContext *avctx)
 }
 
 
-AVCodec ff_rl2_decoder = {
+const AVCodec ff_rl2_decoder = {
     .name           = "rl2",
     .long_name      = NULL_IF_CONFIG_SMALL("RL2 video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/roqaudioenc.c b/libavcodec/roqaudioenc.c
index c09212d3d1..9a636179b1 100644
--- a/libavcodec/roqaudioenc.c
+++ b/libavcodec/roqaudioenc.c
@@ -183,7 +183,7 @@ static int roq_dpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_roq_dpcm_encoder = {
+const AVCodec ff_roq_dpcm_encoder = {
     .name           = "roq_dpcm",
     .long_name      = NULL_IF_CONFIG_SMALL("id RoQ DPCM"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/roqvideodec.c b/libavcodec/roqvideodec.c
index 36b4ddf755..a2730af922 100644
--- a/libavcodec/roqvideodec.c
+++ b/libavcodec/roqvideodec.c
@@ -233,7 +233,7 @@ static av_cold int roq_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_roq_decoder = {
+const AVCodec ff_roq_decoder = {
     .name           = "roqvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("id RoQ video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/roqvideoenc.c b/libavcodec/roqvideoenc.c
index 1ab0de0abb..b755d5e3a5 100644
--- a/libavcodec/roqvideoenc.c
+++ b/libavcodec/roqvideoenc.c
@@ -1119,7 +1119,7 @@ static const AVClass roq_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_roq_encoder = {
+const AVCodec ff_roq_encoder = {
     .name                 = "roqvideo",
     .long_name            = NULL_IF_CONFIG_SMALL("id RoQ video"),
     .type                 = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rpza.c b/libavcodec/rpza.c
index 02bbfe753f..a9aeac59fe 100644
--- a/libavcodec/rpza.c
+++ b/libavcodec/rpza.c
@@ -286,7 +286,7 @@ static av_cold int rpza_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_rpza_decoder = {
+const AVCodec ff_rpza_decoder = {
     .name           = "rpza",
     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime video (RPZA)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rpzaenc.c b/libavcodec/rpzaenc.c
index eeb82716c9..e4651d9d9c 100644
--- a/libavcodec/rpzaenc.c
+++ b/libavcodec/rpzaenc.c
@@ -842,7 +842,7 @@ static const AVClass rpza_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_rpza_encoder = {
+const AVCodec ff_rpza_encoder = {
     .name           = "rpza",
     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime video (RPZA)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rscc.c b/libavcodec/rscc.c
index 7b27127bf5..0ec54ac1b0 100644
--- a/libavcodec/rscc.c
+++ b/libavcodec/rscc.c
@@ -362,7 +362,7 @@ end:
     return ret;
 }
 
-AVCodec ff_rscc_decoder = {
+const AVCodec ff_rscc_decoder = {
     .name           = "rscc",
     .long_name      = NULL_IF_CONFIG_SMALL("innoHeim/Rsupport Screen Capture Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rv10.c b/libavcodec/rv10.c
index bd70689cab..46491bbd94 100644
--- a/libavcodec/rv10.c
+++ b/libavcodec/rv10.c
@@ -677,7 +677,7 @@ static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 }
 
-AVCodec ff_rv10_decoder = {
+const AVCodec ff_rv10_decoder = {
     .name           = "rv10",
     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -694,7 +694,7 @@ AVCodec ff_rv10_decoder = {
     },
 };
 
-AVCodec ff_rv20_decoder = {
+const AVCodec ff_rv20_decoder = {
     .name           = "rv20",
     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rv10enc.c b/libavcodec/rv10enc.c
index 42316836c5..2a1640c3a9 100644
--- a/libavcodec/rv10enc.c
+++ b/libavcodec/rv10enc.c
@@ -70,7 +70,7 @@ static const AVClass rv10_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_rv10_encoder = {
+const AVCodec ff_rv10_encoder = {
     .name           = "rv10",
     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rv20enc.c b/libavcodec/rv20enc.c
index d9d63d4d9c..9bdb642893 100644
--- a/libavcodec/rv20enc.c
+++ b/libavcodec/rv20enc.c
@@ -67,7 +67,7 @@ static const AVClass rv20_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_rv20_encoder = {
+const AVCodec ff_rv20_encoder = {
     .name           = "rv20",
     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rv30.c b/libavcodec/rv30.c
index e2b75fbec0..751647bebe 100644
--- a/libavcodec/rv30.c
+++ b/libavcodec/rv30.c
@@ -289,7 +289,7 @@ static av_cold int rv30_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_rv30_decoder = {
+const AVCodec ff_rv30_decoder = {
     .name                  = "rv30",
     .long_name             = NULL_IF_CONFIG_SMALL("RealVideo 3.0"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/rv40.c b/libavcodec/rv40.c
index 8532a872d9..31a7a04e51 100644
--- a/libavcodec/rv40.c
+++ b/libavcodec/rv40.c
@@ -571,7 +571,7 @@ static av_cold int rv40_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_rv40_decoder = {
+const AVCodec ff_rv40_decoder = {
     .name                  = "rv40",
     .long_name             = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/s302m.c b/libavcodec/s302m.c
index 113590aee4..60d1547884 100644
--- a/libavcodec/s302m.c
+++ b/libavcodec/s302m.c
@@ -218,7 +218,7 @@ static const AVClass s302m_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_s302m_decoder = {
+const AVCodec ff_s302m_decoder = {
     .name           = "s302m",
     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE 302M"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/s302menc.c b/libavcodec/s302menc.c
index b04a54e482..2d0615bb2c 100644
--- a/libavcodec/s302menc.c
+++ b/libavcodec/s302menc.c
@@ -167,7 +167,7 @@ static int s302m_encode2_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
-AVCodec ff_s302m_encoder = {
+const AVCodec ff_s302m_encoder = {
     .name                  = "s302m",
     .long_name             = NULL_IF_CONFIG_SMALL("SMPTE 302M"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/samidec.c b/libavcodec/samidec.c
index e32f238c62..62272f119b 100644
--- a/libavcodec/samidec.c
+++ b/libavcodec/samidec.c
@@ -180,7 +180,7 @@ static void sami_flush(AVCodecContext *avctx)
         sami->readorder = 0;
 }
 
-AVCodec ff_sami_decoder = {
+const AVCodec ff_sami_decoder = {
     .name           = "sami",
     .long_name      = NULL_IF_CONFIG_SMALL("SAMI subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/sanm.c b/libavcodec/sanm.c
index d0000ebd0c..dddc2c871b 100644
--- a/libavcodec/sanm.c
+++ b/libavcodec/sanm.c
@@ -1515,7 +1515,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     return pkt->size;
 }
 
-AVCodec ff_sanm_decoder = {
+const AVCodec ff_sanm_decoder = {
     .name           = "sanm",
     .long_name      = NULL_IF_CONFIG_SMALL("LucasArts SANM/Smush video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/sbcdec.c b/libavcodec/sbcdec.c
index bb590e8a05..db61f43a5a 100644
--- a/libavcodec/sbcdec.c
+++ b/libavcodec/sbcdec.c
@@ -363,7 +363,7 @@ static int sbc_decode_frame(AVCodecContext *avctx,
     return frame_length;
 }
 
-AVCodec ff_sbc_decoder = {
+const AVCodec ff_sbc_decoder = {
     .name                  = "sbc",
     .long_name             = NULL_IF_CONFIG_SMALL("SBC (low-complexity subband codec)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/sbcenc.c b/libavcodec/sbcenc.c
index 33de8edab4..e87c623d4b 100644
--- a/libavcodec/sbcenc.c
+++ b/libavcodec/sbcenc.c
@@ -341,7 +341,7 @@ static const AVClass sbc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_sbc_encoder = {
+const AVCodec ff_sbc_encoder = {
     .name                  = "sbc",
     .long_name             = NULL_IF_CONFIG_SMALL("SBC (low-complexity subband codec)"),
     .type                  = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/scpr.c b/libavcodec/scpr.c
index 2a0ebcecfc..ba6e849c66 100644
--- a/libavcodec/scpr.c
+++ b/libavcodec/scpr.c
@@ -667,7 +667,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_scpr_decoder = {
+const AVCodec ff_scpr_decoder = {
     .name             = "scpr",
     .long_name        = NULL_IF_CONFIG_SMALL("ScreenPressor"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/screenpresso.c b/libavcodec/screenpresso.c
index d73c24df83..dd4df6d405 100644
--- a/libavcodec/screenpresso.c
+++ b/libavcodec/screenpresso.c
@@ -183,7 +183,7 @@ static int screenpresso_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_screenpresso_decoder = {
+const AVCodec ff_screenpresso_decoder = {
     .name           = "screenpresso",
     .long_name      = NULL_IF_CONFIG_SMALL("Screenpresso"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/sga.c b/libavcodec/sga.c
index 7e6bea530c..5103d01f85 100644
--- a/libavcodec/sga.c
+++ b/libavcodec/sga.c
@@ -520,7 +520,7 @@ static av_cold int sga_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_sga_decoder = {
+const AVCodec ff_sga_decoder = {
     .name           = "sga",
     .long_name      = NULL_IF_CONFIG_SMALL("Digital Pictures SGA Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/sgidec.c b/libavcodec/sgidec.c
index e954140258..aa77a3b921 100644
--- a/libavcodec/sgidec.c
+++ b/libavcodec/sgidec.c
@@ -288,7 +288,7 @@ static av_cold int sgi_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_sgi_decoder = {
+const AVCodec ff_sgi_decoder = {
     .name           = "sgi",
     .long_name      = NULL_IF_CONFIG_SMALL("SGI image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/sgienc.c b/libavcodec/sgienc.c
index d31f6340f7..962dac0f8a 100644
--- a/libavcodec/sgienc.c
+++ b/libavcodec/sgienc.c
@@ -270,7 +270,7 @@ static const AVClass sgi_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_sgi_encoder = {
+const AVCodec ff_sgi_encoder = {
     .name      = "sgi",
     .long_name = NULL_IF_CONFIG_SMALL("SGI image"),
     .type      = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/sgirledec.c b/libavcodec/sgirledec.c
index 9cb637b07f..aa5107fe22 100644
--- a/libavcodec/sgirledec.c
+++ b/libavcodec/sgirledec.c
@@ -131,7 +131,7 @@ static int sgirle_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_sgirle_decoder = {
+const AVCodec ff_sgirle_decoder = {
     .name           = "sgirle",
     .long_name      = NULL_IF_CONFIG_SMALL("Silicon Graphics RLE 8-bit video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/sheervideo.c b/libavcodec/sheervideo.c
index b3fb92b6b5..fb5a39303e 100644
--- a/libavcodec/sheervideo.c
+++ b/libavcodec/sheervideo.c
@@ -2005,7 +2005,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_sheervideo_decoder = {
+const AVCodec ff_sheervideo_decoder = {
     .name             = "sheervideo",
     .long_name        = NULL_IF_CONFIG_SMALL("BitJazz SheerVideo"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/shorten.c b/libavcodec/shorten.c
index 70d164a0b3..fde5c4b982 100644
--- a/libavcodec/shorten.c
+++ b/libavcodec/shorten.c
@@ -799,7 +799,7 @@ static av_cold int shorten_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_shorten_decoder = {
+const AVCodec ff_shorten_decoder = {
     .name           = "shorten",
     .long_name      = NULL_IF_CONFIG_SMALL("Shorten"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/sipr.c b/libavcodec/sipr.c
index 7ba9fd4a07..a792b22c9f 100644
--- a/libavcodec/sipr.c
+++ b/libavcodec/sipr.c
@@ -562,7 +562,7 @@ static int sipr_decode_frame(AVCodecContext *avctx, void *data,
     return mode_par->bits_per_frame >> 3;
 }
 
-AVCodec ff_sipr_decoder = {
+const AVCodec ff_sipr_decoder = {
     .name           = "sipr",
     .long_name      = NULL_IF_CONFIG_SMALL("RealAudio SIPR / ACELP.NET"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/siren.c b/libavcodec/siren.c
index 22b6997176..5937f0d56c 100644
--- a/libavcodec/siren.c
+++ b/libavcodec/siren.c
@@ -759,7 +759,7 @@ static av_cold int siren_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_siren_decoder = {
+const AVCodec ff_siren_decoder = {
     .name           = "siren",
     .long_name      = NULL_IF_CONFIG_SMALL("Siren"),
     .priv_data_size = sizeof(SirenContext),
diff --git a/libavcodec/smacker.c b/libavcodec/smacker.c
index 8db33c9275..75ab5d7120 100644
--- a/libavcodec/smacker.c
+++ b/libavcodec/smacker.c
@@ -720,7 +720,7 @@ error:
     return ret;
 }
 
-AVCodec ff_smacker_decoder = {
+const AVCodec ff_smacker_decoder = {
     .name           = "smackvid",
     .long_name      = NULL_IF_CONFIG_SMALL("Smacker video"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -733,7 +733,7 @@ AVCodec ff_smacker_decoder = {
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,
 };
 
-AVCodec ff_smackaud_decoder = {
+const AVCodec ff_smackaud_decoder = {
     .name           = "smackaud",
     .long_name      = NULL_IF_CONFIG_SMALL("Smacker audio"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/smc.c b/libavcodec/smc.c
index 880bf0620e..70851e5e07 100644
--- a/libavcodec/smc.c
+++ b/libavcodec/smc.c
@@ -468,7 +468,7 @@ static av_cold int smc_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_smc_decoder = {
+const AVCodec ff_smc_decoder = {
     .name           = "smc",
     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime Graphics (SMC)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/snowdec.c b/libavcodec/snowdec.c
index 68afe0df26..7367176f07 100644
--- a/libavcodec/snowdec.c
+++ b/libavcodec/snowdec.c
@@ -648,7 +648,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_snow_decoder = {
+const AVCodec ff_snow_decoder = {
     .name           = "snow",
     .long_name      = NULL_IF_CONFIG_SMALL("Snow"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/snowenc.c b/libavcodec/snowenc.c
index e694d51a67..5d384e8d91 100644
--- a/libavcodec/snowenc.c
+++ b/libavcodec/snowenc.c
@@ -1916,7 +1916,7 @@ static const AVClass snowenc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_snow_encoder = {
+const AVCodec ff_snow_encoder = {
     .name           = "snow",
     .long_name      = NULL_IF_CONFIG_SMALL("Snow"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/sonic.c b/libavcodec/sonic.c
index 13409d6efa..b31258eaa1 100644
--- a/libavcodec/sonic.c
+++ b/libavcodec/sonic.c
@@ -1070,7 +1070,7 @@ static int sonic_decode_frame(AVCodecContext *avctx,
     return buf_size;
 }
 
-AVCodec ff_sonic_decoder = {
+const AVCodec ff_sonic_decoder = {
     .name           = "sonic",
     .long_name      = NULL_IF_CONFIG_SMALL("Sonic"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -1085,7 +1085,7 @@ AVCodec ff_sonic_decoder = {
 #endif /* CONFIG_SONIC_DECODER */
 
 #if CONFIG_SONIC_ENCODER
-AVCodec ff_sonic_encoder = {
+const AVCodec ff_sonic_encoder = {
     .name           = "sonic",
     .long_name      = NULL_IF_CONFIG_SMALL("Sonic"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -1101,7 +1101,7 @@ AVCodec ff_sonic_encoder = {
 #endif
 
 #if CONFIG_SONIC_LS_ENCODER
-AVCodec ff_sonic_ls_encoder = {
+const AVCodec ff_sonic_ls_encoder = {
     .name           = "sonicls",
     .long_name      = NULL_IF_CONFIG_SMALL("Sonic lossless"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/sp5xdec.c b/libavcodec/sp5xdec.c
index 0b2b2d8418..a1b43f8f80 100644
--- a/libavcodec/sp5xdec.c
+++ b/libavcodec/sp5xdec.c
@@ -90,7 +90,7 @@ int ff_sp5x_process_packet(AVCodecContext *avctx, AVPacket *avpkt)
 }
 
 #if CONFIG_SP5X_DECODER
-AVCodec ff_sp5x_decoder = {
+const AVCodec ff_sp5x_decoder = {
     .name           = "sp5x",
     .long_name      = NULL_IF_CONFIG_SMALL("Sunplus JPEG (SP5X)"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -106,7 +106,7 @@ AVCodec ff_sp5x_decoder = {
 };
 #endif
 #if CONFIG_AMV_DECODER
-AVCodec ff_amv_decoder = {
+const AVCodec ff_amv_decoder = {
     .name           = "amv",
     .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/speedhq.c b/libavcodec/speedhq.c
index 711bcd66d7..4f6a539ad8 100644
--- a/libavcodec/speedhq.c
+++ b/libavcodec/speedhq.c
@@ -724,7 +724,7 @@ static av_cold int speedhq_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_speedhq_decoder = {
+const AVCodec ff_speedhq_decoder = {
     .name           = "speedhq",
     .long_name      = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/speedhqenc.c b/libavcodec/speedhqenc.c
index a5bedd5301..6ff7b447a0 100644
--- a/libavcodec/speedhqenc.c
+++ b/libavcodec/speedhqenc.c
@@ -289,7 +289,7 @@ static const AVClass speedhq_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_speedhq_encoder = {
+const AVCodec ff_speedhq_encoder = {
     .name           = "speedhq",
     .long_name      = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/srtdec.c b/libavcodec/srtdec.c
index e77b94f74e..c2afb006f3 100644
--- a/libavcodec/srtdec.c
+++ b/libavcodec/srtdec.c
@@ -88,7 +88,7 @@ static int srt_decode_frame(AVCodecContext *avctx,
 
 #if CONFIG_SRT_DECODER
 /* deprecated decoder */
-AVCodec ff_srt_decoder = {
+const AVCodec ff_srt_decoder = {
     .name         = "srt",
     .long_name    = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
     .type         = AVMEDIA_TYPE_SUBTITLE,
@@ -101,7 +101,7 @@ AVCodec ff_srt_decoder = {
 #endif
 
 #if CONFIG_SUBRIP_DECODER
-AVCodec ff_subrip_decoder = {
+const AVCodec ff_subrip_decoder = {
     .name         = "subrip",
     .long_name    = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
     .type         = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/srtenc.c b/libavcodec/srtenc.c
index 08c52c2d56..346f281af3 100644
--- a/libavcodec/srtenc.c
+++ b/libavcodec/srtenc.c
@@ -290,7 +290,7 @@ static int srt_encode_close(AVCodecContext *avctx)
 
 #if CONFIG_SRT_ENCODER
 /* deprecated encoder */
-AVCodec ff_srt_encoder = {
+const AVCodec ff_srt_encoder = {
     .name           = "srt",
     .long_name      = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
@@ -303,7 +303,7 @@ AVCodec ff_srt_encoder = {
 #endif
 
 #if CONFIG_SUBRIP_ENCODER
-AVCodec ff_subrip_encoder = {
+const AVCodec ff_subrip_encoder = {
     .name           = "subrip",
     .long_name      = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
@@ -316,7 +316,7 @@ AVCodec ff_subrip_encoder = {
 #endif
 
 #if CONFIG_TEXT_ENCODER
-AVCodec ff_text_encoder = {
+const AVCodec ff_text_encoder = {
     .name           = "text",
     .long_name      = NULL_IF_CONFIG_SMALL("Raw text subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/subviewerdec.c b/libavcodec/subviewerdec.c
index 805c7dd547..35c1ad78dd 100644
--- a/libavcodec/subviewerdec.c
+++ b/libavcodec/subviewerdec.c
@@ -65,7 +65,7 @@ static int subviewer_decode_frame(AVCodecContext *avctx,
     return avpkt->size;
 }
 
-AVCodec ff_subviewer_decoder = {
+const AVCodec ff_subviewer_decoder = {
     .name           = "subviewer",
     .long_name      = NULL_IF_CONFIG_SMALL("SubViewer subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/sunrast.c b/libavcodec/sunrast.c
index e1ec8a0832..7e9a9b0be5 100644
--- a/libavcodec/sunrast.c
+++ b/libavcodec/sunrast.c
@@ -205,7 +205,7 @@ static int sunrast_decode_frame(AVCodecContext *avctx, void *data,
     return buf - bufstart;
 }
 
-AVCodec ff_sunrast_decoder = {
+const AVCodec ff_sunrast_decoder = {
     .name           = "sunrast",
     .long_name      = NULL_IF_CONFIG_SMALL("Sun Rasterfile image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/sunrastenc.c b/libavcodec/sunrastenc.c
index af4529815b..c47ea61d03 100644
--- a/libavcodec/sunrastenc.c
+++ b/libavcodec/sunrastenc.c
@@ -208,7 +208,7 @@ static const AVClass sunrast_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_sunrast_encoder = {
+const AVCodec ff_sunrast_encoder = {
     .name           = "sunrast",
     .long_name      = NULL_IF_CONFIG_SMALL("Sun Rasterfile image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/svq1dec.c b/libavcodec/svq1dec.c
index d6b6bec72d..a67d1866b6 100644
--- a/libavcodec/svq1dec.c
+++ b/libavcodec/svq1dec.c
@@ -843,7 +843,7 @@ static void svq1_flush(AVCodecContext *avctx)
     av_frame_unref(s->prev);
 }
 
-AVCodec ff_svq1_decoder = {
+const AVCodec ff_svq1_decoder = {
     .name           = "svq1",
     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/svq1enc.c b/libavcodec/svq1enc.c
index b68df598c1..814b2bad06 100644
--- a/libavcodec/svq1enc.c
+++ b/libavcodec/svq1enc.c
@@ -671,7 +671,7 @@ static const AVClass svq1enc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_svq1_encoder = {
+const AVCodec ff_svq1_encoder = {
     .name           = "svq1",
     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/svq3.c b/libavcodec/svq3.c
index edc8aeacc6..c589c77ded 100644
--- a/libavcodec/svq3.c
+++ b/libavcodec/svq3.c
@@ -1601,7 +1601,7 @@ static av_cold int svq3_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_svq3_decoder = {
+const AVCodec ff_svq3_decoder = {
     .name           = "svq3",
     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/takdec.c b/libavcodec/takdec.c
index 931e5d3fb4..93caaae7ad 100644
--- a/libavcodec/takdec.c
+++ b/libavcodec/takdec.c
@@ -938,7 +938,7 @@ static av_cold int tak_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_tak_decoder = {
+const AVCodec ff_tak_decoder = {
     .name             = "tak",
     .long_name        = NULL_IF_CONFIG_SMALL("TAK (Tom's lossless Audio Kompressor)"),
     .type             = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/targa.c b/libavcodec/targa.c
index a61fef1d7b..3502636c16 100644
--- a/libavcodec/targa.c
+++ b/libavcodec/targa.c
@@ -297,7 +297,7 @@ static int decode_frame(AVCodecContext *avctx,
     return avpkt->size;
 }
 
-AVCodec ff_targa_decoder = {
+const AVCodec ff_targa_decoder = {
     .name           = "targa",
     .long_name      = NULL_IF_CONFIG_SMALL("Truevision Targa image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/targa_y216dec.c b/libavcodec/targa_y216dec.c
index 443d48a92f..d002c1006a 100644
--- a/libavcodec/targa_y216dec.c
+++ b/libavcodec/targa_y216dec.c
@@ -73,7 +73,7 @@ static int y216_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_targa_y216_decoder = {
+const AVCodec ff_targa_y216_decoder = {
     .name         = "targa_y216",
     .long_name    = NULL_IF_CONFIG_SMALL("Pinnacle TARGA CineWave YUV16"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/targaenc.c b/libavcodec/targaenc.c
index cd6cc9e874..6a9edd9aa5 100644
--- a/libavcodec/targaenc.c
+++ b/libavcodec/targaenc.c
@@ -202,7 +202,7 @@ static const AVClass targa_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_targa_encoder = {
+const AVCodec ff_targa_encoder = {
     .name           = "targa",
     .long_name      = NULL_IF_CONFIG_SMALL("Truevision Targa image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/tdsc.c b/libavcodec/tdsc.c
index 9e7381c2bb..79bdc422e1 100644
--- a/libavcodec/tdsc.c
+++ b/libavcodec/tdsc.c
@@ -621,7 +621,7 @@ static int tdsc_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_tdsc_decoder = {
+const AVCodec ff_tdsc_decoder = {
     .name           = "tdsc",
     .long_name      = NULL_IF_CONFIG_SMALL("TDSC"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/textdec.c b/libavcodec/textdec.c
index 964da72ad5..c1fcc5c6cb 100644
--- a/libavcodec/textdec.c
+++ b/libavcodec/textdec.c
@@ -81,7 +81,7 @@ static void text_flush(AVCodecContext *avctx)
 #define text_options options
 DECLARE_CLASS(text);
 
-AVCodec ff_text_decoder = {
+const AVCodec ff_text_decoder = {
     .name           = "text",
     .long_name      = NULL_IF_CONFIG_SMALL("Raw text subtitle"),
     .priv_data_size = sizeof(TextContext),
@@ -107,7 +107,7 @@ static int linebreak_init(AVCodecContext *avctx)
 #define vplayer_options options
 DECLARE_CLASS(vplayer);
 
-AVCodec ff_vplayer_decoder = {
+const AVCodec ff_vplayer_decoder = {
     .name           = "vplayer",
     .long_name      = NULL_IF_CONFIG_SMALL("VPlayer subtitle"),
     .priv_data_size = sizeof(TextContext),
@@ -124,7 +124,7 @@ AVCodec ff_vplayer_decoder = {
 #define stl_options options
 DECLARE_CLASS(stl);
 
-AVCodec ff_stl_decoder = {
+const AVCodec ff_stl_decoder = {
     .name           = "stl",
     .long_name      = NULL_IF_CONFIG_SMALL("Spruce subtitle format"),
     .priv_data_size = sizeof(TextContext),
@@ -141,7 +141,7 @@ AVCodec ff_stl_decoder = {
 #define pjs_options options
 DECLARE_CLASS(pjs);
 
-AVCodec ff_pjs_decoder = {
+const AVCodec ff_pjs_decoder = {
     .name           = "pjs",
     .long_name      = NULL_IF_CONFIG_SMALL("PJS subtitle"),
     .priv_data_size = sizeof(TextContext),
@@ -158,7 +158,7 @@ AVCodec ff_pjs_decoder = {
 #define subviewer1_options options
 DECLARE_CLASS(subviewer1);
 
-AVCodec ff_subviewer1_decoder = {
+const AVCodec ff_subviewer1_decoder = {
     .name           = "subviewer1",
     .long_name      = NULL_IF_CONFIG_SMALL("SubViewer1 subtitle"),
     .priv_data_size = sizeof(TextContext),
diff --git a/libavcodec/tiertexseqv.c b/libavcodec/tiertexseqv.c
index 91c8314379..e5b863b6af 100644
--- a/libavcodec/tiertexseqv.c
+++ b/libavcodec/tiertexseqv.c
@@ -261,7 +261,7 @@ static av_cold int seqvideo_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_tiertexseqvideo_decoder = {
+const AVCodec ff_tiertexseqvideo_decoder = {
     .name           = "tiertexseqvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Tiertex Limited SEQ video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/tiff.c b/libavcodec/tiff.c
index 819672eea0..8566f7ba74 100644
--- a/libavcodec/tiff.c
+++ b/libavcodec/tiff.c
@@ -2195,7 +2195,7 @@ static const AVClass tiff_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_tiff_decoder = {
+const AVCodec ff_tiff_decoder = {
     .name           = "tiff",
     .long_name      = NULL_IF_CONFIG_SMALL("TIFF image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/tiffenc.c b/libavcodec/tiffenc.c
index 03262f97b2..32ee2d5f3e 100644
--- a/libavcodec/tiffenc.c
+++ b/libavcodec/tiffenc.c
@@ -568,7 +568,7 @@ static const AVClass tiffenc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_tiff_encoder = {
+const AVCodec ff_tiff_encoder = {
     .name           = "tiff",
     .long_name      = NULL_IF_CONFIG_SMALL("TIFF image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/tmv.c b/libavcodec/tmv.c
index f8485cda59..67aeb23665 100644
--- a/libavcodec/tmv.c
+++ b/libavcodec/tmv.c
@@ -86,7 +86,7 @@ static av_cold int tmv_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_tmv_decoder = {
+const AVCodec ff_tmv_decoder = {
     .name           = "tmv",
     .long_name      = NULL_IF_CONFIG_SMALL("8088flex TMV"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/truemotion1.c b/libavcodec/truemotion1.c
index 94782fef4b..56ef059ce1 100644
--- a/libavcodec/truemotion1.c
+++ b/libavcodec/truemotion1.c
@@ -910,7 +910,7 @@ static av_cold int truemotion1_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_truemotion1_decoder = {
+const AVCodec ff_truemotion1_decoder = {
     .name           = "truemotion1",
     .long_name      = NULL_IF_CONFIG_SMALL("Duck TrueMotion 1.0"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/truemotion2.c b/libavcodec/truemotion2.c
index 012ad4ffde..f29db593f9 100644
--- a/libavcodec/truemotion2.c
+++ b/libavcodec/truemotion2.c
@@ -1008,7 +1008,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_truemotion2_decoder = {
+const AVCodec ff_truemotion2_decoder = {
     .name           = "truemotion2",
     .long_name      = NULL_IF_CONFIG_SMALL("Duck TrueMotion 2.0"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/truemotion2rt.c b/libavcodec/truemotion2rt.c
index e3ab998fda..a2206a60e0 100644
--- a/libavcodec/truemotion2rt.c
+++ b/libavcodec/truemotion2rt.c
@@ -220,7 +220,7 @@ static av_cold int truemotion2rt_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_truemotion2rt_decoder = {
+const AVCodec ff_truemotion2rt_decoder = {
     .name           = "truemotion2rt",
     .long_name      = NULL_IF_CONFIG_SMALL("Duck TrueMotion 2.0 Real Time"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/truespeech.c b/libavcodec/truespeech.c
index 272fc43deb..5eac34fefc 100644
--- a/libavcodec/truespeech.c
+++ b/libavcodec/truespeech.c
@@ -355,7 +355,7 @@ static int truespeech_decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_truespeech_decoder = {
+const AVCodec ff_truespeech_decoder = {
     .name           = "truespeech",
     .long_name      = NULL_IF_CONFIG_SMALL("DSP Group TrueSpeech"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/tscc.c b/libavcodec/tscc.c
index f67a910c73..043d78d018 100644
--- a/libavcodec/tscc.c
+++ b/libavcodec/tscc.c
@@ -180,7 +180,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_tscc_decoder = {
+const AVCodec ff_tscc_decoder = {
     .name           = "camtasia",
     .long_name      = NULL_IF_CONFIG_SMALL("TechSmith Screen Capture Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/tscc2.c b/libavcodec/tscc2.c
index 13e7a41a31..419a7775b3 100644
--- a/libavcodec/tscc2.c
+++ b/libavcodec/tscc2.c
@@ -355,7 +355,7 @@ static av_cold int tscc2_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_tscc2_decoder = {
+const AVCodec ff_tscc2_decoder = {
     .name           = "tscc2",
     .long_name      = NULL_IF_CONFIG_SMALL("TechSmith Screen Codec 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/tta.c b/libavcodec/tta.c
index f1e159b03d..83e857ae25 100644
--- a/libavcodec/tta.c
+++ b/libavcodec/tta.c
@@ -414,7 +414,7 @@ static const AVClass tta_decoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_tta_decoder = {
+const AVCodec ff_tta_decoder = {
     .name           = "tta",
     .long_name      = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/ttaenc.c b/libavcodec/ttaenc.c
index bb4734e013..3255347b62 100644
--- a/libavcodec/ttaenc.c
+++ b/libavcodec/ttaenc.c
@@ -200,7 +200,7 @@ static av_cold int tta_encode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_tta_encoder = {
+const AVCodec ff_tta_encoder = {
     .name           = "tta",
     .long_name      = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/ttmlenc.c b/libavcodec/ttmlenc.c
index 26ab76e9e7..56c80d7bea 100644
--- a/libavcodec/ttmlenc.c
+++ b/libavcodec/ttmlenc.c
@@ -169,7 +169,7 @@ static av_cold int ttml_encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_ttml_encoder = {
+const AVCodec ff_ttml_encoder = {
     .name           = "ttml",
     .long_name      = NULL_IF_CONFIG_SMALL("TTML subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/twinvqdec.c b/libavcodec/twinvqdec.c
index 0c1782ecbf..b972facfdd 100644
--- a/libavcodec/twinvqdec.c
+++ b/libavcodec/twinvqdec.c
@@ -414,7 +414,7 @@ static av_cold int twinvq_decode_init(AVCodecContext *avctx)
     return ff_twinvq_decode_init(avctx);
 }
 
-AVCodec ff_twinvq_decoder = {
+const AVCodec ff_twinvq_decoder = {
     .name           = "twinvq",
     .long_name      = NULL_IF_CONFIG_SMALL("VQF TwinVQ"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/txd.c b/libavcodec/txd.c
index f00ba89e82..86d60f3377 100644
--- a/libavcodec/txd.c
+++ b/libavcodec/txd.c
@@ -155,7 +155,7 @@ unsupported:
     return AVERROR_PATCHWELCOME;
 }
 
-AVCodec ff_txd_decoder = {
+const AVCodec ff_txd_decoder = {
     .name           = "txd",
     .long_name      = NULL_IF_CONFIG_SMALL("Renderware TXD (TeXture Dictionary) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ulti.c b/libavcodec/ulti.c
index cf6891d530..55548ae3f6 100644
--- a/libavcodec/ulti.c
+++ b/libavcodec/ulti.c
@@ -418,7 +418,7 @@ err:
     return AVERROR_INVALIDDATA;
 }
 
-AVCodec ff_ulti_decoder = {
+const AVCodec ff_ulti_decoder = {
     .name           = "ultimotion",
     .long_name      = NULL_IF_CONFIG_SMALL("IBM UltiMotion"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/utvideodec.c b/libavcodec/utvideodec.c
index 1b10b3bd06..b39d8a7948 100644
--- a/libavcodec/utvideodec.c
+++ b/libavcodec/utvideodec.c
@@ -1051,7 +1051,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_utvideo_decoder = {
+const AVCodec ff_utvideo_decoder = {
     .name           = "utvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Ut Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/utvideoenc.c b/libavcodec/utvideoenc.c
index 670e48aa9f..29b29bc658 100644
--- a/libavcodec/utvideoenc.c
+++ b/libavcodec/utvideoenc.c
@@ -649,7 +649,7 @@ static const AVClass utvideo_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_utvideo_encoder = {
+const AVCodec ff_utvideo_encoder = {
     .name           = "utvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Ut Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v210dec.c b/libavcodec/v210dec.c
index 044d35338b..868822e298 100644
--- a/libavcodec/v210dec.c
+++ b/libavcodec/v210dec.c
@@ -214,7 +214,7 @@ static const AVClass v210dec_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_v210_decoder = {
+const AVCodec ff_v210_decoder = {
     .name           = "v210",
     .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v210enc.c b/libavcodec/v210enc.c
index 91af88b359..020f0fffe5 100644
--- a/libavcodec/v210enc.c
+++ b/libavcodec/v210enc.c
@@ -151,7 +151,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_v210_encoder = {
+const AVCodec ff_v210_encoder = {
     .name           = "v210",
     .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v210x.c b/libavcodec/v210x.c
index f6a453aabf..da9e2e3649 100644
--- a/libavcodec/v210x.c
+++ b/libavcodec/v210x.c
@@ -120,7 +120,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 }
 
-AVCodec ff_v210x_decoder = {
+const AVCodec ff_v210x_decoder = {
     .name           = "v210x",
     .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v308dec.c b/libavcodec/v308dec.c
index dd53fbded4..c2b0a69561 100644
--- a/libavcodec/v308dec.c
+++ b/libavcodec/v308dec.c
@@ -72,7 +72,7 @@ static int v308_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_v308_decoder = {
+const AVCodec ff_v308_decoder = {
     .name         = "v308",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:4:4"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v308enc.c b/libavcodec/v308enc.c
index 0891251dea..919f0ea10b 100644
--- a/libavcodec/v308enc.c
+++ b/libavcodec/v308enc.c
@@ -68,7 +68,7 @@ static int v308_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_v308_encoder = {
+const AVCodec ff_v308_encoder = {
     .name         = "v308",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:4:4"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v408dec.c b/libavcodec/v408dec.c
index 196c575c09..749b3b65e5 100644
--- a/libavcodec/v408dec.c
+++ b/libavcodec/v408dec.c
@@ -80,7 +80,7 @@ static int v408_decode_frame(AVCodecContext *avctx, void *data,
 }
 
 #if CONFIG_AYUV_DECODER
-AVCodec ff_ayuv_decoder = {
+const AVCodec ff_ayuv_decoder = {
     .name         = "ayuv",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed packed MS 4:4:4:4"),
     .type         = AVMEDIA_TYPE_VIDEO,
@@ -92,7 +92,7 @@ AVCodec ff_ayuv_decoder = {
 };
 #endif
 #if CONFIG_V408_DECODER
-AVCodec ff_v408_decoder = {
+const AVCodec ff_v408_decoder = {
     .name         = "v408",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed packed QT 4:4:4:4"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v408enc.c b/libavcodec/v408enc.c
index d2d84d9c40..7df371f0ea 100644
--- a/libavcodec/v408enc.c
+++ b/libavcodec/v408enc.c
@@ -74,7 +74,7 @@ static int v408_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 }
 
 #if CONFIG_AYUV_ENCODER
-AVCodec ff_ayuv_encoder = {
+const AVCodec ff_ayuv_encoder = {
     .name         = "ayuv",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed packed MS 4:4:4:4"),
     .type         = AVMEDIA_TYPE_VIDEO,
@@ -85,7 +85,7 @@ AVCodec ff_ayuv_encoder = {
 };
 #endif
 #if CONFIG_V408_ENCODER
-AVCodec ff_v408_encoder = {
+const AVCodec ff_v408_encoder = {
     .name         = "v408",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed packed QT 4:4:4:4"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v410dec.c b/libavcodec/v410dec.c
index 7ad5eb8fb5..2160f88e8b 100644
--- a/libavcodec/v410dec.c
+++ b/libavcodec/v410dec.c
@@ -116,7 +116,7 @@ static int v410_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_v410_decoder = {
+const AVCodec ff_v410_decoder = {
     .name         = "v410",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed 4:4:4 10-bit"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v410enc.c b/libavcodec/v410enc.c
index 9dc13f7144..c31bf7f4d8 100644
--- a/libavcodec/v410enc.c
+++ b/libavcodec/v410enc.c
@@ -73,7 +73,7 @@ static int v410_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_v410_encoder = {
+const AVCodec ff_v410_encoder = {
     .name         = "v410",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed 4:4:4 10-bit"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/v4l2_m2m_dec.c b/libavcodec/v4l2_m2m_dec.c
index ab07c0a24a..224eb3d5e7 100644
--- a/libavcodec/v4l2_m2m_dec.c
+++ b/libavcodec/v4l2_m2m_dec.c
@@ -236,7 +236,7 @@ static const AVOption options[] = {
 
 #define M2MDEC(NAME, LONGNAME, CODEC, bsf_name) \
     M2MDEC_CLASS(NAME) \
-    AVCodec ff_ ## NAME ## _v4l2m2m_decoder = { \
+    const AVCodec ff_ ## NAME ## _v4l2m2m_decoder = { \
         .name           = #NAME "_v4l2m2m" , \
         .long_name      = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " decoder wrapper"), \
         .type           = AVMEDIA_TYPE_VIDEO, \
diff --git a/libavcodec/v4l2_m2m_enc.c b/libavcodec/v4l2_m2m_enc.c
index f644b50133..043fe80c69 100644
--- a/libavcodec/v4l2_m2m_enc.c
+++ b/libavcodec/v4l2_m2m_enc.c
@@ -421,7 +421,7 @@ static const AVCodecDefault v4l2_m2m_defaults[] = {
 
 #define M2MENC(NAME, LONGNAME, OPTIONS_NAME, CODEC) \
     M2MENC_CLASS(NAME, OPTIONS_NAME) \
-    AVCodec ff_ ## NAME ## _v4l2m2m_encoder = { \
+    const AVCodec ff_ ## NAME ## _v4l2m2m_encoder = { \
         .name           = #NAME "_v4l2m2m" , \
         .long_name      = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " encoder wrapper"), \
         .type           = AVMEDIA_TYPE_VIDEO, \
diff --git a/libavcodec/vaapi_encode_h264.c b/libavcodec/vaapi_encode_h264.c
index 6e20e2d015..ff37de1f7e 100644
--- a/libavcodec/vaapi_encode_h264.c
+++ b/libavcodec/vaapi_encode_h264.c
@@ -1324,7 +1324,7 @@ static const AVClass vaapi_encode_h264_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_h264_vaapi_encoder = {
+const AVCodec ff_h264_vaapi_encoder = {
     .name           = "h264_vaapi",
     .long_name      = NULL_IF_CONFIG_SMALL("H.264/AVC (VAAPI)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vaapi_encode_h265.c b/libavcodec/vaapi_encode_h265.c
index 287ac58690..e1dc53dfa9 100644
--- a/libavcodec/vaapi_encode_h265.c
+++ b/libavcodec/vaapi_encode_h265.c
@@ -1302,7 +1302,7 @@ static const AVClass vaapi_encode_h265_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_hevc_vaapi_encoder = {
+const AVCodec ff_hevc_vaapi_encoder = {
     .name           = "hevc_vaapi",
     .long_name      = NULL_IF_CONFIG_SMALL("H.265/HEVC (VAAPI)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vaapi_encode_mjpeg.c b/libavcodec/vaapi_encode_mjpeg.c
index 3878f3eeb9..d35f416ad7 100644
--- a/libavcodec/vaapi_encode_mjpeg.c
+++ b/libavcodec/vaapi_encode_mjpeg.c
@@ -552,7 +552,7 @@ static const AVClass vaapi_encode_mjpeg_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_mjpeg_vaapi_encoder = {
+const AVCodec ff_mjpeg_vaapi_encoder = {
     .name           = "mjpeg_vaapi",
     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (VAAPI)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vaapi_encode_mpeg2.c b/libavcodec/vaapi_encode_mpeg2.c
index 4c81d785d6..af3a63dab7 100644
--- a/libavcodec/vaapi_encode_mpeg2.c
+++ b/libavcodec/vaapi_encode_mpeg2.c
@@ -688,7 +688,7 @@ static const AVClass vaapi_encode_mpeg2_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_mpeg2_vaapi_encoder = {
+const AVCodec ff_mpeg2_vaapi_encoder = {
     .name           = "mpeg2_vaapi",
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 (VAAPI)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vaapi_encode_vp8.c b/libavcodec/vaapi_encode_vp8.c
index 66cf2321be..7d4578f674 100644
--- a/libavcodec/vaapi_encode_vp8.c
+++ b/libavcodec/vaapi_encode_vp8.c
@@ -245,7 +245,7 @@ static const AVClass vaapi_encode_vp8_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_vp8_vaapi_encoder = {
+const AVCodec ff_vp8_vaapi_encoder = {
     .name           = "vp8_vaapi",
     .long_name      = NULL_IF_CONFIG_SMALL("VP8 (VAAPI)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vaapi_encode_vp9.c b/libavcodec/vaapi_encode_vp9.c
index 0e1c52c92a..b3f45fb8fe 100644
--- a/libavcodec/vaapi_encode_vp9.c
+++ b/libavcodec/vaapi_encode_vp9.c
@@ -279,7 +279,7 @@ static const AVClass vaapi_encode_vp9_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_vp9_vaapi_encoder = {
+const AVCodec ff_vp9_vaapi_encoder = {
     .name           = "vp9_vaapi",
     .long_name      = NULL_IF_CONFIG_SMALL("VP9 (VAAPI)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vb.c b/libavcodec/vb.c
index fe419c7663..f5b7f89853 100644
--- a/libavcodec/vb.c
+++ b/libavcodec/vb.c
@@ -278,7 +278,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_vb_decoder = {
+const AVCodec ff_vb_decoder = {
     .name           = "vb",
     .long_name      = NULL_IF_CONFIG_SMALL("Beam Software VB"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vble.c b/libavcodec/vble.c
index 2cddd550b1..f1400959e0 100644
--- a/libavcodec/vble.c
+++ b/libavcodec/vble.c
@@ -203,7 +203,7 @@ static av_cold int vble_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_vble_decoder = {
+const AVCodec ff_vble_decoder = {
     .name           = "vble",
     .long_name      = NULL_IF_CONFIG_SMALL("VBLE Lossless Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vc1dec.c b/libavcodec/vc1dec.c
index 8f112bf9b2..6cd74a09f1 100644
--- a/libavcodec/vc1dec.c
+++ b/libavcodec/vc1dec.c
@@ -1196,7 +1196,7 @@ static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
     AV_PIX_FMT_NONE
 };
 
-AVCodec ff_vc1_decoder = {
+const AVCodec ff_vc1_decoder = {
     .name           = "vc1",
     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -1233,7 +1233,7 @@ AVCodec ff_vc1_decoder = {
 };
 
 #if CONFIG_WMV3_DECODER
-AVCodec ff_wmv3_decoder = {
+const AVCodec ff_wmv3_decoder = {
     .name           = "wmv3",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -1271,7 +1271,7 @@ AVCodec ff_wmv3_decoder = {
 #endif
 
 #if CONFIG_WMV3IMAGE_DECODER
-AVCodec ff_wmv3image_decoder = {
+const AVCodec ff_wmv3image_decoder = {
     .name           = "wmv3image",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -1290,7 +1290,7 @@ AVCodec ff_wmv3image_decoder = {
 #endif
 
 #if CONFIG_VC1IMAGE_DECODER
-AVCodec ff_vc1image_decoder = {
+const AVCodec ff_vc1image_decoder = {
     .name           = "vc1image",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vc2enc.c b/libavcodec/vc2enc.c
index 7bd2e4c2ab..6432532eae 100644
--- a/libavcodec/vc2enc.c
+++ b/libavcodec/vc2enc.c
@@ -1226,7 +1226,7 @@ static const enum AVPixelFormat allowed_pix_fmts[] = {
     AV_PIX_FMT_NONE
 };
 
-AVCodec ff_vc2_encoder = {
+const AVCodec ff_vc2_encoder = {
     .name           = "vc2",
     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-2"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vcr1.c b/libavcodec/vcr1.c
index 28a5eec7d1..8220cf3b38 100644
--- a/libavcodec/vcr1.c
+++ b/libavcodec/vcr1.c
@@ -121,7 +121,7 @@ static int vcr1_decode_frame(AVCodecContext *avctx, void *data,
     return bytestream - avpkt->data;
 }
 
-AVCodec ff_vcr1_decoder = {
+const AVCodec ff_vcr1_decoder = {
     .name           = "vcr1",
     .long_name      = NULL_IF_CONFIG_SMALL("ATI VCR1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/videotoolboxenc.c b/libavcodec/videotoolboxenc.c
index 9b7ee6720c..e576ff7d7e 100644
--- a/libavcodec/videotoolboxenc.c
+++ b/libavcodec/videotoolboxenc.c
@@ -2659,7 +2659,7 @@ static const AVClass h264_videotoolbox_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_h264_videotoolbox_encoder = {
+const AVCodec ff_h264_videotoolbox_encoder = {
     .name             = "h264_videotoolbox",
     .long_name        = NULL_IF_CONFIG_SMALL("VideoToolbox H.264 Encoder"),
     .type             = AVMEDIA_TYPE_VIDEO,
@@ -2693,7 +2693,7 @@ static const AVClass hevc_videotoolbox_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_hevc_videotoolbox_encoder = {
+const AVCodec ff_hevc_videotoolbox_encoder = {
     .name             = "hevc_videotoolbox",
     .long_name        = NULL_IF_CONFIG_SMALL("VideoToolbox H.265 Encoder"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vima.c b/libavcodec/vima.c
index 2dfc2cc5c8..5c7618861f 100644
--- a/libavcodec/vima.c
+++ b/libavcodec/vima.c
@@ -207,7 +207,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     return pkt->size;
 }
 
-AVCodec ff_adpcm_vima_decoder = {
+const AVCodec ff_adpcm_vima_decoder = {
     .name         = "adpcm_vima",
     .long_name    = NULL_IF_CONFIG_SMALL("LucasArts VIMA audio"),
     .type         = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/vmdaudio.c b/libavcodec/vmdaudio.c
index dfbd49fd84..d513479c54 100644
--- a/libavcodec/vmdaudio.c
+++ b/libavcodec/vmdaudio.c
@@ -228,7 +228,7 @@ static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_vmdaudio_decoder = {
+const AVCodec ff_vmdaudio_decoder = {
     .name           = "vmdaudio",
     .long_name      = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/vmdvideo.c b/libavcodec/vmdvideo.c
index bb9306e4ff..15846919d8 100644
--- a/libavcodec/vmdvideo.c
+++ b/libavcodec/vmdvideo.c
@@ -467,7 +467,7 @@ static int vmdvideo_decode_frame(AVCodecContext *avctx,
     return buf_size;
 }
 
-AVCodec ff_vmdvideo_decoder = {
+const AVCodec ff_vmdvideo_decoder = {
     .name           = "vmdvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vmnc.c b/libavcodec/vmnc.c
index 7f441bc4bd..d65e8dc4e5 100644
--- a/libavcodec/vmnc.c
+++ b/libavcodec/vmnc.c
@@ -572,7 +572,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_vmnc_decoder = {
+const AVCodec ff_vmnc_decoder = {
     .name           = "vmnc",
     .long_name      = NULL_IF_CONFIG_SMALL("VMware Screen Codec / VMware Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vorbisdec.c b/libavcodec/vorbisdec.c
index 169df591b3..dac2b6841c 100644
--- a/libavcodec/vorbisdec.c
+++ b/libavcodec/vorbisdec.c
@@ -1880,7 +1880,7 @@ static av_cold void vorbis_decode_flush(AVCodecContext *avctx)
     vc->first_frame = 0;
 }
 
-AVCodec ff_vorbis_decoder = {
+const AVCodec ff_vorbis_decoder = {
     .name            = "vorbis",
     .long_name       = NULL_IF_CONFIG_SMALL("Vorbis"),
     .type            = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/vorbisenc.c b/libavcodec/vorbisenc.c
index 1b0ab3cadb..b89bb206e0 100644
--- a/libavcodec/vorbisenc.c
+++ b/libavcodec/vorbisenc.c
@@ -1293,7 +1293,7 @@ error:
     return ret;
 }
 
-AVCodec ff_vorbis_encoder = {
+const AVCodec ff_vorbis_encoder = {
     .name           = "vorbis",
     .long_name      = NULL_IF_CONFIG_SMALL("Vorbis"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/vp3.c b/libavcodec/vp3.c
index 57c6eb1ff9..0cae075452 100644
--- a/libavcodec/vp3.c
+++ b/libavcodec/vp3.c
@@ -3159,7 +3159,7 @@ static av_cold int theora_decode_init(AVCodecContext *avctx)
     return vp3_decode_init(avctx);
 }
 
-AVCodec ff_theora_decoder = {
+const AVCodec ff_theora_decoder = {
     .name                  = "theora",
     .long_name             = NULL_IF_CONFIG_SMALL("Theora"),
     .type                  = AVMEDIA_TYPE_VIDEO,
@@ -3177,7 +3177,7 @@ AVCodec ff_theora_decoder = {
 };
 #endif
 
-AVCodec ff_vp3_decoder = {
+const AVCodec ff_vp3_decoder = {
     .name                  = "vp3",
     .long_name             = NULL_IF_CONFIG_SMALL("On2 VP3"),
     .type                  = AVMEDIA_TYPE_VIDEO,
@@ -3194,7 +3194,7 @@ AVCodec ff_vp3_decoder = {
 };
 
 #if CONFIG_VP4_DECODER
-AVCodec ff_vp4_decoder = {
+const AVCodec ff_vp4_decoder = {
     .name                  = "vp4",
     .long_name             = NULL_IF_CONFIG_SMALL("On2 VP4"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vp5.c b/libavcodec/vp5.c
index f3946f508c..f68c62527b 100644
--- a/libavcodec/vp5.c
+++ b/libavcodec/vp5.c
@@ -296,7 +296,7 @@ static av_cold int vp5_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_vp5_decoder = {
+const AVCodec ff_vp5_decoder = {
     .name           = "vp5",
     .long_name      = NULL_IF_CONFIG_SMALL("On2 VP5"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vp6.c b/libavcodec/vp6.c
index e5dec19f50..73822a00f9 100644
--- a/libavcodec/vp6.c
+++ b/libavcodec/vp6.c
@@ -703,7 +703,7 @@ static av_cold void vp6_decode_free_context(VP56Context *s)
     }
 }
 
-AVCodec ff_vp6_decoder = {
+const AVCodec ff_vp6_decoder = {
     .name           = "vp6",
     .long_name      = NULL_IF_CONFIG_SMALL("On2 VP6"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -716,7 +716,7 @@ AVCodec ff_vp6_decoder = {
 };
 
 /* flash version, not flipped upside-down */
-AVCodec ff_vp6f_decoder = {
+const AVCodec ff_vp6f_decoder = {
     .name           = "vp6f",
     .long_name      = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version)"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -729,7 +729,7 @@ AVCodec ff_vp6f_decoder = {
 };
 
 /* flash version, not flipped upside-down, with alpha channel */
-AVCodec ff_vp6a_decoder = {
+const AVCodec ff_vp6a_decoder = {
     .name           = "vp6a",
     .long_name      = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version, with alpha channel)"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vp8.c b/libavcodec/vp8.c
index d16e7b6aa3..b964d2fd2d 100644
--- a/libavcodec/vp8.c
+++ b/libavcodec/vp8.c
@@ -2938,7 +2938,7 @@ static int vp8_decode_update_thread_context(AVCodecContext *dst,
 #endif /* CONFIG_VP8_DECODER */
 
 #if CONFIG_VP7_DECODER
-AVCodec ff_vp7_decoder = {
+const AVCodec ff_vp7_decoder = {
     .name                  = "vp7",
     .long_name             = NULL_IF_CONFIG_SMALL("On2 VP7"),
     .type                  = AVMEDIA_TYPE_VIDEO,
@@ -2953,7 +2953,7 @@ AVCodec ff_vp7_decoder = {
 #endif /* CONFIG_VP7_DECODER */
 
 #if CONFIG_VP8_DECODER
-AVCodec ff_vp8_decoder = {
+const AVCodec ff_vp8_decoder = {
     .name                  = "vp8",
     .long_name             = NULL_IF_CONFIG_SMALL("On2 VP8"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vp9.c b/libavcodec/vp9.c
index b4b644d509..32776ebae7 100644
--- a/libavcodec/vp9.c
+++ b/libavcodec/vp9.c
@@ -1873,7 +1873,7 @@ static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecCo
 }
 #endif
 
-AVCodec ff_vp9_decoder = {
+const AVCodec ff_vp9_decoder = {
     .name                  = "vp9",
     .long_name             = NULL_IF_CONFIG_SMALL("Google VP9"),
     .type                  = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/vqavideo.c b/libavcodec/vqavideo.c
index f45390cfe5..a396615ce5 100644
--- a/libavcodec/vqavideo.c
+++ b/libavcodec/vqavideo.c
@@ -642,7 +642,7 @@ static const AVCodecDefault vqa_defaults[] = {
     { NULL },
 };
 
-AVCodec ff_vqa_decoder = {
+const AVCodec ff_vqa_decoder = {
     .name           = "vqavideo",
     .long_name      = NULL_IF_CONFIG_SMALL("Westwood Studios VQA (Vector Quantized Animation) video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c
index 2d49172eaf..6b2ec19bf1 100644
--- a/libavcodec/wavpack.c
+++ b/libavcodec/wavpack.c
@@ -1699,7 +1699,7 @@ error:
     return ret;
 }
 
-AVCodec ff_wavpack_decoder = {
+const AVCodec ff_wavpack_decoder = {
     .name           = "wavpack",
     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/wavpackenc.c b/libavcodec/wavpackenc.c
index 0c82633a72..b856f56e3b 100644
--- a/libavcodec/wavpackenc.c
+++ b/libavcodec/wavpackenc.c
@@ -2957,7 +2957,7 @@ static const AVClass wavpack_encoder_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_wavpack_encoder = {
+const AVCodec ff_wavpack_encoder = {
     .name           = "wavpack",
     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/wcmv.c b/libavcodec/wcmv.c
index d7a3cbd1b7..04c597e767 100644
--- a/libavcodec/wcmv.c
+++ b/libavcodec/wcmv.c
@@ -249,7 +249,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_wcmv_decoder = {
+const AVCodec ff_wcmv_decoder = {
     .name             = "wcmv",
     .long_name        = NULL_IF_CONFIG_SMALL("WinCAM Motion Video"),
     .type             = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/webp.c b/libavcodec/webp.c
index 5a7aebc587..23558309c6 100644
--- a/libavcodec/webp.c
+++ b/libavcodec/webp.c
@@ -1550,7 +1550,7 @@ static av_cold int webp_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_webp_decoder = {
+const AVCodec ff_webp_decoder = {
     .name           = "webp",
     .long_name      = NULL_IF_CONFIG_SMALL("WebP image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/webvttdec.c b/libavcodec/webvttdec.c
index 7b2d1750de..eb0a5600a6 100644
--- a/libavcodec/webvttdec.c
+++ b/libavcodec/webvttdec.c
@@ -98,7 +98,7 @@ static int webvtt_decode_frame(AVCodecContext *avctx,
     return avpkt->size;
 }
 
-AVCodec ff_webvtt_decoder = {
+const AVCodec ff_webvtt_decoder = {
     .name           = "webvtt",
     .long_name      = NULL_IF_CONFIG_SMALL("WebVTT subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/webvttenc.c b/libavcodec/webvttenc.c
index fcbd9698f4..cc47b5aca3 100644
--- a/libavcodec/webvttenc.c
+++ b/libavcodec/webvttenc.c
@@ -210,7 +210,7 @@ static av_cold int webvtt_encode_init(AVCodecContext *avctx)
     return s->ass_ctx ? 0 : AVERROR_INVALIDDATA;
 }
 
-AVCodec ff_webvtt_encoder = {
+const AVCodec ff_webvtt_encoder = {
     .name           = "webvtt",
     .long_name      = NULL_IF_CONFIG_SMALL("WebVTT subtitle"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/wmadec.c b/libavcodec/wmadec.c
index 9c79556bb5..9081f35a16 100644
--- a/libavcodec/wmadec.c
+++ b/libavcodec/wmadec.c
@@ -964,7 +964,7 @@ static av_cold void flush(AVCodecContext *avctx)
 }
 
 #if CONFIG_WMAV1_DECODER
-AVCodec ff_wmav1_decoder = {
+const AVCodec ff_wmav1_decoder = {
     .name           = "wmav1",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -980,7 +980,7 @@ AVCodec ff_wmav1_decoder = {
 };
 #endif
 #if CONFIG_WMAV2_DECODER
-AVCodec ff_wmav2_decoder = {
+const AVCodec ff_wmav2_decoder = {
     .name           = "wmav2",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/wmaenc.c b/libavcodec/wmaenc.c
index 4ad37cc70b..89273ba978 100644
--- a/libavcodec/wmaenc.c
+++ b/libavcodec/wmaenc.c
@@ -425,7 +425,7 @@ static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
 }
 
 #if CONFIG_WMAV1_ENCODER
-AVCodec ff_wmav1_encoder = {
+const AVCodec ff_wmav1_encoder = {
     .name           = "wmav1",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -439,7 +439,7 @@ AVCodec ff_wmav1_encoder = {
 };
 #endif
 #if CONFIG_WMAV2_ENCODER
-AVCodec ff_wmav2_encoder = {
+const AVCodec ff_wmav2_encoder = {
     .name           = "wmav2",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/wmalosslessdec.c b/libavcodec/wmalosslessdec.c
index e1fcf8afeb..f750e1a479 100644
--- a/libavcodec/wmalosslessdec.c
+++ b/libavcodec/wmalosslessdec.c
@@ -1323,7 +1323,7 @@ static av_cold int decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_wmalossless_decoder = {
+const AVCodec ff_wmalossless_decoder = {
     .name           = "wmalossless",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/wmaprodec.c b/libavcodec/wmaprodec.c
index 8024ce1611..9607e50968 100644
--- a/libavcodec/wmaprodec.c
+++ b/libavcodec/wmaprodec.c
@@ -2005,7 +2005,7 @@ static void xma_flush(AVCodecContext *avctx)
 /**
  *@brief wmapro decoder
  */
-AVCodec ff_wmapro_decoder = {
+const AVCodec ff_wmapro_decoder = {
     .name           = "wmapro",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -2021,7 +2021,7 @@ AVCodec ff_wmapro_decoder = {
                                                       AV_SAMPLE_FMT_NONE },
 };
 
-AVCodec ff_xma1_decoder = {
+const AVCodec ff_xma1_decoder = {
     .name           = "xma1",
     .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
     .type           = AVMEDIA_TYPE_AUDIO,
@@ -2036,7 +2036,7 @@ AVCodec ff_xma1_decoder = {
                                                       AV_SAMPLE_FMT_NONE },
 };
 
-AVCodec ff_xma2_decoder = {
+const AVCodec ff_xma2_decoder = {
     .name           = "xma2",
     .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/wmavoice.c b/libavcodec/wmavoice.c
index 2cb4219b84..a9d50f95ca 100644
--- a/libavcodec/wmavoice.c
+++ b/libavcodec/wmavoice.c
@@ -1997,7 +1997,7 @@ static av_cold int wmavoice_decode_end(AVCodecContext *ctx)
     return 0;
 }
 
-AVCodec ff_wmavoice_decoder = {
+const AVCodec ff_wmavoice_decoder = {
     .name             = "wmavoice",
     .long_name        = NULL_IF_CONFIG_SMALL("Windows Media Audio Voice"),
     .type             = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/wmv2dec.c b/libavcodec/wmv2dec.c
index 7aae11568c..c500e3e779 100644
--- a/libavcodec/wmv2dec.c
+++ b/libavcodec/wmv2dec.c
@@ -513,7 +513,7 @@ static av_cold int wmv2_decode_end(AVCodecContext *avctx)
     return ff_h263_decode_end(avctx);
 }
 
-AVCodec ff_wmv2_decoder = {
+const AVCodec ff_wmv2_decoder = {
     .name           = "wmv2",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 8"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index 312dbc0834..bdefee5ca8 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -221,7 +221,7 @@ static const AVClass wmv2_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVCodec ff_wmv2_encoder = {
+const AVCodec ff_wmv2_encoder = {
     .name           = "wmv2",
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 8"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/wnv1.c b/libavcodec/wnv1.c
index dcf417763c..5d6c91d2d2 100644
--- a/libavcodec/wnv1.c
+++ b/libavcodec/wnv1.c
@@ -133,7 +133,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_wnv1_decoder = {
+const AVCodec ff_wnv1_decoder = {
     .name           = "wnv1",
     .long_name      = NULL_IF_CONFIG_SMALL("Winnov WNV1"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/wrapped_avframe.c b/libavcodec/wrapped_avframe.c
index 85ff32d13a..a7834b86e8 100644
--- a/libavcodec/wrapped_avframe.c
+++ b/libavcodec/wrapped_avframe.c
@@ -109,7 +109,7 @@ static int wrapped_avframe_decode(AVCodecContext *avctx, void *data,
     return 0;
 }
 
-AVCodec ff_wrapped_avframe_encoder = {
+const AVCodec ff_wrapped_avframe_encoder = {
     .name           = "wrapped_avframe",
     .long_name      = NULL_IF_CONFIG_SMALL("AVFrame to AVPacket passthrough"),
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -118,7 +118,7 @@ AVCodec ff_wrapped_avframe_encoder = {
     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 
-AVCodec ff_wrapped_avframe_decoder = {
+const AVCodec ff_wrapped_avframe_decoder = {
     .name           = "wrapped_avframe",
     .long_name      = NULL_IF_CONFIG_SMALL("AVPacket to AVFrame passthrough"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ws-snd1.c b/libavcodec/ws-snd1.c
index 958c067736..aa8cd0f5f9 100644
--- a/libavcodec/ws-snd1.c
+++ b/libavcodec/ws-snd1.c
@@ -170,7 +170,7 @@ static int ws_snd_decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_ws_snd1_decoder = {
+const AVCodec ff_ws_snd1_decoder = {
     .name           = "ws_snd1",
     .long_name      = NULL_IF_CONFIG_SMALL("Westwood Audio (SND1)"),
     .type           = AVMEDIA_TYPE_AUDIO,
diff --git a/libavcodec/xan.c b/libavcodec/xan.c
index 6bf754f151..7ab43db1e0 100644
--- a/libavcodec/xan.c
+++ b/libavcodec/xan.c
@@ -635,7 +635,7 @@ static int xan_decode_frame(AVCodecContext *avctx,
     return buf_size;
 }
 
-AVCodec ff_xan_wc3_decoder = {
+const AVCodec ff_xan_wc3_decoder = {
     .name           = "xan_wc3",
     .long_name      = NULL_IF_CONFIG_SMALL("Wing Commander III / Xan"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/xbmdec.c b/libavcodec/xbmdec.c
index c1fc6cb650..bed68c33ed 100644
--- a/libavcodec/xbmdec.c
+++ b/libavcodec/xbmdec.c
@@ -136,7 +136,7 @@ static int xbm_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_xbm_decoder = {
+const AVCodec ff_xbm_decoder = {
     .name         = "xbm",
     .long_name    = NULL_IF_CONFIG_SMALL("XBM (X BitMap) image"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/xbmenc.c b/libavcodec/xbmenc.c
index 1cf13f6f0b..3451ecc88c 100644
--- a/libavcodec/xbmenc.c
+++ b/libavcodec/xbmenc.c
@@ -75,7 +75,7 @@ static int xbm_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_xbm_encoder = {
+const AVCodec ff_xbm_encoder = {
     .name         = "xbm",
     .long_name    = NULL_IF_CONFIG_SMALL("XBM (X BitMap) image"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/xfacedec.c b/libavcodec/xfacedec.c
index 763be6761a..27295ff518 100644
--- a/libavcodec/xfacedec.c
+++ b/libavcodec/xfacedec.c
@@ -176,7 +176,7 @@ static int xface_decode_frame(AVCodecContext *avctx,
     return avpkt->size;
 }
 
-AVCodec ff_xface_decoder = {
+const AVCodec ff_xface_decoder = {
     .name           = "xface",
     .long_name      = NULL_IF_CONFIG_SMALL("X-face image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/xfaceenc.c b/libavcodec/xfaceenc.c
index dd5bb689c2..21c7d8f31c 100644
--- a/libavcodec/xfaceenc.c
+++ b/libavcodec/xfaceenc.c
@@ -211,7 +211,7 @@ static int xface_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_xface_encoder = {
+const AVCodec ff_xface_encoder = {
     .name           = "xface",
     .long_name      = NULL_IF_CONFIG_SMALL("X-face image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/xl.c b/libavcodec/xl.c
index 72fb3bf259..25e5a6444e 100644
--- a/libavcodec/xl.c
+++ b/libavcodec/xl.c
@@ -127,7 +127,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_xl_decoder = {
+const AVCodec ff_xl_decoder = {
     .name         = "xl",
     .long_name    = NULL_IF_CONFIG_SMALL("Miro VideoXL"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/xpmdec.c b/libavcodec/xpmdec.c
index 922dfc0f67..e609a70c6a 100644
--- a/libavcodec/xpmdec.c
+++ b/libavcodec/xpmdec.c
@@ -436,7 +436,7 @@ static av_cold int xpm_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_xpm_decoder = {
+const AVCodec ff_xpm_decoder = {
     .name           = "xpm",
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_XPM,
diff --git a/libavcodec/xsubdec.c b/libavcodec/xsubdec.c
index caab330ed3..979399bae6 100644
--- a/libavcodec/xsubdec.c
+++ b/libavcodec/xsubdec.c
@@ -160,7 +160,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_sub_ptr,
     return buf_size;
 }
 
-AVCodec ff_xsub_decoder = {
+const AVCodec ff_xsub_decoder = {
     .name      = "xsub",
     .long_name = NULL_IF_CONFIG_SMALL("XSUB"),
     .type      = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/xsubenc.c b/libavcodec/xsubenc.c
index 53fcb76656..03d0dc2d86 100644
--- a/libavcodec/xsubenc.c
+++ b/libavcodec/xsubenc.c
@@ -211,7 +211,7 @@ static av_cold int xsub_encoder_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_xsub_encoder = {
+const AVCodec ff_xsub_encoder = {
     .name       = "xsub",
     .long_name  = NULL_IF_CONFIG_SMALL("DivX subtitles (XSUB)"),
     .type       = AVMEDIA_TYPE_SUBTITLE,
diff --git a/libavcodec/xwddec.c b/libavcodec/xwddec.c
index 8c4358fd4c..7b8228332f 100644
--- a/libavcodec/xwddec.c
+++ b/libavcodec/xwddec.c
@@ -247,7 +247,7 @@ static int xwd_decode_frame(AVCodecContext *avctx, void *data,
     return buf_size;
 }
 
-AVCodec ff_xwd_decoder = {
+const AVCodec ff_xwd_decoder = {
     .name           = "xwd",
     .long_name      = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/xwdenc.c b/libavcodec/xwdenc.c
index 81cca6c963..8eec700e9d 100644
--- a/libavcodec/xwdenc.c
+++ b/libavcodec/xwdenc.c
@@ -215,7 +215,7 @@ static int xwd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_xwd_encoder = {
+const AVCodec ff_xwd_encoder = {
     .name         = "xwd",
     .long_name    = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/xxan.c b/libavcodec/xxan.c
index 1dd46b36eb..7c4aaf281f 100644
--- a/libavcodec/xxan.c
+++ b/libavcodec/xxan.c
@@ -433,7 +433,7 @@ static int xan_decode_frame(AVCodecContext *avctx,
     return avpkt->size;
 }
 
-AVCodec ff_xan_wc4_decoder = {
+const AVCodec ff_xan_wc4_decoder = {
     .name           = "xan_wc4",
     .long_name      = NULL_IF_CONFIG_SMALL("Wing Commander IV / Xxan"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/y41pdec.c b/libavcodec/y41pdec.c
index 2bfabe277e..e63d184f25 100644
--- a/libavcodec/y41pdec.c
+++ b/libavcodec/y41pdec.c
@@ -81,7 +81,7 @@ static int y41p_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_y41p_decoder = {
+const AVCodec ff_y41p_decoder = {
     .name         = "y41p",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed YUV 4:1:1 12-bit"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/y41penc.c b/libavcodec/y41penc.c
index 4340a3fbba..e7d639008f 100644
--- a/libavcodec/y41penc.c
+++ b/libavcodec/y41penc.c
@@ -75,7 +75,7 @@ static int y41p_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_y41p_encoder = {
+const AVCodec ff_y41p_encoder = {
     .name         = "y41p",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed YUV 4:1:1 12-bit"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/ylc.c b/libavcodec/ylc.c
index ab1f8958f3..1c2b5000fe 100644
--- a/libavcodec/ylc.c
+++ b/libavcodec/ylc.c
@@ -452,7 +452,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_ylc_decoder = {
+const AVCodec ff_ylc_decoder = {
     .name           = "ylc",
     .long_name      = NULL_IF_CONFIG_SMALL("YUY2 Lossless Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/yop.c b/libavcodec/yop.c
index 8f8ed940ec..38014edef6 100644
--- a/libavcodec/yop.c
+++ b/libavcodec/yop.c
@@ -265,7 +265,7 @@ static int yop_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 }
 
-AVCodec ff_yop_decoder = {
+const AVCodec ff_yop_decoder = {
     .name           = "yop",
     .long_name      = NULL_IF_CONFIG_SMALL("Psygnosis YOP Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/yuv4dec.c b/libavcodec/yuv4dec.c
index 3fb1dbac28..b180e96b5f 100644
--- a/libavcodec/yuv4dec.c
+++ b/libavcodec/yuv4dec.c
@@ -73,7 +73,7 @@ static int yuv4_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-AVCodec ff_yuv4_decoder = {
+const AVCodec ff_yuv4_decoder = {
     .name         = "yuv4",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:2:0"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/yuv4enc.c b/libavcodec/yuv4enc.c
index 63a7fae964..259395d9da 100644
--- a/libavcodec/yuv4enc.c
+++ b/libavcodec/yuv4enc.c
@@ -57,7 +57,7 @@ static int yuv4_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
-AVCodec ff_yuv4_encoder = {
+const AVCodec ff_yuv4_encoder = {
     .name         = "yuv4",
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:2:0"),
     .type         = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/zerocodec.c b/libavcodec/zerocodec.c
index 1051fdaa45..3bd04567a1 100644
--- a/libavcodec/zerocodec.c
+++ b/libavcodec/zerocodec.c
@@ -144,7 +144,7 @@ static void zerocodec_decode_flush(AVCodecContext *avctx)
     av_frame_unref(zc->previous_frame);
 }
 
-AVCodec ff_zerocodec_decoder = {
+const AVCodec ff_zerocodec_decoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .name           = "zerocodec",
     .long_name      = NULL_IF_CONFIG_SMALL("ZeroCodec Lossless Video"),
diff --git a/libavcodec/zmbv.c b/libavcodec/zmbv.c
index e3ccc16d0b..e1aba7f059 100644
--- a/libavcodec/zmbv.c
+++ b/libavcodec/zmbv.c
@@ -654,7 +654,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_zmbv_decoder = {
+const AVCodec ff_zmbv_decoder = {
     .name           = "zmbv",
     .long_name      = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
diff --git a/libavcodec/zmbvenc.c b/libavcodec/zmbvenc.c
index 1d4c617b4a..27d2954352 100644
--- a/libavcodec/zmbvenc.c
+++ b/libavcodec/zmbvenc.c
@@ -422,7 +422,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-AVCodec ff_zmbv_encoder = {
+const AVCodec ff_zmbv_encoder = {
     .name           = "zmbv",
     .long_name      = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"),
     .type           = AVMEDIA_TYPE_VIDEO,
