git.sesse.net Git - ffmpeg/blob - libavcodec/allcodecs.c

   1 /*
   2  * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
   3  * Copyright (c) 2002 Fabrice Bellard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
  25  */
  26
  27 #include "config.h"
  28 #include "avcodec.h"
  29 #include "version.h"
  30
  31 #define REGISTER_ENCODER(X, x)                                          \
  32     {                                                                   \
  33         extern AVCodec ff_##x##_encoder;                                \
  34         if (CONFIG_##X##_ENCODER)                                       \
  35             avcodec_register(&ff_##x##_encoder);                        \
  36     }
  37
  38 #define REGISTER_DECODER(X, x)                                          \
  39     {                                                                   \
  40         extern AVCodec ff_##x##_decoder;                                \
  41         if (CONFIG_##X##_DECODER)                                       \
  42             avcodec_register(&ff_##x##_decoder);                        \
  43     }
  44
  45 #define REGISTER_ENCDEC(X, x) REGISTER_ENCODER(X, x); REGISTER_DECODER(X, x)
  46
  47 #define REGISTER_PARSER(X, x)                                           \
  48     {                                                                   \
  49         extern AVCodecParser ff_##x##_parser;                           \
  50         if (CONFIG_##X##_PARSER)                                        \
  51             av_register_codec_parser(&ff_##x##_parser);                 \
  52     }
  53
  54 void avcodec_register_all(void)
  55 {
  56     static int initialized;
  57
  58     if (initialized)
  59         return;
  60     initialized = 1;
  61
  62     /* video codecs */
  63     REGISTER_ENCODER(A64MULTI,          a64multi);
  64     REGISTER_ENCODER(A64MULTI5,         a64multi5);
  65     REGISTER_DECODER(AASC,              aasc);
  66     REGISTER_DECODER(AIC,               aic);
  67     REGISTER_ENCDEC (ALIAS_PIX,         alias_pix);
  68     REGISTER_DECODER(AMV,               amv);
  69     REGISTER_DECODER(ANM,               anm);
  70     REGISTER_DECODER(ANSI,              ansi);
  71     REGISTER_ENCDEC (ASV1,              asv1);
  72     REGISTER_ENCDEC (ASV2,              asv2);
  73     REGISTER_DECODER(AURA,              aura);
  74     REGISTER_DECODER(AURA2,             aura2);
  75     REGISTER_DECODER(AVS,               avs);
  76     REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
  77     REGISTER_DECODER(BFI,               bfi);
  78     REGISTER_DECODER(BINK,              bink);
  79     REGISTER_ENCDEC (BMP,               bmp);
  80     REGISTER_DECODER(BMV_VIDEO,         bmv_video);
  81     REGISTER_DECODER(BRENDER_PIX,       brender_pix);
  82     REGISTER_DECODER(C93,               c93);
  83     REGISTER_DECODER(CAVS,              cavs);
  84     REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
  85     REGISTER_DECODER(CDXL,              cdxl);
  86     REGISTER_DECODER(CFHD,              cfhd);
  87     REGISTER_ENCDEC (CINEPAK,           cinepak);
  88     REGISTER_DECODER(CLEARVIDEO,        clearvideo);
  89     REGISTER_ENCDEC (CLJR,              cljr);
  90     REGISTER_DECODER(CLLC,              cllc);
  91     REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
  92     REGISTER_DECODER(CSCD,              cscd);
  93     REGISTER_DECODER(CYUV,              cyuv);
  94     REGISTER_DECODER(DDS,               dds);
  95     REGISTER_DECODER(DFA,               dfa);
  96     REGISTER_ENCDEC (DNXHD,             dnxhd);
  97     REGISTER_ENCDEC (DPX,               dpx);
  98     REGISTER_DECODER(DSICINVIDEO,       dsicinvideo);
  99     REGISTER_ENCDEC (DVVIDEO,           dvvideo);
 100     REGISTER_DECODER(DXA,               dxa);
 101     REGISTER_DECODER(DXTORY,            dxtory);
 102     REGISTER_DECODER(DXV,               dxv);
 103     REGISTER_DECODER(EACMV,             eacmv);
 104     REGISTER_DECODER(EAMAD,             eamad);
 105     REGISTER_DECODER(EATGQ,             eatgq);
 106     REGISTER_DECODER(EATGV,             eatgv);
 107     REGISTER_DECODER(EATQI,             eatqi);
 108     REGISTER_DECODER(EIGHTBPS,          eightbps);
 109     REGISTER_DECODER(EIGHTSVX_EXP,      eightsvx_exp);
 110     REGISTER_DECODER(EIGHTSVX_FIB,      eightsvx_fib);
 111     REGISTER_DECODER(ESCAPE124,         escape124);
 112     REGISTER_DECODER(ESCAPE130,         escape130);
 113     REGISTER_DECODER(EXR,               exr);
 114     REGISTER_ENCDEC (FFV1,              ffv1);
 115     REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
 116     REGISTER_DECODER(FIC,               fic);
 117     REGISTER_ENCDEC (FLASHSV,           flashsv);
 118     REGISTER_DECODER(FLASHSV2,          flashsv2);
 119     REGISTER_DECODER(FLIC,              flic);
 120     REGISTER_ENCDEC (FLV,               flv);
 121     REGISTER_DECODER(FMVC,              fmvc);
 122     REGISTER_DECODER(FOURXM,            fourxm);
 123     REGISTER_DECODER(FRAPS,             fraps);
 124     REGISTER_DECODER(FRWU,              frwu);
 125     REGISTER_DECODER(G2M,               g2m);
 126     REGISTER_ENCDEC (GIF,               gif);
 127     REGISTER_ENCDEC (H261,              h261);
 128     REGISTER_ENCDEC (H263,              h263);
 129     REGISTER_DECODER(H263I,             h263i);
 130     REGISTER_ENCODER(H263P,             h263p);
 131     REGISTER_DECODER(H264,              h264);
 132     REGISTER_DECODER(H264_MMAL,         h264_mmal);
 133     REGISTER_DECODER(H264_QSV,          h264_qsv);
 134     REGISTER_ENCDEC (HAP,               hap);
 135     REGISTER_DECODER(HEVC,              hevc);
 136     REGISTER_DECODER(HEVC_QSV,          hevc_qsv);
 137     REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);
 138     REGISTER_DECODER(HQ_HQA,            hq_hqa);
 139     REGISTER_DECODER(HQX,               hqx);
 140     REGISTER_ENCDEC (HUFFYUV,           huffyuv);
 141     REGISTER_DECODER(IDCIN,             idcin);
 142     REGISTER_DECODER(IFF_BYTERUN1,      iff_byterun1);
 143     REGISTER_DECODER(IFF_ILBM,          iff_ilbm);
 144     REGISTER_DECODER(INDEO2,            indeo2);
 145     REGISTER_DECODER(INDEO3,            indeo3);
 146     REGISTER_DECODER(INDEO4,            indeo4);
 147     REGISTER_DECODER(INDEO5,            indeo5);
 148     REGISTER_DECODER(INTERPLAY_VIDEO,   interplay_video);
 149     REGISTER_DECODER(JPEG2000,          jpeg2000);
 150     REGISTER_ENCDEC (JPEGLS,            jpegls);
 151     REGISTER_DECODER(JV,                jv);
 152     REGISTER_DECODER(KGV1,              kgv1);
 153     REGISTER_DECODER(KMVC,              kmvc);
 154     REGISTER_DECODER(LAGARITH,          lagarith);
 155     REGISTER_ENCODER(LJPEG,             ljpeg);
 156     REGISTER_DECODER(LOCO,              loco);
 157     REGISTER_DECODER(MAGICYUV,          magicyuv);
 158     REGISTER_DECODER(MDEC,              mdec);
 159     REGISTER_DECODER(MIMIC,             mimic);
 160     REGISTER_ENCDEC (MJPEG,             mjpeg);
 161     REGISTER_DECODER(MJPEGB,            mjpegb);
 162     REGISTER_DECODER(MMVIDEO,           mmvideo);
 163     REGISTER_DECODER(MOTIONPIXELS,      motionpixels);
 164     REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
 165     REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
 166     REGISTER_DECODER(MPEG2_MMAL,        mpeg2_mmal);
 167     REGISTER_DECODER(MPEG2_QSV,         mpeg2_qsv);
 168     REGISTER_ENCDEC (MPEG4,             mpeg4);
 169     REGISTER_DECODER(MSA1,              msa1);
 170     REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
 171     REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
 172     REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
 173     REGISTER_DECODER(MSRLE,             msrle);
 174     REGISTER_DECODER(MSS1,              mss1);
 175     REGISTER_DECODER(MSS2,              mss2);
 176     REGISTER_DECODER(MSVIDEO1,          msvideo1);
 177     REGISTER_DECODER(MSZH,              mszh);
 178     REGISTER_DECODER(MTS2,              mts2);
 179     REGISTER_DECODER(MVC1,              mvc1);
 180     REGISTER_DECODER(MVC2,              mvc2);
 181     REGISTER_DECODER(MXPEG,             mxpeg);
 182     REGISTER_DECODER(NUV,               nuv);
 183     REGISTER_DECODER(PAF_VIDEO,         paf_video);
 184     REGISTER_ENCDEC (PAM,               pam);
 185     REGISTER_ENCDEC (PBM,               pbm);
 186     REGISTER_ENCDEC (PCX,               pcx);
 187     REGISTER_ENCDEC (PGM,               pgm);
 188     REGISTER_ENCDEC (PGMYUV,            pgmyuv);
 189     REGISTER_DECODER(PICTOR,            pictor);
 190     REGISTER_DECODER(PIXLET,            pixlet);
 191     REGISTER_ENCDEC (PNG,               png);
 192     REGISTER_ENCDEC (PPM,               ppm);
 193     REGISTER_ENCDEC (PRORES,            prores);
 194     REGISTER_DECODER(PTX,               ptx);
 195     REGISTER_DECODER(QDRAW,             qdraw);
 196     REGISTER_DECODER(QPEG,              qpeg);
 197     REGISTER_ENCDEC (QTRLE,             qtrle);
 198     REGISTER_DECODER(R10K,              r10k);
 199     REGISTER_DECODER(R210,              r210);
 200     REGISTER_ENCDEC (RAWVIDEO,          rawvideo);
 201     REGISTER_DECODER(RL2,               rl2);
 202     REGISTER_ENCDEC (ROQ,               roq);
 203     REGISTER_DECODER(RPZA,              rpza);
 204     REGISTER_DECODER(RSCC,              rscc);
 205     REGISTER_ENCDEC (RV10,              rv10);
 206     REGISTER_ENCDEC (RV20,              rv20);
 207     REGISTER_DECODER(RV30,              rv30);
 208     REGISTER_DECODER(RV40,              rv40);
 209     REGISTER_DECODER(S302M,             s302m);
 210     REGISTER_DECODER(SANM,              sanm);
 211     REGISTER_DECODER(SCREENPRESSO,      screenpresso);
 212     REGISTER_ENCDEC (SGI,               sgi);
 213     REGISTER_DECODER(SGIRLE,            sgirle);
 214     REGISTER_DECODER(SMACKER,           smacker);
 215     REGISTER_DECODER(SMC,               smc);
 216     REGISTER_DECODER(SP5X,              sp5x);
 217     REGISTER_ENCDEC (SUNRAST,           sunrast);
 218     REGISTER_ENCDEC (SVQ1,              svq1);
 219     REGISTER_DECODER(SVQ3,              svq3);
 220     REGISTER_ENCDEC (TARGA,             targa);
 221     REGISTER_DECODER(TDSC,              tdsc);
 222     REGISTER_DECODER(THEORA,            theora);
 223     REGISTER_DECODER(THP,               thp);
 224     REGISTER_DECODER(TIERTEXSEQVIDEO,   tiertexseqvideo);
 225     REGISTER_ENCDEC (TIFF,              tiff);
 226     REGISTER_DECODER(TMV,               tmv);
 227     REGISTER_DECODER(TRUEMOTION1,       truemotion1);
 228     REGISTER_DECODER(TRUEMOTION2,       truemotion2);
 229     REGISTER_DECODER(TRUEMOTION2RT,     truemotion2rt);
 230     REGISTER_DECODER(TSCC,              tscc);
 231     REGISTER_DECODER(TSCC2,             tscc2);
 232     REGISTER_DECODER(TXD,               txd);
 233     REGISTER_DECODER(ULTI,              ulti);
 234     REGISTER_ENCDEC (UTVIDEO,           utvideo);
 235     REGISTER_ENCDEC (V210,              v210);
 236     REGISTER_DECODER(V210X,             v210x);
 237     REGISTER_ENCDEC (V410,              v410);
 238     REGISTER_DECODER(VB,                vb);
 239     REGISTER_DECODER(VBLE,              vble);
 240     REGISTER_DECODER(VC1,               vc1);
 241     REGISTER_DECODER(VC1IMAGE,          vc1image);
 242     REGISTER_DECODER(VC1_MMAL,          vc1_mmal);
 243     REGISTER_DECODER(VC1_QSV,           vc1_qsv);
 244     REGISTER_DECODER(VCR1,              vcr1);
 245     REGISTER_DECODER(VMDVIDEO,          vmdvideo);
 246     REGISTER_DECODER(VMNC,              vmnc);
 247     REGISTER_DECODER(VP3,               vp3);
 248     REGISTER_DECODER(VP5,               vp5);
 249     REGISTER_DECODER(VP6,               vp6);
 250     REGISTER_DECODER(VP6A,              vp6a);
 251     REGISTER_DECODER(VP6F,              vp6f);
 252     REGISTER_DECODER(VP7,               vp7);
 253     REGISTER_DECODER(VP8,               vp8);
 254     REGISTER_DECODER(VP8_QSV,           vp8_qsv);
 255     REGISTER_DECODER(VP9,               vp9);
 256     REGISTER_DECODER(VQA,               vqa);
 257     REGISTER_DECODER(WEBP,              webp);
 258     REGISTER_ENCODER(WRAPPED_AVFRAME,   wrapped_avframe);
 259     REGISTER_ENCDEC (WMV1,              wmv1);
 260     REGISTER_ENCDEC (WMV2,              wmv2);
 261     REGISTER_DECODER(WMV3,              wmv3);
 262     REGISTER_DECODER(WMV3IMAGE,         wmv3image);
 263     REGISTER_DECODER(WNV1,              wnv1);
 264     REGISTER_DECODER(XAN_WC3,           xan_wc3);
 265     REGISTER_DECODER(XAN_WC4,           xan_wc4);
 266     REGISTER_ENCDEC (XBM,               xbm);
 267     REGISTER_DECODER(XL,                xl);
 268     REGISTER_ENCDEC (XWD,               xwd);
 269     REGISTER_DECODER(YOP,               yop);
 270     REGISTER_DECODER(ZEROCODEC,         zerocodec);
 271     REGISTER_ENCDEC (ZLIB,              zlib);
 272     REGISTER_ENCDEC (ZMBV,              zmbv);
 273
 274     /* audio codecs */
 275     REGISTER_ENCDEC (AAC,               aac);
 276     REGISTER_DECODER(AAC_LATM,          aac_latm);
 277     REGISTER_ENCDEC (AC3,               ac3);
 278     REGISTER_ENCODER(AC3_FIXED,         ac3_fixed);
 279     REGISTER_ENCDEC (ALAC,              alac);
 280     REGISTER_DECODER(ALS,               als);
 281     REGISTER_DECODER(AMRNB,             amrnb);
 282     REGISTER_DECODER(AMRWB,             amrwb);
 283     REGISTER_DECODER(APE,               ape);
 284     REGISTER_DECODER(ATRAC1,            atrac1);
 285     REGISTER_DECODER(ATRAC3,            atrac3);
 286     REGISTER_DECODER(ATRAC3P,           atrac3p);
 287     REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
 288     REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
 289     REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
 290     REGISTER_DECODER(COOK,              cook);
 291     REGISTER_DECODER(DCA,               dca);
 292     REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
 293     REGISTER_DECODER(DSS_SP,            dss_sp);
 294     REGISTER_ENCDEC (EAC3,              eac3);
 295     REGISTER_ENCDEC (FLAC,              flac);
 296     REGISTER_ENCDEC (G723_1,            g723_1);
 297     REGISTER_DECODER(GSM,               gsm);
 298     REGISTER_DECODER(GSM_MS,            gsm_ms);
 299     REGISTER_DECODER(IAC,               iac);
 300     REGISTER_DECODER(IMC,               imc);
 301     REGISTER_DECODER(MACE3,             mace3);
 302     REGISTER_DECODER(MACE6,             mace6);
 303     REGISTER_DECODER(METASOUND,         metasound);
 304     REGISTER_DECODER(MLP,               mlp);
 305     REGISTER_DECODER(MP1,               mp1);
 306     REGISTER_DECODER(MP1FLOAT,          mp1float);
 307     REGISTER_ENCDEC (MP2,               mp2);
 308     REGISTER_DECODER(MP2FLOAT,          mp2float);
 309     REGISTER_DECODER(MP3,               mp3);
 310     REGISTER_DECODER(MP3FLOAT,          mp3float);
 311     REGISTER_DECODER(MP3ADU,            mp3adu);
 312     REGISTER_DECODER(MP3ADUFLOAT,       mp3adufloat);
 313     REGISTER_DECODER(MP3ON4,            mp3on4);
 314     REGISTER_DECODER(MP3ON4FLOAT,       mp3on4float);
 315     REGISTER_DECODER(MPC7,              mpc7);
 316     REGISTER_DECODER(MPC8,              mpc8);
 317     REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
 318     REGISTER_DECODER(ON2AVC,            on2avc);
 319     REGISTER_DECODER(OPUS,              opus);
 320     REGISTER_DECODER(PAF_AUDIO,         paf_audio);
 321     REGISTER_DECODER(QCELP,             qcelp);
 322     REGISTER_DECODER(QDM2,              qdm2);
 323     REGISTER_ENCDEC (RA_144,            ra_144);
 324     REGISTER_DECODER(RA_288,            ra_288);
 325     REGISTER_DECODER(RALF,              ralf);
 326     REGISTER_DECODER(SHORTEN,           shorten);
 327     REGISTER_DECODER(SIPR,              sipr);
 328     REGISTER_DECODER(SMACKAUD,          smackaud);
 329     REGISTER_DECODER(TAK,               tak);
 330     REGISTER_DECODER(TRUEHD,            truehd);
 331     REGISTER_DECODER(TRUESPEECH,        truespeech);
 332     REGISTER_DECODER(TTA,               tta);
 333     REGISTER_DECODER(TWINVQ,            twinvq);
 334     REGISTER_DECODER(VMDAUDIO,          vmdaudio);
 335     REGISTER_ENCDEC (VORBIS,            vorbis);
 336     REGISTER_DECODER(WAVPACK,           wavpack);
 337     REGISTER_DECODER(WMALOSSLESS,       wmalossless);
 338     REGISTER_DECODER(WMAPRO,            wmapro);
 339     REGISTER_ENCDEC (WMAV1,             wmav1);
 340     REGISTER_ENCDEC (WMAV2,             wmav2);
 341     REGISTER_DECODER(WMAVOICE,          wmavoice);
 342     REGISTER_DECODER(WS_SND1,           ws_snd1);
 343
 344     /* PCM codecs */
 345     REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
 346     REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
 347     REGISTER_DECODER(PCM_DVD,           pcm_dvd);
 348     REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
 349     REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
 350     REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
 351     REGISTER_ENCDEC (PCM_F64LE,         pcm_f64le);
 352     REGISTER_DECODER(PCM_LXF,           pcm_lxf);
 353     REGISTER_ENCDEC (PCM_MULAW,         pcm_mulaw);
 354     REGISTER_ENCDEC (PCM_S8,            pcm_s8);
 355     REGISTER_DECODER(PCM_S8_PLANAR,     pcm_s8_planar);
 356     REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
 357     REGISTER_DECODER(PCM_S16BE_PLANAR,  pcm_s16be_planar);
 358     REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
 359     REGISTER_DECODER(PCM_S16LE_PLANAR,  pcm_s16le_planar);
 360     REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
 361     REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
 362     REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
 363     REGISTER_DECODER(PCM_S24LE_PLANAR,  pcm_s24le_planar);
 364     REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
 365     REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
 366     REGISTER_DECODER(PCM_S32LE_PLANAR,  pcm_s32le_planar);
 367     REGISTER_ENCDEC (PCM_U8,            pcm_u8);
 368     REGISTER_ENCDEC (PCM_U16BE,         pcm_u16be);
 369     REGISTER_ENCDEC (PCM_U16LE,         pcm_u16le);
 370     REGISTER_ENCDEC (PCM_U24BE,         pcm_u24be);
 371     REGISTER_ENCDEC (PCM_U24LE,         pcm_u24le);
 372     REGISTER_ENCDEC (PCM_U32BE,         pcm_u32be);
 373     REGISTER_ENCDEC (PCM_U32LE,         pcm_u32le);
 374     REGISTER_DECODER(PCM_ZORK ,         pcm_zork);
 375
 376     /* DPCM codecs */
 377     REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
 378     REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
 379     REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
 380     REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
 381
 382     /* ADPCM codecs */
 383     REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
 384     REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
 385     REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
 386     REGISTER_DECODER(ADPCM_EA,          adpcm_ea);
 387     REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
 388     REGISTER_DECODER(ADPCM_EA_R1,       adpcm_ea_r1);
 389     REGISTER_DECODER(ADPCM_EA_R2,       adpcm_ea_r2);
 390     REGISTER_DECODER(ADPCM_EA_R3,       adpcm_ea_r3);
 391     REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
 392     REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
 393     REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
 394     REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
 395     REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
 396     REGISTER_DECODER(ADPCM_IMA_DK3,     adpcm_ima_dk3);
 397     REGISTER_DECODER(ADPCM_IMA_DK4,     adpcm_ima_dk4);
 398     REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
 399     REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
 400     REGISTER_DECODER(ADPCM_IMA_ISS,     adpcm_ima_iss);
 401     REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
 402     REGISTER_DECODER(ADPCM_IMA_SMJPEG,  adpcm_ima_smjpeg);
 403     REGISTER_ENCDEC (ADPCM_IMA_WAV,     adpcm_ima_wav);
 404     REGISTER_DECODER(ADPCM_IMA_WS,      adpcm_ima_ws);
 405     REGISTER_ENCDEC (ADPCM_MS,          adpcm_ms);
 406     REGISTER_DECODER(ADPCM_SBPRO_2,     adpcm_sbpro_2);
 407     REGISTER_DECODER(ADPCM_SBPRO_3,     adpcm_sbpro_3);
 408     REGISTER_DECODER(ADPCM_SBPRO_4,     adpcm_sbpro_4);
 409     REGISTER_ENCDEC (ADPCM_SWF,         adpcm_swf);
 410     REGISTER_DECODER(ADPCM_THP,         adpcm_thp);
 411     REGISTER_DECODER(ADPCM_VIMA,        adpcm_vima);
 412     REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
 413     REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
 414
 415     /* subtitles */
 416     REGISTER_ENCDEC (ASS,               ass);
 417     REGISTER_ENCDEC (DVBSUB,            dvbsub);
 418     REGISTER_ENCDEC (DVDSUB,            dvdsub);
 419     REGISTER_DECODER(PGSSUB,            pgssub);
 420     REGISTER_DECODER(SRT,               srt);
 421     REGISTER_ENCDEC (XSUB,              xsub);
 422
 423     /* external libraries */
 424     REGISTER_ENCDEC (LIBAOM_AV1,        libaom_av1);
 425     REGISTER_DECODER(LIBDAV1D,          libdav1d)
 426     REGISTER_DECODER(LIBDCADEC,         libdcadec)
 427     REGISTER_ENCODER(LIBFAAC,           libfaac);
 428     REGISTER_ENCDEC (LIBFDK_AAC,        libfdk_aac);
 429     REGISTER_ENCDEC (LIBGSM,            libgsm);
 430     REGISTER_ENCDEC (LIBGSM_MS,         libgsm_ms);
 431     REGISTER_ENCDEC (LIBILBC,           libilbc);
 432     REGISTER_ENCODER(LIBMP3LAME,        libmp3lame);
 433     REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
 434     REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
 435     REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
 436     REGISTER_ENCDEC (LIBOPUS,           libopus);
 437     REGISTER_ENCDEC (LIBSCHROEDINGER,   libschroedinger);
 438     REGISTER_ENCDEC (LIBSPEEX,          libspeex);
 439     REGISTER_ENCODER(LIBTHEORA,         libtheora);
 440     REGISTER_ENCODER(LIBTWOLAME,        libtwolame);
 441     REGISTER_ENCODER(LIBVO_AACENC,      libvo_aacenc);
 442     REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
 443     REGISTER_ENCODER(LIBVORBIS,         libvorbis);
 444     REGISTER_ENCDEC (LIBVPX_VP8,        libvpx_vp8);
 445     REGISTER_ENCDEC (LIBVPX_VP9,        libvpx_vp9);
 446     REGISTER_ENCODER(LIBWAVPACK,        libwavpack);
 447     REGISTER_ENCODER(LIBWEBP,           libwebp);
 448     REGISTER_ENCODER(LIBX262,           libx262);
 449     REGISTER_ENCODER(LIBX264,           libx264);
 450     REGISTER_ENCODER(LIBX265,           libx265);
 451     REGISTER_ENCODER(LIBXAVS,           libxavs);
 452     REGISTER_ENCODER(LIBXVID,           libxvid);
 453
 454     /* external libraries, that shouldn't be used by default if one of the
 455      * above is available */
 456     REGISTER_ENCDEC (LIBOPENH264,       libopenh264);
 457     REGISTER_ENCODER(H264_AMF,          h264_amf);
 458     REGISTER_ENCODER(H264_NVENC,        h264_nvenc);
 459     REGISTER_ENCODER(H264_OMX,          h264_omx);
 460     REGISTER_ENCODER(H264_QSV,          h264_qsv);
 461     REGISTER_ENCODER(H264_VAAPI,        h264_vaapi);
 462     REGISTER_ENCODER(LIBKVAZAAR,        libkvazaar);
 463     REGISTER_ENCODER(HEVC_AMF,          hevc_amf);
 464     REGISTER_ENCODER(HEVC_NVENC,        hevc_nvenc);
 465     REGISTER_ENCODER(HEVC_QSV,          hevc_qsv);
 466     REGISTER_ENCODER(HEVC_VAAPI,        hevc_vaapi);
 467     REGISTER_ENCODER(MJPEG_QSV,         mjpeg_qsv);
 468     REGISTER_ENCODER(MJPEG_VAAPI,       mjpeg_vaapi);
 469     REGISTER_ENCODER(MPEG2_QSV,         mpeg2_qsv);
 470     REGISTER_ENCODER(MPEG2_VAAPI,       mpeg2_vaapi);
 471     REGISTER_ENCODER(MPEG4_OMX,         mpeg4_omx);
 472 #if FF_API_NVENC_OLD_NAME
 473     REGISTER_ENCODER(NVENC_H264,        nvenc_h264);
 474     REGISTER_ENCODER(NVENC_HEVC,        nvenc_hevc);
 475 #endif
 476     REGISTER_ENCODER(VP8_VAAPI,         vp8_vaapi);
 477     REGISTER_ENCODER(VP9_VAAPI,         vp9_vaapi);
 478
 479     /* parsers */
 480     REGISTER_PARSER(AAC,                aac);
 481     REGISTER_PARSER(AAC_LATM,           aac_latm);
 482     REGISTER_PARSER(AC3,                ac3);
 483     REGISTER_PARSER(ADX,                adx);
 484     REGISTER_PARSER(BMP,                bmp);
 485     REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
 486     REGISTER_PARSER(COOK,               cook);
 487     REGISTER_PARSER(DCA,                dca);
 488     REGISTER_PARSER(DIRAC,              dirac);
 489     REGISTER_PARSER(DNXHD,              dnxhd);
 490     REGISTER_PARSER(DPX,                dpx);
 491     REGISTER_PARSER(DVBSUB,             dvbsub);
 492     REGISTER_PARSER(DVDSUB,             dvdsub);
 493     REGISTER_PARSER(FLAC,               flac);
 494     REGISTER_PARSER(GSM,                gsm);
 495     REGISTER_PARSER(H261,               h261);
 496     REGISTER_PARSER(H263,               h263);
 497     REGISTER_PARSER(H264,               h264);
 498     REGISTER_PARSER(HEVC,               hevc);
 499     REGISTER_PARSER(MJPEG,              mjpeg);
 500     REGISTER_PARSER(MLP,                mlp);
 501     REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
 502     REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
 503     REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
 504     REGISTER_PARSER(OPUS,               opus);
 505     REGISTER_PARSER(PNG,                png);
 506     REGISTER_PARSER(PNM,                pnm);
 507     REGISTER_PARSER(RV30,               rv30);
 508     REGISTER_PARSER(RV40,               rv40);
 509     REGISTER_PARSER(TAK,                tak);
 510     REGISTER_PARSER(VC1,                vc1);
 511     REGISTER_PARSER(VORBIS,             vorbis);
 512     REGISTER_PARSER(VP3,                vp3);
 513     REGISTER_PARSER(VP8,                vp8);
 514 }