cosmetics: Prettyprint codec/format/filter registration files
authorDiego Biurrun <diego@biurrun.de>
Tue, 25 Dec 2012 14:29:39 +0000 (15:29 +0100)
committerDiego Biurrun <diego@biurrun.de>
Fri, 28 Dec 2012 18:18:13 +0000 (19:18 +0100)
libavcodec/allcodecs.c
libavdevice/alldevices.c
libavfilter/allfilters.c
libavformat/allformats.c

index 03949e6d26bbf3a4bd5f8e2de2d8db9d080ee2df..878d3de3bc5a97c080ff7393df0810027eb767e3 100644 (file)
 #include "avcodec.h"
 #include "config.h"
 
-#define REGISTER_HWACCEL(X,x) { \
-          extern AVHWAccel ff_##x##_hwaccel; \
-          if(CONFIG_##X##_HWACCEL) av_register_hwaccel(&ff_##x##_hwaccel); }
+#define REGISTER_HWACCEL(X, x)                                          \
+    {                                                                   \
+        extern AVHWAccel ff_##x##_hwaccel;                              \
+        if (CONFIG_##X##_HWACCEL)                                       \
+            av_register_hwaccel(&ff_##x##_hwaccel);                     \
+    }
 
-#define REGISTER_ENCODER(X,x) { \
-          extern AVCodec ff_##x##_encoder; \
-          if(CONFIG_##X##_ENCODER)  avcodec_register(&ff_##x##_encoder); }
-#define REGISTER_DECODER(X,x) { \
-          extern AVCodec ff_##x##_decoder; \
-          if(CONFIG_##X##_DECODER)  avcodec_register(&ff_##x##_decoder); }
-#define REGISTER_ENCDEC(X,x)  REGISTER_ENCODER(X,x); REGISTER_DECODER(X,x)
+#define REGISTER_ENCODER(X, x)                                          \
+    {                                                                   \
+        extern AVCodec ff_##x##_encoder;                                \
+        if (CONFIG_##X##_ENCODER)                                       \
+            avcodec_register(&ff_##x##_encoder);                        \
+    }
 
-#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); }
+#define REGISTER_DECODER(X, x)                                          \
+    {                                                                   \
+        extern AVCodec ff_##x##_decoder;                                \
+        if (CONFIG_##X##_DECODER)                                       \
+            avcodec_register(&ff_##x##_decoder);                        \
+    }
+
+#define REGISTER_ENCDEC(X, x)                                           \
+    REGISTER_ENCODER(X, x);                                             \
+    REGISTER_DECODER(X,x)
+
+#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);                \
+    }
 
 void avcodec_register_all(void)
 {
@@ -55,401 +75,401 @@ void avcodec_register_all(void)
     initialized = 1;
 
     /* hardware accelerators */
-    REGISTER_HWACCEL (H263_VAAPI, h263_vaapi);
-    REGISTER_HWACCEL (H264_DXVA2, h264_dxva2);
-    REGISTER_HWACCEL (H264_VAAPI, h264_vaapi);
-    REGISTER_HWACCEL (H264_VDA, h264_vda);
-    REGISTER_HWACCEL (MPEG2_DXVA2, mpeg2_dxva2);
-    REGISTER_HWACCEL (MPEG2_VAAPI, mpeg2_vaapi);
-    REGISTER_HWACCEL (MPEG4_VAAPI, mpeg4_vaapi);
-    REGISTER_HWACCEL (VC1_DXVA2, vc1_dxva2);
-    REGISTER_HWACCEL (VC1_VAAPI, vc1_vaapi);
-    REGISTER_HWACCEL (WMV3_DXVA2, wmv3_dxva2);
-    REGISTER_HWACCEL (WMV3_VAAPI, wmv3_vaapi);
+    REGISTER_HWACCEL(H263_VAAPI,        h263_vaapi);
+    REGISTER_HWACCEL(H264_DXVA2,        h264_dxva2);
+    REGISTER_HWACCEL(H264_VAAPI,        h264_vaapi);
+    REGISTER_HWACCEL(H264_VDA,          h264_vda);
+    REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
+    REGISTER_HWACCEL(MPEG2_VAAPI,       mpeg2_vaapi);
+    REGISTER_HWACCEL(MPEG4_VAAPI,       mpeg4_vaapi);
+    REGISTER_HWACCEL(VC1_DXVA2,         vc1_dxva2);
+    REGISTER_HWACCEL(VC1_VAAPI,         vc1_vaapi);
+    REGISTER_HWACCEL(WMV3_DXVA2,        wmv3_dxva2);
+    REGISTER_HWACCEL(WMV3_VAAPI,        wmv3_vaapi);
 
     /* video codecs */
-    REGISTER_ENCODER (A64MULTI, a64multi);
-    REGISTER_ENCODER (A64MULTI5, a64multi5);
-    REGISTER_DECODER (AASC, aasc);
-    REGISTER_DECODER (AMV, amv);
-    REGISTER_DECODER (ANM, anm);
-    REGISTER_DECODER (ANSI, ansi);
-    REGISTER_ENCDEC  (ASV1, asv1);
-    REGISTER_ENCDEC  (ASV2, asv2);
-    REGISTER_DECODER (AURA, aura);
-    REGISTER_DECODER (AURA2, aura2);
-    REGISTER_DECODER (AVS, avs);
-    REGISTER_DECODER (BETHSOFTVID, bethsoftvid);
-    REGISTER_DECODER (BFI, bfi);
-    REGISTER_DECODER (BINK, bink);
-    REGISTER_ENCDEC  (BMP, bmp);
-    REGISTER_DECODER (BMV_VIDEO, bmv_video);
-    REGISTER_DECODER (C93, c93);
-    REGISTER_DECODER (CAVS, cavs);
-    REGISTER_DECODER (CDGRAPHICS, cdgraphics);
-    REGISTER_DECODER (CDXL, cdxl);
-    REGISTER_DECODER (CINEPAK, cinepak);
-    REGISTER_ENCDEC  (CLJR, cljr);
-    REGISTER_DECODER (CLLC, cllc);
-    REGISTER_ENCDEC  (COMFORTNOISE, comfortnoise);
-    REGISTER_DECODER (CSCD, cscd);
-    REGISTER_DECODER (CYUV, cyuv);
-    REGISTER_DECODER (DFA, dfa);
-    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);
-    REGISTER_ENCDEC  (FFV1, ffv1);
-    REGISTER_ENCDEC  (FFVHUFF, ffvhuff);
-    REGISTER_ENCDEC  (FLASHSV, flashsv);
-    REGISTER_DECODER (FLASHSV2, flashsv2);
-    REGISTER_DECODER (FLIC, flic);
-    REGISTER_ENCDEC  (FLV, flv);
-    REGISTER_DECODER (FOURXM, fourxm);
-    REGISTER_DECODER (FRAPS, fraps);
-    REGISTER_DECODER (FRWU, frwu);
-    REGISTER_ENCDEC  (GIF, gif);
-    REGISTER_ENCDEC  (H261, h261);
-    REGISTER_ENCDEC  (H263, h263);
-    REGISTER_DECODER (H263I, h263i);
-    REGISTER_ENCODER (H263P, h263p);
-    REGISTER_DECODER (H264, h264);
-    REGISTER_DECODER (H264_VDPAU, h264_vdpau);
-    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);
-    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);
-    REGISTER_DECODER (MPEG_XVMC, mpeg_xvmc);
-    REGISTER_ENCDEC  (MPEG1VIDEO, mpeg1video);
-    REGISTER_ENCDEC  (MPEG2VIDEO, mpeg2video);
-    REGISTER_ENCDEC  (MPEG4, mpeg4);
-    REGISTER_DECODER (MPEG4_VDPAU, mpeg4_vdpau);
-    REGISTER_DECODER (MPEG_VDPAU, mpeg_vdpau);
-    REGISTER_DECODER (MPEG1_VDPAU, mpeg1_vdpau);
-    REGISTER_DECODER (MSA1, msa1);
-    REGISTER_DECODER (MSMPEG4V1, msmpeg4v1);
-    REGISTER_ENCDEC  (MSMPEG4V2, msmpeg4v2);
-    REGISTER_ENCDEC  (MSMPEG4V3, msmpeg4v3);
-    REGISTER_DECODER (MSRLE, msrle);
-    REGISTER_DECODER (MSS1, mss1);
-    REGISTER_DECODER (MSS2, mss2);
-    REGISTER_DECODER (MSVIDEO1, msvideo1);
-    REGISTER_DECODER (MSZH, mszh);
-    REGISTER_DECODER (MTS2, mts2);
-    REGISTER_DECODER (MXPEG, mxpeg);
-    REGISTER_DECODER (NUV, nuv);
-    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);
-    REGISTER_DECODER (PTX, ptx);
-    REGISTER_DECODER (QDRAW, qdraw);
-    REGISTER_DECODER (QPEG, qpeg);
-    REGISTER_ENCDEC  (QTRLE, qtrle);
-    REGISTER_DECODER (R10K,  r10k);
-    REGISTER_DECODER (R210,  r210);
-    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);
-    REGISTER_DECODER (S302M, s302m);
-    REGISTER_ENCDEC  (SGI, sgi);
-    REGISTER_DECODER (SMACKER, smacker);
-    REGISTER_DECODER (SMC, smc);
-    REGISTER_ENCDEC  (SNOW, snow);
-    REGISTER_DECODER (SP5X, sp5x);
-    REGISTER_ENCDEC  (SUNRAST, sunrast);
-    REGISTER_ENCDEC  (SVQ1, svq1);
-    REGISTER_DECODER (SVQ3, svq3);
-    REGISTER_ENCDEC  (TARGA, targa);
-    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);
-    REGISTER_ENCDEC  (V410, v410);
-    REGISTER_DECODER (VB, vb);
-    REGISTER_DECODER (VBLE, vble);
-    REGISTER_DECODER (VC1, vc1);
-    REGISTER_DECODER (VC1_VDPAU, vc1_vdpau);
-    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);
-    REGISTER_DECODER (VP8, vp8);
-    REGISTER_DECODER (VQA, vqa);
-    REGISTER_ENCDEC  (WMV1, wmv1);
-    REGISTER_ENCDEC  (WMV2, wmv2);
-    REGISTER_DECODER (WMV3, wmv3);
-    REGISTER_DECODER (WMV3_VDPAU, wmv3_vdpau);
-    REGISTER_DECODER (WMV3IMAGE, wmv3image);
-    REGISTER_DECODER (WNV1, wnv1);
-    REGISTER_DECODER (XAN_WC3, xan_wc3);
-    REGISTER_DECODER (XAN_WC4, xan_wc4);
-    REGISTER_ENCODER (XBM, xbm);
-    REGISTER_DECODER (XL, xl);
-    REGISTER_ENCDEC  (XWD, xwd);
-    REGISTER_DECODER (YOP, yop);
-    REGISTER_DECODER (ZEROCODEC, zerocodec);
-    REGISTER_ENCDEC  (ZLIB, zlib);
-    REGISTER_ENCDEC  (ZMBV, zmbv);
+    REGISTER_ENCODER(A64MULTI,          a64multi);
+    REGISTER_ENCODER(A64MULTI5,         a64multi5);
+    REGISTER_DECODER(AASC,              aasc);
+    REGISTER_DECODER(AMV,               amv);
+    REGISTER_DECODER(ANM,               anm);
+    REGISTER_DECODER(ANSI,              ansi);
+    REGISTER_ENCDEC (ASV1,              asv1);
+    REGISTER_ENCDEC (ASV2,              asv2);
+    REGISTER_DECODER(AURA,              aura);
+    REGISTER_DECODER(AURA2,             aura2);
+    REGISTER_DECODER(AVS,               avs);
+    REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
+    REGISTER_DECODER(BFI,               bfi);
+    REGISTER_DECODER(BINK,              bink);
+    REGISTER_ENCDEC (BMP,               bmp);
+    REGISTER_DECODER(BMV_VIDEO,         bmv_video);
+    REGISTER_DECODER(C93,               c93);
+    REGISTER_DECODER(CAVS,              cavs);
+    REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
+    REGISTER_DECODER(CDXL,              cdxl);
+    REGISTER_DECODER(CINEPAK,           cinepak);
+    REGISTER_ENCDEC (CLJR,              cljr);
+    REGISTER_DECODER(CLLC,              cllc);
+    REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
+    REGISTER_DECODER(CSCD,              cscd);
+    REGISTER_DECODER(CYUV,              cyuv);
+    REGISTER_DECODER(DFA,               dfa);
+    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);
+    REGISTER_ENCDEC (FFV1,              ffv1);
+    REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
+    REGISTER_ENCDEC (FLASHSV,           flashsv);
+    REGISTER_DECODER(FLASHSV2,          flashsv2);
+    REGISTER_DECODER(FLIC,              flic);
+    REGISTER_ENCDEC (FLV,               flv);
+    REGISTER_DECODER(FOURXM,            fourxm);
+    REGISTER_DECODER(FRAPS,             fraps);
+    REGISTER_DECODER(FRWU,              frwu);
+    REGISTER_ENCDEC (GIF,               gif);
+    REGISTER_ENCDEC (H261,              h261);
+    REGISTER_ENCDEC (H263,              h263);
+    REGISTER_DECODER(H263I,             h263i);
+    REGISTER_ENCODER(H263P,             h263p);
+    REGISTER_DECODER(H264,              h264);
+    REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
+    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);
+    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);
+    REGISTER_DECODER(MPEG_XVMC,         mpeg_xvmc);
+    REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
+    REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
+    REGISTER_ENCDEC (MPEG4,             mpeg4);
+    REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);
+    REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);
+    REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);
+    REGISTER_DECODER(MSA1,              msa1);
+    REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
+    REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
+    REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
+    REGISTER_DECODER(MSRLE,             msrle);
+    REGISTER_DECODER(MSS1,              mss1);
+    REGISTER_DECODER(MSS2,              mss2);
+    REGISTER_DECODER(MSVIDEO1,          msvideo1);
+    REGISTER_DECODER(MSZH,              mszh);
+    REGISTER_DECODER(MTS2,              mts2);
+    REGISTER_DECODER(MXPEG,             mxpeg);
+    REGISTER_DECODER(NUV,               nuv);
+    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);
+    REGISTER_DECODER(PTX,               ptx);
+    REGISTER_DECODER(QDRAW,             qdraw);
+    REGISTER_DECODER(QPEG,              qpeg);
+    REGISTER_ENCDEC (QTRLE,             qtrle);
+    REGISTER_DECODER(R10K,              r10k);
+    REGISTER_DECODER(R210,              r210);
+    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);
+    REGISTER_DECODER(S302M,             s302m);
+    REGISTER_ENCDEC (SGI,               sgi);
+    REGISTER_DECODER(SMACKER,           smacker);
+    REGISTER_DECODER(SMC,               smc);
+    REGISTER_ENCDEC (SNOW,              snow);
+    REGISTER_DECODER(SP5X,              sp5x);
+    REGISTER_ENCDEC (SUNRAST,           sunrast);
+    REGISTER_ENCDEC (SVQ1,              svq1);
+    REGISTER_DECODER(SVQ3,              svq3);
+    REGISTER_ENCDEC (TARGA,             targa);
+    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);
+    REGISTER_ENCDEC (V410,              v410);
+    REGISTER_DECODER(VB,                vb);
+    REGISTER_DECODER(VBLE,              vble);
+    REGISTER_DECODER(VC1,               vc1);
+    REGISTER_DECODER(VC1_VDPAU,         vc1_vdpau);
+    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);
+    REGISTER_DECODER(VP8,               vp8);
+    REGISTER_DECODER(VQA,               vqa);
+    REGISTER_ENCDEC (WMV1,              wmv1);
+    REGISTER_ENCDEC (WMV2,              wmv2);
+    REGISTER_DECODER(WMV3,              wmv3);
+    REGISTER_DECODER(WMV3_VDPAU,        wmv3_vdpau);
+    REGISTER_DECODER(WMV3IMAGE,         wmv3image);
+    REGISTER_DECODER(WNV1,              wnv1);
+    REGISTER_DECODER(XAN_WC3,           xan_wc3);
+    REGISTER_DECODER(XAN_WC4,           xan_wc4);
+    REGISTER_ENCODER(XBM,               xbm);
+    REGISTER_DECODER(XL,                xl);
+    REGISTER_ENCDEC (XWD,               xwd);
+    REGISTER_DECODER(YOP,               yop);
+    REGISTER_DECODER(ZEROCODEC,         zerocodec);
+    REGISTER_ENCDEC (ZLIB,              zlib);
+    REGISTER_ENCDEC (ZMBV,              zmbv);
 
     /* audio codecs */
