avcodec: Constify AVCodecs

Given that the AVCodec.next pointer has now been removed, most of the
AVCodecs are not modified at all any more and can therefore be made
const (as this patch does); the only exceptions are the very few codecs
for external libraries that have a init_static_data callback.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
Signed-off-by: James Almer <jamrial@gmail.com>

diff --git a/libavcodec/012v.c b/libavcodec/012v.c
index b5a4066656ea93a66e57bdcb27d83acb8b5a5970..f8aea0d04f71ab1d08b9d5d5df9d530a8cabf5ac 100644 (file)
--- 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 cbd863776378ea36949fcef93a3fb62f2328fd53..e628edde4323b93ec0c0a6d80504f2caadb4b745 100644 (file)
--- 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 dda8b8b1c956070d835f661f7b25c68c0fded8df..6865b9b12eb68d0252982764c3435bb92b83f39b 100644 (file)
--- 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 092dbaae0403bd8094cc89dd6c8e75f168aaa308..54ad806ec9222fce3060c2cd859b4b08863b481d 100644 (file)
--- 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 91c89c87ebb96b7c58ae658713d6cf8265c1d1a7..9dc859b271b84e20b8c1034801a4e6e01e12af3d 100644 (file)
--- 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 0174bf8d5bd1521400107047b03d21977ae81c00..3ce5330c06f6bc19b298778b77ab103f66c2473d 100644 (file)
--- 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 c5d923a8b40870dcad94b5c75fc51f4a80f574a7..00257a547864a873dca32c970109ffd46de6a146 100644 (file)
--- 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 6dc68eb9b0f0b972c22a5b0dab387685f71f2f60..219bf0216373787e2cf189e800fe525f2f37d830 100644 (file)
--- 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 26570f49e5c6233681a8d46ddda2c271bb992cef..2177aa8f567fa1230e83425cc28702c58655b949 100644 (file)
--- 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 daab4332958aeb9c38333a5d4195b25416bc06e3..f6c2810ce552a955bc1f589c8e359c3f7b167a8f 100644 (file)
--- 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 b18317f8b368c6f1a6145f57b5a919b3f8b8d585..3aa6482b1a13392fc6f9e6e820b0db23d1e58a89 100644 (file)
--- 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 8b1a062c6693fd7fb9e4b0cc1b8df4df2df7891a..fe8607988b06bc5f498371dcb744fe5d5f7e4fb5 100644 (file)
--- 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 223874907fe10403d9fe25aa8e11331bd49b97b8..e5c2cbd42ce696eb4d2de9fb2e53c35a88ae23a9 100644 (file)
--- 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 87ec91d6e89dadf0ff262b31c42fa171d8f8ed7d..16e015b0f812eb811f98fbe383cc3c46e3cfe014 100644 (file)
--- 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 752cae5cf429e34eed468bcaa7536a17aa803ab1..1c62ca5a83289a30c5eaf073d8f5a94a0e18d8d1 100644 (file)
--- a/libavcodec/adpcmenc.c
+++ b/libavcodec/adpcmenc.c
@@ -995,7 +995,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 eb05145da99393f414d3142152aea0bb2dd4571a..bff15d826caba4ffd11d64330880fd48e0ca2cce 100644 (file)
--- 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 93b902b0e166441da78fffab588fba39a60641b8..f507840a1a38915eb5b72a23b558fd6a342da738 100644 (file)
--- 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 f39383140fdb7b4c52105cec52c3b499ee9702e5..7579d9765d10c41ea954bbdf71ebe3b20ca26de5 100644 (file)
--- 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 cf5b0782bebcaa3a401c580799546f918f9d4766..c95bdae1edc7e8f147152108dc1a16a149ad634a 100644 (file)
--- 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 7edbb06a3ee7bcf0f01d407b2fb22aada944bab4..67c02ab6af0e034af69eee79ed6ea864acf5ece0 100644 (file)
--- 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 7c7a35c002179ab1fb19f1c3172bfb80a0c256d0..d6b2e1c991b820b23f190a03a40248025a3472d5 100644 (file)
--- 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 def7e17c0f8c031cf1cff67122cac38e3ee1e6a8..e08891ec1bf705f3f8d48b710a4236d38d8632d5 100644 (file)
--- 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 7c881d2e0ae755731ebcb22aed0ef289d1a8932c..01e9b3ab96bd876d950e0f0b30e6daf81114f4d7 100644 (file)
--- 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 c33d5a52617153c9c1713d0ed6444d219431eff7..73dd3d069540eccba910b768f471c4deeb8737a6 100644 (file)
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -28,812 +28,819 @@
 #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_encoder;
