0bb9976f74f9785d884425fe8646bc173717962c
[ffmpeg.git] / 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 "avcodec.h"
28 #include "config.h"
29
30 #define REGISTER_HWACCEL(X, x)                                          \
31     {                                                                   \
32         extern AVHWAccel ff_##x##_hwaccel;                              \
33         if (CONFIG_##X##_HWACCEL)                                       \
34             av_register_hwaccel(&ff_##x##_hwaccel);                     \
35     }
36
37 #define REGISTER_ENCODER(X, x)                                          \
38     {                                                                   \
39         extern AVCodec ff_##x##_encoder;                                \
40         if (CONFIG_##X##_ENCODER)                                       \
41             avcodec_register(&ff_##x##_encoder);                        \
42     }
43
44 #define REGISTER_DECODER(X, x)                                          \
45     {                                                                   \
46         extern AVCodec ff_##x##_decoder;                                \
47         if (CONFIG_##X##_DECODER)                                       \
48             avcodec_register(&ff_##x##_decoder);                        \
49     }
50
51 #define REGISTER_ENCDEC(X, x) REGISTER_ENCODER(X, x); REGISTER_DECODER(X, x)
52
53 #define REGISTER_PARSER(X, x)                                           \
54     {                                                                   \
55         extern AVCodecParser ff_##x##_parser;                           \
56         if (CONFIG_##X##_PARSER)                                        \
57             av_register_codec_parser(&ff_##x##_parser);                 \
58     }
59
60 #define REGISTER_BSF(X, x)                                              \
61     {                                                                   \
62         extern AVBitStreamFilter ff_##x##_bsf;                          \
63         if (CONFIG_##X##_BSF)                                           \
64             av_register_bitstream_filter(&ff_##x##_bsf);                \
65     }
66
67 void avcodec_register_all(void)
68 {
69     static int initialized;
70
71     if (initialized)
72         return;
73     initialized = 1;
74
75     /* hardware accelerators */
76     REGISTER_HWACCEL(H263_VAAPI,        h263_vaapi);
77     REGISTER_HWACCEL(H263_VDPAU,        h263_vdpau);
78     REGISTER_HWACCEL(H264_DXVA2,        h264_dxva2);
79     REGISTER_HWACCEL(H264_VAAPI,        h264_vaapi);
80     REGISTER_HWACCEL(H264_VDA,          h264_vda);
81     REGISTER_HWACCEL(MPEG1_VDPAU,       mpeg1_vdpau);
82     REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
83     REGISTER_HWACCEL(MPEG2_VAAPI,       mpeg2_vaapi);
84     REGISTER_HWACCEL(MPEG2_VDPAU,       mpeg2_vdpau);
85     REGISTER_HWACCEL(MPEG4_VAAPI,       mpeg4_vaapi);
86     REGISTER_HWACCEL(MPEG4_VDPAU,       mpeg4_vdpau);
87     REGISTER_HWACCEL(VC1_DXVA2,         vc1_dxva2);
88     REGISTER_HWACCEL(VC1_VAAPI,         vc1_vaapi);
89     REGISTER_HWACCEL(WMV3_DXVA2,        wmv3_dxva2);
90     REGISTER_HWACCEL(WMV3_VAAPI,        wmv3_vaapi);
91
92     /* video codecs */
93     REGISTER_ENCODER(A64MULTI,          a64multi);
94     REGISTER_ENCODER(A64MULTI5,         a64multi5);
95     REGISTER_DECODER(AASC,              aasc);
96     REGISTER_DECODER(AMV,               amv);
97     REGISTER_DECODER(ANM,               anm);
98     REGISTER_DECODER(ANSI,              ansi);
99     REGISTER_ENCDEC (ASV1,              asv1);
100     REGISTER_ENCDEC (ASV2,              asv2);
101     REGISTER_DECODER(AURA,              aura);
102     REGISTER_DECODER(AURA2,             aura2);
103     REGISTER_DECODER(AVS,               avs);
104     REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
105     REGISTER_DECODER(BFI,               bfi);
106     REGISTER_DECODER(BINK,              bink);
107     REGISTER_ENCDEC (BMP,               bmp);
108     REGISTER_DECODER(BMV_VIDEO,         bmv_video);
109     REGISTER_DECODER(C93,               c93);
110     REGISTER_DECODER(CAVS,              cavs);
111     REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
112     REGISTER_DECODER(CDXL,              cdxl);
113     REGISTER_DECODER(CINEPAK,           cinepak);
114     REGISTER_ENCDEC (CLJR,              cljr);
115     REGISTER_DECODER(CLLC,              cllc);
116     REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
117     REGISTER_DECODER(CSCD,              cscd);
118     REGISTER_DECODER(CYUV,              cyuv);
119     REGISTER_DECODER(DFA,               dfa);
120     REGISTER_ENCDEC (DNXHD,             dnxhd);
121     REGISTER_ENCDEC (DPX,               dpx);
122     REGISTER_DECODER(DSICINVIDEO,       dsicinvideo);
123     REGISTER_ENCDEC (DVVIDEO,           dvvideo);
124     REGISTER_DECODER(DXA,               dxa);
125     REGISTER_DECODER(DXTORY,            dxtory);
126     REGISTER_DECODER(EACMV,             eacmv);
127     REGISTER_DECODER(EAMAD,             eamad);
128     REGISTER_DECODER(EATGQ,             eatgq);
129     REGISTER_DECODER(EATGV,             eatgv);
130     REGISTER_DECODER(EATQI,             eatqi);
131     REGISTER_DECODER(EIGHTBPS,          eightbps);
132     REGISTER_DECODER(EIGHTSVX_EXP,      eightsvx_exp);
133     REGISTER_DECODER(EIGHTSVX_FIB,      eightsvx_fib);
134     REGISTER_DECODER(ESCAPE124,         escape124);
135     REGISTER_ENCDEC (FFV1,              ffv1);
136     REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
137     REGISTER_ENCDEC (FLASHSV,           flashsv);
138     REGISTER_DECODER(FLASHSV2,          flashsv2);
139     REGISTER_DECODER(FLIC,              flic);
140     REGISTER_ENCDEC (FLV,               flv);
141     REGISTER_DECODER(FOURXM,            fourxm);
142     REGISTER_DECODER(FRAPS,             fraps);
143     REGISTER_DECODER(FRWU,              frwu);
144     REGISTER_ENCDEC (GIF,               gif);
145     REGISTER_ENCDEC (H261,              h261);
146     REGISTER_ENCDEC (H263,              h263);
147     REGISTER_DECODER(H263I,             h263i);
148     REGISTER_ENCODER(H263P,             h263p);
149     REGISTER_DECODER(H264,              h264);
150     REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
151     REGISTER_ENCDEC (HUFFYUV,           huffyuv);
152     REGISTER_DECODER(IDCIN,             idcin);
153     REGISTER_DECODER(IFF_BYTERUN1,      iff_byterun1);
154     REGISTER_DECODER(IFF_ILBM,          iff_ilbm);
155     REGISTER_DECODER(INDEO2,            indeo2);
156     REGISTER_DECODER(INDEO3,            indeo3);
157     REGISTER_DECODER(INDEO4,            indeo4);
158     REGISTER_DECODER(INDEO5,            indeo5);
159     REGISTER_DECODER(INTERPLAY_VIDEO,   interplay_video);
160     REGISTER_ENCDEC (JPEGLS,            jpegls);
161     REGISTER_DECODER(JV,                jv);
162     REGISTER_DECODER(KGV1,              kgv1);
163     REGISTER_DECODER(KMVC,              kmvc);
164     REGISTER_DECODER(LAGARITH,          lagarith);
165     REGISTER_ENCODER(LJPEG,             ljpeg);
166     REGISTER_DECODER(LOCO,              loco);
167     REGISTER_DECODER(MDEC,              mdec);
168     REGISTER_DECODER(MIMIC,             mimic);
169     REGISTER_ENCDEC (MJPEG,             mjpeg);
170     REGISTER_DECODER(MJPEGB,            mjpegb);
171     REGISTER_DECODER(MMVIDEO,           mmvideo);
172     REGISTER_DECODER(MOTIONPIXELS,      motionpixels);
173     REGISTER_DECODER(MPEG_XVMC,         mpeg_xvmc);
174     REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
175     REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
176     REGISTER_ENCDEC (MPEG4,             mpeg4);
177     REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);
178     REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);
179     REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);
180     REGISTER_DECODER(MSA1,              msa1);
181     REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
182     REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
183     REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
184     REGISTER_DECODER(MSRLE,             msrle);
185     REGISTER_DECODER(MSS1,              mss1);
186     REGISTER_DECODER(MSS2,              mss2);
187     REGISTER_DECODER(MSVIDEO1,          msvideo1);
188     REGISTER_DECODER(MSZH,              mszh);
189     REGISTER_DECODER(MTS2,              mts2);
190     REGISTER_DECODER(MXPEG,             mxpeg);
191     REGISTER_DECODER(NUV,               nuv);
192     REGISTER_ENCDEC (PAM,               pam);
193     REGISTER_ENCDEC (PBM,               pbm);
194     REGISTER_ENCDEC (PCX,               pcx);
195     REGISTER_ENCDEC (PGM,               pgm);
196     REGISTER_ENCDEC (PGMYUV,            pgmyuv);
197     REGISTER_DECODER(PICTOR,            pictor);
198     REGISTER_ENCDEC (PNG,               png);
199     REGISTER_ENCDEC (PPM,               ppm);
200     REGISTER_ENCDEC (PRORES,            prores);
201     REGISTER_DECODER(PTX,               ptx);
202     REGISTER_DECODER(QDRAW,             qdraw);
203     REGISTER_DECODER(QPEG,              qpeg);
204     REGISTER_ENCDEC (QTRLE,             qtrle);
205     REGISTER_DECODER(R10K,              r10k);
206     REGISTER_DECODER(R210,              r210);
207     REGISTER_ENCDEC (RAWVIDEO,          rawvideo);
208     REGISTER_DECODER(RL2,               rl2);
209     REGISTER_ENCDEC (ROQ,               roq);
210     REGISTER_DECODER(RPZA,              rpza);
211     REGISTER_ENCDEC (RV10,              rv10);
212     REGISTER_ENCDEC (RV20,              rv20);
213     REGISTER_DECODER(RV30,              rv30);
214     REGISTER_DECODER(RV40,              rv40);
215     REGISTER_DECODER(S302M,             s302m);
216     REGISTER_ENCDEC (SGI,               sgi);
217     REGISTER_DECODER(SMACKER,           smacker);
218     REGISTER_DECODER(SMC,               smc);
219     REGISTER_DECODER(SP5X,              sp5x);
220     REGISTER_ENCDEC (SUNRAST,           sunrast);
221     REGISTER_ENCDEC (SVQ1,              svq1);
222     REGISTER_DECODER(SVQ3,              svq3);
223     REGISTER_ENCDEC (TARGA,             targa);
224     REGISTER_DECODER(THEORA,            theora);
225     REGISTER_DECODER(THP,               thp);
226     REGISTER_DECODER(TIERTEXSEQVIDEO,   tiertexseqvideo);
227     REGISTER_ENCDEC (TIFF,              tiff);
228     REGISTER_DECODER(TMV,               tmv);
229     REGISTER_DECODER(TRUEMOTION1,       truemotion1);
230     REGISTER_DECODER(TRUEMOTION2,       truemotion2);
231     REGISTER_DECODER(TSCC,              tscc);
232     REGISTER_DECODER(TSCC2,             tscc2);
233     REGISTER_DECODER(TXD,               txd);
234     REGISTER_DECODER(ULTI,              ulti);
235     REGISTER_ENCDEC (UTVIDEO,           utvideo);
236     REGISTER_ENCDEC (V210,              v210);
237     REGISTER_DECODER(V210X,             v210x);
238     REGISTER_ENCDEC (V410,              v410);
239     REGISTER_DECODER(VB,                vb);
240     REGISTER_DECODER(VBLE,              vble);
241     REGISTER_DECODER(VC1,               vc1);
242     REGISTER_DECODER(VC1_VDPAU,         vc1_vdpau);
243     REGISTER_DECODER(VC1IMAGE,          vc1image);
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(VP8,               vp8);
253     REGISTER_DECODER(VQA,               vqa);
254     REGISTER_ENCDEC (WMV1,              wmv1);
255     REGISTER_ENCDEC (WMV2,              wmv2);
256     REGISTER_DECODER(WMV3,              wmv3);
257     REGISTER_DECODER(WMV3_VDPAU,        wmv3_vdpau);
258     REGISTER_DECODER(WMV3IMAGE,         wmv3image);
259     REGISTER_DECODER(WNV1,              wnv1);
260     REGISTER_DECODER(XAN_WC3,           xan_wc3);
261     REGISTER_DECODER(XAN_WC4,           xan_wc4);
262     REGISTER_ENCODER(XBM,               xbm);
263     REGISTER_DECODER(XL,                xl);
264     REGISTER_ENCDEC (XWD,               xwd);
265     REGISTER_DECODER(YOP,               yop);
266     REGISTER_DECODER(ZEROCODEC,         zerocodec);
267     REGISTER_ENCDEC (ZLIB,              zlib);
268     REGISTER_ENCDEC (ZMBV,              zmbv);
269
270     /* audio codecs */
271     REGISTER_ENCDEC (AAC,               aac);
272     REGISTER_DECODER(AAC_LATM,          aac_latm);
273     REGISTER_ENCDEC (AC3,               ac3);
274     REGISTER_ENCODER(AC3_FIXED,         ac3_fixed);
275     REGISTER_ENCDEC (ALAC,              alac);
276     REGISTER_DECODER(ALS,               als);
277     REGISTER_DECODER(AMRNB,             amrnb);
278     REGISTER_DECODER(AMRWB,             amrwb);
279     REGISTER_DECODER(APE,               ape);
280     REGISTER_DECODER(ATRAC1,            atrac1);
281     REGISTER_DECODER(ATRAC3,            atrac3);
282     REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
283     REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
284     REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
285     REGISTER_DECODER(COOK,              cook);
286     REGISTER_DECODER(DCA,               dca);
287     REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
288     REGISTER_ENCDEC (EAC3,              eac3);
289     REGISTER_ENCDEC (FLAC,              flac);
290     REGISTER_DECODER(G723_1,            g723_1);
291     REGISTER_DECODER(GSM,               gsm);
292     REGISTER_DECODER(GSM_MS,            gsm_ms);
293     REGISTER_DECODER(IAC,               iac);
294     REGISTER_DECODER(IMC,               imc);
295     REGISTER_DECODER(MACE3,             mace3);
296     REGISTER_DECODER(MACE6,             mace6);
297     REGISTER_DECODER(MLP,               mlp);
298     REGISTER_DECODER(MP1,               mp1);
299     REGISTER_DECODER(MP1FLOAT,          mp1float);
300     REGISTER_ENCDEC (MP2,               mp2);
301     REGISTER_DECODER(MP2FLOAT,          mp2float);
302     REGISTER_DECODER(MP3,               mp3);
303     REGISTER_DECODER(MP3FLOAT,          mp3float);
304     REGISTER_DECODER(MP3ADU,            mp3adu);
305     REGISTER_DECODER(MP3ADUFLOAT,       mp3adufloat);
306     REGISTER_DECODER(MP3ON4,            mp3on4);
307     REGISTER_DECODER(MP3ON4FLOAT,       mp3on4float);
308     REGISTER_DECODER(MPC7,              mpc7);
309     REGISTER_DECODER(MPC8,              mpc8);
310     REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
311     REGISTER_DECODER(QCELP,             qcelp);
312     REGISTER_DECODER(QDM2,              qdm2);
313     REGISTER_ENCDEC (RA_144,            ra_144);
314     REGISTER_DECODER(RA_288,            ra_288);
315     REGISTER_DECODER(RALF,              ralf);
316     REGISTER_DECODER(SHORTEN,           shorten);
317     REGISTER_DECODER(SIPR,              sipr);
318     REGISTER_DECODER(SMACKAUD,          smackaud);
319     REGISTER_DECODER(TAK,               tak);
320     REGISTER_DECODER(TRUEHD,            truehd);
321     REGISTER_DECODER(TRUESPEECH,        truespeech);
322     REGISTER_DECODER(TTA,               tta);
323     REGISTER_DECODER(TWINVQ,            twinvq);
324     REGISTER_DECODER(VMDAUDIO,          vmdaudio);
325     REGISTER_ENCDEC (VORBIS,            vorbis);
326     REGISTER_DECODER(WAVPACK,           wavpack);
327     REGISTER_DECODER(WMALOSSLESS,       wmalossless);
328     REGISTER_DECODER(WMAPRO,            wmapro);
329     REGISTER_ENCDEC (WMAV1,             wmav1);
330     REGISTER_ENCDEC (WMAV2,             wmav2);
331     REGISTER_DECODER(WMAVOICE,          wmavoice);
332     REGISTER_DECODER(WS_SND1,           ws_snd1);
333
334     /* PCM codecs */
335     REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
336     REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
337     REGISTER_DECODER(PCM_DVD,           pcm_dvd);
338     REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
339     REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
340     REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
341     REGISTER_ENCDEC (PCM_F64LE,         pcm_f64le);
342     REGISTER_DECODER(PCM_LXF,           pcm_lxf);
343     REGISTER_ENCDEC (PCM_MULAW,         pcm_mulaw);
344     REGISTER_ENCDEC (PCM_S8,            pcm_s8);
345     REGISTER_DECODER(PCM_S8_PLANAR,     pcm_s8_planar);
346     REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
347     REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
348     REGISTER_DECODER(PCM_S16LE_PLANAR,  pcm_s16le_planar);
349     REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
350     REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
351     REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
352     REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
353     REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
354     REGISTER_ENCDEC (PCM_U8,            pcm_u8);
355     REGISTER_ENCDEC (PCM_U16BE,         pcm_u16be);
356     REGISTER_ENCDEC (PCM_U16LE,         pcm_u16le);
357     REGISTER_ENCDEC (PCM_U24BE,         pcm_u24be);
358     REGISTER_ENCDEC (PCM_U24LE,         pcm_u24le);
359     REGISTER_ENCDEC (PCM_U32BE,         pcm_u32be);
360     REGISTER_ENCDEC (PCM_U32LE,         pcm_u32le);
361     REGISTER_DECODER(PCM_ZORK ,         pcm_zork);
362
363     /* DPCM codecs */
364     REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
365     REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
366     REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
367     REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
368
369     /* ADPCM codecs */
370     REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
371     REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
372     REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
373     REGISTER_DECODER(ADPCM_EA,          adpcm_ea);
374     REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
375     REGISTER_DECODER(ADPCM_EA_R1,       adpcm_ea_r1);
376     REGISTER_DECODER(ADPCM_EA_R2,       adpcm_ea_r2);
377     REGISTER_DECODER(ADPCM_EA_R3,       adpcm_ea_r3);
378     REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
379     REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
380     REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
381     REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
382     REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
383     REGISTER_DECODER(ADPCM_IMA_DK3,     adpcm_ima_dk3);
384     REGISTER_DECODER(ADPCM_IMA_DK4,     adpcm_ima_dk4);
385     REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
386     REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
387     REGISTER_DECODER(ADPCM_IMA_ISS,     adpcm_ima_iss);
388     REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
389     REGISTER_DECODER(ADPCM_IMA_SMJPEG,  adpcm_ima_smjpeg);
390     REGISTER_ENCDEC (ADPCM_IMA_WAV,     adpcm_ima_wav);
391     REGISTER_DECODER(ADPCM_IMA_WS,      adpcm_ima_ws);
392     REGISTER_ENCDEC (ADPCM_MS,          adpcm_ms);
393     REGISTER_DECODER(ADPCM_SBPRO_2,     adpcm_sbpro_2);
394     REGISTER_DECODER(ADPCM_SBPRO_3,     adpcm_sbpro_3);
395     REGISTER_DECODER(ADPCM_SBPRO_4,     adpcm_sbpro_4);
396     REGISTER_ENCDEC (ADPCM_SWF,         adpcm_swf);
397     REGISTER_DECODER(ADPCM_THP,         adpcm_thp);
398     REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
399     REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
400
401     /* subtitles */
402     REGISTER_ENCDEC (ASS,               ass);
403     REGISTER_ENCDEC (DVBSUB,            dvbsub);
404     REGISTER_ENCDEC (DVDSUB,            dvdsub);
405     REGISTER_DECODER(PGSSUB,            pgssub);
406     REGISTER_DECODER(SRT,               srt);
407     REGISTER_ENCDEC (XSUB,              xsub);
408
409     /* external libraries */
410     REGISTER_ENCODER(LIBFAAC,           libfaac);
411     REGISTER_ENCODER(LIBFDK_AAC,        libfdk_aac);
412     REGISTER_ENCDEC (LIBGSM,            libgsm);
413     REGISTER_ENCDEC (LIBGSM_MS,         libgsm_ms);
414     REGISTER_ENCDEC (LIBILBC,           libilbc);
415     REGISTER_ENCODER(LIBMP3LAME,        libmp3lame);
416     REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
417     REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
418     REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
419     REGISTER_ENCDEC (LIBOPUS,           libopus);
420     REGISTER_ENCDEC (LIBSCHROEDINGER,   libschroedinger);
421     REGISTER_ENCDEC (LIBSPEEX,          libspeex);
422     REGISTER_ENCODER(LIBTHEORA,         libtheora);
423     REGISTER_ENCODER(LIBVO_AACENC,      libvo_aacenc);
424     REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
425     REGISTER_ENCODER(LIBVORBIS,         libvorbis);
426     REGISTER_ENCDEC (LIBVPX,            libvpx);
427     REGISTER_ENCODER(LIBX264,           libx264);
428     REGISTER_ENCODER(LIBXAVS,           libxavs);
429     REGISTER_ENCODER(LIBXVID,           libxvid);
430
431     /* parsers */
432     REGISTER_PARSER(AAC,                aac);
433     REGISTER_PARSER(AAC_LATM,           aac_latm);
434     REGISTER_PARSER(AC3,                ac3);
435     REGISTER_PARSER(ADX,                adx);
436     REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
437     REGISTER_PARSER(COOK,               cook);
438     REGISTER_PARSER(DCA,                dca);
439     REGISTER_PARSER(DIRAC,              dirac);
440     REGISTER_PARSER(DNXHD,              dnxhd);
441     REGISTER_PARSER(DVBSUB,             dvbsub);
442     REGISTER_PARSER(DVDSUB,             dvdsub);
443     REGISTER_PARSER(FLAC,               flac);
444     REGISTER_PARSER(GSM,                gsm);
445     REGISTER_PARSER(H261,               h261);
446     REGISTER_PARSER(H263,               h263);
447     REGISTER_PARSER(H264,               h264);
448     REGISTER_PARSER(MJPEG,              mjpeg);
449     REGISTER_PARSER(MLP,                mlp);
450     REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
451     REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
452     REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
453     REGISTER_PARSER(PNM,                pnm);
454     REGISTER_PARSER(RV30,               rv30);
455     REGISTER_PARSER(RV40,               rv40);
456     REGISTER_PARSER(TAK,                tak);
457     REGISTER_PARSER(VC1,                vc1);
458     REGISTER_PARSER(VORBIS,             vorbis);
459     REGISTER_PARSER(VP3,                vp3);
460     REGISTER_PARSER(VP8,                vp8);
461
462     /* bitstream filters */
463     REGISTER_BSF(AAC_ADTSTOASC,         aac_adtstoasc);
464     REGISTER_BSF(CHOMP,                 chomp);
465     REGISTER_BSF(DUMP_EXTRADATA,        dump_extradata);
466     REGISTER_BSF(H264_MP4TOANNEXB,      h264_mp4toannexb);
467     REGISTER_BSF(IMX_DUMP_HEADER,       imx_dump_header);
468     REGISTER_BSF(MJPEG2JPEG,            mjpeg2jpeg);
469     REGISTER_BSF(MJPEGA_DUMP_HEADER,    mjpega_dump_header);
470     REGISTER_BSF(MP3_HEADER_COMPRESS,   mp3_header_compress);
471     REGISTER_BSF(MP3_HEADER_DECOMPRESS, mp3_header_decompress);
472     REGISTER_BSF(MOV2TEXTSUB,           mov2textsub);
473     REGISTER_BSF(NOISE,                 noise);
474     REGISTER_BSF(REMOVE_EXTRADATA,      remove_extradata);
475     REGISTER_BSF(TEXT2MOVSUB,           text2movsub);
476 }