-    REGISTER_ENCDEC  (AAC, aac);
-    REGISTER_DECODER (AAC_LATM, aac_latm);
-    REGISTER_ENCDEC  (AC3, ac3);
-    REGISTER_ENCODER (AC3_FIXED, ac3_fixed);
-    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);
-    REGISTER_DECODER (BINKAUDIO_DCT, binkaudio_dct);
-    REGISTER_DECODER (BINKAUDIO_RDFT, binkaudio_rdft);
-    REGISTER_DECODER (BMV_AUDIO, bmv_audio);
-    REGISTER_DECODER (COOK, cook);
-    REGISTER_DECODER (DCA, dca);
-    REGISTER_DECODER (DSICINAUDIO, dsicinaudio);
-    REGISTER_ENCDEC  (EAC3, eac3);
-    REGISTER_ENCDEC  (FLAC, flac);
-    REGISTER_DECODER (G723_1, g723_1);
-    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);
-    REGISTER_DECODER (MLP, mlp);
-    REGISTER_DECODER (MP1, mp1);
-    REGISTER_DECODER (MP1FLOAT, mp1float);
-    REGISTER_ENCDEC  (MP2, mp2);
-    REGISTER_DECODER (MP2FLOAT, mp2float);
-    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);
-    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);
-    REGISTER_DECODER (TAK, tak);
-    REGISTER_DECODER (TRUEHD, truehd);
-    REGISTER_DECODER (TRUESPEECH, truespeech);
-    REGISTER_DECODER (TTA, tta);
-    REGISTER_DECODER (TWINVQ, twinvq);
-    REGISTER_DECODER (VMDAUDIO, vmdaudio);
-    REGISTER_ENCDEC  (VORBIS, vorbis);
-    REGISTER_DECODER (WAVPACK, wavpack);
-    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);
+    REGISTER_ENCDEC (AAC,               aac);
+    REGISTER_DECODER(AAC_LATM,          aac_latm);
+    REGISTER_ENCDEC (AC3,               ac3);
+    REGISTER_ENCODER(AC3_FIXED,         ac3_fixed);
+    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);
+    REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
+    REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
+    REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
+    REGISTER_DECODER(COOK,              cook);
+    REGISTER_DECODER(DCA,               dca);
+    REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
+    REGISTER_ENCDEC (EAC3,              eac3);
+    REGISTER_ENCDEC (FLAC,              flac);
+    REGISTER_DECODER(G723_1,            g723_1);
+    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);
+    REGISTER_DECODER(MLP,               mlp);
+    REGISTER_DECODER(MP1,               mp1);
+    REGISTER_DECODER(MP1FLOAT,          mp1float);
+    REGISTER_ENCDEC (MP2,               mp2);
+    REGISTER_DECODER(MP2FLOAT,          mp2float);
+    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);
+    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);
+    REGISTER_DECODER(TAK,               tak);
+    REGISTER_DECODER(TRUEHD,            truehd);
+    REGISTER_DECODER(TRUESPEECH,        truespeech);
+    REGISTER_DECODER(TTA,               tta);
+    REGISTER_DECODER(TWINVQ,            twinvq);
+    REGISTER_DECODER(VMDAUDIO,          vmdaudio);
+    REGISTER_ENCDEC (VORBIS,            vorbis);
+    REGISTER_DECODER(WAVPACK,           wavpack);
+    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);
 
     /* PCM codecs */