-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_encoder;
+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 a8c3433fa869668faec0e903c3de10479b8cb58b..0aada774508135844c0f979b3906ed4cd6ad7be5 100644 (file)
--- 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 fe30d7f11d9c2229591bff14b31fc01a7a5b1abc..aeca99f7c67ea6819cd303d11cef18ecd5e6f78b 100644 (file)
--- 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 b5c840e5f3fca2c0580f247af5887719ea7bf0fa..79541b9b2fef1b5c179d62325560129f51f1ac0f 100644 (file)
--- 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 8e02d4cb2029aa0c96acf768eafdc3bd23a8eb4f..e366a09976deb0582f4414397d89c8fedc5e5e50 100644 (file)
--- 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 070f276904eb6c106a7836600d39d75437f80091..a6c1d894d75cb780b5b04ea88a8d3a46d05a9990 100644 (file)
--- 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 134640ee368ae37b72ffca9c0663c16f8e8b026a..494903235d158cc383fae6df402b97d0a1e5e617 100644 (file)
--- 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 3a461eec260dcde819914bc728c6d7c00191cc12..0965f8cd56319b96ea596ce02051cfd7bc4916f0 100644 (file)
--- 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 e0c6b6bb8b85f89e84ef1848fc28945322482ce6..022a6f9398c8dac7ba8b8021c71764327ecf91cb 100644 (file)
--- 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 3bbf0104dff6c308d973060133741d57362d4ca7..e7e5459bbf2b769e9249b265a2bdb80b0db8d6d6 100644 (file)
--- 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 60de73ec28b7686cdb00ba6fa858683d466b37ad..f432a123d0c72fefed3913ab2cdf41e78aaa02cb 100644 (file)
--- 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 06970f140b048afcfbb45ac0dfc8cbfc579ef659..c4fc30e047a7ea1f23f34e8b9741d54c3c42cba3 100644 (file)
--- 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 7358d102e3254cf02a022852670529977a2ebbe3..0df66f1cee45a741826fc6df3aa036d079714761 100644 (file)
--- 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 f0b1069cd255407cf697851e312697cc6d066558..3b1a119496942ffcdaa1c05116cc9d09a2203371 100644 (file)
--- 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 3decf670d7d5f31e548affebd40ede1db190c70b..c8fcf45bedd32887cd9b78da28e468220aa2218c 100644 (file)
--- 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 a72e11b8480641947153d363f957f2ca62fc996c..60a4e138c493f264b516fc10bc0eb082ecaa908f 100644 (file)
--- 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 c33a3b4681abfccd8e6b48587800a74651ab5e0d..bf11701d1764111b3bf5636a0e8e990c54dfe306 100644 (file)
--- 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 54f9b1c2d8633bb534ffbff7baf6993bb17f17e3..228477d778aea5d9cbb6d5f42a98a5af52e7864b 100644 (file)
--- 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 37ccbcc946cbc394cbb426a09cc6776f8db107bf..b4809111f8a4f7fb1f1919ef3284b305f4a500ef 100644 (file)
--- 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 c024ab6bded112d5ff298045fed106858da55303..9917f2d81914cdd2b8a11b50d0e550dc0d09ffd2 100644 (file)
--- 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 f88b25da48ef683f9339dfcf5542b950a24f7bbe..eebb412145566d93dc743e7d0cf261b4baf98616 100644 (file)
--- 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 a4fb8c91209029a66c8735de473880c325b607c0..cbd381ef12721a6a2f6a84d63bc1bb27f7c7a84d 100644 (file)
--- 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 b0a4340ae3969856bfebcc6bceeece733480aa4c..e3d056a79da4c29e13ced2f93d4daf625d3118b4 100644 (file)
--- 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 5ef9316632ada2552f293714e88bcb9f007c4bcd..585c710f5a4996f4d83768daf359927447136433 100644 (file)
--- 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 a75d6744d315c0903801edf8e4d00127c3468467..1dda0f91601405ac2b3a0436837e194322877a7b 100644 (file)
--- 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 477afd8bf1630a8b687885853e1d4e44ffba58dc..70e34c617dd37fe804d99e59a6c8ee710f5a4a58 100644 (file)
--- 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 2f2361e5ea6f9eb637b50ab7653074d8cbba314a..28f5f0b1379ce0724fe2026f2926144211b89649 100644 (file)
--- 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 4cf620d43a944cece8dc80d376a21dd17a76b3ea..f7172845c37808d0b4580e29ef6ddde8c2ad6082 100644 (file)
--- 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 2091309e7e277f993214ee51662788c0ae352665..e9e30fe7f4fdbd0bb2b147904baf969dda3059da 100644 (file)
--- 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 a931b54911389c80022f6e2387d7702f775c3093..b529aba7e9d3557ffbf38d6375c9ebd1f277b5ea 100644 (file)
--- 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 a4cb002053e145e381b1653e4bee9dd02d453ace..78685e87777389bf91cd3e26a0d0935551e2527d 100644 (file)
--- 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 5efd24e9c3bb9e4e9cb96224d04d327b1a46dd9c..36d1ab6c0a9472136e88d725056d9d831f229305 100644 (file)
--- 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 df15a0fd5bb6d9b52ed2f9125642191ceadca492..e42ceb3673454a0ec34cfb90ebc3228cb732fcc9 100644 (file)
--- 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 1aeed21f516746e7dc1aed76d21a31f25faecf04..520d68a7c072c3e2c8e469a81343d55578df332e 100644 (file)
--- 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 23e82c69b59db4b22abc532c3914271dac12e453..57ae93b6b4cd33f17cc1290c360ff360c8683f1b 100644 (file)
--- 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 40010ac46f5a4e74b2000fba6c470e624fb21f5a..c4f6044cb465772396037731a752568c25851d9a 100644 (file)
--- 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 bab2558bc9ec432ec45aefa6d908b4b785307c12..ee2a2d0ea97c4cd97d0b38de5dbd395db7f48fb3 100644 (file)
--- 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 7c4dad7f8de7f4f6c7aec4fcbba3446f1bcd3cd9..0c3aad0f2fda23217475eb1ceb170b1e260774cb 100644 (file)
--- 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 679b14208ae71ddd18dcfbaad1817741bc4591ca..d76ba442be4e74da02c6e8abc85c6e738446c17c 100644 (file)
--- 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 46b7a59aa49562d168d285395d8fe8240f6ba10f..4726fd3d7742fc0bec8888319d4937bee9a381f1 100644 (file)
--- 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 7e3bfdbc72f5faec827c87f8b3738fd8753ab2f2..3464c85e237f33abee160bbe3a6ec89c174bf967 100644 (file)
--- 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 9c3825df3846d4e2ef2e915bdf94a0af918db2b7..692c77eb3900d8eb5659d965ab9c130bac9932ae 100644 (file)
--- 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 a208e19b9541ef0be68d5aeabdcde5c8da940338..9ad00cb2541490428d6decde8b2527375cd3571b 100644 (file)
--- 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 263459d0f2e1d98f99c1a7b2a487fde8897e237c..faa43c1c83437acc94a63091898ed4fb6c80bda7 100644 (file)
--- 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 3530f8145263c9d8d14ab30ef7df4de4964f3a65..14c15c4579cb156d148d28518c39a072675c91af 100644 (file)
--- 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 056c3577ab759af49431059677cf0936d3bbe004..860dc639f6e5b0064e5f0d95f4ef26189574d3bb 100644 (file)
--- 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 6f13207cc147e91e3ee85be142adccba6b8e5ddd..66e1695ec91128020c459f67a281b47cdae3051e 100644 (file)
--- 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 0369164fab9f8f20766afa6f2d440b91edac5271..e0b1172ede61a8362a7d1ca4de4aa3f0fa30299f 100644 (file)
--- 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 ccd6af320860691d03d0b86416f8d3acbb2ae87a..090ab9cea0c2a19569018af1a5ccd8d6c3fc136c 100644 (file)
--- 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 4c9b96166001fdf07dee7634eeec1cd0f6dc4c4c..422cb3f8e96ee46070d25f2dc8c642b1c68f3d56 100644 (file)
--- 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 79ba88857cb1f3696d740ddf8d01f8e706e33759..e5e33d33139c6acbdbd160cc2c8ebad0a9896886 100644 (file)
--- 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 c41df12d5336b5a39b26c3fb80cd57dc28551fed..4a8c9d2ae1bb8a695679b310ce47a04eebe826b0 100644 (file)
--- 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 fe58f50f092381db74862534d4fa34972d54b7db..6f04c62cb0992da074ac34c264fe911252cadd12 100644 (file)
--- 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 837e04f173f9856f752849af26bc47b30e502049..41b3a4ef83f3bbbf0569b348091d414435a37063 100644 (file)
--- 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 ceee087c576a70405c9c090426af285881b99d30..57cb620179c2dbdc01070e7d1942d488c907a19b 100644 (file)
--- 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 b622d7bbdab57096c6dd05a9d5ce0b5550b5dd9d..55826c75beb0f704095615f5bbf043598b631b1b 100644 (file)
--- 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 a9de3c8b1a56d972ac38f05f8b5f21b017358727..361baeb3ac298844aba4bc0faf53cc34643e8aa2 100644 (file)
--- 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 5f12a99a83a7677e368095672b202e19b59dd454..d88bd1aae7be556acbd955bb03a3313b5e75e900 100644 (file)
--- 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 0558d0c8dd24f6de827ffa652b9aeaf2f8f53a51..dfea24d9798f1de86e32e581b9b42dcc24ca16c6 100644 (file)
--- 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 fbfe5e8f62d2ff0d76f7b0e446a7d811817eab31..f709cf74a70437da8f758e0d544b113ce86b6586 100644 (file)
--- 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 f5c93e99125a4eca67726b7e5da7521686f5dfbd..af12246281e1ffab2e17fee6d2c5bc107a5edce6 100644 (file)
--- 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 1e5e3ea9a6682ab99061d681b1d5906ae72bf767..a5f33e6fc1f48461b4922f1505bb290e90e4b80b 100644 (file)
--- 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 f2b0a7cbab7b87ed1ecbf9229656add6af65de43..cfaa5cfa66994407ae76879cf46b490d5b717c61 100644 (file)
--- 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 4146a85ec5c8571e741092e1b0be8b0338198608..1aa1b4235b48e5c1cf50bffe984995128bbb6ebe 100644 (file)
--- 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 12aa7e0df24c9814d4e6bfb2711d1b6600e91217..bd08ccd331c4d395ccc0ab499e626d6864d3d42c 100644 (file)
--- 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 9154f692fa96fc840727d87bb708b8f694baf9c7..e5183cade1a03db9b1de776e28888bf3652e49c1 100644 (file)
--- 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 31c6c3908942528a166ebd54362006ea03666f5c..13d1e71f820654b86b24e4a8cfab29d7ab8d61bf 100644 (file)
--- 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 b9999cde014cfe32c418f6eea5f35ae813abc764..30a5b1340b784b57c17d1689019f39c390c6569a 100644 (file)
--- 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 c78d55aee51ec282af3ae3b5d8a31d46edbb63e6..b9e07a85626464852624f9129e231dc4d9e225cf 100644 (file)
--- 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 19e11b421481a9b7fa1f2b4e841a910ed3fba298..23c3f6fdb9e437a0b75f5f88eed0b9c9d02f7420 100644 (file)
--- 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 ecb2f4802a30b35d0bd6c561970656418de810e9..cd4c8c2c3c69fbad3a0394aa5021c1b2ee7d9183 100644 (file)
--- 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 7078419f080b45b9e535afcf65809cdbb86f606e..3bd7a3e1175378b256a87f53e15b8c7186bec51e 100644 (file)
--- 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 b02996f04c6635b6a4bb3ea10da41a65f947f889..8e77c09bb17aec20b54cccee501a08e52984fc86 100644 (file)
--- 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 a5960334d58d33e57bda61b9924dfbc842cea6ef..615623bf94dc26cd4eb94dee4aa35a663e549f73 100644 (file)
--- 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 21d1d9f5de513a77340d9bdd47a9b83cfbe4720b..19fb75ee850a94c3d4bb8153396ff01e75a0a03b 100644 (file)
--- 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 3ee6c196d2e0616df675e82450708c9dc4ebb9f4..cb3fd22e46bc64436982496d6fe4a6802e156918 100644 (file)
--- 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 52f660fb5134a38764a4f087ec023c6886d84e91..73eea9aeb7ee86db6b266c6a1e7baf9cfedd3990 100644 (file)
--- 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 568757d212249e31e3ba9d145965be273b821a54..26e196db148461b2bf807a93f957568283da682b 100644 (file)
--- 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 84d19b91aa0d538c979e243b492c4a3c36282fae..7be97126ca0ae3e40b0ef8c84ad3767f0d554c6c 100644 (file)
--- 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 5aa2a95553b8f9c1578caeb3e4c11a33914f1ede..64721c45b2337e6c0db22445ac65e32dd455b912 100644 (file)
--- 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 7db1fef216274266f8451ba6e81ceb64423b801e..f33744df0fa1c177c103e8967ac650d7278c22a9 100644 (file)
--- 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 d1620e0c500243150d7576b108de9ccfa4e9d24a..322fc27cb4ba4f61df440bac01a0927982318258 100644 (file)
--- 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 a0647e58b46513674e8d460697fc9ed76f301e6d..d768326661a9d1bec072a5837ea267389e0a060d 100644 (file)
--- 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 91906b9df43f720d27847a082f2909a705eef2b0..b0127951c51a01bac758b17ebe2d5461b0ad1d9e 100644 (file)
--- 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 e55e2eab4fd6e9f9e7a17506d056a817366483fc..cbea4e372cd8bdcfda7aecdf4dad1fae958c9a1e 100644 (file)
--- 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 f1be3e43f664b4d58c116ad8c0b9d41c3be6461e..458f39b558d97135163902d6a8697129f40b7e63 100644 (file)
--- 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 3f62eac2527c330ff8aeea2c46760e021a4da886..cddb13fea55ba5c50eb984425163c183e6e1ce70 100644 (file)
--- 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 f314bcec753e00f8d2d6aec27ccfd5fd2b86d41e..914131e74249d9d6936b3958b06b2446a64cdf8c 100644 (file)
--- 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 71d85208d869761d7571f3da307ac0a149bb9fd6..5f17347913fd2c18666dd964318a6e609cebe812 100644 (file)
--- 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 06d4df8f5613504af1c7fb87ff8f90e68fe9e03e..38ca31a21984a6a63033b68b9df9e20eb9aaff0d 100644 (file)
--- 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 b239acffda0c85f5d7ffed104f0aeb1e73c65106..6c4a85214fb63ddaef3348bfc2ae7f4f70364974 100644 (file)
--- 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 2c03aa5a1cef4cf6d4c0546297b257599de7df51..896f940735f6d65d1d8c96b7a6029c6df6e5d77f 100644 (file)
--- 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 197ba6fc6e12b518ca90029da69610ec9e2dc4f7..f390fb3f41c6d925cf03721d8c71f264755f5302 100644 (file)
--- 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 f82f7b9cca8df742be12a8f4c03212db2dc30010..42cd07a60fdf0dfa8c765a415e25104bd53010ea 100644 (file)
--- 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 2be2737fd66747806242253a833e18900b8786e2..9beab58a839c84f23bc655f2234ed171374d086b 100644 (file)
--- 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 94c2a961e6a024e0b9e29df02ee682e246f83052..3b514e7eb054c09e13dd2f09175f32b99fbbd0fd 100644 (file)
--- 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 a6fda901de0a55fe4c65067c5f3556bfb4211a38..67373c34705da01e93b00378e684cab1f955f990 100644 (file)
--- 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 00e342a1f6029d4975aa447176e1751b840118f1..436c9d1373d8c87d60b8c0e7603d4395eda66f2d 100644 (file)
--- 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 4f55609b0cc3a044d4983f2a27740e674a1d1ab4..fed4c127b8995ad43383fe4e4a1c8a90bf82b5d9 100644 (file)
--- 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 db9000a85c3947742beeb0190263346174ac8277..b2cb9c4205912a5d06030f48ed997ae1a769f301 100644 (file)
--- 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 9de42d2134afc1b1d3a008c40ab5d213bd8eaf1d..e771534e9f2358409251a22b03e5a1fe18282ddb 100644 (file)
--- 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 14879779fa168fce49452907ac794618c9d15d3f..7430bea960bc8ac16ccfb3ac65b364f724f32f7f 100644 (file)
--- 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 749f6265f33dd67a729e7d650d74e37178000e7e..98abd936cde0cd4003f2f0a55440faffcf4f3ca5 100644 (file)
--- 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 3f982d07cf9a65d805dd1f10a21bc17c53f345b3..a1211facb91addbe293af9274e0908d61e54525c 100644 (file)
--- 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 ef5f3f44d1ae7e1c4296902125dc25b20a619876..457d74d7cda855715330e598e8fd04851ab7cb2f 100644 (file)
--- 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 802aa5b509b648e58c34b66bcef794f4ae754b78..af60217a8a04c25e53c9f7192d282e2a6e26e5b1 100644 (file)
--- 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 b44507e43660d63a2770e577c216dfdc38336eb7..80d0d71d1dc291c25dfad78268311140e05dbed8 100644 (file)
--- 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 9e55bc136181094c3f153dd12025423cd1416ebe..c62661a3539174cfcba0b6799997007338a3004c 100644 (file)
--- 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 9460b1afc8840e535af9ba9aded165a13a31f24b..caa9092314853a155d9368ec66d28344ee1171e8 100644 (file)
--- 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 9481f80f0b277c65901f5240d2ecfb06de3478c2..4240091d92f1e093ef6f4c6a90e9c26453f7f0c1 100644 (file)
--- 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 00aedf07953d34d92035729b2a71bedaf2330343..5e91367796354533e108125f62a03aa5c7e9767b 100644 (file)
--- 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 d365ff39998635b725ff8ac224e402c513280e42..0b01550c1e9746271ba09c2f06095e7a4457aed8 100644 (file)
--- 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 276c2ff2a625ef674f181f630acd4d2a5c5a3df3..db35d917a914da5fae03e8c3b624e67c964c6f2a 100644 (file)
--- 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 c19f07fe0561d47c254a906a14d649c7b6e519bc..6258c1c0a730920a1c738aa9f18454aae26bdbc8 100644 (file)
--- 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 942986215988eb9f44471ff885ac43e577671ab4..b40178cd43e5a85ac6d6a32dbff550ee8289762f 100644 (file)
--- 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 3701b0849b79c48a26fbd34a83fe80ecb0092f66..aab46da9cff75a0f7c54f26518ee4905119555e1 100644 (file)
--- 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 8d01b44f1106389a18879936cceaa1873de40aa1..b3262a4b23ea99d235fe04307fc6e72d156d7eef 100644 (file)
--- 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 e68fda967f1fbaf96b459b49f66bfea59a084aad..d0a9102fe3c8ce97d805feacbdf5cc5425ff896e 100644 (file)
--- 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 da910c1e59c787c1e1160510f040ddc250abe403..66f4557f06c99f822abbeb36c94cd3a4a81ace35 100644 (file)
--- 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 8444d9a4bc9b04039a44a5576b82ca26d0a6868b..96cf1a86f1446d434477f6a2639a3d2db67e5070 100644 (file)
--- 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 9e2ebf67c58ca2ada2b8ecadbd9b8e64644e4d22..24880f9550c0a4a3bcddb057cf7e6fb7a1ba00b1 100644 (file)
--- 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 fddd4b03c06ff0991a46624f5f4eff3454b0f39e..3b052f3801b2042c94f8be3180fc3131dbd26ee4 100644 (file)
--- 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 11b0c7f71e41613b0b54eee03c0bb90a090d52be..2fb4b7fc823b955b19260a2e83590ede9993babe 100644 (file)
--- 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 71f5791416c06ce101a4794321eeafb8682fc571..d643fbf968ea6ae3f19fde68bfc59917ef6175bd 100644 (file)
--- 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 c181f23452760dea0987b970f30cc8838b8d6c95..eca69026c03bb7a769844b7094ef4143ad6559a6 100644 (file)
--- 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 406d79df01cacfdab43ef370898dd539018c0c2e..222e604c8b5b4d61e7dd5a097dd404e4bf7c026d 100644 (file)
--- 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 cafd93e190532aca9dd10f6dfd2e3f3af9a5ce43..f3ee15c2ac8a55b84aa4f76fb35a0254805a56c5 100644 (file)
--- 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 dffc860bbc853411a0e6e3c2111f93a093bf1035..80f1ba0cce6607d6c66a97a8804147c27bcaa5ab 100644 (file)
--- 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 bf3740aa5d0e04d94dea26cea1ee8cd67e93707a..373ed087efd2c0687fbb5983544691538511f4d7 100644 (file)
--- 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 0d8cd8c20d29cf169418eec2b5fc9fe914da8796..80ec1c8814ae022cd7dab2b9cfb08782af89c3d6 100644 (file)
--- 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 eec526c5000d34795bb20dcc282dae890f605f92..da681f140a59120ca215645d11d96cf189a49f0b 100644 (file)
--- 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 192cc487da53382052fc2e402e470a134cee8582..f05dfbf25ebcbaec54cf305286582045b399e4b6 100644 (file)
--- 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 536020095c5f68e6f7950aea5e24694822c8ebd2..38f89672653e4b0557a7138acc9054e447e10368 100644 (file)
--- 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 692bb6e7501d8b9c17c9fc3fa4c20978c92dda00..2c8c5c36ba125f79029e0d66b84385be0c11d9e4 100644 (file)
--- 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 3a1bc870b13f8c267a2a3ee07ea1ed6deef29cbd..7801111e15028042dec449f5b4c97a5a825dbf82 100644 (file)
--- 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 9c3eda21afda77d48b57d5a2392b0ff4ffa4f4f3..c98f8eb37905c4294f83d02967c5f87cf796f439 100644 (file)
--- 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 06fa25fcd242c9f36c39675e9da6733f76e14205..1c49988b3a0dd308e10a7353e4ca7ad3dae7b6b1 100644 (file)
--- 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 ad38f3718731b14352eb2f9eec874bab6bf5c1e6..2d35b0b1824ab504d342ec883f2c86c185b037c5 100644 (file)
--- 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 43baa9c572f732a5ca8eef1f9f961f84be372b57..0d3fa7d1e8a8d40b2eb061388aeadaaa93ef3535 100644 (file)
--- 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 8404e80ec8ed90a8971c1689b2248a9e7c82ecfa..71753e7cc2ba5871f2d7de66343cbe5b49cef518 100644 (file)
--- 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 aa4ff22a8fe662d649bf0946b975410ce0c75f77..3a4db1b6c38dd14d91b73e5eade3878ae8b95737 100644 (file)
--- 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 e713b91e4dd0585e56e51e598df7106edaf8921d..62907ecb5e90e29707d14f7d26aecab3620ead09 100644 (file)
--- 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 f1b42c849904c78292737e09a7f297e36ae5c774..6e08a94d4169b9859ac01cd11a28c6d9fa7c4e54 100644 (file)
--- 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 b79ec93108914f25711e380a72c644c461c564f6..41df54554247ad0cae4ceee0031efed5388b6bf7 100644 (file)
--- 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 79f6215c7700bef2008cc4c06680024b1b997ddd..fe1baf3a0c7d1e9d23120f595e6ffc7f921f5c45 100644 (file)
--- 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 33f4e2c1eb119488605289091c74d72d677e093c..a23b6978066cf38e870897ac1c559d79a7da7f3f 100644 (file)
--- 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 51e7c1b2e11b2338bac289314f4bb6f55535cce3..cbe3edeeecc23b3e3ff3bfc34b727ddca9184630 100644 (file)
--- 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 636130dd54df796a6bbfb109fd91240474698442..a47c1e1ed8d81987d53ea94aa47b4a8e919bc315 100644 (file)
--- 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 5f8faa4dd029194c3bee323f1ca66543d2f95ca8..cb8a619a4ae035989441e466e8b3c061193795d1 100644 (file)
--- 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 d86c747c6d526679d5bf5f5ecb7dac9d78e51370..d81a0de7be5d3963777c7431f07667c26f4e8cae 100644 (file)
--- 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 57213082675273c73e6119ecfcffa4220c3d688b..02fc7fefa1b7f8feaa28d2aa45456160f68a5927 100644 (file)
--- 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 5257d983c2a28f3080a69dbec0ba8de60fdf5277..3a8b8712bce557a02b3202b6f9d7f5520e099fa8 100644 (file)
--- 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 e2778af6caaee085cd674e9f324cd94543e535ae..3d3579d76b6e4ed61d3d8b66104cd21205c8dad9 100644 (file)
--- 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 3de4a30ee20d685e0ee39f6e960da1ac9f478b58..fbf0c004d8951028c12b48eef1bde140671bb73c 100644 (file)
--- 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 283fb1cb0a81ea987893716aceb0e822125abb15..7c794dc5e39a09c28bb7f17e136035e758042e88 100644 (file)
--- 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 3704d1a2f2df4fc749e81327f3bd80df081079c3..9838411cdc995a074769a49031698babb56c0528 100644 (file)
--- 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 388fe2665e755a8048cbc48951d780102aafc562..bd1d7c74ba8380d80a235c3b65ccc1386a227eca 100644 (file)
--- 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 40ba965cdbe4abc53cd199e47c0af0762422adf3..c51adadd137db457e0460264372fc297cde7ce3c 100644 (file)
--- 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 cdb372af587608382b7db7172b6cbdc8e3abc93e..4054612a3d39551c56b6e6e3d0f2bbd3b3094bd1 100644 (file)
--- 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 63edbcda0966ace10d77f89f4de8eff1ed0266a3..5364631432252420c956504d56d32a83697bee51 100644 (file)
--- 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 4ab0cb5bd8205740ae00ffebd92417250e95b7b4..bf51d63c3aa71e644fa6aa066e87ddc55d69321d 100644 (file)
--- a/libavcodec/jpeglsdec.c
+++ b/libavcodec/jpeglsdec.c
@@ -542,7 +542,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 bc64288c9547960bd0eedf02b4243923106f5e03..3e73b04c0efac1ed25718c98de89a213c2b8b412 100644 (file)
--- 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 6f10157b0d89f85b41ba93d7a0d7ca8c110f6521..584b4a717ce3c4d6e6f5486813a245367d48d70e 100644 (file)
--- 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 a6bd9400ac16fe93bd2a1758ee9a8977610acc30..427f57f4167be5ca517d358e82198308ffea2d19 100644 (file)
--- 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 56c1977254158614c22e272541465ffd08207539..5d3dd4ce63790dd3ff950d11aa684cf4ac65e3e6 100644 (file)
--- 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 d81e55cf4ca1f60ec42f46a44edc10daa4181e56..69899e423e3baf9d32afb81b7bccf328b44a4239 100644 (file)
--- 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 d281733fdd2dbd110ab4ef242bbcc70f6276553d..a47e3bd78060e17c337ad4dbe8b98d254d2df5db 100644 (file)
--- 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 250cb5625c3c1cd207ee36cad30099ecb95bf9b7..94842797713cf3ddc802f32ce0b170cc29acae63 100644 (file)
--- 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 4b9125a32c17ef3300487bf031b9b5660f57b2b2..6e7324a832fddaac0a609558d454d0b8ce919a9e 100644 (file)
--- 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 3a59938451fa0b62ad4d30dde234c00f35739ae5..0766c0079d980cc7b0b8bb34ae0a507b7e820591 100644 (file)
--- 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 75b438b2855197e5bb7256cda9dc162fe3e85faa..c0fb4013c9d64f1984a37dcc9f88ae28eaedf0ba 100644 (file)
--- 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 2164f3605139598c3d7149a02e033de18ebd45ba..562a616f59c23175101b8f0edf196f2eac91b371 100644 (file)
--- 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 90c531fb91811bf0130f2f3f66bb22c0d2161c37..50e6200f5dfb20518926fa53b6be25aa8b9dc4ea 100644 (file)
--- 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 0f18353c93eb65875c0e03207eb37475d123312a..28cad9c5f7a971d44163c99d9e3632c437364d6f 100644 (file)
--- 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 1a86dffe4bd50a68639595e85f7ef361f44d46bb..ffa1fdcce3ecb2b8d8093b83c2cd9c2a2cb60a02 100644 (file)
--- 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 6494c11ddc19d03d0f8d5af2abb642efc13a23cd..b848cd8851fb5a0283e344fed2913bfe590c3c96 100644 (file)
--- 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 1182afae6b54f6688f36d921e859327d48157593..ae4a952d99103714b92fcc9c022c85a34bdfb28d 100644 (file)
--- 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 fdb11c705eecc2dcded5e0bd3258c424dce3caab..850963e8f6e12b7908cb1e4f7a9924f35e86736f 100644 (file)
--- 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 9c82589918016ca944414c16366c5f221456e64b..20a295185053a92fd302f8436dfc14a18b1d93bd 100644 (file)
--- 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 7dca605059a9a26c96fc1e5733f4dbbb3bbbef65..54788e154beb9a4c913c0392fb6031e61dfb2f25 100644 (file)
--- 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 2beb28e569ee19658247ce86f87c0c4a035c2ddf..fe4b50257f465ff07080a9fae655bff08f4952e2 100644 (file)
--- 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 f23bb48d5b7436c55c59f1d6eb1cc9a7c96de5ed..e88431ba9f8eeb88bdacd2635e637ea90510606c 100644 (file)
--- 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 832bfc49ef2ef29a4fdc46f6b26b80190529921b..ea70a8e143ad6576b2dabd7490d047baaf228118 100644 (file)
--- 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 608fa59cddf58a186d153c5b87ed1426e1faa938..54babc3e975d8bc2ebbbb065ac44040cbcd33a46 100644 (file)
--- 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 344c5ba5a385ce12e0cfde1be9a272bdc1c58f12..8982d21be44e32b55b9b9a1d7edf040b667db0c6 100644 (file)
--- 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 e4641235f5d2a7d8686bf5a50fff4f97b7bf7e64..14808a75914db572d96dad2b8feaa9d66b0f6661 100644 (file)
--- 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 082a431c6c6c0e0facd813deaae25d7f6adc3d1e..86ef71520532479454b698758cd11212537d73cb 100644 (file)
--- 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 70d17f802bdc6e4e47d33e11268a07157d1db59c..8c99b26ddf85fab48dd523cb92f9e1cce391347b 100644 (file)
--- 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 37c3007d812fcf8287dc731992e36e2832eeac5e..619a4d0b36c1485ce322f06692684cc71633a3de 100644 (file)
--- 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 e9a181d092c70edfeb67fdf8e3823782e4f6f79c..2895bbf28b4d2dded8cb0277fe87a224e6575989 100644 (file)
--- 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 7056fcd2e3d29ef96187de888183dd8119283174..4a9fc617f0a06bfac06eca7608e66835d738fe1a 100644 (file)
--- 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 b02582b3800dca82e9c0b1972b22c979e5635333..6f032907fc4d55466bcdd6d8d963027d967c8b15 100644 (file)
--- 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 6a37dbc76cc28a34501dadeeeb0d157f7ed5af94..c96e2d87fdbccae4080b44782222be40a56eb0c1 100644 (file)
--- 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 cfd93a2484c55471999da11029160a26a887cec0..fabc4e6428f1eebb08c34395576add4b1c050db3 100644 (file)
--- 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 a067fa33446e0a5cd3a46e36cdf79416e3cc4bcc..f26ab501f428d48bc56eeb15747cb1c60bfd1a5b 100644 (file)
--- 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 5ceb3d9f3f502f30e69bfabb6444a0ec066b743a..e28141022d617e95957ea2c09c81e537c0364c3f 100644 (file)
--- 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 be03da39e2e16315d144e0fdd6f467a5da72f4a1..f7e458b3565a3445095d1f23c2ebcb5778bd111d 100644 (file)
--- 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 77d0ccef15acf3c7914eb629a47450efa2d231c9..e48dc8a5b72c402f61ce0ad4079613c4b297c583 100644 (file)
--- 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 ebb0fcdd864ea6f714da2247fe3eca099bfb6d33..5686aaf0965890d10302230dd5f0b25689c70f58 100644 (file)
--- 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 bf9476495438c956e366ec4c6ac9fb54280fb575..8999a18bf416e50877b5ea2f668d75040c92c9bb 100644 (file)
--- 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 67d56fb05ec5fb493521ed6cfb4286339faad00e..f9b4c9f42783543988eb192b0738bec9cc788bf4 100644 (file)
--- 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 bcfbbf3e76776cd5a2c2a4b6f0fe37dbcdd1caf9..8173af5dce36ddabdc9b9cfd32697d54da4037b8 100644 (file)
--- 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 48f45b6320852a30bd8087838c4842efa4936be8..2e5b811455892086f63a3c8d90e2deda744be69d 100644 (file)
--- 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 835891d890384629579cf590cab6cb174fe6156e..5f0c6ba1945074245b8bbff7dc3cd42b1875e6b4 100644 (file)
--- 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 23f7ad897b7bc1db0f79a2e839e499cf8e739fcb..2bed61f91e17512f8e9a491070cba4d8c1af483e 100644 (file)
--- 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 b0b6b247b6fe98a78e809f7080927dd959e39105..3135e221c7bd00e783636f6dce06ee5a5518b011 100644 (file)
--- 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 2a4a3e36bd16d12f2f6e0acafef1b17e314ff95b..99fe0e3286287f4b5482a797f1b85787d24acd5b 100644 (file)
--- 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 2bc32bddb196eaa35c8dbd1dad9f3116381a60b8..7ba709b1bce92c3ff2a4ed46c7ee8b0d81ec1999 100644 (file)
--- 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 e056ea5ef0c87c66085268de89145009d24f428d..1073d6a0bd6ad945c3b8e6a2e970b901d9ecef19 100644 (file)
--- 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 788fd4260b1c1300d988f511ea29af2b0716bcc2..80b5e799ed9c035962c3d892fec5d5e1b5b42d3a 100644 (file)
--- 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 99e3a1d021d39443fccf19c66e5abfb12873bfa5..ebd81f43f27970b1c0ffeccd9d3c3f01de902ec9 100644 (file)
--- 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 042da84bf9030eb46f07ebf606e43c8d5a5a6625..18f46bd27c475dc4fc0f8e11f2c978de6399a822 100644 (file)
--- 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 70f1da4f457e15bc1d18878be23f3cc36b536798..795a4fba63c4761c97826508dba237a3fe481d8a 100644 (file)
--- 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 e332a72d6de1055fb13cccb041b056429151560c..aa1f8e2de5be300d7b55c66869780ee52a1b4728 100644 (file)
--- 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 13cb34611906b002d0ab8ce06564666a97981452..594196063bd9eab3000360fa99897660b7f81689 100644 (file)
--- 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 7ec3c963bff9ec210eafb9cf1c0aa3c40169e1d8..7edaf1b45ef308ee85d73a82415f9d807b856b3b 100644 (file)
--- 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 101e558336a27ec8f897b70dcddf51f9093c109f..39efed69b1854cbb86a92fbc87f25d56d9ddc5d4 100644 (file)
--- 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 ad592d14a38d3c1c675f36f5893fee72b4e41855..1cebb3d76d14f4e27ac567c8fd61b874a68aef6a 100644 (file)
--- 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 27cf1dd83fcb1f9c1053bfd5aeafdca4a60ab93a..be47510d7a6f82c9a0e8507a121ac5e1b6b0e541 100644 (file)
--- 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 d70e49351a24206428660b3a58f46f6ae0e5de4d..26f1c8057faa7abb2e55aa75297ce28fc96a6280 100644 (file)
--- 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 dad0ec8a22acd1d5685e9bbe60dee5c05b589b57..777445997bb0efdabf747783e5b2bd5de19ab074 100644 (file)
--- 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 2200440e2cabceea2617cb1474234f6c9e4968a0..69f9f4d0ec201a0920903b9039cf97699f5e0f20 100644 (file)
--- 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 407faa02da487758d9741532849e1673105f9195..ade973d860adf523ad7c0ef075ff701142fced81 100644 (file)
--- 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 890befb52261770248ad5fe8cfb06c4bb3d56669..abc607176a5b282e5b243ab4739e9df89d5fa405 100644 (file)
--- a/libavcodec/mjpegbdec.c
+++ b/libavcodec/mjpegbdec.c
@@ -153,7 +153,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 62684001649ff8ecbf854d1c488b2fb4316de5c5..16aed078f66b3d2fd7acc9f2de310e2d95e4ca83 100644 (file)
--- a/libavcodec/mjpegdec.c
+++ b/libavcodec/mjpegdec.c
@@ -2961,7 +2961,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,
@@ -2989,7 +2989,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,
@@ -3007,7 +3007,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 b355f97f14b0193ab2bafda8a9b6685f2fb404f5..0ade66bc5f0946f7d5632d4d7ea07b235b582d8d 100644 (file)
--- 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 0c30034dd47e8d3b7298d1b9e70a86264c7276fd..e4992550eea8ef9d07d6fb1c66d1edcc0c75fa5d 100644 (file)
--- 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 8684056cab3bba46306c1c37b4274022c24f1613..a66965f2bfd4d59e245ee1c8d4e56d46fd34543c 100644 (file)
--- 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 db9e4f95897374cf8d28720b6705358b31dbe573..8c7d7497425d2d2a8639f7f17aabec6ae4c2cd43 100644 (file)
--- 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 7f650be80efd64708ee098010d2bdd6d0789469e..11a819dc6da2fd8fd5eec124d7d9fb6dacb97150 100644 (file)
--- 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 bf47a5bc416c6d45147d331077862e73f0bfd6b7..6ea1c3eefa170c8e6a4f007ec0450be77bf2c46f 100644 (file)
--- 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 b08a2f624b62e7ef3dd4313e51c4d84286239d1a..1896330fe147ec0a2e03bf4463725ef74a87783b 100644 (file)
--- 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 7adc16d262b4198df2d88445909b92d193da47d1..873c1350a4b32f240c35fbe0851935540b54fe0b 100644 (file)
--- 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 3c166639ba702faa59d085a19f9ca55b7bed0f4b..4e782c785607279791a2c6ce2aabeb88e53f25e3 100644 (file)
--- 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 af12a6fd8e0d04cfc8989610b813449ce89f0ed8..c1a63203d622f60ea5f491d590fb18730623c3d8 100644 (file)
--- 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 e9919aea62579b911bee35a33c792dcdbeea0e2e..ae07093338384710f617eeedbaff4eb6957de0b0 100644 (file)
--- 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 c4d89e10cee3957f67a6ca46ecf125ac9a050226..b27ed5bd6db9a4fd05f6b81b0a46fcebd26beaf1 100644 (file)
--- 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 432d27e1f688d50abce908f1833336a6b45762e2..2fb2232f3c416e37525057471bfac205ebfb88de 100644 (file)
--- 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 fc76485dbe6ee472260ea2a965203304542e1901..a6ed842ea2a584ffc048b3d72ab2c2759abc747e 100644 (file)
--- a/libavcodec/mpeg4videodec.c
+++ b/libavcodec/mpeg4videodec.c
@@ -3580,7 +3580,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 eb8d55287777aee9f00ea88bdbb7c99388bed326..b77653d453bb2fa828b85fc1d1d2b0f6cfdd8810 100644 (file)
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -1396,7 +1396,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 a3c8ddc21ed9bfdc22f144b241b08d0dd9e8b468..f9f24330fd753bb282480b4956657313d38170f6 100644 (file)
--- 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 3ab7651d5b606eaa6c97e6d5bbc0296abd1f266b..c7b783999783d22523f8592ef71056f648a8a6ac 100644 (file)
--- 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 022b6fedd3a621c70c6ad34f89d555e73b797335..15048349250488a1de29ce593d8268340f237850 100644 (file)
--- 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 4d4ab2d7fa6677e4952206382de02443f6f898b2..22c5f916b280453a0f06f828b77117785c6cab62 100644 (file)
--- 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 89ff02eadd9b863c626914d05727dd8922735a7c..b2b33a89c5085437b1b513429a2d77613e590505 100644 (file)
--- 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 409e4b3708a19f9dd59b4f9a2a2aa16f365442a4..3ad094b97aa696f177929ff3be43d985f1a30865 100644 (file)
--- 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 e685b2a32b8b90c45892ba9a748f0c10100ece6a..027eb160853c22abb2bddae2125c1b3f9f9582d0 100644 (file)
--- 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 ef8d510a02a5adcf74a35d3c3627498a1edd81d2..f302509589423b7da71ef7b8a28e61bf106023a7 100644 (file)
--- a/libavcodec/msmpeg4dec.c
+++ b/libavcodec/msmpeg4dec.c
@@ -855,7 +855,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,
@@ -873,7 +873,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,
@@ -891,7 +891,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,
@@ -909,7 +909,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 16c5ac6f0254477febf2c10b93ff5b791c8969ad..8772bff6bc084144a22a3a9e97ebda8e80ea2536 100644 (file)
--- 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 42c8f483730d02d0f9d2e940fbb8c12e1eb9db3e..bbac2a3ffbfe9b6e6f54b84223fbf1da57c46cf3 100644 (file)
--- 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 7af8024d63d1f6e2220898fcacf7aaa10d5bdc1c..10c2c34eb42792e1078a3e3bd9fedb797ac95a00 100644 (file)
--- 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 a27fae7559267e2e59af5ed216d8e5dff9b98140..d7a19f6ad2497929bb5dd5987da67e6d550cf3e1 100644 (file)
--- 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 74f4b5e6712b1a846a48d7907b1c25d4e254924c..0ce7c961213c70af742373a09df6f26e919a1853 100644 (file)
--- 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 7f11f30dc801e800b18981374643b0879362a08e..6c44c76c50d7d21e1fd77976c1c2ca395e0ae9d4 100644 (file)
--- 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 cfd51cfd672cb7fc4425961c39d6036e288c4be0..99965b04a2cc02377ce97c566b334bdd20d801ae 100644 (file)
--- 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 b6ae92b2ac79d43ac68c378c4c264a95800aaf4f..34c8d47c2bb701369b3e681b389d873356ba8d7c 100644 (file)
--- 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 7ae264e0f0157dc3af591af76db1902de6e23754..21f52679c068d5819788249cb4946085c708dda5 100644 (file)
--- 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 e507674c227a7aba9f56b3041667c0c4ada24855..84cdae212369e8e4051f725239ce6bd59810b2d3 100644 (file)
--- 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 c603ef69755fbac38e3b894057a13300e06c7d2d..4048e4625cb85324eecac6f9adbc331631ca02fa 100644 (file)
--- 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 4db7642e858607f10bfd125f848e312e4a61941f..b62db67ff5d33aea17d853a4c55e6d2f59058cfe 100644 (file)
--- 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 617da52cf0a690239dfc4f096847128a4871d76d..8283a3976a6dff40e5879fc75f7ead9f6473a09d 100644 (file)
--- 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 e091ec94bde4721e6e38f811f3a429c9c08b34f0..ccfe8817901ed1bd304a8dbbba2cf26b38f34d94 100644 (file)
--- 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 8670431dcc45ebb2039cbcf46c085cee40e1c195..2e13e6af089b5a3394c47a341a9bd9500b7972a3 100644 (file)
--- 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 9a53cad9cb1e3bc3c87224450e890bd0bda3dab8..c109c5f6f313c9515522b304ff236b5cf8a50617 100644 (file)
--- 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 3ceaaac4e9dd79ca495c46b4e783ada95a9f4336..3ba12fd8e6514c5a05ac52f8c58d3a371a566b1f 100644 (file)
--- 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 ea7390cbf13d87a62d02d69a2cbaaec2468cf3cd..5ad6b358366f4f7e4ef0cb62cc54a4a9042d066e 100644 (file)
--- 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 1aacec5f9cb1a7a66b02ab66342bfd3ef29551e6..007099242aa43082362b65f8e6678613d61ff683 100644 (file)
--- 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 0a6a3083090e2879d8ec2c6885b70f4a8587c49d..3a113723d312ec934e39eff3258b9c857d672b4c 100644 (file)
--- 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 d7a3e4945a160350332ce96b7aee3b169d91fa02..2ab67350caa44019ead5a29f22542f7476e2ddf4 100644 (file)
--- 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 f0d7ed62a1a613bf6e88277814267cf01ea7921e..3ebf199219fb68af3021e96c2c90050a9ee2ab1b 100644 (file)
--- 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 8bc9e9dc4a27cf6ce377fdc1b0c292ce644e5f84..da83ef4d3215521991ad3ad26aecc1e01a2ec300 100644 (file)
--- 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 f306e3b96cad1187028c66e8134c31bb2643c3b5..cb80f3a1867f1e4cb380142313b53e35297883bf 100644 (file)
--- 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 1e5d891332bf7d7e974fefbd3006acd63738aad5..bb5c17b6a10ca9c7392b63abc18d3bc2d406485a 100644 (file)
--- 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 ef3bc3bf165fa1a74014702076aec5e287477433..10dbdf558991a583271a45873263375b51a33aaa 100644 (file)
--- 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 8e6f562b52e0d12da37a14b572d229788e63a0de..c2a6e82b1db71bf49fc3c2cee9034996fa54cd99 100644 (file)
--- 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 3dda218bf46ab6a8f884e45fe4c701f5fae29776..775d342eaa8a812377ca13673a17cf7e476ed63a 100644 (file)
--- 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 97ac77833426c8e7f2d80e3389ef43d6e666f2b0..e644f30f5db6bf72ceaf39e2cf60391d57e44762 100644 (file)
--- 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 19d04e9181625495df0908801d202819ab6297c8..79b33b935cb1d37684288a40fc8cc738976d93a1 100644 (file)
--- 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 4505db75b82e2f402328b44b04602de0a906c6fa..b8d911be6b2eca3f8ab4867e3efdee1cdd2477d9 100644 (file)
--- 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 709bf84d12e3b4be925702ce3bac400d2d2a3456..4cba1019e6320a67fefa61213b83f3c7a0ad02d7 100644 (file)
--- 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 eaf069017a3b9b495113d47061bea4b1c41d9608..8b088bda8f0ae7c068092c5d908b88d7fefcac28 100644 (file)
--- 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 65b2929283f376f7ae5242293a6120f421e041e3..1d659e82c2c8f883487436463db454223d49918a 100644 (file)
--- 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 408ddeaac8561e2bb47fb1e0e8f11873b2ed0d89..f95d5a8eb87a809761141b0bf3a0ae55cc443c08 100644 (file)
--- 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 6340902526e4eef89e94874aafa8d26193f923c6..c37c5e7106d5082f83c154d6011d337d7437d918 100644 (file)
--- 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 ad9d830af7ad1e57e95ac5d8b10c6cc56f853835..5361bc42bfde2c11f79804cb0c8db6acc94a17ca 100644 (file)
--- 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 3e509e8ae0144643ac29816764e7bddb70e1eae4..f2e6f689b03aaed7b90755fe57c060fd94d855ec 100644 (file)
--- 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 374d7c9cf7ea2994c79c9933c4499d02eeb05924..831223be63d4dbe6ee936d4443075a9874233ed1 100644 (file)
--- 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 4d5ce0bcb5376e70a1cd442fc72561a9d2e6cbb7..01f9dade1a736075d0d1a41811c9780d5ee2d99d 100644 (file)
--- 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 56e929a5f09b6b15cf7f2d634ce51aa6eda2098a..80c7b66332ee7eba1ebed269c4ca7890b970ee9b 100644 (file)
--- 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 5a01c89c48d0cdc1365c3c3f01af0d44a12c485e..a57cece99be361ec94562f91bf090eab7b754aa7 100644 (file)
--- 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 a4197870ec3029cf918ca09165560f4b4272d27e..2eda471f0c4c4161b87c8c51c61e7819060f33f1 100644 (file)
--- 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 81a8cd73e74431668167eb06e9c400f7911c3da8..d140ef053ab5475a59bc3db1188a7b8d00013773 100644 (file)
--- 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 9950519604c53a8f8f618a8527708095d3f8534e..f57d8dda41e365eb9e6d2361b6a65b1f9450105d 100644 (file)
--- 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 ae7ad4e559aa1ea0ab946268f453c6286c693349..681d8a83c95281592d1bcb53be69352b577e9d39 100644 (file)
--- 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 19f9305cda09fe60f01a4e4b1e5b175654f0ebfb..47b8926f73febc38301d13efe716c691ae30337c 100644 (file)
--- 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 4878af5a2ccc684ef02ed73b26ea811ccd4a6619..6663d8588b95e4e1f7b131b14ff2753a9ba8f85c 100644 (file)
--- 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 07dea55a762c76c95cfb52bbb005cacbcd652e10..5e4e741e59a42ce34a60cf0d0c09adb90ff624f2 100644 (file)
--- 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 a8c930f0e7a17d632169aea0509a1a439e113d6d..ae75ca524ac23b3e2bfa83215da3fa6566d752cf 100644 (file)
--- 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 65279c98052b81a129c6fa901c5c025525b68d9c..fcc1de0c62856ea08c4a335d56ccecca29cf0d6b 100644 (file)
--- 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 2e66d3bf8ade7e25dac3319985f4bb6784b5eeb2..829e08aba1a962936ccadea4ed431c43cee78c03 100644 (file)
--- 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 bf843c8ca27da861869d1a08fc429f0cd6ede951..f543defb1821e756eede49041f4afc8dbfe02199 100644 (file)
--- 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 06b49c46ee6866786ab628d635040e09507d23ce..80fe3cc280b93ff0f3241ef8b4dda0e0b59c6fd4 100644 (file)
--- 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 fc10459628c42891317ee9119998270701667f2f..a5671ebbca229d12678d69d10c54bed7f1766238 100644 (file)
--- 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 f76af9486baaccd70625d1b2d2e56803a306df9b..dd082692be5535990f2b224702ff45721a47e780 100644 (file)
--- 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 538b937f74a9f7cc6ea6a9624dba723895bb75d9..525df99e50354b75f096fb3f557cde5ed9d3bac1 100644 (file)
--- 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 ce44c09397ed474888263dd66ecbacd34abe79c6..9329990d11d6ff8c7d3e85c3bacb9e7389a718ee 100644 (file)
--- 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 33da393bd1137557434f4cb2ee111d0fee0619f0..4ad224e37d3aac191dd087b28c7fb1f9228a7de7 100644 (file)
--- 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 9340563084176e67afcc3580f51772b15a9231b3..1ff288456ae3e18d8fb8c28953b9e023aec82d3f 100644 (file)
--- 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 407684c7fcd6088f3909d58c0f00102c2840ae5c..476f1c0680b667279f4698e480d611eaa9dff3db 100644 (file)
--- 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 be1943f5f9237e209ce6f458f0aeca6ab4a948b5..89518bce29b1883c7c64cd5725430088d4cc10cd 100644 (file)
--- 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 40b278895fb829865719341db425921e47822474..e5e3def15eaf2fe1b44b779fd829547a19ed7d19 100644 (file)
--- 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 c6965c5c470664798c054d94c3d4946a4d7180e4..0eb151a49e87a24320b2ab6a76afb562dfa60238 100644 (file)
--- 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 0eb2a661cb85f3873a5dccde9426cbc15df30de2..05f322c40a8361e100db41871b5ce02f35240ed9 100644 (file)
--- 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 dc012d71b1b75f0a0931a336276bfefdb02013c8..2b253c5711dbd6776a83ed657747728e71943b3a 100644 (file)
--- 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 207d50c4524e6ba305dd41dfa08baa483767631b..c1e91851926a1a9b5b310ecd013a0e1010d282bc 100644 (file)
--- 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 a13f88b148aff4c2f84ae6ee0250c087056001db..96abf6a48c2a38c58def5029c99827d0b841165e 100644 (file)
--- 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 a7dd162d55de6e7c4057660e41a88bdeef6f958a..baaab749fd917f6b63b3adf27524ed48c52e69e1 100644 (file)
--- 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 50847811236619a01c319a2f741d543a93321163..d469a1981bc16ab11cd3455207408c2cd80a4665 100644 (file)
--- 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 a60962dc86bda448f8a1a101765ae86cf29e2dc4..19ef10883210a69f2525219bf2ed2cf9425c03fc 100644 (file)
--- 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 2d336a61e50c4d8f8c00b3dfa1b917513eb00ec2..d75802cc120ec082db8950c1396c47518fda259a 100644 (file)
--- 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 c09212d3d1096f2a83973231e91f8d53d60f6399..9a636179b1c9f0a6906b8d8af0d17d607f188cef 100644 (file)
--- 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 36b4ddf7557055950102b0b48be91618dce14808..a2730af9226e9cc07e2254afcc8e5a46e0286e74 100644 (file)
--- 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 1ab0de0abbd3ca1995519dcfb10d1e2aafcca9dd..b755d5e3a5d7f3be69651fb7e2c830be309e905b 100644 (file)
--- 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 02bbfe753f8d67566ef0826c8538d16e900c5863..a9aeac59feade52c071345f377ae53f56dfec213 100644 (file)
--- 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 eeb82716c99eac23d8f2400c7fec78c01de8e8f0..e4651d9d9c757053b4e9d6926c3702c61d1f6f3e 100644 (file)
--- 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 7b27127bf5318903238f54ad1c37fb30587a5c21..0ec54ac1b05815408cdcf75d4b3ce314ca81fa55 100644 (file)
--- 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 9c3a48c251881ab1dfd6e36f6088b95b2f218cd5..d8261c34c71f202a0c5e8a6f146ed8d3c2f27725 100644 (file)
--- a/libavcodec/rv10.c
+++ b/libavcodec/rv10.c
@@ -681,7 +681,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,
@@ -698,7 +698,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 6add8e4dd17daca723b961b9079e036c0308eb6b..c7bd76bf1a582541c6ec2ba1cdbdc3361e18199a 100644 (file)
--- 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 95f90389bc3ef5e28d99a86f80347d207959de02..9da4d144adb697c32884babafeea8122c7af86d4 100644 (file)
--- 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 e2b75fbec0e0317fad113bd7d93bd7daa9509529..751647bebefb12ae29ac89c3fe558152583c2575 100644 (file)
--- 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 8532a872d933c17d362128c18170602860936637..31a7a04e5173793a96d785c2d625f373c8846488 100644 (file)
--- 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 113590aee4d53b2ce097e8c976ce9c7c24a6ea7e..60d154788404aee7aaa53882c8680074e7a400fa 100644 (file)
--- 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 b04a54e48292c82ea0742c40cb2e7367c777231a..2d0615bb2ce9082a3c243a3018d27f5453e02388 100644 (file)
--- 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 e32f238c629cac38de938716fd80287b940c27f2..62272f119b28b9d3c4956f2f42eabc0c887c6b61 100644 (file)
--- 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 d0000ebd0c689e6c0ab7e085efa5b8a7acb17982..dddc2c871b02c3a5b441c76b051f00217db3f098 100644 (file)
--- 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 bb590e8a05f74248e25e4a91beaeba4f6f0754fd..db61f43a5a7db0152a9f168f8064258eacdf558c 100644 (file)
--- 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 33de8edab4f9913d675e7703f26a6251b57e98e0..e87c623d4bc227c587f4719f9255626cbb0b7be4 100644 (file)
--- 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 2a0ebcecfcd3938d3ea40f2c97cc2fbccb6a6f1c..ba6e849c66ee60d57ee6f434af2bda7ef67711ce 100644 (file)
--- 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 d73c24df834fc585f2c307ac11294e6b8d3b7ccd..dd4df6d405bf944117bb376655981767619505a1 100644 (file)
--- 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 7e6bea530c931110fdae859d35568f4cec9a3664..5103d01f8553c1c6e04f71e323a3a488f9ec18a4 100644 (file)
--- 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 e95414025855879d4392c9dea85ec95bbe74bb7f..aa77a3b92156914f607e3e08947dda4c9e1c6ff0 100644 (file)
--- 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 d31f6340f746bf35cd218a998c864951ad0563f4..962dac0f8af35442c020939db227144931661e46 100644 (file)
--- 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 9cb637b07f13c7b8a1a710eb2e15c4ad2b72dc5f..aa5107fe225e2e5d642b854f2841661427978f64 100644 (file)
--- 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 b3fb92b6b5bccd13c7a1c3468749549f0262f03a..fb5a39303e0cb8fd16d65ee5a27744e418549b00 100644 (file)
--- 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 70d164a0b382f666bcbe168d739b7ded1d4d9b57..fde5c4b98245a7c314d7b67cb11bd799eb394a5c 100644 (file)
--- 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 7ba9fd4a0714c0c4c31456acad4387794db84939..a792b22c9f29d11e9809577ef9396683591492dd 100644 (file)
--- 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 22b699717678fc7898f014a5a4171d89af7b88e3..5937f0d56c86f40951189fb3b491fb5e4a8ba1b0 100644 (file)
--- 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 8db33c92758e9315d6768f364c731015c466e22c..75ab5d71205eb69afa0f7e1c777ca7b4e806cc1d 100644 (file)
--- 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 880bf0620e3a31b1e8e73bcf2b861d245a6984a0..70851e5e07260185fb8d08705ca81b886ae0dc75 100644 (file)
--- 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 68afe0df26d3d3af37823915dabcaeda8ce40e2b..7367176f07bbb9b39731acaaccb2a3a56e7be4d9 100644 (file)
--- 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 e694d51a67c21ca0e6d575163d16e0f9a6b69963..5d384e8d91040ab5a336f5563f3d94260632b504 100644 (file)
--- 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 13409d6efa7fd9144c1d6798cf70e188605a9a16..b31258eaa1784e19a19a1b45a31c3bbf6cead9c8 100644 (file)
--- 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 0b2b2d8418fa21fa5860bf6afcbdb6b3916ad9b7..a1b43f8f80f001ede5f605aca4368145a5eea6bf 100644 (file)
--- 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 711bcd66d7d299053c017036956b29e997f6158e..4f6a539ad848c6a383e335fbc147f868b37504aa 100644 (file)
--- 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 a5bedd5301c3ba4b05b49abdbf5621cecca21635..6ff7b447a0f01ec2e95dae7ec8845a335328751a 100644 (file)
--- 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 e77b94f74e9d457786999a50e225a314acdbaf10..c2afb006f32fe6cd03cfb7bd58d038746393e383 100644 (file)
--- 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 08c52c2d56cef8db6289ad1aa0f4862c07234e31..346f281af3d3adb0b951229190e09be2a1b30f11 100644 (file)
--- 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 805c7dd5476d99bb879073aa2c26c2eeaa30b426..35c1ad78dd50a198ea274e9b6c489fcf2ccbedbf 100644 (file)
--- 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 e1ec8a083274ae80f7923932a1a505d003e8413e..7e9a9b0be51481f8aa3aceda7411815e9ace58b4 100644 (file)
--- 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 af4529815bfa5e7fe6581ff601c4358c9c60e53b..c47ea61d03e5b176bdc4ece5c4d3c9be3e926121 100644 (file)
--- 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 d6b6bec72d13dce16545fc00290b8f7e2dd2c692..a67d1866b685fff48ddddcec3542a72fa57d138b 100644 (file)
--- 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 38c1ede40a7693737236f3f1335afc725fc96417..09fa15a3a202b5de3bdb41f1fffb393623c65f0d 100644 (file)
--- 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 396555b337397d140dc76cdf48814adfa30fd849..b2c8215002dd84a49ce59570e9ffa4225690a072 100644 (file)
--- a/libavcodec/svq3.c
+++ b/libavcodec/svq3.c
@@ -1599,7 +1599,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 931e5d3fb4e935ebe8015ddba93e3b4890038296..93caaae7ad18216c66a76d5d9b104213475cc755 100644 (file)
--- 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 a61fef1d7ba48bb0844701bc731a631f071a5c66..3502636c1609e6835b7fac0a6c4c73ab18101102 100644 (file)
--- 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 443d48a92f29fec4492eb96685fb798fa2b31a34..d002c1006adc2fd4c644e912c3e170c70d1e6238 100644 (file)
--- 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 cd6cc9e87467aeb36411079feb2959e6a9b01e7b..6a9edd9aa53e7b52f44b6976f2cabb0f57622d5c 100644 (file)
--- 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 9e7381c2bbc33ca51ff51afb9b09bec4ccca672d..79bdc422e1f1e0e12db6d3ef63f323e67989a4d7 100644 (file)
--- 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 964da72ad530fff14668bf18bb9ba7571b6b1020..c1fcc5c6cb4eb649d93a8bc1a6925fd09b40eae9 100644 (file)
--- 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 91c8314379cdce8a060a33d822c18124a616a7aa..e5b863b6afe788e256db9be4902113131cd993bd 100644 (file)
--- 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 819672eea0c454e987912a02c29da795271f583b..8566f7ba747589d91adbd641bf54f72ab0a7f0c4 100644 (file)
--- 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 03262f97b2b8386239c4153225e2df6564e76c55..32ee2d5f3e7c34bdd0fcbf86f9f79c27ee5e2e87 100644 (file)
--- 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 f8485cda59ab973411fa3505d03b9adecd993d9f..67aeb23665336741b0af8ae2ce58a1e43484fb19 100644 (file)
--- 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 94782fef4b8ff9e5dfbe7e3b5b248d0a490b503a..56ef059ce153c163982e37fbd0a7446bfcb4cf0b 100644 (file)
--- 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 012ad4ffde8c8b587839f1fbae835568f0119b04..f29db593f9cdf767ed586e216cff4658a9c8522e 100644 (file)
--- 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 e3ab998fda7cb37d8d61f7f03b85dd514998b900..a2206a60e009c3cf00ff231675b2e5b8ad4e3627 100644 (file)
--- 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 272fc43deb4c981a3c5aaadfedb38b6eee817b88..5eac34fefcd104d8cdac98ed0664daee518430e8 100644 (file)
--- 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 f67a910c73136ddfed9a43b0c94278cafc08a785..043d78d0188031e59f978a95cd4654dfda2e8d42 100644 (file)
--- 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 13e7a41a315becf8b0eed3af593f17f8265318eb..419a7775b326f02a4625e1e862bd3d472749e5e8 100644 (file)
--- 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 f1e159b03d37751f010c02419cdf85351f2cd18a..83e857ae257b29eeab884056a8effcdd43dbe9ff 100644 (file)
--- 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 bb4734e01381aaff4ab8d4bd87fe4da74c16ad74..3255347b6255d58dc7a9b044b6ffc965caeb57e8 100644 (file)
--- 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 83485197c991f85ccd76e685ae42852daa0baacf..09f2657cd6585406802cc9b544fbbdfaca7bb480 100644 (file)
--- a/libavcodec/ttmlenc.c
+++ b/libavcodec/ttmlenc.c
@@ -383,7 +383,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 0c1782ecbf619ac911dc83b8f61b96e7992d8c60..b972facfdda7b370bfc33653f6cb2d9a312721ea 100644 (file)
--- 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 f00ba89e82f3db51c63f8ff4b473b26844680313..86d60f33777346a675f008a00ad81e3b7661b736 100644 (file)
--- 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 cf6891d530a9aa7d4f751c83dc89b8df8d3fc190..55548ae3f63d2e6f38a6ec5d731dfe6035ec76a9 100644 (file)
--- 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 1b10b3bd06b89282c56a9533b8ea73840fd92770..b39d8a79481f00884fd697246a188f106c594427 100644 (file)
--- 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 670e48aa9f9c9f78345fdd110b7e9c98dc4dbaa9..29b29bc65834d71c784d9253fddb246c52096b48 100644 (file)
--- 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 044d35338bdea20c2b8b6fe5afb8feb3affc3d92..868822e298ca745b48338db485e1ea4c43f3718a 100644 (file)
--- 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 91af88b359b62a5a424fec650ab5377390a40ec3..020f0fffe55b77c720e2f2e484f23b1c8da4eca5 100644 (file)
--- 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 f6a453aabf6ccd8474346bc52c082f4c551be5b3..da9e2e3649abc0f985ee6053987e1969f2301834 100644 (file)
--- 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 dd53fbded4993769ddfbfa3284c9e31d885ecd36..c2b0a69561799aedd85907e52f19d1b6a7a4f61f 100644 (file)
--- 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 0891251dea611581d5e731d01240598080b5d70c..919f0ea10b1ba80ceaf2d8049475ee0fdc32c0ca 100644 (file)
--- 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 196c575c09772d56d12abefa8d8b14174dc5e66e..749b3b65e5041eab286e70cd1727667847b4fdd9 100644 (file)
--- 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 d2d84d9c40b3f97d8bfb7e30d650848cbdace851..7df371f0eacdd9c01e7ff833b76b4a185255b3e1 100644 (file)
--- 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 7ad5eb8fb5303c5e9108cbbd01d731b2881f1143..2160f88e8bc94a6f6c0d8751bc64384883cbf5a1 100644 (file)
--- 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 9dc13f71440686876a34c887ae8e20aa0572f733..c31bf7f4d8b2b87be644403ce43a457f9de720af 100644 (file)
--- 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 ab07c0a24a2b8ca554d1d3459f3855cb88bc559e..224eb3d5e7be32196b7aafef74a6326cca46e4bd 100644 (file)
--- 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 f644b50133b436e632cd915971e3d9a4dae58ee7..043fe80c695fff5b4767b9c8226a5c2652f62793 100644 (file)
--- 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 6e20e2d0157bbad6e7f8da2ec823a23342b7a786..ff37de1f7ea37d7c9c8173bf66eb1f83ebd1082f 100644 (file)
--- 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 287ac586904b722321a77bca0325efb70c05798b..e1dc53dfa96ec419d77fd65565325d438807720e 100644 (file)
--- 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 3878f3eeb9a3dd7fdf10f2aaad0058319ad5bd0e..d35f416ad7d236a982b93df61620b99c35a472ad 100644 (file)
--- 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 4c81d785d6d8b75377b9b8832e52486348fcf272..af3a63dab735e20e8fdfce26f563d257101e8f10 100644 (file)
--- 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 66cf2321be456aac0d429cf4c1dfc66b40d6cbf3..7d4578f6747497931ba857c9ca85a7ee8a5e9908 100644 (file)
--- 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 0e1c52c92a85182aceba8b264fdd0bfdf8eca3c5..b3f45fb8fe6f7c46d6229741fab59ef28d5c0ab6 100644 (file)
--- 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 fe419c766313a58c51a381d4874d46dee7afb148..f5b7f89853f1d861a81ae6c873356bc365f26952 100644 (file)
--- 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 2cddd550b1887232a334ab1c0762d899a6bc109c..f1400959e05cb68a4383b458796a27f65dd217b6 100644 (file)
--- 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 8f112bf9b2c81273d088f422ef1d44b569ef1169..6cd74a09f12b604df65f73b0daeda8e45a75edbe 100644 (file)
--- 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 6c2e873a2338e9608715d99a676dcddd2d2e586e..ca5cebb742fcbebf1ab8d05e1c49ab1c894bf932 100644 (file)
--- 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 28a5eec7d1cc98b4f9bfaf578b6a0bb2e01f29ed..8220cf3b380a432db8c542e8b270535a5bb3d95b 100644 (file)
--- 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 9b7ee6720c4ec2bd18853a2f3650da2f389321b3..e576ff7d7e8042be91e75f07d5cb9c65bec03b6b 100644 (file)
--- 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 2dfc2cc5c8cb622ccba9e88ef0a312458b77f1fb..5c7618861f52eff8ea18f1beff271a660a7b7e0d 100644 (file)
--- 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 dfbd49fd8408714fa61ec494a30ba59951ac4203..d513479c547ce78b9a2ae9f6c8aea433bbd612c3 100644 (file)
--- 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 bb9306e4ffa71788ed1f40e1e19471e3883ff080..15846919d82a1625481ef8eb5c286bf92ab0688d 100644 (file)
--- 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 7f441bc4bd3d6c70b5023ee2a84588cf24407322..d65e8dc4e556e1e2411900c40fd77ba6c6b75637 100644 (file)
--- 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 169df591b37061b454c56f6b25fd1d43449c21b8..dac2b6841cd823503c84012ba504aad83b2a23ea 100644 (file)
--- 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 1b0ab3cadb42a9ea5c655f86c2aa13a9dbef6dcc..b89bb206e07d1a6cf521811539d05d2e5be6349a 100644 (file)
--- 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 57c6eb1ff9812ab7073a00dd0b8588b6ee3470c8..0cae07545233412634d1a6a4cdecdbec376c44af 100644 (file)
--- 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 f3946f508c23cdf6f3099abda15851b4ea057503..f68c62527baaa86629584477b9f8f5fcc7c66007 100644 (file)
--- 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 e5dec19f509dabb090171a2d7e1dc0d8bfc05063..73822a00f9803089da95db991fe7a60b0ddb1b48 100644 (file)
--- 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 d16e7b6aa34ed2e60c2edc5030ce1c99a89d8ebb..b964d2fd2df0cb98bba590fd7b4f706ab44b8801 100644 (file)
--- 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 b4b644d509cc20d74a259354d035387cbc931320..32776ebae764ab510fc95ae25ae7d8f4ad2eafae 100644 (file)
--- 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 f45390cfe54caba46f18026dd233977da2d023cb..a396615ce513eed820d6983bcaeb333196583a89 100644 (file)
--- 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 2d49172eaffd9f31e2e9bdd5509dba204a70be06..6b2ec19bf1e6ce206953723e32205440852101e9 100644 (file)
--- 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 0c82633a72a9c452de220132b3bbcae9f8f2cd26..b856f56e3b4c81f3a5b2b63bd9166cfffa2fdce0 100644 (file)
--- 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 d7a3cbd1b71bdc72a635c7d709a0e00214da5cd0..04c597e7674616bd70eb6fa00d68604d22f2f5bb 100644 (file)
--- 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 5a7aebc5872db25895c94afc726d6a630cd0de0f..23558309c65e9b7aed8f380023248467351a6875 100644 (file)
--- 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 7b2d1750deb9959417cb8620f24b9a8cf2e5bfa2..eb0a5600a675cea8a28508cd38a4ea58bbfb18ed 100644 (file)
--- 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 fcbd9698f49ccb1cec59dfececebd11ddd63d4d2..cc47b5aca3d840e3841b12bfa2b54e9736a8bf9b 100644 (file)
--- 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 9c79556bb5ae00c044977aae744e2981add3ee1e..9081f35a16ee0f08a369959883a152214235615c 100644 (file)
--- 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 4ad37cc70bdc12625d65156a89091281e5a2df2c..89273ba978437314ede88cb4c779edc38df38988 100644 (file)
--- 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 e1fcf8afeb6a3692e852cfdaad9c8af77fd67a86..f750e1a47980d1bd5d9df921f7a41e27bff0796c 100644 (file)
--- 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 8024ce1611548eba147808dafd3e2e08b040d335..9607e509681ed1ca957ed14620bc590ccb57d1fc 100644 (file)
--- 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 2cb4219b84849610bded00b921c5b6a15e06ffdc..a9d50f95ca9e643e7fa17ba16c72e1c25f048ef6 100644 (file)
--- 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 7aae11568c82b5c51eeb8f1f22a43445d68063f0..c500e3e7797d6a9058ab9b546489a0559a968d61 100644 (file)
--- 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 781873a4b3143d74dbe1f015f69c035a839adca4..b3d2a05c4ec2ba5a19b2bad2aea1ad2b9e8486f7 100644 (file)
--- 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 dcf417763c98926f6c7770524755e2b5026d5257..5d6c91d2d29f753cb337b7aa92d97a7ed8472dd0 100644 (file)
--- 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 85ff32d13aef0e6d0722f793fb455e13eb510432..a7834b86e8058784e5cd16677b44128118202a79 100644 (file)
--- 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 958c0677362ae5544b804f655b9d436845d95a9f..aa8cd0f5f99552a432d3ae3f0e16d035737bf9b5 100644 (file)
--- 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 6bf754f1516ab09fd16e46d56197885f7f90e03b..7ab43db1e08657e1e86d395917f05615fd4edeeb 100644 (file)
--- 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 c1fc6cb65004382ee00fd321bfe34983b7ab5a6d..bed68c33ed790d0a41258939ef8eefaa8b57334c 100644 (file)
--- 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 1cf13f6f0b08d7b0dd18b75a5445949de9f703d9..3451ecc88c3b65108dff6c77b2c3e35e9472da16 100644 (file)
--- 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 763be6761a4d7b449dd4a57edc070e0a210af5a1..27295ff5185deeedbeb304232c90f186a678a636 100644 (file)
--- 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 dd5bb689c26e5469fe026bfb9dfd93b4b565f905..21c7d8f31c913c370c2d75e063900a44c5f2de1b 100644 (file)
--- 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 72fb3bf259de0a579bf083b045fdf41e21f8135f..25e5a6444ef5ea55437b052ae52cfcc1dbda1457 100644 (file)
--- 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 922dfc0f672dd1876b8cb638b6caaf68e5624e8a..e609a70c6ae281ec7e4918de0531fdddb35c49e5 100644 (file)
--- 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 caab330ed308616bced1dc9b16b84a9640ddc4de..979399bae6e32c36272ae558e989a9d06011b5d5 100644 (file)
--- 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 53fcb7665696403e9b78c24d8e271d5c3570f9c5..03d0dc2d869b3dc13291743a04724e37e00009ed 100644 (file)
--- 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 8c4358fd4cd04e4499949515c80e8831b8e89405..7b8228332fdcc0a3ebb82d8b709b53fbf5c7ea0d 100644 (file)
--- 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 81cca6c9636ecaf3ffe0743449d04db12c66d9c3..8eec700e9d88b53089ae72d98b739d734b048ee3 100644 (file)
--- 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 1dd46b36ebd5901e117cd3be7028e02e5b62c932..7c4aaf281fd0510c9f87b739ed0a0dbadc1f57ae 100644 (file)
--- 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 2bfabe277eed62525daa68e717bcbf3ffdef7ad9..e63d184f25649027d3e281cbb5acba312f08f248 100644 (file)
--- 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 4340a3fbbae60a3b0c1ed0d001bea1d48ae944b2..e7d639008f14b4794d6fbc575885c825eca22848 100644 (file)
--- 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 ab1f8958f3ccac3daec1436aee25edd73afccb45..1c2b5000fe597250a6643a0ba0174227b7308d57 100644 (file)
--- 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 8f8ed940ece524eb5e64601fa84f2a115bf1391b..38014edef600f71447411630a2617c9ee03e6d14 100644 (file)
--- 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 3fb1dbac288ef098197fe88cc5be7cb4f57c78f9..b180e96b5fd083fe660e0991a4714a8c1a6ef949 100644 (file)
--- 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 63a7fae9647c604cc14b8233d4b922650bb62f03..259395d9dabb18a0b29fd8fc4eb68686cda19587 100644 (file)
--- 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 1051fdaa45d6b76397d903f6247a903b7612743c..3bd04567a1ebdffcd9595ba11809bbb19e02b88d 100644 (file)
--- 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 e3ccc16d0bca484973969ec48fa3e1958d8c269a..e1aba7f059945a6f3af5fd19db98afe6592b0861 100644 (file)
--- 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 1d4c617b4ae0d9fbe5c0a8c6b95de6177b14dd79..27d2954352612d738a75a206584dfe112d347f85 100644 (file)
--- 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,