allcodecs.c 29.3 KB
Newer Older
1
/*
2
 * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
3
 * Copyright (c) 2002 Fabrice Bellard
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * 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
 * FFmpeg is distributed in the hope that it will be useful,
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
21 22

/**
23
 * @file
24
 * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
Michael Niedermayer's avatar
Michael Niedermayer committed
25 26
 */

27
#include "config.h"
28 29
#include "avcodec.h"
#include "version.h"
30

31 32 33 34 35 36
#define REGISTER_HWACCEL(X, x)                                          \
    {                                                                   \
        extern AVHWAccel ff_##x##_hwaccel;                              \
        if (CONFIG_##X##_HWACCEL)                                       \
            av_register_hwaccel(&ff_##x##_hwaccel);                     \
    }
37

38 39 40 41 42 43
#define REGISTER_ENCODER(X, x)                                          \
    {                                                                   \
        extern AVCodec ff_##x##_encoder;                                \
        if (CONFIG_##X##_ENCODER)                                       \
            avcodec_register(&ff_##x##_encoder);                        \
    }
44

45 46 47 48 49 50 51
#define REGISTER_DECODER(X, x)                                          \
    {                                                                   \
        extern AVCodec ff_##x##_decoder;                                \
        if (CONFIG_##X##_DECODER)                                       \
            avcodec_register(&ff_##x##_decoder);                        \
    }

52
#define REGISTER_ENCDEC(X, x) REGISTER_ENCODER(X, x); REGISTER_DECODER(X, x)
53 54 55 56 57 58 59 60 61 62 63 64 65 66

#define REGISTER_PARSER(X, x)                                           \
    {                                                                   \
        extern AVCodecParser ff_##x##_parser;                           \
        if (CONFIG_##X##_PARSER)                                        \
            av_register_codec_parser(&ff_##x##_parser);                 \
    }

#define REGISTER_BSF(X, x)                                              \
    {                                                                   \
        extern AVBitStreamFilter ff_##x##_bsf;                          \
        if (CONFIG_##X##_BSF)                                           \
            av_register_bitstream_filter(&ff_##x##_bsf);                \
    }
67

68 69
void avcodec_register_all(void)
{
70
    static int initialized;
71

72
    if (initialized)
73
        return;
74
    initialized = 1;
75

76
    /* hardware accelerators */
77
    REGISTER_HWACCEL(H263_VAAPI,        h263_vaapi);
78
    REGISTER_HWACCEL(H263_VDPAU,        h263_vdpau);
79
    REGISTER_HWACCEL(H264_D3D11VA,      h264_d3d11va);
80
    REGISTER_HWACCEL(H264_DXVA2,        h264_dxva2);
81
    REGISTER_HWACCEL(H264_MMAL,         h264_mmal);
82
    REGISTER_HWACCEL(H264_QSV,          h264_qsv);
83 84
    REGISTER_HWACCEL(H264_VAAPI,        h264_vaapi);
    REGISTER_HWACCEL(H264_VDA,          h264_vda);
85
    REGISTER_HWACCEL(H264_VDA_OLD,      h264_vda_old);
86
    REGISTER_HWACCEL(H264_VDPAU,        h264_vdpau);
87
    REGISTER_HWACCEL(HEVC_D3D11VA,      hevc_d3d11va);
88
    REGISTER_HWACCEL(HEVC_DXVA2,        hevc_dxva2);
89
    REGISTER_HWACCEL(HEVC_VDPAU,        hevc_vdpau);
90
    REGISTER_HWACCEL(MPEG1_XVMC,        mpeg1_xvmc);
91
    REGISTER_HWACCEL(MPEG1_VDPAU,       mpeg1_vdpau);
92
    REGISTER_HWACCEL(MPEG2_XVMC,        mpeg2_xvmc);
93
    REGISTER_HWACCEL(MPEG2_D3D11VA,     mpeg2_d3d11va);
94 95
    REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
    REGISTER_HWACCEL(MPEG2_VAAPI,       mpeg2_vaapi);
96
    REGISTER_HWACCEL(MPEG2_VDPAU,       mpeg2_vdpau);
97
    REGISTER_HWACCEL(MPEG4_VAAPI,       mpeg4_vaapi);
98
    REGISTER_HWACCEL(MPEG4_VDPAU,       mpeg4_vdpau);
99
    REGISTER_HWACCEL(VC1_D3D11VA,       vc1_d3d11va);
100 101
    REGISTER_HWACCEL(VC1_DXVA2,         vc1_dxva2);
    REGISTER_HWACCEL(VC1_VAAPI,         vc1_vaapi);
102
    REGISTER_HWACCEL(VC1_VDPAU,         vc1_vdpau);
103
    REGISTER_HWACCEL(WMV3_D3D11VA,      wmv3_d3d11va);
104 105
    REGISTER_HWACCEL(WMV3_DXVA2,        wmv3_dxva2);
    REGISTER_HWACCEL(WMV3_VAAPI,        wmv3_vaapi);
106
    REGISTER_HWACCEL(WMV3_VDPAU,        wmv3_vdpau);
107

108
    /* video codecs */
109 110 111
    REGISTER_ENCODER(A64MULTI,          a64multi);
    REGISTER_ENCODER(A64MULTI5,         a64multi5);
    REGISTER_DECODER(AASC,              aasc);
112
    REGISTER_DECODER(AIC,               aic);
113
    REGISTER_ENCDEC (ALIAS_PIX,         alias_pix);
114
    REGISTER_ENCDEC (AMV,               amv);
115 116
    REGISTER_DECODER(ANM,               anm);
    REGISTER_DECODER(ANSI,              ansi);
117
    REGISTER_ENCDEC (APNG,              apng);
118 119 120 121
    REGISTER_ENCDEC (ASV1,              asv1);
    REGISTER_ENCDEC (ASV2,              asv2);
    REGISTER_DECODER(AURA,              aura);
    REGISTER_DECODER(AURA2,             aura2);
122 123
    REGISTER_ENCDEC (AVRP,              avrp);
    REGISTER_DECODER(AVRN,              avrn);
124
    REGISTER_DECODER(AVS,               avs);
125 126
    REGISTER_ENCDEC (AVUI,              avui);
    REGISTER_ENCDEC (AYUV,              ayuv);
127 128 129 130 131
    REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
    REGISTER_DECODER(BFI,               bfi);
    REGISTER_DECODER(BINK,              bink);
    REGISTER_ENCDEC (BMP,               bmp);
    REGISTER_DECODER(BMV_VIDEO,         bmv_video);
132
    REGISTER_DECODER(BRENDER_PIX,       brender_pix);
133 134 135 136
    REGISTER_DECODER(C93,               c93);
    REGISTER_DECODER(CAVS,              cavs);
    REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
    REGISTER_DECODER(CDXL,              cdxl);
Tomas Härdin's avatar
Tomas Härdin committed
137
    REGISTER_ENCDEC (CINEPAK,           cinepak);
138 139 140
    REGISTER_ENCDEC (CLJR,              cljr);
    REGISTER_DECODER(CLLC,              cllc);
    REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
141
    REGISTER_DECODER(CPIA,              cpia);
142 143
    REGISTER_DECODER(CSCD,              cscd);
    REGISTER_DECODER(CYUV,              cyuv);
144
    REGISTER_DECODER(DDS,               dds);
145
    REGISTER_DECODER(DFA,               dfa);
146
    REGISTER_DECODER(DIRAC,             dirac);
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
    REGISTER_ENCDEC (DNXHD,             dnxhd);
    REGISTER_ENCDEC (DPX,               dpx);
    REGISTER_DECODER(DSICINVIDEO,       dsicinvideo);
    REGISTER_ENCDEC (DVVIDEO,           dvvideo);
    REGISTER_DECODER(DXA,               dxa);
    REGISTER_DECODER(DXTORY,            dxtory);
    REGISTER_DECODER(EACMV,             eacmv);
    REGISTER_DECODER(EAMAD,             eamad);
    REGISTER_DECODER(EATGQ,             eatgq);
    REGISTER_DECODER(EATGV,             eatgv);
    REGISTER_DECODER(EATQI,             eatqi);
    REGISTER_DECODER(EIGHTBPS,          eightbps);
    REGISTER_DECODER(EIGHTSVX_EXP,      eightsvx_exp);
    REGISTER_DECODER(EIGHTSVX_FIB,      eightsvx_fib);
    REGISTER_DECODER(ESCAPE124,         escape124);
162 163
    REGISTER_DECODER(ESCAPE130,         escape130);
    REGISTER_DECODER(EXR,               exr);
164 165
    REGISTER_ENCDEC (FFV1,              ffv1);
    REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
166
    REGISTER_DECODER(FIC,               fic);
167
    REGISTER_ENCDEC (FLASHSV,           flashsv);
168
    REGISTER_ENCDEC (FLASHSV2,          flashsv2);
169 170 171 172 173
    REGISTER_DECODER(FLIC,              flic);
    REGISTER_ENCDEC (FLV,               flv);
    REGISTER_DECODER(FOURXM,            fourxm);
    REGISTER_DECODER(FRAPS,             fraps);
    REGISTER_DECODER(FRWU,              frwu);
Kostya Shishkov's avatar
Kostya Shishkov committed
174
    REGISTER_DECODER(G2M,               g2m);
175 176 177 178
    REGISTER_ENCDEC (GIF,               gif);
    REGISTER_ENCDEC (H261,              h261);
    REGISTER_ENCDEC (H263,              h263);
    REGISTER_DECODER(H263I,             h263i);
179
    REGISTER_ENCDEC (H263P,             h263p);
180
    REGISTER_DECODER(H264,              h264);
181
    REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);
182
    REGISTER_DECODER(H264_MMAL,         h264_mmal);
183
    REGISTER_DECODER(H264_QSV,          h264_qsv);
184
    REGISTER_DECODER(H264_VDA,          h264_vda);
185
    REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
186
    REGISTER_ENCDEC (HAP,               hap);
187
    REGISTER_DECODER(HEVC,              hevc);
188
    REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);
189
    REGISTER_DECODER(HQ_HQA,            hq_hqa);
Vittorio Giovara's avatar
Vittorio Giovara committed
190
    REGISTER_DECODER(HQX,               hqx);
191 192 193 194 195 196 197 198 199
    REGISTER_ENCDEC (HUFFYUV,           huffyuv);
    REGISTER_DECODER(IDCIN,             idcin);
    REGISTER_DECODER(IFF_BYTERUN1,      iff_byterun1);
    REGISTER_DECODER(IFF_ILBM,          iff_ilbm);
    REGISTER_DECODER(INDEO2,            indeo2);
    REGISTER_DECODER(INDEO3,            indeo3);
    REGISTER_DECODER(INDEO4,            indeo4);
    REGISTER_DECODER(INDEO5,            indeo5);
    REGISTER_DECODER(INTERPLAY_VIDEO,   interplay_video);
200
    REGISTER_ENCDEC (JPEG2000,          jpeg2000);
201 202 203 204 205 206 207 208 209 210 211 212 213
    REGISTER_ENCDEC (JPEGLS,            jpegls);
    REGISTER_DECODER(JV,                jv);
    REGISTER_DECODER(KGV1,              kgv1);
    REGISTER_DECODER(KMVC,              kmvc);
    REGISTER_DECODER(LAGARITH,          lagarith);
    REGISTER_ENCODER(LJPEG,             ljpeg);
    REGISTER_DECODER(LOCO,              loco);
    REGISTER_DECODER(MDEC,              mdec);
    REGISTER_DECODER(MIMIC,             mimic);
    REGISTER_ENCDEC (MJPEG,             mjpeg);
    REGISTER_DECODER(MJPEGB,            mjpegb);
    REGISTER_DECODER(MMVIDEO,           mmvideo);
    REGISTER_DECODER(MOTIONPIXELS,      motionpixels);
214
#if FF_API_XVMC
215
    REGISTER_DECODER(MPEG_XVMC,         mpeg_xvmc);
216
#endif /* FF_API_XVMC */
217 218 219
    REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
    REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
    REGISTER_ENCDEC (MPEG4,             mpeg4);
220
    REGISTER_DECODER(MPEG4_CRYSTALHD,   mpeg4_crystalhd);
221
    REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);
222
    REGISTER_DECODER(MPEGVIDEO,         mpegvideo);
223 224
    REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);
    REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);
225
    REGISTER_DECODER(MPEG2_CRYSTALHD,   mpeg2_crystalhd);
226
    REGISTER_DECODER(MSA1,              msa1);
227
    REGISTER_DECODER(MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
228 229 230 231 232 233
    REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
    REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
    REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
    REGISTER_DECODER(MSRLE,             msrle);
    REGISTER_DECODER(MSS1,              mss1);
    REGISTER_DECODER(MSS2,              mss2);
234
    REGISTER_ENCDEC (MSVIDEO1,          msvideo1);
235 236
    REGISTER_DECODER(MSZH,              mszh);
    REGISTER_DECODER(MTS2,              mts2);
237 238
    REGISTER_DECODER(MVC1,              mvc1);
    REGISTER_DECODER(MVC2,              mvc2);
239 240
    REGISTER_DECODER(MXPEG,             mxpeg);
    REGISTER_DECODER(NUV,               nuv);
241
    REGISTER_DECODER(PAF_VIDEO,         paf_video);
242 243 244 245 246 247 248 249 250
    REGISTER_ENCDEC (PAM,               pam);
    REGISTER_ENCDEC (PBM,               pbm);
    REGISTER_ENCDEC (PCX,               pcx);
    REGISTER_ENCDEC (PGM,               pgm);
    REGISTER_ENCDEC (PGMYUV,            pgmyuv);
    REGISTER_DECODER(PICTOR,            pictor);
    REGISTER_ENCDEC (PNG,               png);
    REGISTER_ENCDEC (PPM,               ppm);
    REGISTER_ENCDEC (PRORES,            prores);
251 252
    REGISTER_ENCODER(PRORES_AW,         prores_aw);
    REGISTER_ENCODER(PRORES_KS,         prores_ks);
253
    REGISTER_DECODER(PRORES_LGPL,       prores_lgpl);
254 255 256 257
    REGISTER_DECODER(PTX,               ptx);
    REGISTER_DECODER(QDRAW,             qdraw);
    REGISTER_DECODER(QPEG,              qpeg);
    REGISTER_ENCDEC (QTRLE,             qtrle);
258 259
    REGISTER_ENCDEC (R10K,              r10k);
    REGISTER_ENCDEC (R210,              r210);
260 261 262 263 264 265 266 267
    REGISTER_ENCDEC (RAWVIDEO,          rawvideo);
    REGISTER_DECODER(RL2,               rl2);
    REGISTER_ENCDEC (ROQ,               roq);
    REGISTER_DECODER(RPZA,              rpza);
    REGISTER_ENCDEC (RV10,              rv10);
    REGISTER_ENCDEC (RV20,              rv20);
    REGISTER_DECODER(RV30,              rv30);
    REGISTER_DECODER(RV40,              rv40);
Darryl Wallace's avatar
Darryl Wallace committed
268
    REGISTER_ENCDEC (S302M,             s302m);
269
    REGISTER_DECODER(SANM,              sanm);
270
    REGISTER_ENCDEC (SGI,               sgi);
271
    REGISTER_DECODER(SGIRLE,            sgirle);
272 273
    REGISTER_DECODER(SMACKER,           smacker);
    REGISTER_DECODER(SMC,               smc);
Ash Hughes's avatar
Ash Hughes committed
274
    REGISTER_DECODER(SMVJPEG,           smvjpeg);
275 276 277 278 279 280
    REGISTER_ENCDEC (SNOW,              snow);
    REGISTER_DECODER(SP5X,              sp5x);
    REGISTER_ENCDEC (SUNRAST,           sunrast);
    REGISTER_ENCDEC (SVQ1,              svq1);
    REGISTER_DECODER(SVQ3,              svq3);
    REGISTER_ENCDEC (TARGA,             targa);
281
    REGISTER_DECODER(TARGA_Y216,        targa_y216);
Vittorio Giovara's avatar
Vittorio Giovara committed
282
    REGISTER_DECODER(TDSC,              tdsc);
283 284 285 286 287 288 289 290 291 292 293 294 295 296
    REGISTER_DECODER(THEORA,            theora);
    REGISTER_DECODER(THP,               thp);
    REGISTER_DECODER(TIERTEXSEQVIDEO,   tiertexseqvideo);
    REGISTER_ENCDEC (TIFF,              tiff);
    REGISTER_DECODER(TMV,               tmv);
    REGISTER_DECODER(TRUEMOTION1,       truemotion1);
    REGISTER_DECODER(TRUEMOTION2,       truemotion2);
    REGISTER_DECODER(TSCC,              tscc);
    REGISTER_DECODER(TSCC2,             tscc2);
    REGISTER_DECODER(TXD,               txd);
    REGISTER_DECODER(ULTI,              ulti);
    REGISTER_ENCDEC (UTVIDEO,           utvideo);
    REGISTER_ENCDEC (V210,              v210);
    REGISTER_DECODER(V210X,             v210x);
297 298
    REGISTER_ENCDEC (V308,              v308);
    REGISTER_ENCDEC (V408,              v408);
299 300 301 302
    REGISTER_ENCDEC (V410,              v410);
    REGISTER_DECODER(VB,                vb);
    REGISTER_DECODER(VBLE,              vble);
    REGISTER_DECODER(VC1,               vc1);
303
    REGISTER_DECODER(VC1_CRYSTALHD,     vc1_crystalhd);
304
    REGISTER_DECODER(VC1_VDPAU,         vc1_vdpau);
305 306 307 308 309 310 311 312 313
    REGISTER_DECODER(VC1IMAGE,          vc1image);
    REGISTER_DECODER(VCR1,              vcr1);
    REGISTER_DECODER(VMDVIDEO,          vmdvideo);
    REGISTER_DECODER(VMNC,              vmnc);
    REGISTER_DECODER(VP3,               vp3);
    REGISTER_DECODER(VP5,               vp5);
    REGISTER_DECODER(VP6,               vp6);
    REGISTER_DECODER(VP6A,              vp6a);
    REGISTER_DECODER(VP6F,              vp6f);
Peter Ross's avatar
Peter Ross committed
314
    REGISTER_DECODER(VP7,               vp7);
315
    REGISTER_DECODER(VP8,               vp8);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
316
    REGISTER_DECODER(VP9,               vp9);
317
    REGISTER_DECODER(VQA,               vqa);
318
    REGISTER_DECODER(WEBP,              webp);
319 320 321
    REGISTER_ENCDEC (WMV1,              wmv1);
    REGISTER_ENCDEC (WMV2,              wmv2);
    REGISTER_DECODER(WMV3,              wmv3);
322
    REGISTER_DECODER(WMV3_CRYSTALHD,    wmv3_crystalhd);
323
    REGISTER_DECODER(WMV3_VDPAU,        wmv3_vdpau);
324 325 326 327
    REGISTER_DECODER(WMV3IMAGE,         wmv3image);
    REGISTER_DECODER(WNV1,              wnv1);
    REGISTER_DECODER(XAN_WC3,           xan_wc3);
    REGISTER_DECODER(XAN_WC4,           xan_wc4);
328 329
    REGISTER_ENCDEC (XBM,               xbm);
    REGISTER_ENCDEC (XFACE,             xface);
330 331
    REGISTER_DECODER(XL,                xl);
    REGISTER_ENCDEC (XWD,               xwd);
332
    REGISTER_ENCDEC (Y41P,              y41p);
333
    REGISTER_DECODER(YOP,               yop);
334
    REGISTER_ENCDEC (YUV4,              yuv4);
Carl Eugen Hoyos's avatar
Carl Eugen Hoyos committed
335
    REGISTER_DECODER(ZERO12V,           zero12v);
336 337 338
    REGISTER_DECODER(ZEROCODEC,         zerocodec);
    REGISTER_ENCDEC (ZLIB,              zlib);
    REGISTER_ENCDEC (ZMBV,              zmbv);
339

340
    /* audio codecs */
341
    REGISTER_ENCDEC (AAC,               aac);
342
    REGISTER_DECODER(AAC_FIXED,         aac_fixed);
343 344
    REGISTER_DECODER(AAC_LATM,          aac_latm);
    REGISTER_ENCDEC (AC3,               ac3);
345
    REGISTER_ENCDEC (AC3_FIXED,         ac3_fixed);
346 347 348 349 350 351 352
    REGISTER_ENCDEC (ALAC,              alac);
    REGISTER_DECODER(ALS,               als);
    REGISTER_DECODER(AMRNB,             amrnb);
    REGISTER_DECODER(AMRWB,             amrwb);
    REGISTER_DECODER(APE,               ape);
    REGISTER_DECODER(ATRAC1,            atrac1);
    REGISTER_DECODER(ATRAC3,            atrac3);
Maxim Poliakovski's avatar
Maxim Poliakovski committed
353
    REGISTER_DECODER(ATRAC3P,           atrac3p);
354 355 356 357
    REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
    REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
    REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
    REGISTER_DECODER(COOK,              cook);
358
    REGISTER_ENCDEC (DCA,               dca);
359 360 361 362
    REGISTER_DECODER(DSD_LSBF,          dsd_lsbf);
    REGISTER_DECODER(DSD_MSBF,          dsd_msbf);
    REGISTER_DECODER(DSD_LSBF_PLANAR,   dsd_lsbf_planar);
    REGISTER_DECODER(DSD_MSBF_PLANAR,   dsd_msbf_planar);
363
    REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
364
    REGISTER_DECODER(DSS_SP,            dss_sp);
365
    REGISTER_ENCDEC (EAC3,              eac3);
Paul B Mahol's avatar
Paul B Mahol committed
366
    REGISTER_DECODER(EVRC,              evrc);
367
    REGISTER_DECODER(FFWAVESYNTH,       ffwavesynth);
368
    REGISTER_ENCDEC (FLAC,              flac);
369 370
    REGISTER_ENCDEC (G723_1,            g723_1);
    REGISTER_DECODER(G729,              g729);
371 372 373 374 375 376
    REGISTER_DECODER(GSM,               gsm);
    REGISTER_DECODER(GSM_MS,            gsm_ms);
    REGISTER_DECODER(IAC,               iac);
    REGISTER_DECODER(IMC,               imc);
    REGISTER_DECODER(MACE3,             mace3);
    REGISTER_DECODER(MACE6,             mace6);
377
    REGISTER_DECODER(METASOUND,         metasound);
378 379 380 381 382
    REGISTER_DECODER(MLP,               mlp);
    REGISTER_DECODER(MP1,               mp1);
    REGISTER_DECODER(MP1FLOAT,          mp1float);
    REGISTER_ENCDEC (MP2,               mp2);
    REGISTER_DECODER(MP2FLOAT,          mp2float);
383
    REGISTER_ENCODER(MP2FIXED,          mp2fixed);
384 385 386 387 388 389 390 391 392
    REGISTER_DECODER(MP3,               mp3);
    REGISTER_DECODER(MP3FLOAT,          mp3float);
    REGISTER_DECODER(MP3ADU,            mp3adu);
    REGISTER_DECODER(MP3ADUFLOAT,       mp3adufloat);
    REGISTER_DECODER(MP3ON4,            mp3on4);
    REGISTER_DECODER(MP3ON4FLOAT,       mp3on4float);
    REGISTER_DECODER(MPC7,              mpc7);
    REGISTER_DECODER(MPC8,              mpc8);
    REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
Kostya Shishkov's avatar
Kostya Shishkov committed
393
    REGISTER_DECODER(ON2AVC,            on2avc);
394
    REGISTER_DECODER(OPUS,              opus);
395
    REGISTER_DECODER(PAF_AUDIO,         paf_audio);
396 397 398 399 400 401 402 403
    REGISTER_DECODER(QCELP,             qcelp);
    REGISTER_DECODER(QDM2,              qdm2);
    REGISTER_ENCDEC (RA_144,            ra_144);
    REGISTER_DECODER(RA_288,            ra_288);
    REGISTER_DECODER(RALF,              ralf);
    REGISTER_DECODER(SHORTEN,           shorten);
    REGISTER_DECODER(SIPR,              sipr);
    REGISTER_DECODER(SMACKAUD,          smackaud);
404 405
    REGISTER_ENCDEC (SONIC,             sonic);
    REGISTER_ENCODER(SONIC_LS,          sonic_ls);
406 407 408
    REGISTER_DECODER(TAK,               tak);
    REGISTER_DECODER(TRUEHD,            truehd);
    REGISTER_DECODER(TRUESPEECH,        truespeech);
Paul B Mahol's avatar
Paul B Mahol committed
409
    REGISTER_ENCDEC (TTA,               tta);
410 411 412
    REGISTER_DECODER(TWINVQ,            twinvq);
    REGISTER_DECODER(VMDAUDIO,          vmdaudio);
    REGISTER_ENCDEC (VORBIS,            vorbis);
Paul B Mahol's avatar
Paul B Mahol committed
413
    REGISTER_ENCDEC (WAVPACK,           wavpack);
414 415 416 417 418 419
    REGISTER_DECODER(WMALOSSLESS,       wmalossless);
    REGISTER_DECODER(WMAPRO,            wmapro);
    REGISTER_ENCDEC (WMAV1,             wmav1);
    REGISTER_ENCDEC (WMAV2,             wmav2);
    REGISTER_DECODER(WMAVOICE,          wmavoice);
    REGISTER_DECODER(WS_SND1,           ws_snd1);
420

Diego Biurrun's avatar
Diego Biurrun committed
421
    /* PCM codecs */
422 423 424 425 426 427 428 429 430 431
    REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
    REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
    REGISTER_DECODER(PCM_DVD,           pcm_dvd);
    REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
    REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
    REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
    REGISTER_ENCDEC (PCM_F64LE,         pcm_f64le);
    REGISTER_DECODER(PCM_LXF,           pcm_lxf);
    REGISTER_ENCDEC (PCM_MULAW,         pcm_mulaw);
    REGISTER_ENCDEC (PCM_S8,            pcm_s8);
432
    REGISTER_ENCDEC (PCM_S8_PLANAR,     pcm_s8_planar);
433
    REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
434
    REGISTER_ENCDEC (PCM_S16BE_PLANAR,  pcm_s16be_planar);
435
    REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
436
    REGISTER_ENCDEC (PCM_S16LE_PLANAR,  pcm_s16le_planar);
437 438 439
    REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
    REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
    REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
440
    REGISTER_ENCDEC (PCM_S24LE_PLANAR,  pcm_s24le_planar);
441 442
    REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
    REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
443
    REGISTER_ENCDEC (PCM_S32LE_PLANAR,  pcm_s32le_planar);
444 445 446 447 448 449 450
    REGISTER_ENCDEC (PCM_U8,            pcm_u8);
    REGISTER_ENCDEC (PCM_U16BE,         pcm_u16be);
    REGISTER_ENCDEC (PCM_U16LE,         pcm_u16le);
    REGISTER_ENCDEC (PCM_U24BE,         pcm_u24be);
    REGISTER_ENCDEC (PCM_U24LE,         pcm_u24le);
    REGISTER_ENCDEC (PCM_U32BE,         pcm_u32be);
    REGISTER_ENCDEC (PCM_U32LE,         pcm_u32le);
451
    REGISTER_DECODER(PCM_ZORK,          pcm_zork);
452

Diego Biurrun's avatar
Diego Biurrun committed
453
    /* DPCM codecs */
454 455 456 457
    REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
    REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
    REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
    REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
458

Diego Biurrun's avatar
Diego Biurrun committed
459
    /* ADPCM codecs */
460 461
    REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
    REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
462
    REGISTER_DECODER(ADPCM_AFC,         adpcm_afc);
463
    REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
James Almer's avatar
James Almer committed
464
    REGISTER_DECODER(ADPCM_DTK,         adpcm_dtk);
465 466 467 468 469 470 471 472
    REGISTER_DECODER(ADPCM_EA,          adpcm_ea);
    REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
    REGISTER_DECODER(ADPCM_EA_R1,       adpcm_ea_r1);
    REGISTER_DECODER(ADPCM_EA_R2,       adpcm_ea_r2);
    REGISTER_DECODER(ADPCM_EA_R3,       adpcm_ea_r3);
    REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
    REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
    REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
473
    REGISTER_DECODER(ADPCM_G726LE,      adpcm_g726le);
474 475 476 477 478 479 480
    REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
    REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
    REGISTER_DECODER(ADPCM_IMA_DK3,     adpcm_ima_dk3);
    REGISTER_DECODER(ADPCM_IMA_DK4,     adpcm_ima_dk4);
    REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
    REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
    REGISTER_DECODER(ADPCM_IMA_ISS,     adpcm_ima_iss);
481
    REGISTER_DECODER(ADPCM_IMA_OKI,     adpcm_ima_oki);
482
    REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
James Almer's avatar
James Almer committed
483
    REGISTER_DECODER(ADPCM_IMA_RAD,     adpcm_ima_rad);
484 485 486 487 488 489 490 491 492
    REGISTER_DECODER(ADPCM_IMA_SMJPEG,  adpcm_ima_smjpeg);
    REGISTER_ENCDEC (ADPCM_IMA_WAV,     adpcm_ima_wav);
    REGISTER_DECODER(ADPCM_IMA_WS,      adpcm_ima_ws);
    REGISTER_ENCDEC (ADPCM_MS,          adpcm_ms);
    REGISTER_DECODER(ADPCM_SBPRO_2,     adpcm_sbpro_2);
    REGISTER_DECODER(ADPCM_SBPRO_3,     adpcm_sbpro_3);
    REGISTER_DECODER(ADPCM_SBPRO_4,     adpcm_sbpro_4);
    REGISTER_ENCDEC (ADPCM_SWF,         adpcm_swf);
    REGISTER_DECODER(ADPCM_THP,         adpcm_thp);
493
    REGISTER_DECODER(ADPCM_THP_LE,      adpcm_thp_le);
494
    REGISTER_DECODER(ADPCM_VIMA,        adpcm_vima);
495 496
    REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
    REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
497
#if FF_API_VIMA_DECODER
498
    REGISTER_DECODER(VIMA,              vima);
499
#endif
500

501
    /* subtitles */
502
    REGISTER_ENCDEC (SSA,               ssa);
503
    REGISTER_ENCDEC (ASS,               ass);
504
    REGISTER_DECODER(CCAPTION,          ccaption);
505 506
    REGISTER_ENCDEC (DVBSUB,            dvbsub);
    REGISTER_ENCDEC (DVDSUB,            dvdsub);
507 508 509
    REGISTER_DECODER(JACOSUB,           jacosub);
    REGISTER_DECODER(MICRODVD,          microdvd);
    REGISTER_ENCDEC (MOVTEXT,           movtext);
510
    REGISTER_DECODER(MPL2,              mpl2);
511
    REGISTER_DECODER(PGSSUB,            pgssub);
512
    REGISTER_DECODER(PJS,               pjs);
513 514 515
    REGISTER_DECODER(REALTEXT,          realtext);
    REGISTER_DECODER(SAMI,              sami);
    REGISTER_ENCDEC (SRT,               srt);
516
    REGISTER_DECODER(STL,               stl);
517 518
    REGISTER_ENCDEC (SUBRIP,            subrip);
    REGISTER_DECODER(SUBVIEWER,         subviewer);
519
    REGISTER_DECODER(SUBVIEWER1,        subviewer1);
520
    REGISTER_DECODER(TEXT,              text);
521
    REGISTER_DECODER(VPLAYER,           vplayer);
522
    REGISTER_ENCDEC (WEBVTT,            webvtt);
523
    REGISTER_ENCDEC (XSUB,              xsub);
524

525
    /* external libraries */
526
    REGISTER_DECODER(LIBCELT,           libcelt);
527
    REGISTER_DECODER(LIBDCADEC,         libdcadec)
528
    REGISTER_ENCODER(LIBFAAC,           libfaac);
529
    REGISTER_ENCDEC (LIBFDK_AAC,        libfdk_aac);
530 531 532 533 534 535 536 537 538
    REGISTER_ENCDEC (LIBGSM,            libgsm);
    REGISTER_ENCDEC (LIBGSM_MS,         libgsm_ms);
    REGISTER_ENCDEC (LIBILBC,           libilbc);
    REGISTER_ENCODER(LIBMP3LAME,        libmp3lame);
    REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
    REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
    REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
    REGISTER_ENCDEC (LIBOPUS,           libopus);
    REGISTER_ENCDEC (LIBSCHROEDINGER,   libschroedinger);
539
    REGISTER_ENCODER(LIBSHINE,          libshine);
540
    REGISTER_ENCDEC (LIBSPEEX,          libspeex);
541
    REGISTER_DECODER(LIBSTAGEFRIGHT_H264, libstagefright_h264);
542
    REGISTER_ENCODER(LIBTHEORA,         libtheora);
543 544
    REGISTER_ENCODER(LIBTWOLAME,        libtwolame);
    REGISTER_ENCDEC (LIBUTVIDEO,        libutvideo);
545 546
    REGISTER_ENCODER(LIBVO_AACENC,      libvo_aacenc);
    REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
547
    REGISTER_ENCDEC (LIBVORBIS,         libvorbis);
548 549
    REGISTER_ENCDEC (LIBVPX_VP8,        libvpx_vp8);
    REGISTER_ENCDEC (LIBVPX_VP9,        libvpx_vp9);
550
    REGISTER_ENCODER(LIBWAVPACK,        libwavpack);
551
    REGISTER_ENCODER(LIBWEBP_ANIM,      libwebp_anim);  /* preferred over libwebp */
Justin Ruggles's avatar
Justin Ruggles committed
552
    REGISTER_ENCODER(LIBWEBP,           libwebp);
553
    REGISTER_ENCODER(LIBX264,           libx264);
554
    REGISTER_ENCODER(LIBX264RGB,        libx264rgb);
Derek Buitenhuis's avatar
Derek Buitenhuis committed
555
    REGISTER_ENCODER(LIBX265,           libx265);
556 557
    REGISTER_ENCODER(LIBXAVS,           libxavs);
    REGISTER_ENCODER(LIBXVID,           libxvid);
558
    REGISTER_DECODER(LIBZVBI_TELETEXT,  libzvbi_teletext);
559
    REGISTER_ENCODER(LIBAACPLUS,        libaacplus);
560

Peter Ross's avatar
Peter Ross committed
561
    /* text */
562 563 564
    REGISTER_DECODER(BINTEXT,           bintext);
    REGISTER_DECODER(XBIN,              xbin);
    REGISTER_DECODER(IDF,               idf);
Peter Ross's avatar
Peter Ross committed
565

566 567 568
    /* external libraries, that shouldn't be used by default if one of the
     * above is available */
    REGISTER_ENCODER(LIBOPENH264,       libopenh264);
569
    REGISTER_ENCODER(H264_QSV,          h264_qsv);
570 571 572
    REGISTER_ENCODER(NVENC,             nvenc);
    REGISTER_ENCODER(NVENC_H264,        nvenc_h264);
    REGISTER_ENCODER(NVENC_HEVC,        nvenc_hevc);
573
    REGISTER_ENCODER(HEVC_QSV,          hevc_qsv);
574
    REGISTER_ENCODER(LIBKVAZAAR,        libkvazaar);
575
    REGISTER_ENCODER(MPEG2_QSV,         mpeg2_qsv);
576

577
    /* parsers */
578 579 580 581
    REGISTER_PARSER(AAC,                aac);
    REGISTER_PARSER(AAC_LATM,           aac_latm);
    REGISTER_PARSER(AC3,                ac3);
    REGISTER_PARSER(ADX,                adx);
582
    REGISTER_PARSER(BMP,                bmp);
583 584 585 586 587
    REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
    REGISTER_PARSER(COOK,               cook);
    REGISTER_PARSER(DCA,                dca);
    REGISTER_PARSER(DIRAC,              dirac);
    REGISTER_PARSER(DNXHD,              dnxhd);
Paul B Mahol's avatar
Paul B Mahol committed
588
    REGISTER_PARSER(DPX,                dpx);
589 590
    REGISTER_PARSER(DVBSUB,             dvbsub);
    REGISTER_PARSER(DVDSUB,             dvdsub);
591
    REGISTER_PARSER(DVD_NAV,            dvd_nav);
592 593 594 595 596
    REGISTER_PARSER(FLAC,               flac);
    REGISTER_PARSER(GSM,                gsm);
    REGISTER_PARSER(H261,               h261);
    REGISTER_PARSER(H263,               h263);
    REGISTER_PARSER(H264,               h264);
597
    REGISTER_PARSER(HEVC,               hevc);
598 599 600 601 602
    REGISTER_PARSER(MJPEG,              mjpeg);
    REGISTER_PARSER(MLP,                mlp);
    REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
    REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
    REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
603
    REGISTER_PARSER(OPUS,               opus);
604
    REGISTER_PARSER(PNG,                png);
605 606 607 608 609 610 611 612
    REGISTER_PARSER(PNM,                pnm);
    REGISTER_PARSER(RV30,               rv30);
    REGISTER_PARSER(RV40,               rv40);
    REGISTER_PARSER(TAK,                tak);
    REGISTER_PARSER(VC1,                vc1);
    REGISTER_PARSER(VORBIS,             vorbis);
    REGISTER_PARSER(VP3,                vp3);
    REGISTER_PARSER(VP8,                vp8);
613
    REGISTER_PARSER(VP9,                vp9);
614

615
    /* bitstream filters */
616 617 618 619 620 621 622 623
    REGISTER_BSF(AAC_ADTSTOASC,         aac_adtstoasc);
    REGISTER_BSF(CHOMP,                 chomp);
    REGISTER_BSF(DUMP_EXTRADATA,        dump_extradata);
    REGISTER_BSF(H264_MP4TOANNEXB,      h264_mp4toannexb);
    REGISTER_BSF(IMX_DUMP_HEADER,       imx_dump_header);
    REGISTER_BSF(MJPEG2JPEG,            mjpeg2jpeg);
    REGISTER_BSF(MJPEGA_DUMP_HEADER,    mjpega_dump_header);
    REGISTER_BSF(MP3_HEADER_DECOMPRESS, mp3_header_decompress);
624
    REGISTER_BSF(MPEG4_UNPACK_BFRAMES,  mpeg4_unpack_bframes);
625 626 627 628
    REGISTER_BSF(MOV2TEXTSUB,           mov2textsub);
    REGISTER_BSF(NOISE,                 noise);
    REGISTER_BSF(REMOVE_EXTRADATA,      remove_extradata);
    REGISTER_BSF(TEXT2MOVSUB,           text2movsub);
629
}