-    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);
-    REGISTER_DECODER (PCM_S8_PLANAR, pcm_s8_planar);
-    REGISTER_ENCDEC  (PCM_S16BE, pcm_s16be);
-    REGISTER_ENCDEC  (PCM_S16LE, pcm_s16le);
-    REGISTER_DECODER (PCM_S16LE_PLANAR, pcm_s16le_planar);
-    REGISTER_ENCDEC  (PCM_S24BE, pcm_s24be);
-    REGISTER_ENCDEC  (PCM_S24DAUD, pcm_s24daud);
-    REGISTER_ENCDEC  (PCM_S24LE, pcm_s24le);
-    REGISTER_ENCDEC  (PCM_S32BE, pcm_s32be);
-    REGISTER_ENCDEC  (PCM_S32LE, pcm_s32le);
-    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);
-    REGISTER_DECODER (PCM_ZORK , pcm_zork);
+    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);
+    REGISTER_DECODER(PCM_S8_PLANAR,     pcm_s8_planar);
+    REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
+    REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
+    REGISTER_DECODER(PCM_S16LE_PLANAR,  pcm_s16le_planar);
+    REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
+    REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
+    REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
+    REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
+    REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
+    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);
+    REGISTER_DECODER(PCM_ZORK ,         pcm_zork);
 
     /* DPCM codecs */
-    REGISTER_DECODER (INTERPLAY_DPCM, interplay_dpcm);
-    REGISTER_ENCDEC  (ROQ_DPCM, roq_dpcm);
-    REGISTER_DECODER (SOL_DPCM, sol_dpcm);
-    REGISTER_DECODER (XAN_DPCM, xan_dpcm);
+    REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
+    REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
+    REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
+    REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
 
     /* ADPCM codecs */
-    REGISTER_DECODER (ADPCM_4XM, adpcm_4xm);
-    REGISTER_ENCDEC  (ADPCM_ADX, adpcm_adx);
-    REGISTER_DECODER (ADPCM_CT, adpcm_ct);
-    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);
-    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);
-    REGISTER_ENCDEC  (ADPCM_IMA_QT, adpcm_ima_qt);
-    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);
-    REGISTER_DECODER (ADPCM_XA, adpcm_xa);
-    REGISTER_ENCDEC  (ADPCM_YAMAHA, adpcm_yamaha);
+    REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
+    REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
+    REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
+    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);
+    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);
+    REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
+    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);
+    REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
+    REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
 
     /* subtitles */
-    REGISTER_ENCDEC  (ASS, ass);
-    REGISTER_ENCDEC  (DVBSUB, dvbsub);
-    REGISTER_ENCDEC  (DVDSUB, dvdsub);
-    REGISTER_DECODER (PGSSUB, pgssub);
-    REGISTER_DECODER (SRT, srt);
-    REGISTER_ENCDEC  (XSUB, xsub);
+    REGISTER_ENCDEC (ASS,               ass);
+    REGISTER_ENCDEC (DVBSUB,            dvbsub);
+    REGISTER_ENCDEC (DVDSUB,            dvdsub);
+    REGISTER_DECODER(PGSSUB,            pgssub);
+    REGISTER_DECODER(SRT,               srt);
+    REGISTER_ENCDEC (XSUB,              xsub);
 
     /* external libraries */
-    REGISTER_ENCODER (LIBFAAC, libfaac);
-    REGISTER_ENCODER (LIBFDK_AAC, libfdk_aac);
-    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);
-    REGISTER_ENCDEC  (LIBSPEEX, libspeex);
-    REGISTER_ENCODER (LIBTHEORA, libtheora);
-    REGISTER_ENCODER (LIBVO_AACENC, libvo_aacenc);
-    REGISTER_ENCODER (LIBVO_AMRWBENC, libvo_amrwbenc);
-    REGISTER_ENCODER (LIBVORBIS, libvorbis);
-    REGISTER_ENCDEC  (LIBVPX, libvpx);
-    REGISTER_ENCODER (LIBX264, libx264);
-    REGISTER_ENCODER (LIBXAVS, libxavs);
-    REGISTER_ENCODER (LIBXVID, libxvid);
+    REGISTER_ENCODER(LIBFAAC,           libfaac);
+    REGISTER_ENCODER(LIBFDK_AAC,        libfdk_aac);
+    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);
+    REGISTER_ENCDEC (LIBSPEEX,          libspeex);
+    REGISTER_ENCODER(LIBTHEORA,         libtheora);
+    REGISTER_ENCODER(LIBVO_AACENC,      libvo_aacenc);
+    REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
+    REGISTER_ENCODER(LIBVORBIS,         libvorbis);
+    REGISTER_ENCDEC (LIBVPX,            libvpx);
+    REGISTER_ENCODER(LIBX264,           libx264);
+    REGISTER_ENCODER(LIBXAVS,           libxavs);
+    REGISTER_ENCODER(LIBXVID,           libxvid);
 
     /* parsers */
-    REGISTER_PARSER  (AAC, aac);
-    REGISTER_PARSER  (AAC_LATM, aac_latm);
-    REGISTER_PARSER  (AC3, ac3);
-    REGISTER_PARSER  (ADX, adx);
-    REGISTER_PARSER  (CAVSVIDEO, cavsvideo);
-    REGISTER_PARSER  (COOK, cook);
-    REGISTER_PARSER  (DCA, dca);
-    REGISTER_PARSER  (DIRAC, dirac);
-    REGISTER_PARSER  (DNXHD, dnxhd);
-    REGISTER_PARSER  (DVBSUB, dvbsub);
-    REGISTER_PARSER  (DVDSUB, dvdsub);
-    REGISTER_PARSER  (FLAC, flac);
-    REGISTER_PARSER  (GSM, gsm);
-    REGISTER_PARSER  (H261, h261);
-    REGISTER_PARSER  (H263, h263);
-    REGISTER_PARSER  (H264, h264);
-    REGISTER_PARSER  (MJPEG, mjpeg);
-    REGISTER_PARSER  (MLP, mlp);
-    REGISTER_PARSER  (MPEG4VIDEO, mpeg4video);
-    REGISTER_PARSER  (MPEGAUDIO, mpegaudio);
-    REGISTER_PARSER  (MPEGVIDEO, mpegvideo);
-    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);
+    REGISTER_PARSER(AAC,                aac);
+    REGISTER_PARSER(AAC_LATM,           aac_latm);
+    REGISTER_PARSER(AC3,                ac3);
+    REGISTER_PARSER(ADX,                adx);
+    REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
+    REGISTER_PARSER(COOK,               cook);
+    REGISTER_PARSER(DCA,                dca);
+    REGISTER_PARSER(DIRAC,              dirac);
+    REGISTER_PARSER(DNXHD,              dnxhd);
+    REGISTER_PARSER(DVBSUB,             dvbsub);
+    REGISTER_PARSER(DVDSUB,             dvdsub);
+    REGISTER_PARSER(FLAC,               flac);
+    REGISTER_PARSER(GSM,                gsm);
+    REGISTER_PARSER(H261,               h261);
+    REGISTER_PARSER(H263,               h263);
+    REGISTER_PARSER(H264,               h264);
+    REGISTER_PARSER(MJPEG,              mjpeg);
+    REGISTER_PARSER(MLP,                mlp);
+    REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
+    REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
+    REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
+    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);
 
     /* bitstream filters */
-    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_COMPRESS, mp3_header_compress);
-    REGISTER_BSF     (MP3_HEADER_DECOMPRESS, mp3_header_decompress);
-    REGISTER_BSF     (MOV2TEXTSUB, mov2textsub);
-    REGISTER_BSF     (NOISE, noise);
-    REGISTER_BSF     (REMOVE_EXTRADATA, remove_extradata);
-    REGISTER_BSF     (TEXT2MOVSUB, text2movsub);
+    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_COMPRESS,   mp3_header_compress);
+    REGISTER_BSF(MP3_HEADER_DECOMPRESS, mp3_header_decompress);
+    REGISTER_BSF(MOV2TEXTSUB,           mov2textsub);
+    REGISTER_BSF(NOISE,                 noise);
+    REGISTER_BSF(REMOVE_EXTRADATA,      remove_extradata);
+    REGISTER_BSF(TEXT2MOVSUB,           text2movsub);
 }
index 9ec9fdfc496799d750b434e220c4dec4d7c97f35..5d419b0f4075970805514d2220a3485173cfe162 100644 (file)
 #include "libavformat/avformat.h"
 #include "avdevice.h"
 
-#define REGISTER_OUTDEV(X,x) { \
-          extern AVOutputFormat ff_##x##_muxer; \
-          if(CONFIG_##X##_OUTDEV)  av_register_output_format(&ff_##x##_muxer); }
-#define REGISTER_INDEV(X,x) { \
-          extern AVInputFormat ff_##x##_demuxer; \
-          if(CONFIG_##X##_INDEV)   av_register_input_format(&ff_##x##_demuxer); }
-#define REGISTER_INOUTDEV(X,x)  REGISTER_OUTDEV(X,x); REGISTER_INDEV(X,x)
+#define REGISTER_OUTDEV(X, x)                                           \
+    {                                                                   \
+        extern AVOutputFormat ff_##x##_muxer;                           \
+        if (CONFIG_##X##_OUTDEV)                                        \
+            av_register_output_format(&ff_##x##_muxer);                 \
+    }
+
+#define REGISTER_INDEV(X, x)                                            \
+    {                                                                   \
+        extern AVInputFormat ff_##x##_demuxer;                          \
+        if (CONFIG_##X##_INDEV)                                         \
+            av_register_input_format(&ff_##x##_demuxer);                \
+    }
+
+#define REGISTER_INOUTDEV(X, x)                                         \
+    REGISTER_OUTDEV(X, x);                                              \
+    REGISTER_INDEV(X, x)
 
 void avdevice_register_all(void)
 {
@@ -39,19 +49,19 @@ void avdevice_register_all(void)
     initialized = 1;
 
     /* devices */
-    REGISTER_INOUTDEV (ALSA, alsa);
-    REGISTER_INDEV    (BKTR, bktr);
-    REGISTER_INDEV    (DV1394, dv1394);
-    REGISTER_INDEV    (FBDEV, fbdev);
-    REGISTER_INDEV    (JACK, jack);
-    REGISTER_INOUTDEV (OSS, oss);
-    REGISTER_INDEV    (PULSE, pulse);
-    REGISTER_INOUTDEV (SNDIO, sndio);
-    REGISTER_INDEV    (V4L2, v4l2);
-    REGISTER_INDEV    (VFWCAP, vfwcap);
-    REGISTER_INDEV    (X11GRAB, x11grab);
+    REGISTER_INOUTDEV(ALSA,             alsa);
+    REGISTER_INDEV   (BKTR,             bktr);
+    REGISTER_INDEV   (DV1394,           dv1394);
+    REGISTER_INDEV   (FBDEV,            fbdev);
+    REGISTER_INDEV   (JACK,             jack);
+    REGISTER_INOUTDEV(OSS,              oss);
+    REGISTER_INDEV   (PULSE,            pulse);
+    REGISTER_INOUTDEV(SNDIO,            sndio);
+    REGISTER_INDEV   (V4L2,             v4l2);
+    REGISTER_INDEV   (VFWCAP,           vfwcap);
+    REGISTER_INDEV   (X11GRAB,          x11grab);
 
     /* external libraries */
-    REGISTER_INDEV    (LIBCDIO, libcdio);
-    REGISTER_INDEV    (LIBDC1394, libdc1394);
+    REGISTER_INDEV   (LIBCDIO,          libcdio);
+    REGISTER_INDEV   (LIBDC1394,        libdc1394);
 }
index 5ff8ceaccc1a33341ae43d558ba44550aa273210..f3ce91c163357069d361a206b675a19fe6b603bd 100644 (file)
 #include "config.h"
 
 
-#define REGISTER_FILTER(X,x,y) { \
-          extern AVFilter avfilter_##y##_##x ; \
-          if(CONFIG_##X##_FILTER )  avfilter_register(&avfilter_##y##_##x ); }
+#define REGISTER_FILTER(X, x, y)                                        \
+    {                                                                   \
+        extern AVFilter avfilter_##y##_##x;                             \
+        if (CONFIG_##X##_FILTER)                                        \
+            avfilter_register(&avfilter_##y##_##x);                     \
+    }
 
 #define REGISTER_FILTER_UNCONDITIONAL(x)                                \
     {                                                                   \
@@ -41,69 +44,69 @@ void avfilter_register_all(void)
         return;
     initialized = 1;
 
-    REGISTER_FILTER (AFORMAT,     aformat,     af);
-    REGISTER_FILTER (AMIX,        amix,        af);
-    REGISTER_FILTER (ANULL,       anull,       af);
-    REGISTER_FILTER (ASHOWINFO,   ashowinfo,   af);
-    REGISTER_FILTER (ASPLIT,      asplit,      af);
-    REGISTER_FILTER (ASYNCTS,     asyncts,     af);
-    REGISTER_FILTER (CHANNELMAP,  channelmap,  af);
-    REGISTER_FILTER (CHANNELSPLIT,channelsplit,af);
-    REGISTER_FILTER (JOIN,        join,        af);
-    REGISTER_FILTER (RESAMPLE,    resample,    af);
-    REGISTER_FILTER (VOLUME,      volume,      af);
+    REGISTER_FILTER(AFORMAT,        aformat,        af);
+    REGISTER_FILTER(AMIX,           amix,           af);
+    REGISTER_FILTER(ANULL,          anull,          af);
+    REGISTER_FILTER(ASHOWINFO,      ashowinfo,      af);
+    REGISTER_FILTER(ASPLIT,         asplit,         af);
+    REGISTER_FILTER(ASYNCTS,        asyncts,        af);
+    REGISTER_FILTER(CHANNELMAP,     channelmap,     af);
+    REGISTER_FILTER(CHANNELSPLIT,   channelsplit,   af);
+    REGISTER_FILTER(JOIN,           join,           af);
+    REGISTER_FILTER(RESAMPLE,       resample,       af);
+    REGISTER_FILTER(VOLUME,         volume,         af);
 
-    REGISTER_FILTER (ANULLSRC,    anullsrc,    asrc);
+    REGISTER_FILTER(ANULLSRC,       anullsrc,       asrc);
 
-    REGISTER_FILTER (ANULLSINK,   anullsink,   asink);
+    REGISTER_FILTER(ANULLSINK,      anullsink,      asink);
 
-    REGISTER_FILTER (BLACKFRAME,  blackframe,  vf);
-    REGISTER_FILTER (BOXBLUR,     boxblur,     vf);
-    REGISTER_FILTER (COPY,        copy,        vf);
-    REGISTER_FILTER (CROP,        crop,        vf);
-    REGISTER_FILTER (CROPDETECT,  cropdetect,  vf);
-    REGISTER_FILTER (DELOGO,      delogo,      vf);
-    REGISTER_FILTER (DRAWBOX,     drawbox,     vf);
-    REGISTER_FILTER (DRAWTEXT,    drawtext,    vf);
-    REGISTER_FILTER (FADE,        fade,        vf);
-    REGISTER_FILTER (FIELDORDER,  fieldorder,  vf);
-    REGISTER_FILTER (FORMAT,      format,      vf);
-    REGISTER_FILTER (FPS,         fps,         vf);
-    REGISTER_FILTER (FREI0R,      frei0r,      vf);
-    REGISTER_FILTER (GRADFUN,     gradfun,     vf);
-    REGISTER_FILTER (HFLIP,       hflip,       vf);
-    REGISTER_FILTER (HQDN3D,      hqdn3d,      vf);
-    REGISTER_FILTER (LUT,         lut,         vf);
-    REGISTER_FILTER (LUTRGB,      lutrgb,      vf);
-    REGISTER_FILTER (LUTYUV,      lutyuv,      vf);
-    REGISTER_FILTER (NEGATE,      negate,      vf);
-    REGISTER_FILTER (NOFORMAT,    noformat,    vf);
-    REGISTER_FILTER (NULL,        null,        vf);
-    REGISTER_FILTER (OCV,         ocv,         vf);
-    REGISTER_FILTER (OVERLAY,     overlay,     vf);
-    REGISTER_FILTER (PAD,         pad,         vf);
-    REGISTER_FILTER (PIXDESCTEST, pixdesctest, vf);
-    REGISTER_FILTER (SCALE,       scale,       vf);
-    REGISTER_FILTER (SELECT,      select,      vf);
-    REGISTER_FILTER (SETDAR,      setdar,      vf);
-    REGISTER_FILTER (SETPTS,      setpts,      vf);
-    REGISTER_FILTER (SETSAR,      setsar,      vf);
-    REGISTER_FILTER (SETTB,       settb,       vf);
-    REGISTER_FILTER (SHOWINFO,    showinfo,    vf);
-    REGISTER_FILTER (SPLIT,       split,       vf);
-    REGISTER_FILTER (TRANSPOSE,   transpose,   vf);
-    REGISTER_FILTER (UNSHARP,     unsharp,     vf);
-    REGISTER_FILTER (VFLIP,       vflip,       vf);
-    REGISTER_FILTER (YADIF,       yadif,       vf);
+    REGISTER_FILTER(BLACKFRAME,     blackframe,     vf);
+    REGISTER_FILTER(BOXBLUR,        boxblur,        vf);
+    REGISTER_FILTER(COPY,           copy,           vf);
+    REGISTER_FILTER(CROP,           crop,           vf);
+    REGISTER_FILTER(CROPDETECT,     cropdetect,     vf);
+    REGISTER_FILTER(DELOGO,         delogo,         vf);
+    REGISTER_FILTER(DRAWBOX,        drawbox,        vf);
+    REGISTER_FILTER(DRAWTEXT,       drawtext,       vf);
+    REGISTER_FILTER(FADE,           fade,           vf);
+    REGISTER_FILTER(FIELDORDER,     fieldorder,     vf);
+    REGISTER_FILTER(FORMAT,         format,         vf);
+    REGISTER_FILTER(FPS,            fps,            vf);
+    REGISTER_FILTER(FREI0R,         frei0r,         vf);
+    REGISTER_FILTER(GRADFUN,        gradfun,        vf);
+    REGISTER_FILTER(HFLIP,          hflip,          vf);
+    REGISTER_FILTER(HQDN3D,         hqdn3d,         vf);
+    REGISTER_FILTER(LUT,            lut,            vf);
+    REGISTER_FILTER(LUTRGB,         lutrgb,         vf);
+    REGISTER_FILTER(LUTYUV,         lutyuv,         vf);
+    REGISTER_FILTER(NEGATE,         negate,         vf);
+    REGISTER_FILTER(NOFORMAT,       noformat,       vf);
+    REGISTER_FILTER(NULL,           null,           vf);
+    REGISTER_FILTER(OCV,            ocv,            vf);
+    REGISTER_FILTER(OVERLAY,        overlay,        vf);
+    REGISTER_FILTER(PAD,            pad,            vf);
+    REGISTER_FILTER(PIXDESCTEST,    pixdesctest,    vf);
+    REGISTER_FILTER(SCALE,          scale,          vf);
+    REGISTER_FILTER(SELECT,         select,         vf);
+    REGISTER_FILTER(SETDAR,         setdar,         vf);
+    REGISTER_FILTER(SETPTS,         setpts,         vf);
+    REGISTER_FILTER(SETSAR,         setsar,         vf);
+    REGISTER_FILTER(SETTB,          settb,          vf);
+    REGISTER_FILTER(SHOWINFO,       showinfo,       vf);
+    REGISTER_FILTER(SPLIT,          split,          vf);
+    REGISTER_FILTER(TRANSPOSE,      transpose,      vf);
+    REGISTER_FILTER(UNSHARP,        unsharp,        vf);
+    REGISTER_FILTER(VFLIP,          vflip,          vf);
+    REGISTER_FILTER(YADIF,          yadif,          vf);
 
-    REGISTER_FILTER (COLOR,       color,       vsrc);
-    REGISTER_FILTER (FREI0R,      frei0r_src,  vsrc);
-    REGISTER_FILTER (MOVIE,       movie,       vsrc);
-    REGISTER_FILTER (NULLSRC,     nullsrc,     vsrc);
-    REGISTER_FILTER (RGBTESTSRC,  rgbtestsrc,  vsrc);
-    REGISTER_FILTER (TESTSRC,     testsrc,     vsrc);
+    REGISTER_FILTER(COLOR,          color,          vsrc);
+    REGISTER_FILTER(FREI0R,         frei0r_src,     vsrc);
+    REGISTER_FILTER(MOVIE,          movie,          vsrc);
+    REGISTER_FILTER(NULLSRC,        nullsrc,        vsrc);
+    REGISTER_FILTER(RGBTESTSRC,     rgbtestsrc,     vsrc);
+    REGISTER_FILTER(TESTSRC,        testsrc,        vsrc);
 
-    REGISTER_FILTER (NULLSINK,    nullsink,    vsink);
+    REGISTER_FILTER(NULLSINK,       nullsink,       vsink);
 
     /* those filters are part of public or internal API => registered
      * unconditionally */
index 042d3b9aa03ffa5bb21328b3b6a6070c02301807..9a5e2b74efaf7f92a6fc43953258f2045a265f5f 100644 (file)
  * License along with Libav; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
+
 #include "avformat.h"
 #include "rtp.h"
 #include "rdt.h"
 #include "url.h"
 #include "version.h"
 
-#define REGISTER_MUXER(X,x) { \
-    extern AVOutputFormat ff_##x##_muxer; \
-    if(CONFIG_##X##_MUXER) av_register_output_format(&ff_##x##_muxer); }
+#define REGISTER_MUXER(X, x)                                            \
+    {                                                                   \
+        extern AVOutputFormat ff_##x##_muxer;                           \
+        if (CONFIG_##X##_MUXER)                                         \
+            av_register_output_format(&ff_##x##_muxer);                 \
+    }
 
-#define REGISTER_DEMUXER(X,x) { \
-    extern AVInputFormat ff_##x##_demuxer; \
-    if(CONFIG_##X##_DEMUXER) av_register_input_format(&ff_##x##_demuxer); }
+#define REGISTER_DEMUXER(X, x)                                          \
+    {                                                                   \
+        extern AVInputFormat ff_##x##_demuxer;                          \
+        if (CONFIG_##X##_DEMUXER)                                       \
+            av_register_input_format(&ff_##x##_demuxer);                \
+    }
 
-#define REGISTER_MUXDEMUX(X,x)  REGISTER_MUXER(X,x); REGISTER_DEMUXER(X,x)
+#define REGISTER_MUXDEMUX(X, x)                                         \
+    REGISTER_MUXER(X, x);                                               \
+    REGISTER_DEMUXER(X,x)
 
-#define REGISTER_PROTOCOL(X,x) { \
-    extern URLProtocol ff_##x##_protocol; \
-    if(CONFIG_##X##_PROTOCOL) ffurl_register_protocol(&ff_##x##_protocol, sizeof(ff_##x##_protocol)); }
+#define REGISTER_PROTOCOL(X, x)                                         \
+    {                                                                   \
+        extern URLProtocol ff_##x##_protocol;                           \
+        if (CONFIG_##X##_PROTOCOL)                                      \
+            ffurl_register_protocol(&ff_##x##_protocol,                 \
+                                    sizeof(ff_##x##_protocol));         \
+    }
 
 void av_register_all(void)
 {
@@ -49,234 +62,234 @@ void av_register_all(void)
     avcodec_register_all();
 
     /* (de)muxers */
-    REGISTER_MUXER    (A64, a64);
-    REGISTER_DEMUXER  (AAC, aac);
-    REGISTER_MUXDEMUX (AC3, ac3);
-    REGISTER_MUXER    (ADTS, adts);
-    REGISTER_MUXDEMUX (ADX, adx);
-    REGISTER_DEMUXER  (AEA, aea);
-    REGISTER_MUXDEMUX (AIFF, aiff);
-    REGISTER_MUXDEMUX (AMR, amr);
-    REGISTER_DEMUXER  (ANM, anm);
-    REGISTER_DEMUXER  (APC, apc);
-    REGISTER_DEMUXER  (APE, ape);
-    REGISTER_MUXDEMUX (ASF, asf);
-    REGISTER_MUXDEMUX (ASS, ass);
-    REGISTER_MUXER    (ASF_STREAM, asf_stream);
-    REGISTER_MUXDEMUX (AU, au);
-    REGISTER_MUXDEMUX (AVI, avi);
-    REGISTER_DEMUXER  (AVISYNTH, avisynth);
-    REGISTER_MUXER    (AVM2, avm2);
-    REGISTER_DEMUXER  (AVS, avs);
-    REGISTER_DEMUXER  (BETHSOFTVID, bethsoftvid);
-    REGISTER_DEMUXER  (BFI, bfi);
-    REGISTER_DEMUXER  (BINK, bink);
-    REGISTER_DEMUXER  (BMV, bmv);
-    REGISTER_DEMUXER  (C93, c93);
-    REGISTER_DEMUXER  (CAF, caf);
-    REGISTER_MUXDEMUX (CAVSVIDEO, cavsvideo);
-    REGISTER_DEMUXER  (CDG, cdg);
-    REGISTER_DEMUXER  (CDXL, cdxl);
-    REGISTER_MUXER    (CRC, crc);
-    REGISTER_MUXDEMUX (DAUD, daud);
-    REGISTER_DEMUXER  (DFA, dfa);
-    REGISTER_MUXDEMUX (DIRAC, dirac);
-    REGISTER_MUXDEMUX (DNXHD, dnxhd);
-    REGISTER_DEMUXER  (DSICIN, dsicin);
-    REGISTER_MUXDEMUX (DTS, dts);
-    REGISTER_MUXDEMUX (DV, dv);
-    REGISTER_DEMUXER  (DXA, dxa);
-    REGISTER_DEMUXER  (EA, ea);
-    REGISTER_DEMUXER  (EA_CDATA, ea_cdata);
-    REGISTER_MUXDEMUX (EAC3, eac3);
-    REGISTER_MUXDEMUX (FFM, ffm);
-    REGISTER_MUXDEMUX (FFMETADATA, ffmetadata);
-    REGISTER_MUXDEMUX (FILMSTRIP, filmstrip);
-    REGISTER_MUXDEMUX (FLAC, flac);
-    REGISTER_DEMUXER  (FLIC, flic);
-    REGISTER_MUXDEMUX (FLV, flv);
-    REGISTER_DEMUXER  (FOURXM, fourxm);
-    REGISTER_MUXER    (FRAMECRC, framecrc);
-    REGISTER_MUXER    (FRAMEMD5, framemd5);
-    REGISTER_MUXDEMUX (G722, g722);
-    REGISTER_DEMUXER  (G723_1, g723_1);
-    REGISTER_MUXER    (GIF, gif);
-    REGISTER_DEMUXER  (GSM, gsm);
-    REGISTER_MUXDEMUX (GXF, gxf);
-    REGISTER_MUXDEMUX (H261, h261);
-    REGISTER_MUXDEMUX (H263, h263);
-    REGISTER_MUXDEMUX (H264, h264);
-    REGISTER_MUXDEMUX (HLS, hls);
-    REGISTER_DEMUXER  (IDCIN, idcin);
-    REGISTER_DEMUXER  (IFF, iff);
-    REGISTER_MUXDEMUX (ILBC, ilbc);
-    REGISTER_MUXDEMUX (IMAGE2, image2);
-    REGISTER_MUXDEMUX (IMAGE2PIPE, image2pipe);
-    REGISTER_DEMUXER  (INGENIENT, ingenient);
-    REGISTER_DEMUXER  (IPMOVIE, ipmovie);
-    REGISTER_MUXER    (IPOD, ipod);
-    REGISTER_MUXER    (ISMV, ismv);
-    REGISTER_DEMUXER  (ISS, iss);
-    REGISTER_DEMUXER  (IV8, iv8);
-    REGISTER_MUXDEMUX (IVF, ivf);
-    REGISTER_DEMUXER  (JV, jv);
-    REGISTER_MUXDEMUX (LATM, latm);
-    REGISTER_DEMUXER  (LMLM4, lmlm4);
-    REGISTER_DEMUXER  (LXF, lxf);
-    REGISTER_MUXDEMUX (M4V, m4v);
-    REGISTER_MUXER    (MD5, md5);
-    REGISTER_MUXDEMUX (MATROSKA, matroska);
-    REGISTER_MUXER    (MATROSKA_AUDIO, matroska_audio);
-    REGISTER_MUXDEMUX (MJPEG, mjpeg);
-    REGISTER_MUXDEMUX (MLP, mlp);
-    REGISTER_DEMUXER  (MM, mm);
-    REGISTER_MUXDEMUX (MMF, mmf);
-    REGISTER_MUXDEMUX (MOV, mov);
-    REGISTER_MUXER    (MP2, mp2);
-    REGISTER_MUXDEMUX (MP3, mp3);
-    REGISTER_MUXER    (MP4, mp4);
-    REGISTER_DEMUXER  (MPC, mpc);
-    REGISTER_DEMUXER  (MPC8, mpc8);
-    REGISTER_MUXER    (MPEG1SYSTEM, mpeg1system);
-    REGISTER_MUXER    (MPEG1VCD, mpeg1vcd);
-    REGISTER_MUXER    (MPEG1VIDEO, mpeg1video);
-    REGISTER_MUXER    (MPEG2DVD, mpeg2dvd);
-    REGISTER_MUXER    (MPEG2SVCD, mpeg2svcd);
-    REGISTER_MUXER    (MPEG2VIDEO, mpeg2video);
-    REGISTER_MUXER    (MPEG2VOB, mpeg2vob);
-    REGISTER_DEMUXER  (MPEGPS, mpegps);
-    REGISTER_MUXDEMUX (MPEGTS, mpegts);
-    REGISTER_DEMUXER  (MPEGTSRAW, mpegtsraw);
-    REGISTER_DEMUXER  (MPEGVIDEO, mpegvideo);
-    REGISTER_MUXER    (MPJPEG, mpjpeg);
-    REGISTER_DEMUXER  (MSNWC_TCP, msnwc_tcp);
-    REGISTER_DEMUXER  (MTV, mtv);
-    REGISTER_DEMUXER  (MVI, mvi);
-    REGISTER_MUXDEMUX (MXF, mxf);
-    REGISTER_MUXER    (MXF_D10, mxf_d10);
-    REGISTER_DEMUXER  (MXG, mxg);
-    REGISTER_DEMUXER  (NC, nc);
-    REGISTER_DEMUXER  (NSV, nsv);
-    REGISTER_MUXER    (NULL, null);
-    REGISTER_MUXDEMUX (NUT, nut);
-    REGISTER_DEMUXER  (NUV, nuv);
-    REGISTER_MUXDEMUX (OGG, ogg);
-    REGISTER_MUXDEMUX (OMA, oma);
-    REGISTER_MUXDEMUX (PCM_ALAW,  pcm_alaw);
-    REGISTER_MUXDEMUX (PCM_MULAW, pcm_mulaw);
-    REGISTER_MUXDEMUX (PCM_F64BE, pcm_f64be);
-    REGISTER_MUXDEMUX (PCM_F64LE, pcm_f64le);
-    REGISTER_MUXDEMUX (PCM_F32BE, pcm_f32be);
-    REGISTER_MUXDEMUX (PCM_F32LE, pcm_f32le);
-    REGISTER_MUXDEMUX (PCM_S32BE, pcm_s32be);
-    REGISTER_MUXDEMUX (PCM_S32LE, pcm_s32le);
-    REGISTER_MUXDEMUX (PCM_S24BE, pcm_s24be);
-    REGISTER_MUXDEMUX (PCM_S24LE, pcm_s24le);
-    REGISTER_MUXDEMUX (PCM_S16BE, pcm_s16be);
-    REGISTER_MUXDEMUX (PCM_S16LE, pcm_s16le);
-    REGISTER_MUXDEMUX (PCM_S8,    pcm_s8);
-    REGISTER_MUXDEMUX (PCM_U32BE, pcm_u32be);
-    REGISTER_MUXDEMUX (PCM_U32LE, pcm_u32le);
-    REGISTER_MUXDEMUX (PCM_U24BE, pcm_u24be);
-    REGISTER_MUXDEMUX (PCM_U24LE, pcm_u24le);
-    REGISTER_MUXDEMUX (PCM_U16BE, pcm_u16be);
-    REGISTER_MUXDEMUX (PCM_U16LE, pcm_u16le);
-    REGISTER_MUXDEMUX (PCM_U8,    pcm_u8);
-    REGISTER_DEMUXER  (PMP, pmp);
-    REGISTER_MUXER    (PSP, psp);
-    REGISTER_DEMUXER  (PVA, pva);
-    REGISTER_DEMUXER  (QCP, qcp);
-    REGISTER_DEMUXER  (R3D, r3d);
-    REGISTER_MUXDEMUX (RAWVIDEO, rawvideo);
-    REGISTER_DEMUXER  (RL2, rl2);
-    REGISTER_MUXDEMUX (RM, rm);
-    REGISTER_MUXDEMUX (ROQ, roq);
-    REGISTER_DEMUXER  (RPL, rpl);
-    REGISTER_MUXDEMUX (RSO, rso);
-    REGISTER_MUXDEMUX (RTP, rtp);
-    REGISTER_MUXDEMUX (RTSP, rtsp);
-    REGISTER_MUXDEMUX (SAP, sap);
-    REGISTER_DEMUXER  (SDP, sdp);
+    REGISTER_MUXER   (A64,              a64);
+    REGISTER_DEMUXER (AAC,              aac);
+    REGISTER_MUXDEMUX(AC3,              ac3);
+    REGISTER_MUXER   (ADTS,             adts);
+    REGISTER_MUXDEMUX(ADX,              adx);
+    REGISTER_DEMUXER (AEA,              aea);
+    REGISTER_MUXDEMUX(AIFF,             aiff);
+    REGISTER_MUXDEMUX(AMR,              amr);
+    REGISTER_DEMUXER (ANM,              anm);
+    REGISTER_DEMUXER (APC,              apc);
+    REGISTER_DEMUXER (APE,              ape);
+    REGISTER_MUXDEMUX(ASF,              asf);
+    REGISTER_MUXDEMUX(ASS,              ass);
+    REGISTER_MUXER   (ASF_STREAM,       asf_stream);
+    REGISTER_MUXDEMUX(AU,               au);
+    REGISTER_MUXDEMUX(AVI,              avi);
+    REGISTER_DEMUXER (AVISYNTH,         avisynth);
+    REGISTER_MUXER   (AVM2,             avm2);
+    REGISTER_DEMUXER (AVS,              avs);
+    REGISTER_DEMUXER (BETHSOFTVID,      bethsoftvid);
+    REGISTER_DEMUXER (BFI,              bfi);
+    REGISTER_DEMUXER (BINK,             bink);
+    REGISTER_DEMUXER (BMV,              bmv);
+    REGISTER_DEMUXER (C93,              c93);
+    REGISTER_DEMUXER (CAF,              caf);
+    REGISTER_MUXDEMUX(CAVSVIDEO,        cavsvideo);
+    REGISTER_DEMUXER (CDG,              cdg);
+    REGISTER_DEMUXER (CDXL,             cdxl);
+    REGISTER_MUXER   (CRC,              crc);
+    REGISTER_MUXDEMUX(DAUD,             daud);
+    REGISTER_DEMUXER (DFA,              dfa);
+    REGISTER_MUXDEMUX(DIRAC,            dirac);
+    REGISTER_MUXDEMUX(DNXHD,            dnxhd);
+    REGISTER_DEMUXER (DSICIN,           dsicin);
+    REGISTER_MUXDEMUX(DTS,              dts);
+    REGISTER_MUXDEMUX(DV,               dv);
+    REGISTER_DEMUXER (DXA,              dxa);
+    REGISTER_DEMUXER (EA,               ea);
+    REGISTER_DEMUXER (EA_CDATA,         ea_cdata);
+    REGISTER_MUXDEMUX(EAC3,             eac3);
+    REGISTER_MUXDEMUX(FFM,              ffm);
+    REGISTER_MUXDEMUX(FFMETADATA,       ffmetadata);
+    REGISTER_MUXDEMUX(FILMSTRIP,        filmstrip);
+    REGISTER_MUXDEMUX(FLAC,             flac);
+    REGISTER_DEMUXER (FLIC,             flic);
+    REGISTER_MUXDEMUX(FLV,              flv);
+    REGISTER_DEMUXER (FOURXM,           fourxm);
+    REGISTER_MUXER   (FRAMECRC,         framecrc);
+    REGISTER_MUXER   (FRAMEMD5,         framemd5);
+    REGISTER_MUXDEMUX(G722,             g722);
+    REGISTER_DEMUXER (G723_1,           g723_1);
+    REGISTER_MUXER   (GIF,              gif);
+    REGISTER_DEMUXER (GSM,              gsm);
+    REGISTER_MUXDEMUX(GXF,              gxf);
+    REGISTER_MUXDEMUX(H261,             h261);
+    REGISTER_MUXDEMUX(H263,             h263);
+    REGISTER_MUXDEMUX(H264,             h264);
+    REGISTER_MUXDEMUX(HLS,              hls);
+    REGISTER_DEMUXER (IDCIN,            idcin);
+    REGISTER_DEMUXER (IFF,              iff);
+    REGISTER_MUXDEMUX(ILBC,             ilbc);
+    REGISTER_MUXDEMUX(IMAGE2,           image2);
+    REGISTER_MUXDEMUX(IMAGE2PIPE,       image2pipe);
+    REGISTER_DEMUXER (INGENIENT,        ingenient);
+    REGISTER_DEMUXER (IPMOVIE,          ipmovie);
+    REGISTER_MUXER   (IPOD,             ipod);
+    REGISTER_MUXER   (ISMV,             ismv);
+    REGISTER_DEMUXER (ISS,              iss);
+    REGISTER_DEMUXER (IV8,              iv8);
+    REGISTER_MUXDEMUX(IVF,              ivf);
+    REGISTER_DEMUXER (JV,               jv);
+    REGISTER_MUXDEMUX(LATM,             latm);
+    REGISTER_DEMUXER (LMLM4,            lmlm4);
+    REGISTER_DEMUXER (LXF,              lxf);
+    REGISTER_MUXDEMUX(M4V,              m4v);
+    REGISTER_MUXER   (MD5,              md5);
+    REGISTER_MUXDEMUX(MATROSKA,         matroska);
+    REGISTER_MUXER   (MATROSKA_AUDIO,   matroska_audio);
+    REGISTER_MUXDEMUX(MJPEG,            mjpeg);
+    REGISTER_MUXDEMUX(MLP,              mlp);
+    REGISTER_DEMUXER (MM,               mm);
+    REGISTER_MUXDEMUX(MMF,              mmf);
+    REGISTER_MUXDEMUX(MOV,              mov);
+    REGISTER_MUXER   (MP2,              mp2);
+    REGISTER_MUXDEMUX(MP3,              mp3);
+    REGISTER_MUXER   (MP4,              mp4);
+    REGISTER_DEMUXER (MPC,              mpc);
+    REGISTER_DEMUXER (MPC8,             mpc8);
+    REGISTER_MUXER   (MPEG1SYSTEM,      mpeg1system);
+    REGISTER_MUXER   (MPEG1VCD,         mpeg1vcd);
+    REGISTER_MUXER   (MPEG1VIDEO,       mpeg1video);
+    REGISTER_MUXER   (MPEG2DVD,         mpeg2dvd);
+    REGISTER_MUXER   (MPEG2SVCD,        mpeg2svcd);
+    REGISTER_MUXER   (MPEG2VIDEO,       mpeg2video);
+    REGISTER_MUXER   (MPEG2VOB,         mpeg2vob);
+    REGISTER_DEMUXER (MPEGPS,           mpegps);
+    REGISTER_MUXDEMUX(MPEGTS,           mpegts);
+    REGISTER_DEMUXER (MPEGTSRAW,        mpegtsraw);
+    REGISTER_DEMUXER (MPEGVIDEO,        mpegvideo);
+    REGISTER_MUXER   (MPJPEG,           mpjpeg);
+    REGISTER_DEMUXER (MSNWC_TCP,        msnwc_tcp);
+    REGISTER_DEMUXER (MTV,              mtv);
+    REGISTER_DEMUXER (MVI,              mvi);
+    REGISTER_MUXDEMUX(MXF,              mxf);
+    REGISTER_MUXER   (MXF_D10,          mxf_d10);
+    REGISTER_DEMUXER (MXG,              mxg);
+    REGISTER_DEMUXER (NC,               nc);
+    REGISTER_DEMUXER (NSV,              nsv);
+    REGISTER_MUXER   (NULL,             null);
+    REGISTER_MUXDEMUX(NUT,              nut);
+    REGISTER_DEMUXER (NUV,              nuv);
+    REGISTER_MUXDEMUX(OGG,              ogg);
+    REGISTER_MUXDEMUX(OMA,              oma);
+    REGISTER_MUXDEMUX(PCM_ALAW,         pcm_alaw);
+    REGISTER_MUXDEMUX(PCM_MULAW,        pcm_mulaw);
+    REGISTER_MUXDEMUX(PCM_F64BE,        pcm_f64be);
+    REGISTER_MUXDEMUX(PCM_F64LE,        pcm_f64le);
+    REGISTER_MUXDEMUX(PCM_F32BE,        pcm_f32be);
+    REGISTER_MUXDEMUX(PCM_F32LE,        pcm_f32le);
+    REGISTER_MUXDEMUX(PCM_S32BE,        pcm_s32be);
+    REGISTER_MUXDEMUX(PCM_S32LE,        pcm_s32le);
+    REGISTER_MUXDEMUX(PCM_S24BE,        pcm_s24be);
+    REGISTER_MUXDEMUX(PCM_S24LE,        pcm_s24le);
+    REGISTER_MUXDEMUX(PCM_S16BE,        pcm_s16be);
+    REGISTER_MUXDEMUX(PCM_S16LE,        pcm_s16le);
+    REGISTER_MUXDEMUX(PCM_S8,           pcm_s8);
+    REGISTER_MUXDEMUX(PCM_U32BE,        pcm_u32be);
+    REGISTER_MUXDEMUX(PCM_U32LE,        pcm_u32le);
+    REGISTER_MUXDEMUX(PCM_U24BE,        pcm_u24be);
+    REGISTER_MUXDEMUX(PCM_U24LE,        pcm_u24le);
+    REGISTER_MUXDEMUX(PCM_U16BE,        pcm_u16be);
+    REGISTER_MUXDEMUX(PCM_U16LE,        pcm_u16le);
+    REGISTER_MUXDEMUX(PCM_U8,           pcm_u8);
+    REGISTER_DEMUXER (PMP,              pmp);
+    REGISTER_MUXER   (PSP,              psp);
+    REGISTER_DEMUXER (PVA,              pva);
+    REGISTER_DEMUXER (QCP,              qcp);
+    REGISTER_DEMUXER (R3D,              r3d);
+    REGISTER_MUXDEMUX(RAWVIDEO,         rawvideo);
+    REGISTER_DEMUXER (RL2,              rl2);
+    REGISTER_MUXDEMUX(RM,               rm);
+    REGISTER_MUXDEMUX(ROQ,              roq);
+    REGISTER_DEMUXER (RPL,              rpl);
+    REGISTER_MUXDEMUX(RSO,              rso);
+    REGISTER_MUXDEMUX(RTP,              rtp);
+    REGISTER_MUXDEMUX(RTSP,             rtsp);
+    REGISTER_MUXDEMUX(SAP,              sap);
+    REGISTER_DEMUXER (SDP,              sdp);
 #if CONFIG_RTPDEC
     av_register_rtp_dynamic_payload_handlers();
     av_register_rdt_dynamic_payload_handlers();
 #endif
-    REGISTER_DEMUXER  (SEGAFILM, segafilm);
-    REGISTER_MUXER    (SEGMENT, segment);
-    REGISTER_DEMUXER  (SHORTEN, shorten);
-    REGISTER_DEMUXER  (SIFF, siff);
-    REGISTER_DEMUXER  (SMACKER, smacker);
-    REGISTER_MUXDEMUX (SMJPEG, smjpeg);
-    REGISTER_MUXER    (SMOOTHSTREAMING, smoothstreaming);
-    REGISTER_DEMUXER  (SOL, sol);
-    REGISTER_MUXDEMUX (SOX, sox);
-    REGISTER_MUXDEMUX (SPDIF, spdif);
-    REGISTER_MUXDEMUX (SRT, srt);
-    REGISTER_DEMUXER  (STR, str);
-    REGISTER_MUXDEMUX (SWF, swf);
-    REGISTER_DEMUXER  (TAK, tak);
-    REGISTER_MUXER    (TG2, tg2);
-    REGISTER_MUXER    (TGP, tgp);
-    REGISTER_DEMUXER  (THP, thp);
-    REGISTER_DEMUXER  (TIERTEXSEQ, tiertexseq);
-    REGISTER_DEMUXER  (TMV, tmv);
-    REGISTER_MUXDEMUX (TRUEHD, truehd);
-    REGISTER_DEMUXER  (TTA, tta);
-    REGISTER_DEMUXER  (TXD, txd);
-    REGISTER_DEMUXER  (TTY, tty);
-    REGISTER_DEMUXER  (VC1, vc1);
-    REGISTER_MUXDEMUX (VC1T, vc1t);
-    REGISTER_DEMUXER  (VMD, vmd);
-    REGISTER_MUXDEMUX (VOC, voc);
-    REGISTER_DEMUXER  (VQF, vqf);
-    REGISTER_DEMUXER  (W64, w64);
-    REGISTER_MUXDEMUX (WAV, wav);
-    REGISTER_DEMUXER  (WC3, wc3);
-    REGISTER_MUXER    (WEBM, webm);
-    REGISTER_DEMUXER  (WSAUD, wsaud);
-    REGISTER_DEMUXER  (WSVQA, wsvqa);
-    REGISTER_DEMUXER  (WTV, wtv);
-    REGISTER_DEMUXER  (WV, wv);
-    REGISTER_DEMUXER  (XA, xa);
-    REGISTER_DEMUXER  (XMV, xmv);
-    REGISTER_DEMUXER  (XWMA, xwma);
-    REGISTER_DEMUXER  (YOP, yop);
-    REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe);
+    REGISTER_DEMUXER (SEGAFILM,         segafilm);
+    REGISTER_MUXER   (SEGMENT,          segment);
+    REGISTER_DEMUXER (SHORTEN,          shorten);
+    REGISTER_DEMUXER (SIFF,             siff);
+    REGISTER_DEMUXER (SMACKER,          smacker);
+    REGISTER_MUXDEMUX(SMJPEG,           smjpeg);
+    REGISTER_MUXER   (SMOOTHSTREAMING,  smoothstreaming);
+    REGISTER_DEMUXER (SOL,              sol);
+    REGISTER_MUXDEMUX(SOX,              sox);
+    REGISTER_MUXDEMUX(SPDIF,            spdif);
+    REGISTER_MUXDEMUX(SRT,              srt);
+    REGISTER_DEMUXER (STR,              str);
+    REGISTER_MUXDEMUX(SWF,              swf);
+    REGISTER_DEMUXER (TAK,              tak);
+    REGISTER_MUXER   (TG2,              tg2);
+    REGISTER_MUXER   (TGP,              tgp);
+    REGISTER_DEMUXER (THP,              thp);
+    REGISTER_DEMUXER (TIERTEXSEQ,       tiertexseq);
+    REGISTER_DEMUXER (TMV,              tmv);
+    REGISTER_MUXDEMUX(TRUEHD,           truehd);
+    REGISTER_DEMUXER (TTA,              tta);
+    REGISTER_DEMUXER (TXD,              txd);
+    REGISTER_DEMUXER (TTY,              tty);
+    REGISTER_DEMUXER (VC1,              vc1);
+    REGISTER_MUXDEMUX(VC1T,             vc1t);
+    REGISTER_DEMUXER (VMD,              vmd);
+    REGISTER_MUXDEMUX(VOC,              voc);
+    REGISTER_DEMUXER (VQF,              vqf);
+    REGISTER_DEMUXER (W64,              w64);
+    REGISTER_MUXDEMUX(WAV,              wav);
+    REGISTER_DEMUXER (WC3,              wc3);
+    REGISTER_MUXER   (WEBM,             webm);
+    REGISTER_DEMUXER (WSAUD,            wsaud);
+    REGISTER_DEMUXER (WSVQA,            wsvqa);
+    REGISTER_DEMUXER (WTV,              wtv);
+    REGISTER_DEMUXER (WV,               wv);
+    REGISTER_DEMUXER (XA,               xa);
+    REGISTER_DEMUXER (XMV,              xmv);
+    REGISTER_DEMUXER (XWMA,             xwma);
+    REGISTER_DEMUXER (YOP,              yop);
+    REGISTER_MUXDEMUX(YUV4MPEGPIPE,     yuv4mpegpipe);
 
     /* protocols */
 #if FF_API_APPLEHTTP_PROTO
-    REGISTER_PROTOCOL (APPLEHTTP, applehttp);
+    REGISTER_PROTOCOL(APPLEHTTP,        applehttp);
 #endif
-    REGISTER_PROTOCOL (CONCAT, concat);
-    REGISTER_PROTOCOL (CRYPTO, crypto);
-    REGISTER_PROTOCOL (FFRTMPCRYPT, ffrtmpcrypt);
-    REGISTER_PROTOCOL (FFRTMPHTTP, ffrtmphttp);
-    REGISTER_PROTOCOL (FILE, file);
-    REGISTER_PROTOCOL (GOPHER, gopher);
-    REGISTER_PROTOCOL (HLS, hls);
-    REGISTER_PROTOCOL (HTTP, http);
-    REGISTER_PROTOCOL (HTTPPROXY, httpproxy);
-    REGISTER_PROTOCOL (HTTPS, https);
-    REGISTER_PROTOCOL (MMSH, mmsh);
-    REGISTER_PROTOCOL (MMST, mmst);
-    REGISTER_PROTOCOL (MD5,  md5);
-    REGISTER_PROTOCOL (PIPE, pipe);
-    REGISTER_PROTOCOL (RTMP, rtmp);
-    REGISTER_PROTOCOL (RTMPE, rtmpe);
-    REGISTER_PROTOCOL (RTMPS, rtmps);
-    REGISTER_PROTOCOL (RTMPT, rtmpt);
-    REGISTER_PROTOCOL (RTMPTE, rtmpte);
-    REGISTER_PROTOCOL (RTMPTS, rtmpts);
-    REGISTER_PROTOCOL (RTP, rtp);
-    REGISTER_PROTOCOL (SCTP, sctp);
-    REGISTER_PROTOCOL (TCP, tcp);
-    REGISTER_PROTOCOL (TLS, tls);
-    REGISTER_PROTOCOL (UDP, udp);
+    REGISTER_PROTOCOL(CONCAT,           concat);
+    REGISTER_PROTOCOL(CRYPTO,           crypto);
+    REGISTER_PROTOCOL(FFRTMPCRYPT,      ffrtmpcrypt);
+    REGISTER_PROTOCOL(FFRTMPHTTP,       ffrtmphttp);
+    REGISTER_PROTOCOL(FILE,             file);
+    REGISTER_PROTOCOL(GOPHER,           gopher);
+    REGISTER_PROTOCOL(HLS,              hls);
+    REGISTER_PROTOCOL(HTTP,             http);
+    REGISTER_PROTOCOL(HTTPPROXY,        httpproxy);
+    REGISTER_PROTOCOL(HTTPS,            https);
+    REGISTER_PROTOCOL(MMSH,             mmsh);
+    REGISTER_PROTOCOL(MMST,             mmst);
+    REGISTER_PROTOCOL(MD5,              md5);
+    REGISTER_PROTOCOL(PIPE,             pipe);
+    REGISTER_PROTOCOL(RTMP,             rtmp);
+    REGISTER_PROTOCOL(RTMPE,            rtmpe);
+    REGISTER_PROTOCOL(RTMPS,            rtmps);
+    REGISTER_PROTOCOL(RTMPT,            rtmpt);
+    REGISTER_PROTOCOL(RTMPTE,           rtmpte);
+    REGISTER_PROTOCOL(RTMPTS,           rtmpts);
+    REGISTER_PROTOCOL(RTP,              rtp);
+    REGISTER_PROTOCOL(SCTP,             sctp);
+    REGISTER_PROTOCOL(TCP,              tcp);
+    REGISTER_PROTOCOL(TLS,              tls);
+    REGISTER_PROTOCOL(UDP,              udp);
 
     /* external libraries */
-    REGISTER_PROTOCOL (LIBRTMP, librtmp);
-    REGISTER_PROTOCOL (LIBRTMPE, librtmpe);
-    REGISTER_PROTOCOL (LIBRTMPS, librtmps);
-    REGISTER_PROTOCOL (LIBRTMPT, librtmpt);
-    REGISTER_PROTOCOL (LIBRTMPTE, librtmpte);
+    REGISTER_PROTOCOL(LIBRTMP,          librtmp);
+    REGISTER_PROTOCOL(LIBRTMPE,         librtmpe);
+    REGISTER_PROTOCOL(LIBRTMPS,         librtmps);
+    REGISTER_PROTOCOL(LIBRTMPT,         librtmpt);
+    REGISTER_PROTOCOL(LIBRTMPTE,        librtmpte);
 }