1. ffmpeg
  2. Commit c73c87b41298ff81b5a86569b0f680a556fc1a21
Browse code

cosmetics: Prettyprint codec/format/filter registration files

Diego Biurrun authored on 2012/12/25 23:29:39
Showing 4 changed files
libavcodec/allcodecs.c
History View file @ c73c87b
... ... 
@@ -27,24 +27,44 @@
27 27 
 #include "avcodec.h"
28 28 
 #include "config.h"
29 29
30 
-#define REGISTER_HWACCEL(X,x) { \
31 
-          extern AVHWAccel ff_##x##_hwaccel; \
32 
-          if(CONFIG_##X##_HWACCEL) av_register_hwaccel(&ff_##x##_hwaccel); }
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 
+    }
33 36
34 
-#define REGISTER_ENCODER(X,x) { \
35 
-          extern AVCodec ff_##x##_encoder; \
36 
-          if(CONFIG_##X##_ENCODER)  avcodec_register(&ff_##x##_encoder); }
37 
-#define REGISTER_DECODER(X,x) { \
38 
-          extern AVCodec ff_##x##_decoder; \
39 
-          if(CONFIG_##X##_DECODER)  avcodec_register(&ff_##x##_decoder); }
40 
-#define REGISTER_ENCDEC(X,x)  REGISTER_ENCODER(X,x); REGISTER_DECODER(X,x)
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 
+    }
41 43
42 
-#define REGISTER_PARSER(X,x) { \
43 
-          extern AVCodecParser ff_##x##_parser; \
44 
-          if(CONFIG_##X##_PARSER)  av_register_codec_parser(&ff_##x##_parser); }
45 
-#define REGISTER_BSF(X,x) { \
46 
-          extern AVBitStreamFilter ff_##x##_bsf; \
47 
-          if(CONFIG_##X##_BSF)     av_register_bitstream_filter(&ff_##x##_bsf); }
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)                                           \
52 
+    REGISTER_ENCODER(X, x);                                             \
53 
+    REGISTER_DECODER(X,x)
54 
+
55 
+#define REGISTER_PARSER(X, x)                                           \
56 
+    {                                                                   \
57 
+        extern AVCodecParser ff_##x##_parser;                           \
58 
+        if (CONFIG_##X##_PARSER)                                        \
59 
+            av_register_codec_parser(&ff_##x##_parser);                 \
60 
+    }
61 
+
62 
+#define REGISTER_BSF(X, x)                                              \
63 
+    {                                                                   \
64 
+        extern AVBitStreamFilter ff_##x##_bsf;                          \
65 
+        if (CONFIG_##X##_BSF)                                           \
66 
+            av_register_bitstream_filter(&ff_##x##_bsf);                \
67 
+    }
48 68
49 69 
 void avcodec_register_all(void)
50 70 
 {
... ... 
@@ -55,401 +75,401 @@ void avcodec_register_all(void)
55 55 
     initialized = 1;
56 56
57 57 
     /* hardware accelerators */
58 
-    REGISTER_HWACCEL (H263_VAAPI, h263_vaapi);
59 
-    REGISTER_HWACCEL (H264_DXVA2, h264_dxva2);
60 
-    REGISTER_HWACCEL (H264_VAAPI, h264_vaapi);
61 
-    REGISTER_HWACCEL (H264_VDA, h264_vda);
62 
-    REGISTER_HWACCEL (MPEG2_DXVA2, mpeg2_dxva2);
63 
-    REGISTER_HWACCEL (MPEG2_VAAPI, mpeg2_vaapi);
64 
-    REGISTER_HWACCEL (MPEG4_VAAPI, mpeg4_vaapi);
65 
-    REGISTER_HWACCEL (VC1_DXVA2, vc1_dxva2);
66 
-    REGISTER_HWACCEL (VC1_VAAPI, vc1_vaapi);
67 
-    REGISTER_HWACCEL (WMV3_DXVA2, wmv3_dxva2);
68 
-    REGISTER_HWACCEL (WMV3_VAAPI, wmv3_vaapi);
58 
+    REGISTER_HWACCEL(H263_VAAPI,        h263_vaapi);
59 
+    REGISTER_HWACCEL(H264_DXVA2,        h264_dxva2);
60 
+    REGISTER_HWACCEL(H264_VAAPI,        h264_vaapi);
61 
+    REGISTER_HWACCEL(H264_VDA,          h264_vda);
62 
+    REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
63 
+    REGISTER_HWACCEL(MPEG2_VAAPI,       mpeg2_vaapi);
64 
+    REGISTER_HWACCEL(MPEG4_VAAPI,       mpeg4_vaapi);
65 
+    REGISTER_HWACCEL(VC1_DXVA2,         vc1_dxva2);
66 
+    REGISTER_HWACCEL(VC1_VAAPI,         vc1_vaapi);
67 
+    REGISTER_HWACCEL(WMV3_DXVA2,        wmv3_dxva2);
68 
+    REGISTER_HWACCEL(WMV3_VAAPI,        wmv3_vaapi);
69 69
70 70 
     /* video codecs */
71 
-    REGISTER_ENCODER (A64MULTI, a64multi);
72 
-    REGISTER_ENCODER (A64MULTI5, a64multi5);
73 
-    REGISTER_DECODER (AASC, aasc);
74 
-    REGISTER_DECODER (AMV, amv);
75 
-    REGISTER_DECODER (ANM, anm);
76 
-    REGISTER_DECODER (ANSI, ansi);
77 
-    REGISTER_ENCDEC  (ASV1, asv1);
78 
-    REGISTER_ENCDEC  (ASV2, asv2);
79 
-    REGISTER_DECODER (AURA, aura);
80 
-    REGISTER_DECODER (AURA2, aura2);
81 
-    REGISTER_DECODER (AVS, avs);
82 
-    REGISTER_DECODER (BETHSOFTVID, bethsoftvid);
83 
-    REGISTER_DECODER (BFI, bfi);
84 
-    REGISTER_DECODER (BINK, bink);
85 
-    REGISTER_ENCDEC  (BMP, bmp);
86 
-    REGISTER_DECODER (BMV_VIDEO, bmv_video);
87 
-    REGISTER_DECODER (C93, c93);
88 
-    REGISTER_DECODER (CAVS, cavs);
89 
-    REGISTER_DECODER (CDGRAPHICS, cdgraphics);
90 
-    REGISTER_DECODER (CDXL, cdxl);
91 
-    REGISTER_DECODER (CINEPAK, cinepak);
92 
-    REGISTER_ENCDEC  (CLJR, cljr);
93 
-    REGISTER_DECODER (CLLC, cllc);
94 
-    REGISTER_ENCDEC  (COMFORTNOISE, comfortnoise);
95 
-    REGISTER_DECODER (CSCD, cscd);
96 
-    REGISTER_DECODER (CYUV, cyuv);
97 
-    REGISTER_DECODER (DFA, dfa);
98 
-    REGISTER_ENCDEC  (DNXHD, dnxhd);
99 
-    REGISTER_ENCDEC  (DPX, dpx);
100 
-    REGISTER_DECODER (DSICINVIDEO, dsicinvideo);
101 
-    REGISTER_ENCDEC  (DVVIDEO, dvvideo);
102 
-    REGISTER_DECODER (DXA, dxa);
103 
-    REGISTER_DECODER (DXTORY, dxtory);
104 
-    REGISTER_DECODER (EACMV, eacmv);
105 
-    REGISTER_DECODER (EAMAD, eamad);
106 
-    REGISTER_DECODER (EATGQ, eatgq);
107 
-    REGISTER_DECODER (EATGV, eatgv);
108 
-    REGISTER_DECODER (EATQI, eatqi);
109 
-    REGISTER_DECODER (EIGHTBPS, eightbps);
110 
-    REGISTER_DECODER (EIGHTSVX_EXP, eightsvx_exp);
111 
-    REGISTER_DECODER (EIGHTSVX_FIB, eightsvx_fib);
112 
-    REGISTER_DECODER (ESCAPE124, escape124);
113 
-    REGISTER_ENCDEC  (FFV1, ffv1);
114 
-    REGISTER_ENCDEC  (FFVHUFF, ffvhuff);
115 
-    REGISTER_ENCDEC  (FLASHSV, flashsv);
116 
-    REGISTER_DECODER (FLASHSV2, flashsv2);
117 
-    REGISTER_DECODER (FLIC, flic);
118 
-    REGISTER_ENCDEC  (FLV, flv);
119 
-    REGISTER_DECODER (FOURXM, fourxm);
120 
-    REGISTER_DECODER (FRAPS, fraps);
121 
-    REGISTER_DECODER (FRWU, frwu);
122 
-    REGISTER_ENCDEC  (GIF, gif);
123 
-    REGISTER_ENCDEC  (H261, h261);
124 
-    REGISTER_ENCDEC  (H263, h263);
125 
-    REGISTER_DECODER (H263I, h263i);
126 
-    REGISTER_ENCODER (H263P, h263p);
127 
-    REGISTER_DECODER (H264, h264);
128 
-    REGISTER_DECODER (H264_VDPAU, h264_vdpau);
129 
-    REGISTER_ENCDEC  (HUFFYUV, huffyuv);
130 
-    REGISTER_DECODER (IDCIN, idcin);
131 
-    REGISTER_DECODER (IFF_BYTERUN1, iff_byterun1);
132 
-    REGISTER_DECODER (IFF_ILBM, iff_ilbm);
133 
-    REGISTER_DECODER (INDEO2, indeo2);
134 
-    REGISTER_DECODER (INDEO3, indeo3);
135 
-    REGISTER_DECODER (INDEO4, indeo4);
136 
-    REGISTER_DECODER (INDEO5, indeo5);
137 
-    REGISTER_DECODER (INTERPLAY_VIDEO, interplay_video);
138 
-    REGISTER_ENCDEC  (JPEGLS, jpegls);
139 
-    REGISTER_DECODER (JV, jv);
140 
-    REGISTER_DECODER (KGV1, kgv1);
141 
-    REGISTER_DECODER (KMVC, kmvc);
142 
-    REGISTER_DECODER (LAGARITH, lagarith);
143 
-    REGISTER_ENCODER (LJPEG, ljpeg);
144 
-    REGISTER_DECODER (LOCO, loco);
145 
-    REGISTER_DECODER (MDEC, mdec);
146 
-    REGISTER_DECODER (MIMIC, mimic);
147 
-    REGISTER_ENCDEC  (MJPEG, mjpeg);
148 
-    REGISTER_DECODER (MJPEGB, mjpegb);
149 
-    REGISTER_DECODER (MMVIDEO, mmvideo);
150 
-    REGISTER_DECODER (MOTIONPIXELS, motionpixels);
151 
-    REGISTER_DECODER (MPEG_XVMC, mpeg_xvmc);
152 
-    REGISTER_ENCDEC  (MPEG1VIDEO, mpeg1video);
153 
-    REGISTER_ENCDEC  (MPEG2VIDEO, mpeg2video);
154 
-    REGISTER_ENCDEC  (MPEG4, mpeg4);
155 
-    REGISTER_DECODER (MPEG4_VDPAU, mpeg4_vdpau);
156 
-    REGISTER_DECODER (MPEG_VDPAU, mpeg_vdpau);
157 
-    REGISTER_DECODER (MPEG1_VDPAU, mpeg1_vdpau);
158 
-    REGISTER_DECODER (MSA1, msa1);
159 
-    REGISTER_DECODER (MSMPEG4V1, msmpeg4v1);
160 
-    REGISTER_ENCDEC  (MSMPEG4V2, msmpeg4v2);
161 
-    REGISTER_ENCDEC  (MSMPEG4V3, msmpeg4v3);
162 
-    REGISTER_DECODER (MSRLE, msrle);
163 
-    REGISTER_DECODER (MSS1, mss1);
164 
-    REGISTER_DECODER (MSS2, mss2);
165 
-    REGISTER_DECODER (MSVIDEO1, msvideo1);
166 
-    REGISTER_DECODER (MSZH, mszh);
167 
-    REGISTER_DECODER (MTS2, mts2);
168 
-    REGISTER_DECODER (MXPEG, mxpeg);
169 
-    REGISTER_DECODER (NUV, nuv);
170 
-    REGISTER_ENCDEC  (PAM, pam);
171 
-    REGISTER_ENCDEC  (PBM, pbm);
172 
-    REGISTER_ENCDEC  (PCX, pcx);
173 
-    REGISTER_ENCDEC  (PGM, pgm);
174 
-    REGISTER_ENCDEC  (PGMYUV, pgmyuv);
175 
-    REGISTER_DECODER (PICTOR, pictor);
176 
-    REGISTER_ENCDEC  (PNG, png);
177 
-    REGISTER_ENCDEC  (PPM, ppm);
178 
-    REGISTER_ENCDEC  (PRORES, prores);
179 
-    REGISTER_DECODER (PTX, ptx);
180 
-    REGISTER_DECODER (QDRAW, qdraw);
181 
-    REGISTER_DECODER (QPEG, qpeg);
182 
-    REGISTER_ENCDEC  (QTRLE, qtrle);
183 
-    REGISTER_DECODER (R10K,  r10k);
184 
-    REGISTER_DECODER (R210,  r210);
185 
-    REGISTER_ENCDEC  (RAWVIDEO, rawvideo);
186 
-    REGISTER_DECODER (RL2, rl2);
187 
-    REGISTER_ENCDEC  (ROQ, roq);
188 
-    REGISTER_DECODER (RPZA, rpza);
189 
-    REGISTER_ENCDEC  (RV10, rv10);
190 
-    REGISTER_ENCDEC  (RV20, rv20);
191 
-    REGISTER_DECODER (RV30, rv30);
192 
-    REGISTER_DECODER (RV40, rv40);
193 
-    REGISTER_DECODER (S302M, s302m);
194 
-    REGISTER_ENCDEC  (SGI, sgi);
195 
-    REGISTER_DECODER (SMACKER, smacker);
196 
-    REGISTER_DECODER (SMC, smc);
197 
-    REGISTER_ENCDEC  (SNOW, snow);
198 
-    REGISTER_DECODER (SP5X, sp5x);
199 
-    REGISTER_ENCDEC  (SUNRAST, sunrast);
200 
-    REGISTER_ENCDEC  (SVQ1, svq1);
201 
-    REGISTER_DECODER (SVQ3, svq3);
202 
-    REGISTER_ENCDEC  (TARGA, targa);
203 
-    REGISTER_DECODER (THEORA, theora);
204 
-    REGISTER_DECODER (THP, thp);
205 
-    REGISTER_DECODER (TIERTEXSEQVIDEO, tiertexseqvideo);
206 
-    REGISTER_ENCDEC  (TIFF, tiff);
207 
-    REGISTER_DECODER (TMV, tmv);
208 
-    REGISTER_DECODER (TRUEMOTION1, truemotion1);
209 
-    REGISTER_DECODER (TRUEMOTION2, truemotion2);
210 
-    REGISTER_DECODER (TSCC, tscc);
211 
-    REGISTER_DECODER (TSCC2, tscc2);
212 
-    REGISTER_DECODER (TXD, txd);
213 
-    REGISTER_DECODER (ULTI, ulti);
214 
-    REGISTER_ENCDEC  (UTVIDEO, utvideo);
215 
-    REGISTER_ENCDEC  (V210,  v210);
216 
-    REGISTER_DECODER (V210X, v210x);
217 
-    REGISTER_ENCDEC  (V410, v410);
218 
-    REGISTER_DECODER (VB, vb);
219 
-    REGISTER_DECODER (VBLE, vble);
220 
-    REGISTER_DECODER (VC1, vc1);
221 
-    REGISTER_DECODER (VC1_VDPAU, vc1_vdpau);
222 
-    REGISTER_DECODER (VC1IMAGE, vc1image);
223 
-    REGISTER_DECODER (VCR1, vcr1);
224 
-    REGISTER_DECODER (VMDVIDEO, vmdvideo);
225 
-    REGISTER_DECODER (VMNC, vmnc);
226 
-    REGISTER_DECODER (VP3, vp3);
227 
-    REGISTER_DECODER (VP5, vp5);
228 
-    REGISTER_DECODER (VP6, vp6);
229 
-    REGISTER_DECODER (VP6A, vp6a);
230 
-    REGISTER_DECODER (VP6F, vp6f);
231 
-    REGISTER_DECODER (VP8, vp8);
232 
-    REGISTER_DECODER (VQA, vqa);
233 
-    REGISTER_ENCDEC  (WMV1, wmv1);
234 
-    REGISTER_ENCDEC  (WMV2, wmv2);
235 
-    REGISTER_DECODER (WMV3, wmv3);
236 
-    REGISTER_DECODER (WMV3_VDPAU, wmv3_vdpau);
237 
-    REGISTER_DECODER (WMV3IMAGE, wmv3image);
238 
-    REGISTER_DECODER (WNV1, wnv1);
239 
-    REGISTER_DECODER (XAN_WC3, xan_wc3);
240 
-    REGISTER_DECODER (XAN_WC4, xan_wc4);
241 
-    REGISTER_ENCODER (XBM, xbm);
242 
-    REGISTER_DECODER (XL, xl);
243 
-    REGISTER_ENCDEC  (XWD, xwd);
244 
-    REGISTER_DECODER (YOP, yop);
245 
-    REGISTER_DECODER (ZEROCODEC, zerocodec);
246 
-    REGISTER_ENCDEC  (ZLIB, zlib);
247 
-    REGISTER_ENCDEC  (ZMBV, zmbv);
71 
+    REGISTER_ENCODER(A64MULTI,          a64multi);
72 
+    REGISTER_ENCODER(A64MULTI5,         a64multi5);
73 
+    REGISTER_DECODER(AASC,              aasc);
74 
+    REGISTER_DECODER(AMV,               amv);
75 
+    REGISTER_DECODER(ANM,               anm);
76 
+    REGISTER_DECODER(ANSI,              ansi);
77 
+    REGISTER_ENCDEC (ASV1,              asv1);
78 
+    REGISTER_ENCDEC (ASV2,              asv2);
79 
+    REGISTER_DECODER(AURA,              aura);
80 
+    REGISTER_DECODER(AURA2,             aura2);
81 
+    REGISTER_DECODER(AVS,               avs);
82 
+    REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
83 
+    REGISTER_DECODER(BFI,               bfi);
84 
+    REGISTER_DECODER(BINK,              bink);
85 
+    REGISTER_ENCDEC (BMP,               bmp);
86 
+    REGISTER_DECODER(BMV_VIDEO,         bmv_video);
87 
+    REGISTER_DECODER(C93,               c93);
88 
+    REGISTER_DECODER(CAVS,              cavs);
89 
+    REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
90 
+    REGISTER_DECODER(CDXL,              cdxl);
91 
+    REGISTER_DECODER(CINEPAK,           cinepak);
92 
+    REGISTER_ENCDEC (CLJR,              cljr);
93 
+    REGISTER_DECODER(CLLC,              cllc);
94 
+    REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
95 
+    REGISTER_DECODER(CSCD,              cscd);
96 
+    REGISTER_DECODER(CYUV,              cyuv);
97 
+    REGISTER_DECODER(DFA,               dfa);
98 
+    REGISTER_ENCDEC (DNXHD,             dnxhd);
99 
+    REGISTER_ENCDEC (DPX,               dpx);
100 
+    REGISTER_DECODER(DSICINVIDEO,       dsicinvideo);
101 
+    REGISTER_ENCDEC (DVVIDEO,           dvvideo);
102 
+    REGISTER_DECODER(DXA,               dxa);
103 
+    REGISTER_DECODER(DXTORY,            dxtory);
104 
+    REGISTER_DECODER(EACMV,             eacmv);
105 
+    REGISTER_DECODER(EAMAD,             eamad);
106 
+    REGISTER_DECODER(EATGQ,             eatgq);
107 
+    REGISTER_DECODER(EATGV,             eatgv);
108 
+    REGISTER_DECODER(EATQI,             eatqi);
109 
+    REGISTER_DECODER(EIGHTBPS,          eightbps);
110 
+    REGISTER_DECODER(EIGHTSVX_EXP,      eightsvx_exp);
111 
+    REGISTER_DECODER(EIGHTSVX_FIB,      eightsvx_fib);
112 
+    REGISTER_DECODER(ESCAPE124,         escape124);
113 
+    REGISTER_ENCDEC (FFV1,              ffv1);
114 
+    REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
115 
+    REGISTER_ENCDEC (FLASHSV,           flashsv);
116 
+    REGISTER_DECODER(FLASHSV2,          flashsv2);
117 
+    REGISTER_DECODER(FLIC,              flic);
118 
+    REGISTER_ENCDEC (FLV,               flv);
119 
+    REGISTER_DECODER(FOURXM,            fourxm);
120 
+    REGISTER_DECODER(FRAPS,             fraps);
121 
+    REGISTER_DECODER(FRWU,              frwu);
122 
+    REGISTER_ENCDEC (GIF,               gif);
123 
+    REGISTER_ENCDEC (H261,              h261);
124 
+    REGISTER_ENCDEC (H263,              h263);
125 
+    REGISTER_DECODER(H263I,             h263i);
126 
+    REGISTER_ENCODER(H263P,             h263p);
127 
+    REGISTER_DECODER(H264,              h264);
128 
+    REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
129 
+    REGISTER_ENCDEC (HUFFYUV,           huffyuv);
130 
+    REGISTER_DECODER(IDCIN,             idcin);
131 
+    REGISTER_DECODER(IFF_BYTERUN1,      iff_byterun1);
132 
+    REGISTER_DECODER(IFF_ILBM,          iff_ilbm);
133 
+    REGISTER_DECODER(INDEO2,            indeo2);
134 
+    REGISTER_DECODER(INDEO3,            indeo3);
135 
+    REGISTER_DECODER(INDEO4,            indeo4);
136 
+    REGISTER_DECODER(INDEO5,            indeo5);
137 
+    REGISTER_DECODER(INTERPLAY_VIDEO,   interplay_video);
138 
+    REGISTER_ENCDEC (JPEGLS,            jpegls);
139 
+    REGISTER_DECODER(JV,                jv);
140 
+    REGISTER_DECODER(KGV1,              kgv1);
141 
+    REGISTER_DECODER(KMVC,              kmvc);
142 
+    REGISTER_DECODER(LAGARITH,          lagarith);
143 
+    REGISTER_ENCODER(LJPEG,             ljpeg);
144 
+    REGISTER_DECODER(LOCO,              loco);
145 
+    REGISTER_DECODER(MDEC,              mdec);
146 
+    REGISTER_DECODER(MIMIC,             mimic);
147 
+    REGISTER_ENCDEC (MJPEG,             mjpeg);
148 
+    REGISTER_DECODER(MJPEGB,            mjpegb);
149 
+    REGISTER_DECODER(MMVIDEO,           mmvideo);
150 
+    REGISTER_DECODER(MOTIONPIXELS,      motionpixels);
151 
+    REGISTER_DECODER(MPEG_XVMC,         mpeg_xvmc);
152 
+    REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
153 
+    REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
154 
+    REGISTER_ENCDEC (MPEG4,             mpeg4);
155 
+    REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);
156 
+    REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);
157 
+    REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);
158 
+    REGISTER_DECODER(MSA1,              msa1);
159 
+    REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
160 
+    REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
161 
+    REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
162 
+    REGISTER_DECODER(MSRLE,             msrle);
163 
+    REGISTER_DECODER(MSS1,              mss1);
164 
+    REGISTER_DECODER(MSS2,              mss2);
165 
+    REGISTER_DECODER(MSVIDEO1,          msvideo1);
166 
+    REGISTER_DECODER(MSZH,              mszh);
167 
+    REGISTER_DECODER(MTS2,              mts2);
168 
+    REGISTER_DECODER(MXPEG,             mxpeg);
169 
+    REGISTER_DECODER(NUV,               nuv);
170 
+    REGISTER_ENCDEC (PAM,               pam);
171 
+    REGISTER_ENCDEC (PBM,               pbm);
172 
+    REGISTER_ENCDEC (PCX,               pcx);
173 
+    REGISTER_ENCDEC (PGM,               pgm);
174 
+    REGISTER_ENCDEC (PGMYUV,            pgmyuv);
175 
+    REGISTER_DECODER(PICTOR,            pictor);
176 
+    REGISTER_ENCDEC (PNG,               png);
177 
+    REGISTER_ENCDEC (PPM,               ppm);
178 
+    REGISTER_ENCDEC (PRORES,            prores);
179 
+    REGISTER_DECODER(PTX,               ptx);
180 
+    REGISTER_DECODER(QDRAW,             qdraw);
181 
+    REGISTER_DECODER(QPEG,              qpeg);
182 
+    REGISTER_ENCDEC (QTRLE,             qtrle);
183 
+    REGISTER_DECODER(R10K,              r10k);
184 
+    REGISTER_DECODER(R210,              r210);
185 
+    REGISTER_ENCDEC (RAWVIDEO,          rawvideo);
186 
+    REGISTER_DECODER(RL2,               rl2);
187 
+    REGISTER_ENCDEC (ROQ,               roq);
188 
+    REGISTER_DECODER(RPZA,              rpza);
189 
+    REGISTER_ENCDEC (RV10,              rv10);
190 
+    REGISTER_ENCDEC (RV20,              rv20);
191 
+    REGISTER_DECODER(RV30,              rv30);
192 
+    REGISTER_DECODER(RV40,              rv40);
193 
+    REGISTER_DECODER(S302M,             s302m);
194 
+    REGISTER_ENCDEC (SGI,               sgi);
195 
+    REGISTER_DECODER(SMACKER,           smacker);
196 
+    REGISTER_DECODER(SMC,               smc);
197 
+    REGISTER_ENCDEC (SNOW,              snow);
198 
+    REGISTER_DECODER(SP5X,              sp5x);
199 
+    REGISTER_ENCDEC (SUNRAST,           sunrast);
200 
+    REGISTER_ENCDEC (SVQ1,              svq1);
201 
+    REGISTER_DECODER(SVQ3,              svq3);
202 
+    REGISTER_ENCDEC (TARGA,             targa);
203 
+    REGISTER_DECODER(THEORA,            theora);
204 
+    REGISTER_DECODER(THP,               thp);
205 
+    REGISTER_DECODER(TIERTEXSEQVIDEO,   tiertexseqvideo);
206 
+    REGISTER_ENCDEC (TIFF,              tiff);
207 
+    REGISTER_DECODER(TMV,               tmv);
208 
+    REGISTER_DECODER(TRUEMOTION1,       truemotion1);
209 
+    REGISTER_DECODER(TRUEMOTION2,       truemotion2);
210 
+    REGISTER_DECODER(TSCC,              tscc);
211 
+    REGISTER_DECODER(TSCC2,             tscc2);
212 
+    REGISTER_DECODER(TXD,               txd);
213 
+    REGISTER_DECODER(ULTI,              ulti);
214 
+    REGISTER_ENCDEC (UTVIDEO,           utvideo);
215 
+    REGISTER_ENCDEC (V210,              v210);
216 
+    REGISTER_DECODER(V210X,             v210x);
217 
+    REGISTER_ENCDEC (V410,              v410);
218 
+    REGISTER_DECODER(VB,                vb);
219 
+    REGISTER_DECODER(VBLE,              vble);
220 
+    REGISTER_DECODER(VC1,               vc1);
221 
+    REGISTER_DECODER(VC1_VDPAU,         vc1_vdpau);
222 
+    REGISTER_DECODER(VC1IMAGE,          vc1image);
223 
+    REGISTER_DECODER(VCR1,              vcr1);
224 
+    REGISTER_DECODER(VMDVIDEO,          vmdvideo);
225 
+    REGISTER_DECODER(VMNC,              vmnc);
226 
+    REGISTER_DECODER(VP3,               vp3);
227 
+    REGISTER_DECODER(VP5,               vp5);
228 
+    REGISTER_DECODER(VP6,               vp6);
229 
+    REGISTER_DECODER(VP6A,              vp6a);
230 
+    REGISTER_DECODER(VP6F,              vp6f);
231 
+    REGISTER_DECODER(VP8,               vp8);
232 
+    REGISTER_DECODER(VQA,               vqa);
233 
+    REGISTER_ENCDEC (WMV1,              wmv1);
234 
+    REGISTER_ENCDEC (WMV2,              wmv2);
235 
+    REGISTER_DECODER(WMV3,              wmv3);
236 
+    REGISTER_DECODER(WMV3_VDPAU,        wmv3_vdpau);
237 
+    REGISTER_DECODER(WMV3IMAGE,         wmv3image);
238 
+    REGISTER_DECODER(WNV1,              wnv1);
239 
+    REGISTER_DECODER(XAN_WC3,           xan_wc3);
240 
+    REGISTER_DECODER(XAN_WC4,           xan_wc4);
241 
+    REGISTER_ENCODER(XBM,               xbm);
242 
+    REGISTER_DECODER(XL,                xl);
243 
+    REGISTER_ENCDEC (XWD,               xwd);
244 
+    REGISTER_DECODER(YOP,               yop);
245 
+    REGISTER_DECODER(ZEROCODEC,         zerocodec);
246 
+    REGISTER_ENCDEC (ZLIB,              zlib);
247 
+    REGISTER_ENCDEC (ZMBV,              zmbv);
248 248
249 249 
     /* audio codecs */
250 
-    REGISTER_ENCDEC  (AAC, aac);
251 
-    REGISTER_DECODER (AAC_LATM, aac_latm);
252 
-    REGISTER_ENCDEC  (AC3, ac3);
253 
-    REGISTER_ENCODER (AC3_FIXED, ac3_fixed);
254 
-    REGISTER_ENCDEC  (ALAC, alac);
255 
-    REGISTER_DECODER (ALS, als);
256 
-    REGISTER_DECODER (AMRNB, amrnb);
257 
-    REGISTER_DECODER (AMRWB, amrwb);
258 
-    REGISTER_DECODER (APE, ape);
259 
-    REGISTER_DECODER (ATRAC1, atrac1);
260 
-    REGISTER_DECODER (ATRAC3, atrac3);
261 
-    REGISTER_DECODER (BINKAUDIO_DCT, binkaudio_dct);
262 
-    REGISTER_DECODER (BINKAUDIO_RDFT, binkaudio_rdft);
263 
-    REGISTER_DECODER (BMV_AUDIO, bmv_audio);
264 
-    REGISTER_DECODER (COOK, cook);
265 
-    REGISTER_DECODER (DCA, dca);
266 
-    REGISTER_DECODER (DSICINAUDIO, dsicinaudio);
267 
-    REGISTER_ENCDEC  (EAC3, eac3);
268 
-    REGISTER_ENCDEC  (FLAC, flac);
269 
-    REGISTER_DECODER (G723_1, g723_1);
270 
-    REGISTER_DECODER (GSM, gsm);
271 
-    REGISTER_DECODER (GSM_MS, gsm_ms);
272 
-    REGISTER_DECODER (IAC, iac);
273 
-    REGISTER_DECODER (IMC, imc);
274 
-    REGISTER_DECODER (MACE3, mace3);
275 
-    REGISTER_DECODER (MACE6, mace6);
276 
-    REGISTER_DECODER (MLP, mlp);
277 
-    REGISTER_DECODER (MP1, mp1);
278 
-    REGISTER_DECODER (MP1FLOAT, mp1float);
279 
-    REGISTER_ENCDEC  (MP2, mp2);
280 
-    REGISTER_DECODER (MP2FLOAT, mp2float);
281 
-    REGISTER_DECODER (MP3, mp3);
282 
-    REGISTER_DECODER (MP3FLOAT, mp3float);
283 
-    REGISTER_DECODER (MP3ADU, mp3adu);
284 
-    REGISTER_DECODER (MP3ADUFLOAT, mp3adufloat);
285 
-    REGISTER_DECODER (MP3ON4, mp3on4);
286 
-    REGISTER_DECODER (MP3ON4FLOAT, mp3on4float);
287 
-    REGISTER_DECODER (MPC7, mpc7);
288 
-    REGISTER_DECODER (MPC8, mpc8);
289 
-    REGISTER_ENCDEC  (NELLYMOSER, nellymoser);
290 
-    REGISTER_DECODER (QCELP, qcelp);
291 
-    REGISTER_DECODER (QDM2, qdm2);
292 
-    REGISTER_ENCDEC  (RA_144, ra_144);
293 
-    REGISTER_DECODER (RA_288, ra_288);
294 
-    REGISTER_DECODER (RALF, ralf);
295 
-    REGISTER_DECODER (SHORTEN, shorten);
296 
-    REGISTER_DECODER (SIPR, sipr);
297 
-    REGISTER_DECODER (SMACKAUD, smackaud);
298 
-    REGISTER_DECODER (TAK, tak);
299 
-    REGISTER_DECODER (TRUEHD, truehd);
300 
-    REGISTER_DECODER (TRUESPEECH, truespeech);
301 
-    REGISTER_DECODER (TTA, tta);
302 
-    REGISTER_DECODER (TWINVQ, twinvq);
303 
-    REGISTER_DECODER (VMDAUDIO, vmdaudio);
304 
-    REGISTER_ENCDEC  (VORBIS, vorbis);
305 
-    REGISTER_DECODER (WAVPACK, wavpack);
306 
-    REGISTER_DECODER (WMALOSSLESS, wmalossless);
307 
-    REGISTER_DECODER (WMAPRO, wmapro);
308 
-    REGISTER_ENCDEC  (WMAV1, wmav1);
309 
-    REGISTER_ENCDEC  (WMAV2, wmav2);
310 
-    REGISTER_DECODER (WMAVOICE, wmavoice);
311 
-    REGISTER_DECODER (WS_SND1, ws_snd1);
250 
+    REGISTER_ENCDEC (AAC,               aac);
251 
+    REGISTER_DECODER(AAC_LATM,          aac_latm);
252 
+    REGISTER_ENCDEC (AC3,               ac3);
253 
+    REGISTER_ENCODER(AC3_FIXED,         ac3_fixed);
254 
+    REGISTER_ENCDEC (ALAC,              alac);
255 
+    REGISTER_DECODER(ALS,               als);
256 
+    REGISTER_DECODER(AMRNB,             amrnb);
257 
+    REGISTER_DECODER(AMRWB,             amrwb);
258 
+    REGISTER_DECODER(APE,               ape);
259 
+    REGISTER_DECODER(ATRAC1,            atrac1);
260 
+    REGISTER_DECODER(ATRAC3,            atrac3);
261 
+    REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
262 
+    REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
263 
+    REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
264 
+    REGISTER_DECODER(COOK,              cook);
265 
+    REGISTER_DECODER(DCA,               dca);
266 
+    REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
267 
+    REGISTER_ENCDEC (EAC3,              eac3);
268 
+    REGISTER_ENCDEC (FLAC,              flac);
269 
+    REGISTER_DECODER(G723_1,            g723_1);
270 
+    REGISTER_DECODER(GSM,               gsm);
271 
+    REGISTER_DECODER(GSM_MS,            gsm_ms);
272 
+    REGISTER_DECODER(IAC,               iac);
273 
+    REGISTER_DECODER(IMC,               imc);
274 
+    REGISTER_DECODER(MACE3,             mace3);
275 
+    REGISTER_DECODER(MACE6,             mace6);
276 
+    REGISTER_DECODER(MLP,               mlp);
277 
+    REGISTER_DECODER(MP1,               mp1);
278 
+    REGISTER_DECODER(MP1FLOAT,          mp1float);
279 
+    REGISTER_ENCDEC (MP2,               mp2);
280 
+    REGISTER_DECODER(MP2FLOAT,          mp2float);
281 
+    REGISTER_DECODER(MP3,               mp3);
282 
+    REGISTER_DECODER(MP3FLOAT,          mp3float);
283 
+    REGISTER_DECODER(MP3ADU,            mp3adu);
284 
+    REGISTER_DECODER(MP3ADUFLOAT,       mp3adufloat);
285 
+    REGISTER_DECODER(MP3ON4,            mp3on4);
286 
+    REGISTER_DECODER(MP3ON4FLOAT,       mp3on4float);
287 
+    REGISTER_DECODER(MPC7,              mpc7);
288 
+    REGISTER_DECODER(MPC8,              mpc8);
289 
+    REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
290 
+    REGISTER_DECODER(QCELP,             qcelp);
291 
+    REGISTER_DECODER(QDM2,              qdm2);
292 
+    REGISTER_ENCDEC (RA_144,            ra_144);
293 
+    REGISTER_DECODER(RA_288,            ra_288);
294 
+    REGISTER_DECODER(RALF,              ralf);
295 
+    REGISTER_DECODER(SHORTEN,           shorten);
296 
+    REGISTER_DECODER(SIPR,              sipr);
297 
+    REGISTER_DECODER(SMACKAUD,          smackaud);
298 
+    REGISTER_DECODER(TAK,               tak);
299 
+    REGISTER_DECODER(TRUEHD,            truehd);
300 
+    REGISTER_DECODER(TRUESPEECH,        truespeech);
301 
+    REGISTER_DECODER(TTA,               tta);
302 
+    REGISTER_DECODER(TWINVQ,            twinvq);
303 
+    REGISTER_DECODER(VMDAUDIO,          vmdaudio);
304 
+    REGISTER_ENCDEC (VORBIS,            vorbis);
305 
+    REGISTER_DECODER(WAVPACK,           wavpack);
306 
+    REGISTER_DECODER(WMALOSSLESS,       wmalossless);
307 
+    REGISTER_DECODER(WMAPRO,            wmapro);
308 
+    REGISTER_ENCDEC (WMAV1,             wmav1);
309 
+    REGISTER_ENCDEC (WMAV2,             wmav2);
310 
+    REGISTER_DECODER(WMAVOICE,          wmavoice);
311 
+    REGISTER_DECODER(WS_SND1,           ws_snd1);
312 312
313 313 
     /* PCM codecs */
314 
-    REGISTER_ENCDEC  (PCM_ALAW, pcm_alaw);
315 
-    REGISTER_DECODER (PCM_BLURAY, pcm_bluray);
316 
-    REGISTER_DECODER (PCM_DVD, pcm_dvd);
317 
-    REGISTER_ENCDEC  (PCM_F32BE, pcm_f32be);
318 
-    REGISTER_ENCDEC  (PCM_F32LE, pcm_f32le);
319 
-    REGISTER_ENCDEC  (PCM_F64BE, pcm_f64be);
320 
-    REGISTER_ENCDEC  (PCM_F64LE, pcm_f64le);
321 
-    REGISTER_DECODER (PCM_LXF, pcm_lxf);
322 
-    REGISTER_ENCDEC  (PCM_MULAW, pcm_mulaw);
323 
-    REGISTER_ENCDEC  (PCM_S8, pcm_s8);
324 
-    REGISTER_DECODER (PCM_S8_PLANAR, pcm_s8_planar);
325 
-    REGISTER_ENCDEC  (PCM_S16BE, pcm_s16be);
326 
-    REGISTER_ENCDEC  (PCM_S16LE, pcm_s16le);
327 
-    REGISTER_DECODER (PCM_S16LE_PLANAR, pcm_s16le_planar);
328 
-    REGISTER_ENCDEC  (PCM_S24BE, pcm_s24be);
329 
-    REGISTER_ENCDEC  (PCM_S24DAUD, pcm_s24daud);
330 
-    REGISTER_ENCDEC  (PCM_S24LE, pcm_s24le);
331 
-    REGISTER_ENCDEC  (PCM_S32BE, pcm_s32be);
332 
-    REGISTER_ENCDEC  (PCM_S32LE, pcm_s32le);
333 
-    REGISTER_ENCDEC  (PCM_U8, pcm_u8);
334 
-    REGISTER_ENCDEC  (PCM_U16BE, pcm_u16be);
335 
-    REGISTER_ENCDEC  (PCM_U16LE, pcm_u16le);
336 
-    REGISTER_ENCDEC  (PCM_U24BE, pcm_u24be);
337 
-    REGISTER_ENCDEC  (PCM_U24LE, pcm_u24le);
338 
-    REGISTER_ENCDEC  (PCM_U32BE, pcm_u32be);
339 
-    REGISTER_ENCDEC  (PCM_U32LE, pcm_u32le);
340 
-    REGISTER_DECODER (PCM_ZORK , pcm_zork);
314 
+    REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
315 
+    REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
316 
+    REGISTER_DECODER(PCM_DVD,           pcm_dvd);
317 
+    REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
318 
+    REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
319 
+    REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
320 
+    REGISTER_ENCDEC (PCM_F64LE,         pcm_f64le);
321 
+    REGISTER_DECODER(PCM_LXF,           pcm_lxf);
322 
+    REGISTER_ENCDEC (PCM_MULAW,         pcm_mulaw);
323 
+    REGISTER_ENCDEC (PCM_S8,            pcm_s8);
324 
+    REGISTER_DECODER(PCM_S8_PLANAR,     pcm_s8_planar);
325 
+    REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
326 
+    REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
327 
+    REGISTER_DECODER(PCM_S16LE_PLANAR,  pcm_s16le_planar);
328 
+    REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
329 
+    REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
330 
+    REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
331 
+    REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
332 
+    REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
333 
+    REGISTER_ENCDEC (PCM_U8,            pcm_u8);
334 
+    REGISTER_ENCDEC (PCM_U16BE,         pcm_u16be);
335 
+    REGISTER_ENCDEC (PCM_U16LE,         pcm_u16le);
336 
+    REGISTER_ENCDEC (PCM_U24BE,         pcm_u24be);
337 
+    REGISTER_ENCDEC (PCM_U24LE,         pcm_u24le);
338 
+    REGISTER_ENCDEC (PCM_U32BE,         pcm_u32be);
339 
+    REGISTER_ENCDEC (PCM_U32LE,         pcm_u32le);
340 
+    REGISTER_DECODER(PCM_ZORK ,         pcm_zork);
341 341
342 342 
     /* DPCM codecs */
343 
-    REGISTER_DECODER (INTERPLAY_DPCM, interplay_dpcm);
344 
-    REGISTER_ENCDEC  (ROQ_DPCM, roq_dpcm);
345 
-    REGISTER_DECODER (SOL_DPCM, sol_dpcm);
346 
-    REGISTER_DECODER (XAN_DPCM, xan_dpcm);
343 
+    REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
344 
+    REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
345 
+    REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
346 
+    REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
347 347
348 348 
     /* ADPCM codecs */
349 
-    REGISTER_DECODER (ADPCM_4XM, adpcm_4xm);
350 
-    REGISTER_ENCDEC  (ADPCM_ADX, adpcm_adx);
351 
-    REGISTER_DECODER (ADPCM_CT, adpcm_ct);
352 
-    REGISTER_DECODER (ADPCM_EA, adpcm_ea);
353 
-    REGISTER_DECODER (ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
354 
-    REGISTER_DECODER (ADPCM_EA_R1, adpcm_ea_r1);
355 
-    REGISTER_DECODER (ADPCM_EA_R2, adpcm_ea_r2);
356 
-    REGISTER_DECODER (ADPCM_EA_R3, adpcm_ea_r3);
357 
-    REGISTER_DECODER (ADPCM_EA_XAS, adpcm_ea_xas);
358 
-    REGISTER_ENCDEC  (ADPCM_G722, adpcm_g722);
359 
-    REGISTER_ENCDEC  (ADPCM_G726, adpcm_g726);
360 
-    REGISTER_DECODER (ADPCM_IMA_AMV, adpcm_ima_amv);
361 
-    REGISTER_DECODER (ADPCM_IMA_APC, adpcm_ima_apc);
362 
-    REGISTER_DECODER (ADPCM_IMA_DK3, adpcm_ima_dk3);
363 
-    REGISTER_DECODER (ADPCM_IMA_DK4, adpcm_ima_dk4);
364 
-    REGISTER_DECODER (ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
365 
-    REGISTER_DECODER (ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
366 
-    REGISTER_DECODER (ADPCM_IMA_ISS, adpcm_ima_iss);
367 
-    REGISTER_ENCDEC  (ADPCM_IMA_QT, adpcm_ima_qt);
368 
-    REGISTER_DECODER (ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
369 
-    REGISTER_ENCDEC  (ADPCM_IMA_WAV, adpcm_ima_wav);
370 
-    REGISTER_DECODER (ADPCM_IMA_WS, adpcm_ima_ws);
371 
-    REGISTER_ENCDEC  (ADPCM_MS, adpcm_ms);
372 
-    REGISTER_DECODER (ADPCM_SBPRO_2, adpcm_sbpro_2);
373 
-    REGISTER_DECODER (ADPCM_SBPRO_3, adpcm_sbpro_3);
374 
-    REGISTER_DECODER (ADPCM_SBPRO_4, adpcm_sbpro_4);
375 
-    REGISTER_ENCDEC  (ADPCM_SWF, adpcm_swf);
376 
-    REGISTER_DECODER (ADPCM_THP, adpcm_thp);
377 
-    REGISTER_DECODER (ADPCM_XA, adpcm_xa);
378 
-    REGISTER_ENCDEC  (ADPCM_YAMAHA, adpcm_yamaha);
349 
+    REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
350 
+    REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
351 
+    REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
352 
+    REGISTER_DECODER(ADPCM_EA,          adpcm_ea);
353 
+    REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
354 
+    REGISTER_DECODER(ADPCM_EA_R1,       adpcm_ea_r1);
355 
+    REGISTER_DECODER(ADPCM_EA_R2,       adpcm_ea_r2);
356 
+    REGISTER_DECODER(ADPCM_EA_R3,       adpcm_ea_r3);
357 
+    REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
358 
+    REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
359 
+    REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
360 
+    REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
361 
+    REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
362 
+    REGISTER_DECODER(ADPCM_IMA_DK3,     adpcm_ima_dk3);
363 
+    REGISTER_DECODER(ADPCM_IMA_DK4,     adpcm_ima_dk4);
364 
+    REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
365 
+    REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
366 
+    REGISTER_DECODER(ADPCM_IMA_ISS,     adpcm_ima_iss);
367 
+    REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
368 
+    REGISTER_DECODER(ADPCM_IMA_SMJPEG,  adpcm_ima_smjpeg);
369 
+    REGISTER_ENCDEC (ADPCM_IMA_WAV,     adpcm_ima_wav);
370 
+    REGISTER_DECODER(ADPCM_IMA_WS,      adpcm_ima_ws);
371 
+    REGISTER_ENCDEC (ADPCM_MS,          adpcm_ms);
372 
+    REGISTER_DECODER(ADPCM_SBPRO_2,     adpcm_sbpro_2);
373 
+    REGISTER_DECODER(ADPCM_SBPRO_3,     adpcm_sbpro_3);
374 
+    REGISTER_DECODER(ADPCM_SBPRO_4,     adpcm_sbpro_4);
375 
+    REGISTER_ENCDEC (ADPCM_SWF,         adpcm_swf);
376 
+    REGISTER_DECODER(ADPCM_THP,         adpcm_thp);
377 
+    REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
378 
+    REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
379 379
380 380 
     /* subtitles */
381 
-    REGISTER_ENCDEC  (ASS, ass);
382 
-    REGISTER_ENCDEC  (DVBSUB, dvbsub);
383 
-    REGISTER_ENCDEC  (DVDSUB, dvdsub);
384 
-    REGISTER_DECODER (PGSSUB, pgssub);
385 
-    REGISTER_DECODER (SRT, srt);
386 
-    REGISTER_ENCDEC  (XSUB, xsub);
381 
+    REGISTER_ENCDEC (ASS,               ass);
382 
+    REGISTER_ENCDEC (DVBSUB,            dvbsub);
383 
+    REGISTER_ENCDEC (DVDSUB,            dvdsub);
384 
+    REGISTER_DECODER(PGSSUB,            pgssub);
385 
+    REGISTER_DECODER(SRT,               srt);
386 
+    REGISTER_ENCDEC (XSUB,              xsub);
387 387
388 388 
     /* external libraries */
389 
-    REGISTER_ENCODER (LIBFAAC, libfaac);
390 
-    REGISTER_ENCODER (LIBFDK_AAC, libfdk_aac);
391 
-    REGISTER_ENCDEC  (LIBGSM, libgsm);
392 
-    REGISTER_ENCDEC  (LIBGSM_MS, libgsm_ms);
393 
-    REGISTER_ENCDEC  (LIBILBC, libilbc);
394 
-    REGISTER_ENCODER (LIBMP3LAME, libmp3lame);
395 
-    REGISTER_ENCDEC  (LIBOPENCORE_AMRNB, libopencore_amrnb);
396 
-    REGISTER_DECODER (LIBOPENCORE_AMRWB, libopencore_amrwb);
397 
-    REGISTER_ENCDEC  (LIBOPENJPEG, libopenjpeg);
398 
-    REGISTER_ENCDEC  (LIBOPUS, libopus);
399 
-    REGISTER_ENCDEC  (LIBSCHROEDINGER, libschroedinger);
400 
-    REGISTER_ENCDEC  (LIBSPEEX, libspeex);
401 
-    REGISTER_ENCODER (LIBTHEORA, libtheora);
402 
-    REGISTER_ENCODER (LIBVO_AACENC, libvo_aacenc);
403 
-    REGISTER_ENCODER (LIBVO_AMRWBENC, libvo_amrwbenc);
404 
-    REGISTER_ENCODER (LIBVORBIS, libvorbis);
405 
-    REGISTER_ENCDEC  (LIBVPX, libvpx);
406 
-    REGISTER_ENCODER (LIBX264, libx264);
407 
-    REGISTER_ENCODER (LIBXAVS, libxavs);
408 
-    REGISTER_ENCODER (LIBXVID, libxvid);
389 
+    REGISTER_ENCODER(LIBFAAC,           libfaac);
390 
+    REGISTER_ENCODER(LIBFDK_AAC,        libfdk_aac);
391 
+    REGISTER_ENCDEC (LIBGSM,            libgsm);
392 
+    REGISTER_ENCDEC (LIBGSM_MS,         libgsm_ms);
393 
+    REGISTER_ENCDEC (LIBILBC,           libilbc);
394 
+    REGISTER_ENCODER(LIBMP3LAME,        libmp3lame);
395 
+    REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
396 
+    REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
397 
+    REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
398 
+    REGISTER_ENCDEC (LIBOPUS,           libopus);
399 
+    REGISTER_ENCDEC (LIBSCHROEDINGER,   libschroedinger);
400 
+    REGISTER_ENCDEC (LIBSPEEX,          libspeex);
401 
+    REGISTER_ENCODER(LIBTHEORA,         libtheora);
402 
+    REGISTER_ENCODER(LIBVO_AACENC,      libvo_aacenc);
403 
+    REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
404 
+    REGISTER_ENCODER(LIBVORBIS,         libvorbis);
405 
+    REGISTER_ENCDEC (LIBVPX,            libvpx);
406 
+    REGISTER_ENCODER(LIBX264,           libx264);
407 
+    REGISTER_ENCODER(LIBXAVS,           libxavs);
408 
+    REGISTER_ENCODER(LIBXVID,           libxvid);
409 409
410 410 
     /* parsers */
411 
-    REGISTER_PARSER  (AAC, aac);
412 
-    REGISTER_PARSER  (AAC_LATM, aac_latm);
413 
-    REGISTER_PARSER  (AC3, ac3);
414 
-    REGISTER_PARSER  (ADX, adx);
415 
-    REGISTER_PARSER  (CAVSVIDEO, cavsvideo);
416 
-    REGISTER_PARSER  (COOK, cook);
417 
-    REGISTER_PARSER  (DCA, dca);
418 
-    REGISTER_PARSER  (DIRAC, dirac);
419 
-    REGISTER_PARSER  (DNXHD, dnxhd);
420 
-    REGISTER_PARSER  (DVBSUB, dvbsub);
421 
-    REGISTER_PARSER  (DVDSUB, dvdsub);
422 
-    REGISTER_PARSER  (FLAC, flac);
423 
-    REGISTER_PARSER  (GSM, gsm);
424 
-    REGISTER_PARSER  (H261, h261);
425 
-    REGISTER_PARSER  (H263, h263);
426 
-    REGISTER_PARSER  (H264, h264);
427 
-    REGISTER_PARSER  (MJPEG, mjpeg);
428 
-    REGISTER_PARSER  (MLP, mlp);
429 
-    REGISTER_PARSER  (MPEG4VIDEO, mpeg4video);
430 
-    REGISTER_PARSER  (MPEGAUDIO, mpegaudio);
431 
-    REGISTER_PARSER  (MPEGVIDEO, mpegvideo);
432 
-    REGISTER_PARSER  (PNM, pnm);
433 
-    REGISTER_PARSER  (RV30, rv30);
434 
-    REGISTER_PARSER  (RV40, rv40);
435 
-    REGISTER_PARSER  (TAK, tak);
436 
-    REGISTER_PARSER  (VC1, vc1);
437 
-    REGISTER_PARSER  (VORBIS, vorbis);
438 
-    REGISTER_PARSER  (VP3, vp3);
439 
-    REGISTER_PARSER  (VP8, vp8);
411 
+    REGISTER_PARSER(AAC,                aac);
412 
+    REGISTER_PARSER(AAC_LATM,           aac_latm);
413 
+    REGISTER_PARSER(AC3,                ac3);
414 
+    REGISTER_PARSER(ADX,                adx);
415 
+    REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
416 
+    REGISTER_PARSER(COOK,               cook);
417 
+    REGISTER_PARSER(DCA,                dca);
418 
+    REGISTER_PARSER(DIRAC,              dirac);
419 
+    REGISTER_PARSER(DNXHD,              dnxhd);
420 
+    REGISTER_PARSER(DVBSUB,             dvbsub);
421 
+    REGISTER_PARSER(DVDSUB,             dvdsub);
422 
+    REGISTER_PARSER(FLAC,               flac);
423 
+    REGISTER_PARSER(GSM,                gsm);
424 
+    REGISTER_PARSER(H261,               h261);
425 
+    REGISTER_PARSER(H263,               h263);
426 
+    REGISTER_PARSER(H264,               h264);
427 
+    REGISTER_PARSER(MJPEG,              mjpeg);
428 
+    REGISTER_PARSER(MLP,                mlp);
429 
+    REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
430 
+    REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
431 
+    REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
432 
+    REGISTER_PARSER(PNM,                pnm);
433 
+    REGISTER_PARSER(RV30,               rv30);
434 
+    REGISTER_PARSER(RV40,               rv40);
435 
+    REGISTER_PARSER(TAK,                tak);
436 
+    REGISTER_PARSER(VC1,                vc1);
437 
+    REGISTER_PARSER(VORBIS,             vorbis);
438 
+    REGISTER_PARSER(VP3,                vp3);
439 
+    REGISTER_PARSER(VP8,                vp8);
440 440
441 441 
     /* bitstream filters */
442 
-    REGISTER_BSF     (AAC_ADTSTOASC, aac_adtstoasc);
443 
-    REGISTER_BSF     (CHOMP, chomp);
444 
-    REGISTER_BSF     (DUMP_EXTRADATA, dump_extradata);
445 
-    REGISTER_BSF     (H264_MP4TOANNEXB, h264_mp4toannexb);
446 
-    REGISTER_BSF     (IMX_DUMP_HEADER, imx_dump_header);
447 
-    REGISTER_BSF     (MJPEG2JPEG, mjpeg2jpeg);
448 
-    REGISTER_BSF     (MJPEGA_DUMP_HEADER, mjpega_dump_header);
449 
-    REGISTER_BSF     (MP3_HEADER_COMPRESS, mp3_header_compress);
450 
-    REGISTER_BSF     (MP3_HEADER_DECOMPRESS, mp3_header_decompress);
451 
-    REGISTER_BSF     (MOV2TEXTSUB, mov2textsub);
452 
-    REGISTER_BSF     (NOISE, noise);
453 
-    REGISTER_BSF     (REMOVE_EXTRADATA, remove_extradata);
454 
-    REGISTER_BSF     (TEXT2MOVSUB, text2movsub);
442 
+    REGISTER_BSF(AAC_ADTSTOASC,         aac_adtstoasc);
443 
+    REGISTER_BSF(CHOMP,                 chomp);
444 
+    REGISTER_BSF(DUMP_EXTRADATA,        dump_extradata);
445 
+    REGISTER_BSF(H264_MP4TOANNEXB,      h264_mp4toannexb);
446 
+    REGISTER_BSF(IMX_DUMP_HEADER,       imx_dump_header);
447 
+    REGISTER_BSF(MJPEG2JPEG,            mjpeg2jpeg);
448 
+    REGISTER_BSF(MJPEGA_DUMP_HEADER,    mjpega_dump_header);
449 
+    REGISTER_BSF(MP3_HEADER_COMPRESS,   mp3_header_compress);
450 
+    REGISTER_BSF(MP3_HEADER_DECOMPRESS, mp3_header_decompress);
451 
+    REGISTER_BSF(MOV2TEXTSUB,           mov2textsub);
452 
+    REGISTER_BSF(NOISE,                 noise);
453 
+    REGISTER_BSF(REMOVE_EXTRADATA,      remove_extradata);
454 
+    REGISTER_BSF(TEXT2MOVSUB,           text2movsub);
455 455 
 }
libavdevice/alldevices.c
History View file @ c73c87b
... ... 
@@ -22,13 +22,23 @@
22 22 
 #include "libavformat/avformat.h"
23 23 
 #include "avdevice.h"
24 24
25 
-#define REGISTER_OUTDEV(X,x) { \
26 
-          extern AVOutputFormat ff_##x##_muxer; \
27 
-          if(CONFIG_##X##_OUTDEV)  av_register_output_format(&ff_##x##_muxer); }
28 
-#define REGISTER_INDEV(X,x) { \
29 
-          extern AVInputFormat ff_##x##_demuxer; \
30 
-          if(CONFIG_##X##_INDEV)   av_register_input_format(&ff_##x##_demuxer); }
31 
-#define REGISTER_INOUTDEV(X,x)  REGISTER_OUTDEV(X,x); REGISTER_INDEV(X,x)
25 
+#define REGISTER_OUTDEV(X, x)                                           \
26 
+    {                                                                   \
27 
+        extern AVOutputFormat ff_##x##_muxer;                           \
28 
+        if (CONFIG_##X##_OUTDEV)                                        \
29 
+            av_register_output_format(&ff_##x##_muxer);                 \
30 
+    }
31 
+
32 
+#define REGISTER_INDEV(X, x)                                            \
33 
+    {                                                                   \
34 
+        extern AVInputFormat ff_##x##_demuxer;                          \
35 
+        if (CONFIG_##X##_INDEV)                                         \
36 
+            av_register_input_format(&ff_##x##_demuxer);                \
37 
+    }
38 
+
39 
+#define REGISTER_INOUTDEV(X, x)                                         \
40 
+    REGISTER_OUTDEV(X, x);                                              \
41 
+    REGISTER_INDEV(X, x)
32 42
33 43 
 void avdevice_register_all(void)
34 44 
 {
... ... 
@@ -39,19 +49,19 @@ void avdevice_register_all(void)
39 39 
     initialized = 1;
40 40
41 41 
     /* devices */
42 
-    REGISTER_INOUTDEV (ALSA, alsa);
43 
-    REGISTER_INDEV    (BKTR, bktr);
44 
-    REGISTER_INDEV    (DV1394, dv1394);
45 
-    REGISTER_INDEV    (FBDEV, fbdev);
46 
-    REGISTER_INDEV    (JACK, jack);
47 
-    REGISTER_INOUTDEV (OSS, oss);
48 
-    REGISTER_INDEV    (PULSE, pulse);
49 
-    REGISTER_INOUTDEV (SNDIO, sndio);
50 
-    REGISTER_INDEV    (V4L2, v4l2);
51 
-    REGISTER_INDEV    (VFWCAP, vfwcap);
52 
-    REGISTER_INDEV    (X11GRAB, x11grab);
42 
+    REGISTER_INOUTDEV(ALSA,             alsa);
43 
+    REGISTER_INDEV   (BKTR,             bktr);
44 
+    REGISTER_INDEV   (DV1394,           dv1394);
45 
+    REGISTER_INDEV   (FBDEV,            fbdev);
46 
+    REGISTER_INDEV   (JACK,             jack);
47 
+    REGISTER_INOUTDEV(OSS,              oss);
48 
+    REGISTER_INDEV   (PULSE,            pulse);
49 
+    REGISTER_INOUTDEV(SNDIO,            sndio);
50 
+    REGISTER_INDEV   (V4L2,             v4l2);
51 
+    REGISTER_INDEV   (VFWCAP,           vfwcap);
52 
+    REGISTER_INDEV   (X11GRAB,          x11grab);
53 53
54 54 
     /* external libraries */
55 
-    REGISTER_INDEV    (LIBCDIO, libcdio);
56 
-    REGISTER_INDEV    (LIBDC1394, libdc1394);
55 
+    REGISTER_INDEV   (LIBCDIO,          libcdio);
56 
+    REGISTER_INDEV   (LIBDC1394,        libdc1394);
57 57 
 }
libavfilter/allfilters.c
History View file @ c73c87b
... ... 
@@ -23,9 +23,12 @@
23 23 
 #include "config.h"
24 24
25 25
26 
-#define REGISTER_FILTER(X,x,y) { \
27 
-          extern AVFilter avfilter_##y##_##x ; \
28 
-          if(CONFIG_##X##_FILTER )  avfilter_register(&avfilter_##y##_##x ); }
26 
+#define REGISTER_FILTER(X, x, y)                                        \
27 
+    {                                                                   \
28 
+        extern AVFilter avfilter_##y##_##x;                             \
29 
+        if (CONFIG_##X##_FILTER)                                        \
30 
+            avfilter_register(&avfilter_##y##_##x);                     \
31 
+    }
29 32
30 33 
 #define REGISTER_FILTER_UNCONDITIONAL(x)                                \
31 34 
     {                                                                   \
... ... 
@@ -41,69 +44,69 @@ void avfilter_register_all(void)
41 41 
         return;
42 42 
     initialized = 1;
43 43
44 
-    REGISTER_FILTER (AFORMAT,     aformat,     af);
45 
-    REGISTER_FILTER (AMIX,        amix,        af);
46 
-    REGISTER_FILTER (ANULL,       anull,       af);
47 
-    REGISTER_FILTER (ASHOWINFO,   ashowinfo,   af);
48 
-    REGISTER_FILTER (ASPLIT,      asplit,      af);
49 
-    REGISTER_FILTER (ASYNCTS,     asyncts,     af);
50 
-    REGISTER_FILTER (CHANNELMAP,  channelmap,  af);
51 
-    REGISTER_FILTER (CHANNELSPLIT,channelsplit,af);
52 
-    REGISTER_FILTER (JOIN,        join,        af);
53 
-    REGISTER_FILTER (RESAMPLE,    resample,    af);
54 
-    REGISTER_FILTER (VOLUME,      volume,      af);
44 
+    REGISTER_FILTER(AFORMAT,        aformat,        af);
45 
+    REGISTER_FILTER(AMIX,           amix,           af);
46 
+    REGISTER_FILTER(ANULL,          anull,          af);
47 
+    REGISTER_FILTER(ASHOWINFO,      ashowinfo,      af);
48 
+    REGISTER_FILTER(ASPLIT,         asplit,         af);
49 
+    REGISTER_FILTER(ASYNCTS,        asyncts,        af);
50 
+    REGISTER_FILTER(CHANNELMAP,     channelmap,     af);
51 
+    REGISTER_FILTER(CHANNELSPLIT,   channelsplit,   af);
52 
+    REGISTER_FILTER(JOIN,           join,           af);
53 
+    REGISTER_FILTER(RESAMPLE,       resample,       af);
54 
+    REGISTER_FILTER(VOLUME,         volume,         af);
55 55
56 
-    REGISTER_FILTER (ANULLSRC,    anullsrc,    asrc);
56 
+    REGISTER_FILTER(ANULLSRC,       anullsrc,       asrc);
57 57
58 
-    REGISTER_FILTER (ANULLSINK,   anullsink,   asink);
58 
+    REGISTER_FILTER(ANULLSINK,      anullsink,      asink);
59 59
60 
-    REGISTER_FILTER (BLACKFRAME,  blackframe,  vf);
61 
-    REGISTER_FILTER (BOXBLUR,     boxblur,     vf);
62 
-    REGISTER_FILTER (COPY,        copy,        vf);
63 
-    REGISTER_FILTER (CROP,        crop,        vf);
64 
-    REGISTER_FILTER (CROPDETECT,  cropdetect,  vf);
65 
-    REGISTER_FILTER (DELOGO,      delogo,      vf);
66 
-    REGISTER_FILTER (DRAWBOX,     drawbox,     vf);
67 
-    REGISTER_FILTER (DRAWTEXT,    drawtext,    vf);
68 
-    REGISTER_FILTER (FADE,        fade,        vf);
69 
-    REGISTER_FILTER (FIELDORDER,  fieldorder,  vf);
70 
-    REGISTER_FILTER (FORMAT,      format,      vf);
71 
-    REGISTER_FILTER (FPS,         fps,         vf);
72 
-    REGISTER_FILTER (FREI0R,      frei0r,      vf);
73 
-    REGISTER_FILTER (GRADFUN,     gradfun,     vf);
74 
-    REGISTER_FILTER (HFLIP,       hflip,       vf);
75 
-    REGISTER_FILTER (HQDN3D,      hqdn3d,      vf);
76 
-    REGISTER_FILTER (LUT,         lut,         vf);
77 
-    REGISTER_FILTER (LUTRGB,      lutrgb,      vf);
78 
-    REGISTER_FILTER (LUTYUV,      lutyuv,      vf);
79 
-    REGISTER_FILTER (NEGATE,      negate,      vf);
80 
-    REGISTER_FILTER (NOFORMAT,    noformat,    vf);
81 
-    REGISTER_FILTER (NULL,        null,        vf);
82 
-    REGISTER_FILTER (OCV,         ocv,         vf);
83 
-    REGISTER_FILTER (OVERLAY,     overlay,     vf);
84 
-    REGISTER_FILTER (PAD,         pad,         vf);
85 
-    REGISTER_FILTER (PIXDESCTEST, pixdesctest, vf);
86 
-    REGISTER_FILTER (SCALE,       scale,       vf);
87 
-    REGISTER_FILTER (SELECT,      select,      vf);
88 
-    REGISTER_FILTER (SETDAR,      setdar,      vf);
89 
-    REGISTER_FILTER (SETPTS,      setpts,      vf);
90 
-    REGISTER_FILTER (SETSAR,      setsar,      vf);
91 
-    REGISTER_FILTER (SETTB,       settb,       vf);
92 
-    REGISTER_FILTER (SHOWINFO,    showinfo,    vf);
93 
-    REGISTER_FILTER (SPLIT,       split,       vf);
94 
-    REGISTER_FILTER (TRANSPOSE,   transpose,   vf);
95 
-    REGISTER_FILTER (UNSHARP,     unsharp,     vf);
96 
-    REGISTER_FILTER (VFLIP,       vflip,       vf);
97 
-    REGISTER_FILTER (YADIF,       yadif,       vf);
60 
+    REGISTER_FILTER(BLACKFRAME,     blackframe,     vf);
61 
+    REGISTER_FILTER(BOXBLUR,        boxblur,        vf);
62 
+    REGISTER_FILTER(COPY,           copy,           vf);
63 
+    REGISTER_FILTER(CROP,           crop,           vf);
64 
+    REGISTER_FILTER(CROPDETECT,     cropdetect,     vf);
65 
+    REGISTER_FILTER(DELOGO,         delogo,         vf);
66 
+    REGISTER_FILTER(DRAWBOX,        drawbox,        vf);
67 
+    REGISTER_FILTER(DRAWTEXT,       drawtext,       vf);
68 
+    REGISTER_FILTER(FADE,           fade,           vf);
69 
+    REGISTER_FILTER(FIELDORDER,     fieldorder,     vf);
70 
+    REGISTER_FILTER(FORMAT,         format,         vf);
71 
+    REGISTER_FILTER(FPS,            fps,            vf);
72 
+    REGISTER_FILTER(FREI0R,         frei0r,         vf);
73 
+    REGISTER_FILTER(GRADFUN,        gradfun,        vf);
74 
+    REGISTER_FILTER(HFLIP,          hflip,          vf);
75 
+    REGISTER_FILTER(HQDN3D,         hqdn3d,         vf);
76 
+    REGISTER_FILTER(LUT,            lut,            vf);
77 
+    REGISTER_FILTER(LUTRGB,         lutrgb,         vf);
78 
+    REGISTER_FILTER(LUTYUV,         lutyuv,         vf);
79 
+    REGISTER_FILTER(NEGATE,         negate,         vf);
80 
+    REGISTER_FILTER(NOFORMAT,       noformat,       vf);
81 
+    REGISTER_FILTER(NULL,           null,           vf);
82 
+    REGISTER_FILTER(OCV,            ocv,            vf);
83 
+    REGISTER_FILTER(OVERLAY,        overlay,        vf);
84 
+    REGISTER_FILTER(PAD,            pad,            vf);
85 
+    REGISTER_FILTER(PIXDESCTEST,    pixdesctest,    vf);
86 
+    REGISTER_FILTER(SCALE,          scale,          vf);
87 
+    REGISTER_FILTER(SELECT,         select,         vf);
88 
+    REGISTER_FILTER(SETDAR,         setdar,         vf);
89 
+    REGISTER_FILTER(SETPTS,         setpts,         vf);
90 
+    REGISTER_FILTER(SETSAR,         setsar,         vf);
91 
+    REGISTER_FILTER(SETTB,          settb,          vf);
92 
+    REGISTER_FILTER(SHOWINFO,       showinfo,       vf);
93 
+    REGISTER_FILTER(SPLIT,          split,          vf);
94 
+    REGISTER_FILTER(TRANSPOSE,      transpose,      vf);
95 
+    REGISTER_FILTER(UNSHARP,        unsharp,        vf);
96 
+    REGISTER_FILTER(VFLIP,          vflip,          vf);
97 
+    REGISTER_FILTER(YADIF,          yadif,          vf);
98 98
99 
-    REGISTER_FILTER (COLOR,       color,       vsrc);
100 
-    REGISTER_FILTER (FREI0R,      frei0r_src,  vsrc);
101 
-    REGISTER_FILTER (MOVIE,       movie,       vsrc);
102 
-    REGISTER_FILTER (NULLSRC,     nullsrc,     vsrc);
103 
-    REGISTER_FILTER (RGBTESTSRC,  rgbtestsrc,  vsrc);
104 
-    REGISTER_FILTER (TESTSRC,     testsrc,     vsrc);
99 
+    REGISTER_FILTER(COLOR,          color,          vsrc);
100 
+    REGISTER_FILTER(FREI0R,         frei0r_src,     vsrc);
101 
+    REGISTER_FILTER(MOVIE,          movie,          vsrc);
102 
+    REGISTER_FILTER(NULLSRC,        nullsrc,        vsrc);
103 
+    REGISTER_FILTER(RGBTESTSRC,     rgbtestsrc,     vsrc);
104 
+    REGISTER_FILTER(TESTSRC,        testsrc,        vsrc);
105 105
106 
-    REGISTER_FILTER (NULLSINK,    nullsink,    vsink);
106 
+    REGISTER_FILTER(NULLSINK,       nullsink,       vsink);
107 107
108 108 
     /* those filters are part of public or internal API => registered
109 109 
      * unconditionally */
libavformat/allformats.c
History View file @ c73c87b
... ... 
@@ -18,25 +18,38 @@
18 18 
  * License along with Libav; if not, write to the Free Software
19 19 
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 20 
  */
21 
+
21 22 
 #include "avformat.h"
22 23 
 #include "rtp.h"
23 24 
 #include "rdt.h"
24 25 
 #include "url.h"
25 26 
 #include "version.h"
26 27
27 
-#define REGISTER_MUXER(X,x) { \
28 
-    extern AVOutputFormat ff_##x##_muxer; \
29 
-    if(CONFIG_##X##_MUXER) av_register_output_format(&ff_##x##_muxer); }
28 
+#define REGISTER_MUXER(X, x)                                            \
29 
+    {                                                                   \
30 
+        extern AVOutputFormat ff_##x##_muxer;                           \
31 
+        if (CONFIG_##X##_MUXER)                                         \
32 
+            av_register_output_format(&ff_##x##_muxer);                 \
33 
+    }
30 34
31 
-#define REGISTER_DEMUXER(X,x) { \
32 
-    extern AVInputFormat ff_##x##_demuxer; \
33 
-    if(CONFIG_##X##_DEMUXER) av_register_input_format(&ff_##x##_demuxer); }
35 
+#define REGISTER_DEMUXER(X, x)                                          \
36 
+    {                                                                   \
37 
+        extern AVInputFormat ff_##x##_demuxer;                          \
38 
+        if (CONFIG_##X##_DEMUXER)                                       \
39 
+            av_register_input_format(&ff_##x##_demuxer);                \
40 
+    }
34 41
35 
-#define REGISTER_MUXDEMUX(X,x)  REGISTER_MUXER(X,x); REGISTER_DEMUXER(X,x)
42 
+#define REGISTER_MUXDEMUX(X, x)                                         \
43 
+    REGISTER_MUXER(X, x);                                               \
44 
+    REGISTER_DEMUXER(X,x)
36 45
37 
-#define REGISTER_PROTOCOL(X,x) { \
38 
-    extern URLProtocol ff_##x##_protocol; \
39 
-    if(CONFIG_##X##_PROTOCOL) ffurl_register_protocol(&ff_##x##_protocol, sizeof(ff_##x##_protocol)); }
46 
+#define REGISTER_PROTOCOL(X, x)                                         \
47 
+    {                                                                   \
48 
+        extern URLProtocol ff_##x##_protocol;                           \
49 
+        if (CONFIG_##X##_PROTOCOL)                                      \
50 
+            ffurl_register_protocol(&ff_##x##_protocol,                 \
51 
+                                    sizeof(ff_##x##_protocol));         \
52 
+    }
40 53
41 54 
 void av_register_all(void)
42 55 
 {
... ... 
@@ -49,234 +62,234 @@ void av_register_all(void)
49 49 
     avcodec_register_all();
50 50
51 51 
     /* (de)muxers */
52 
-    REGISTER_MUXER    (A64, a64);
53 
-    REGISTER_DEMUXER  (AAC, aac);
54 
-    REGISTER_MUXDEMUX (AC3, ac3);
55 
-    REGISTER_MUXER    (ADTS, adts);
56 
-    REGISTER_MUXDEMUX (ADX, adx);
57 
-    REGISTER_DEMUXER  (AEA, aea);
58 
-    REGISTER_MUXDEMUX (AIFF, aiff);
59 
-    REGISTER_MUXDEMUX (AMR, amr);
60 
-    REGISTER_DEMUXER  (ANM, anm);
61 
-    REGISTER_DEMUXER  (APC, apc);
62 
-    REGISTER_DEMUXER  (APE, ape);
63 
-    REGISTER_MUXDEMUX (ASF, asf);
64 
-    REGISTER_MUXDEMUX (ASS, ass);
65 
-    REGISTER_MUXER    (ASF_STREAM, asf_stream);
66 
-    REGISTER_MUXDEMUX (AU, au);
67 
-    REGISTER_MUXDEMUX (AVI, avi);
68 
-    REGISTER_DEMUXER  (AVISYNTH, avisynth);
69 
-    REGISTER_MUXER    (AVM2, avm2);
70 
-    REGISTER_DEMUXER  (AVS, avs);
71 
-    REGISTER_DEMUXER  (BETHSOFTVID, bethsoftvid);
72 
-    REGISTER_DEMUXER  (BFI, bfi);
73 
-    REGISTER_DEMUXER  (BINK, bink);
74 
-    REGISTER_DEMUXER  (BMV, bmv);
75 
-    REGISTER_DEMUXER  (C93, c93);
76 
-    REGISTER_DEMUXER  (CAF, caf);
77 
-    REGISTER_MUXDEMUX (CAVSVIDEO, cavsvideo);
78 
-    REGISTER_DEMUXER  (CDG, cdg);
79 
-    REGISTER_DEMUXER  (CDXL, cdxl);
80 
-    REGISTER_MUXER    (CRC, crc);
81 
-    REGISTER_MUXDEMUX (DAUD, daud);
82 
-    REGISTER_DEMUXER  (DFA, dfa);
83 
-    REGISTER_MUXDEMUX (DIRAC, dirac);
84 
-    REGISTER_MUXDEMUX (DNXHD, dnxhd);
85 
-    REGISTER_DEMUXER  (DSICIN, dsicin);
86 
-    REGISTER_MUXDEMUX (DTS, dts);
87 
-    REGISTER_MUXDEMUX (DV, dv);
88 
-    REGISTER_DEMUXER  (DXA, dxa);
89 
-    REGISTER_DEMUXER  (EA, ea);
90 
-    REGISTER_DEMUXER  (EA_CDATA, ea_cdata);
91 
-    REGISTER_MUXDEMUX (EAC3, eac3);
92 
-    REGISTER_MUXDEMUX (FFM, ffm);
93 
-    REGISTER_MUXDEMUX (FFMETADATA, ffmetadata);
94 
-    REGISTER_MUXDEMUX (FILMSTRIP, filmstrip);
95 
-    REGISTER_MUXDEMUX (FLAC, flac);
96 
-    REGISTER_DEMUXER  (FLIC, flic);
97 
-    REGISTER_MUXDEMUX (FLV, flv);
98 
-    REGISTER_DEMUXER  (FOURXM, fourxm);
99 
-    REGISTER_MUXER    (FRAMECRC, framecrc);
100 
-    REGISTER_MUXER    (FRAMEMD5, framemd5);
101 
-    REGISTER_MUXDEMUX (G722, g722);
102 
-    REGISTER_DEMUXER  (G723_1, g723_1);
103 
-    REGISTER_MUXER    (GIF, gif);
104 
-    REGISTER_DEMUXER  (GSM, gsm);
105 
-    REGISTER_MUXDEMUX (GXF, gxf);
106 
-    REGISTER_MUXDEMUX (H261, h261);
107 
-    REGISTER_MUXDEMUX (H263, h263);
108 
-    REGISTER_MUXDEMUX (H264, h264);
109 
-    REGISTER_MUXDEMUX (HLS, hls);
110 
-    REGISTER_DEMUXER  (IDCIN, idcin);
111 
-    REGISTER_DEMUXER  (IFF, iff);
112 
-    REGISTER_MUXDEMUX (ILBC, ilbc);
113 
-    REGISTER_MUXDEMUX (IMAGE2, image2);
114 
-    REGISTER_MUXDEMUX (IMAGE2PIPE, image2pipe);
115 
-    REGISTER_DEMUXER  (INGENIENT, ingenient);
116 
-    REGISTER_DEMUXER  (IPMOVIE, ipmovie);
117 
-    REGISTER_MUXER    (IPOD, ipod);
118 
-    REGISTER_MUXER    (ISMV, ismv);
119 
-    REGISTER_DEMUXER  (ISS, iss);
120 
-    REGISTER_DEMUXER  (IV8, iv8);
121 
-    REGISTER_MUXDEMUX (IVF, ivf);
122 
-    REGISTER_DEMUXER  (JV, jv);
123 
-    REGISTER_MUXDEMUX (LATM, latm);
124 
-    REGISTER_DEMUXER  (LMLM4, lmlm4);
125 
-    REGISTER_DEMUXER  (LXF, lxf);
126 
-    REGISTER_MUXDEMUX (M4V, m4v);
127 
-    REGISTER_MUXER    (MD5, md5);
128 
-    REGISTER_MUXDEMUX (MATROSKA, matroska);
129 
-    REGISTER_MUXER    (MATROSKA_AUDIO, matroska_audio);
130 
-    REGISTER_MUXDEMUX (MJPEG, mjpeg);
131 
-    REGISTER_MUXDEMUX (MLP, mlp);
132 
-    REGISTER_DEMUXER  (MM, mm);
133 
-    REGISTER_MUXDEMUX (MMF, mmf);
134 
-    REGISTER_MUXDEMUX (MOV, mov);
135 
-    REGISTER_MUXER    (MP2, mp2);
136 
-    REGISTER_MUXDEMUX (MP3, mp3);
137 
-    REGISTER_MUXER    (MP4, mp4);
138 
-    REGISTER_DEMUXER  (MPC, mpc);
139 
-    REGISTER_DEMUXER  (MPC8, mpc8);
140 
-    REGISTER_MUXER    (MPEG1SYSTEM, mpeg1system);
141 
-    REGISTER_MUXER    (MPEG1VCD, mpeg1vcd);
142 
-    REGISTER_MUXER    (MPEG1VIDEO, mpeg1video);
143 
-    REGISTER_MUXER    (MPEG2DVD, mpeg2dvd);
144 
-    REGISTER_MUXER    (MPEG2SVCD, mpeg2svcd);
145 
-    REGISTER_MUXER    (MPEG2VIDEO, mpeg2video);
146 
-    REGISTER_MUXER    (MPEG2VOB, mpeg2vob);
147 
-    REGISTER_DEMUXER  (MPEGPS, mpegps);
148 
-    REGISTER_MUXDEMUX (MPEGTS, mpegts);
149 
-    REGISTER_DEMUXER  (MPEGTSRAW, mpegtsraw);
150 
-    REGISTER_DEMUXER  (MPEGVIDEO, mpegvideo);
151 
-    REGISTER_MUXER    (MPJPEG, mpjpeg);
152 
-    REGISTER_DEMUXER  (MSNWC_TCP, msnwc_tcp);
153 
-    REGISTER_DEMUXER  (MTV, mtv);
154 
-    REGISTER_DEMUXER  (MVI, mvi);
155 
-    REGISTER_MUXDEMUX (MXF, mxf);
156 
-    REGISTER_MUXER    (MXF_D10, mxf_d10);
157 
-    REGISTER_DEMUXER  (MXG, mxg);
158 
-    REGISTER_DEMUXER  (NC, nc);
159 
-    REGISTER_DEMUXER  (NSV, nsv);
160 
-    REGISTER_MUXER    (NULL, null);
161 
-    REGISTER_MUXDEMUX (NUT, nut);
162 
-    REGISTER_DEMUXER  (NUV, nuv);
163 
-    REGISTER_MUXDEMUX (OGG, ogg);
164 
-    REGISTER_MUXDEMUX (OMA, oma);
165 
-    REGISTER_MUXDEMUX (PCM_ALAW,  pcm_alaw);
166 
-    REGISTER_MUXDEMUX (PCM_MULAW, pcm_mulaw);
167 
-    REGISTER_MUXDEMUX (PCM_F64BE, pcm_f64be);
168 
-    REGISTER_MUXDEMUX (PCM_F64LE, pcm_f64le);
169 
-    REGISTER_MUXDEMUX (PCM_F32BE, pcm_f32be);
170 
-    REGISTER_MUXDEMUX (PCM_F32LE, pcm_f32le);
171 
-    REGISTER_MUXDEMUX (PCM_S32BE, pcm_s32be);
172 
-    REGISTER_MUXDEMUX (PCM_S32LE, pcm_s32le);
173 
-    REGISTER_MUXDEMUX (PCM_S24BE, pcm_s24be);
174 
-    REGISTER_MUXDEMUX (PCM_S24LE, pcm_s24le);
175 
-    REGISTER_MUXDEMUX (PCM_S16BE, pcm_s16be);
176 
-    REGISTER_MUXDEMUX (PCM_S16LE, pcm_s16le);
177 
-    REGISTER_MUXDEMUX (PCM_S8,    pcm_s8);
178 
-    REGISTER_MUXDEMUX (PCM_U32BE, pcm_u32be);
179 
-    REGISTER_MUXDEMUX (PCM_U32LE, pcm_u32le);
180 
-    REGISTER_MUXDEMUX (PCM_U24BE, pcm_u24be);
181 
-    REGISTER_MUXDEMUX (PCM_U24LE, pcm_u24le);
182 
-    REGISTER_MUXDEMUX (PCM_U16BE, pcm_u16be);
183 
-    REGISTER_MUXDEMUX (PCM_U16LE, pcm_u16le);
184 
-    REGISTER_MUXDEMUX (PCM_U8,    pcm_u8);
185 
-    REGISTER_DEMUXER  (PMP, pmp);
186 
-    REGISTER_MUXER    (PSP, psp);
187 
-    REGISTER_DEMUXER  (PVA, pva);
188 
-    REGISTER_DEMUXER  (QCP, qcp);
189 
-    REGISTER_DEMUXER  (R3D, r3d);
190 
-    REGISTER_MUXDEMUX (RAWVIDEO, rawvideo);
191 
-    REGISTER_DEMUXER  (RL2, rl2);
192 
-    REGISTER_MUXDEMUX (RM, rm);
193 
-    REGISTER_MUXDEMUX (ROQ, roq);
194 
-    REGISTER_DEMUXER  (RPL, rpl);
195 
-    REGISTER_MUXDEMUX (RSO, rso);
196 
-    REGISTER_MUXDEMUX (RTP, rtp);
197 
-    REGISTER_MUXDEMUX (RTSP, rtsp);
198 
-    REGISTER_MUXDEMUX (SAP, sap);
199 
-    REGISTER_DEMUXER  (SDP, sdp);
52 
+    REGISTER_MUXER   (A64,              a64);
53 
+    REGISTER_DEMUXER (AAC,              aac);
54 
+    REGISTER_MUXDEMUX(AC3,              ac3);
55 
+    REGISTER_MUXER   (ADTS,             adts);
56 
+    REGISTER_MUXDEMUX(ADX,              adx);
57 
+    REGISTER_DEMUXER (AEA,              aea);
58 
+    REGISTER_MUXDEMUX(AIFF,             aiff);
59 
+    REGISTER_MUXDEMUX(AMR,              amr);
60 
+    REGISTER_DEMUXER (ANM,              anm);
61 
+    REGISTER_DEMUXER (APC,              apc);
62 
+    REGISTER_DEMUXER (APE,              ape);
63 
+    REGISTER_MUXDEMUX(ASF,              asf);
64 
+    REGISTER_MUXDEMUX(ASS,              ass);
65 
+    REGISTER_MUXER   (ASF_STREAM,       asf_stream);
66 
+    REGISTER_MUXDEMUX(AU,               au);
67 
+    REGISTER_MUXDEMUX(AVI,              avi);
68 
+    REGISTER_DEMUXER (AVISYNTH,         avisynth);
69 
+    REGISTER_MUXER   (AVM2,             avm2);
70 
+    REGISTER_DEMUXER (AVS,              avs);
71 
+    REGISTER_DEMUXER (BETHSOFTVID,      bethsoftvid);
72 
+    REGISTER_DEMUXER (BFI,              bfi);
73 
+    REGISTER_DEMUXER (BINK,             bink);
74 
+    REGISTER_DEMUXER (BMV,              bmv);
75 
+    REGISTER_DEMUXER (C93,              c93);
76 
+    REGISTER_DEMUXER (CAF,              caf);
77 
+    REGISTER_MUXDEMUX(CAVSVIDEO,        cavsvideo);
78 
+    REGISTER_DEMUXER (CDG,              cdg);
79 
+    REGISTER_DEMUXER (CDXL,             cdxl);
80 
+    REGISTER_MUXER   (CRC,              crc);
81 
+    REGISTER_MUXDEMUX(DAUD,             daud);
82 
+    REGISTER_DEMUXER (DFA,              dfa);
83 
+    REGISTER_MUXDEMUX(DIRAC,            dirac);
84 
+    REGISTER_MUXDEMUX(DNXHD,            dnxhd);
85 
+    REGISTER_DEMUXER (DSICIN,           dsicin);
86 
+    REGISTER_MUXDEMUX(DTS,              dts);
87 
+    REGISTER_MUXDEMUX(DV,               dv);
88 
+    REGISTER_DEMUXER (DXA,              dxa);
89 
+    REGISTER_DEMUXER (EA,               ea);
90 
+    REGISTER_DEMUXER (EA_CDATA,         ea_cdata);
91 
+    REGISTER_MUXDEMUX(EAC3,             eac3);
92 
+    REGISTER_MUXDEMUX(FFM,              ffm);
93 
+    REGISTER_MUXDEMUX(FFMETADATA,       ffmetadata);
94 
+    REGISTER_MUXDEMUX(FILMSTRIP,        filmstrip);
95 
+    REGISTER_MUXDEMUX(FLAC,             flac);
96 
+    REGISTER_DEMUXER (FLIC,             flic);
97 
+    REGISTER_MUXDEMUX(FLV,              flv);
98 
+    REGISTER_DEMUXER (FOURXM,           fourxm);
99 
+    REGISTER_MUXER   (FRAMECRC,         framecrc);
100 
+    REGISTER_MUXER   (FRAMEMD5,         framemd5);
101 
+    REGISTER_MUXDEMUX(G722,             g722);
102 
+    REGISTER_DEMUXER (G723_1,           g723_1);
103 
+    REGISTER_MUXER   (GIF,              gif);
104 
+    REGISTER_DEMUXER (GSM,              gsm);
105 
+    REGISTER_MUXDEMUX(GXF,              gxf);
106 
+    REGISTER_MUXDEMUX(H261,             h261);
107 
+    REGISTER_MUXDEMUX(H263,             h263);
108 
+    REGISTER_MUXDEMUX(H264,             h264);
109 
+    REGISTER_MUXDEMUX(HLS,              hls);
110 
+    REGISTER_DEMUXER (IDCIN,            idcin);
111 
+    REGISTER_DEMUXER (IFF,              iff);
112 
+    REGISTER_MUXDEMUX(ILBC,             ilbc);
113 
+    REGISTER_MUXDEMUX(IMAGE2,           image2);
114 
+    REGISTER_MUXDEMUX(IMAGE2PIPE,       image2pipe);
115 
+    REGISTER_DEMUXER (INGENIENT,        ingenient);
116 
+    REGISTER_DEMUXER (IPMOVIE,          ipmovie);
117 
+    REGISTER_MUXER   (IPOD,             ipod);
118 
+    REGISTER_MUXER   (ISMV,             ismv);
119 
+    REGISTER_DEMUXER (ISS,              iss);
120 
+    REGISTER_DEMUXER (IV8,              iv8);
121 
+    REGISTER_MUXDEMUX(IVF,              ivf);
122 
+    REGISTER_DEMUXER (JV,               jv);
123 
+    REGISTER_MUXDEMUX(LATM,             latm);
124 
+    REGISTER_DEMUXER (LMLM4,            lmlm4);
125 
+    REGISTER_DEMUXER (LXF,              lxf);
126 
+    REGISTER_MUXDEMUX(M4V,              m4v);
127 
+    REGISTER_MUXER   (MD5,              md5);
128 
+    REGISTER_MUXDEMUX(MATROSKA,         matroska);
129 
+    REGISTER_MUXER   (MATROSKA_AUDIO,   matroska_audio);
130 
+    REGISTER_MUXDEMUX(MJPEG,            mjpeg);
131 
+    REGISTER_MUXDEMUX(MLP,              mlp);
132 
+    REGISTER_DEMUXER (MM,               mm);
133 
+    REGISTER_MUXDEMUX(MMF,              mmf);
134 
+    REGISTER_MUXDEMUX(MOV,              mov);
135 
+    REGISTER_MUXER   (MP2,              mp2);
136 
+    REGISTER_MUXDEMUX(MP3,              mp3);
137 
+    REGISTER_MUXER   (MP4,              mp4);
138 
+    REGISTER_DEMUXER (MPC,              mpc);
139 
+    REGISTER_DEMUXER (MPC8,             mpc8);
140 
+    REGISTER_MUXER   (MPEG1SYSTEM,      mpeg1system);
141 
+    REGISTER_MUXER   (MPEG1VCD,         mpeg1vcd);
142 
+    REGISTER_MUXER   (MPEG1VIDEO,       mpeg1video);
143 
+    REGISTER_MUXER   (MPEG2DVD,         mpeg2dvd);
144 
+    REGISTER_MUXER   (MPEG2SVCD,        mpeg2svcd);
145 
+    REGISTER_MUXER   (MPEG2VIDEO,       mpeg2video);
146 
+    REGISTER_MUXER   (MPEG2VOB,         mpeg2vob);
147 
+    REGISTER_DEMUXER (MPEGPS,           mpegps);
148 
+    REGISTER_MUXDEMUX(MPEGTS,           mpegts);
149 
+    REGISTER_DEMUXER (MPEGTSRAW,        mpegtsraw);
150 
+    REGISTER_DEMUXER (MPEGVIDEO,        mpegvideo);
151 
+    REGISTER_MUXER   (MPJPEG,           mpjpeg);
152 
+    REGISTER_DEMUXER (MSNWC_TCP,        msnwc_tcp);
153 
+    REGISTER_DEMUXER (MTV,              mtv);
154 
+    REGISTER_DEMUXER (MVI,              mvi);
155 
+    REGISTER_MUXDEMUX(MXF,              mxf);
156 
+    REGISTER_MUXER   (MXF_D10,          mxf_d10);
157 
+    REGISTER_DEMUXER (MXG,              mxg);
158 
+    REGISTER_DEMUXER (NC,               nc);
159 
+    REGISTER_DEMUXER (NSV,              nsv);
160 
+    REGISTER_MUXER   (NULL,             null);
161 
+    REGISTER_MUXDEMUX(NUT,              nut);
162 
+    REGISTER_DEMUXER (NUV,              nuv);
163 
+    REGISTER_MUXDEMUX(OGG,              ogg);
164 
+    REGISTER_MUXDEMUX(OMA,              oma);
165 
+    REGISTER_MUXDEMUX(PCM_ALAW,         pcm_alaw);
166 
+    REGISTER_MUXDEMUX(PCM_MULAW,        pcm_mulaw);
167 
+    REGISTER_MUXDEMUX(PCM_F64BE,        pcm_f64be);
168 
+    REGISTER_MUXDEMUX(PCM_F64LE,        pcm_f64le);
169 
+    REGISTER_MUXDEMUX(PCM_F32BE,        pcm_f32be);
170 
+    REGISTER_MUXDEMUX(PCM_F32LE,        pcm_f32le);
171 
+    REGISTER_MUXDEMUX(PCM_S32BE,        pcm_s32be);
172 
+    REGISTER_MUXDEMUX(PCM_S32LE,        pcm_s32le);
173 
+    REGISTER_MUXDEMUX(PCM_S24BE,        pcm_s24be);
174 
+    REGISTER_MUXDEMUX(PCM_S24LE,        pcm_s24le);
175 
+    REGISTER_MUXDEMUX(PCM_S16BE,        pcm_s16be);
176 
+    REGISTER_MUXDEMUX(PCM_S16LE,        pcm_s16le);
177 
+    REGISTER_MUXDEMUX(PCM_S8,           pcm_s8);
178 
+    REGISTER_MUXDEMUX(PCM_U32BE,        pcm_u32be);
179 
+    REGISTER_MUXDEMUX(PCM_U32LE,        pcm_u32le);
180 
+    REGISTER_MUXDEMUX(PCM_U24BE,        pcm_u24be);
181 
+    REGISTER_MUXDEMUX(PCM_U24LE,        pcm_u24le);
182 
+    REGISTER_MUXDEMUX(PCM_U16BE,        pcm_u16be);
183 
+    REGISTER_MUXDEMUX(PCM_U16LE,        pcm_u16le);
184 
+    REGISTER_MUXDEMUX(PCM_U8,           pcm_u8);
185 
+    REGISTER_DEMUXER (PMP,              pmp);
186 
+    REGISTER_MUXER   (PSP,              psp);
187 
+    REGISTER_DEMUXER (PVA,              pva);
188 
+    REGISTER_DEMUXER (QCP,              qcp);
189 
+    REGISTER_DEMUXER (R3D,              r3d);
190 
+    REGISTER_MUXDEMUX(RAWVIDEO,         rawvideo);
191 
+    REGISTER_DEMUXER (RL2,              rl2);
192 
+    REGISTER_MUXDEMUX(RM,               rm);
193 
+    REGISTER_MUXDEMUX(ROQ,              roq);
194 
+    REGISTER_DEMUXER (RPL,              rpl);
195 
+    REGISTER_MUXDEMUX(RSO,              rso);
196 
+    REGISTER_MUXDEMUX(RTP,              rtp);
197 
+    REGISTER_MUXDEMUX(RTSP,             rtsp);
198 
+    REGISTER_MUXDEMUX(SAP,              sap);
199 
+    REGISTER_DEMUXER (SDP,              sdp);
200 200 
 #if CONFIG_RTPDEC
201 201 
     av_register_rtp_dynamic_payload_handlers();
202 202 
     av_register_rdt_dynamic_payload_handlers();
203 203 
 #endif
204 
-    REGISTER_DEMUXER  (SEGAFILM, segafilm);
205 
-    REGISTER_MUXER    (SEGMENT, segment);
206 
-    REGISTER_DEMUXER  (SHORTEN, shorten);
207 
-    REGISTER_DEMUXER  (SIFF, siff);
208 
-    REGISTER_DEMUXER  (SMACKER, smacker);
209 
-    REGISTER_MUXDEMUX (SMJPEG, smjpeg);
210 
-    REGISTER_MUXER    (SMOOTHSTREAMING, smoothstreaming);
211 
-    REGISTER_DEMUXER  (SOL, sol);
212 
-    REGISTER_MUXDEMUX (SOX, sox);
213 
-    REGISTER_MUXDEMUX (SPDIF, spdif);
214 
-    REGISTER_MUXDEMUX (SRT, srt);
215 
-    REGISTER_DEMUXER  (STR, str);
216 
-    REGISTER_MUXDEMUX (SWF, swf);
217 
-    REGISTER_DEMUXER  (TAK, tak);
218 
-    REGISTER_MUXER    (TG2, tg2);
219 
-    REGISTER_MUXER    (TGP, tgp);
220 
-    REGISTER_DEMUXER  (THP, thp);
221 
-    REGISTER_DEMUXER  (TIERTEXSEQ, tiertexseq);
222 
-    REGISTER_DEMUXER  (TMV, tmv);
223 
-    REGISTER_MUXDEMUX (TRUEHD, truehd);
224 
-    REGISTER_DEMUXER  (TTA, tta);
225 
-    REGISTER_DEMUXER  (TXD, txd);
226 
-    REGISTER_DEMUXER  (TTY, tty);
227 
-    REGISTER_DEMUXER  (VC1, vc1);
228 
-    REGISTER_MUXDEMUX (VC1T, vc1t);
229 
-    REGISTER_DEMUXER  (VMD, vmd);
230 
-    REGISTER_MUXDEMUX (VOC, voc);
231 
-    REGISTER_DEMUXER  (VQF, vqf);
232 
-    REGISTER_DEMUXER  (W64, w64);
233 
-    REGISTER_MUXDEMUX (WAV, wav);
234 
-    REGISTER_DEMUXER  (WC3, wc3);
235 
-    REGISTER_MUXER    (WEBM, webm);
236 
-    REGISTER_DEMUXER  (WSAUD, wsaud);
237 
-    REGISTER_DEMUXER  (WSVQA, wsvqa);
238 
-    REGISTER_DEMUXER  (WTV, wtv);
239 
-    REGISTER_DEMUXER  (WV, wv);
240 
-    REGISTER_DEMUXER  (XA, xa);
241 
-    REGISTER_DEMUXER  (XMV, xmv);
242 
-    REGISTER_DEMUXER  (XWMA, xwma);
243 
-    REGISTER_DEMUXER  (YOP, yop);
244 
-    REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe);
204 
+    REGISTER_DEMUXER (SEGAFILM,         segafilm);
205 
+    REGISTER_MUXER   (SEGMENT,          segment);
206 
+    REGISTER_DEMUXER (SHORTEN,          shorten);
207 
+    REGISTER_DEMUXER (SIFF,             siff);
208 
+    REGISTER_DEMUXER (SMACKER,          smacker);
209 
+    REGISTER_MUXDEMUX(SMJPEG,           smjpeg);
210 
+    REGISTER_MUXER   (SMOOTHSTREAMING,  smoothstreaming);
211 
+    REGISTER_DEMUXER (SOL,              sol);
212 
+    REGISTER_MUXDEMUX(SOX,              sox);
213 
+    REGISTER_MUXDEMUX(SPDIF,            spdif);
214 
+    REGISTER_MUXDEMUX(SRT,              srt);
215 
+    REGISTER_DEMUXER (STR,              str);
216 
+    REGISTER_MUXDEMUX(SWF,              swf);
217 
+    REGISTER_DEMUXER (TAK,              tak);
218 
+    REGISTER_MUXER   (TG2,              tg2);
219 
+    REGISTER_MUXER   (TGP,              tgp);
220 
+    REGISTER_DEMUXER (THP,              thp);
221 
+    REGISTER_DEMUXER (TIERTEXSEQ,       tiertexseq);
222 
+    REGISTER_DEMUXER (TMV,              tmv);
223 
+    REGISTER_MUXDEMUX(TRUEHD,           truehd);
224 
+    REGISTER_DEMUXER (TTA,              tta);
225 
+    REGISTER_DEMUXER (TXD,              txd);
226 
+    REGISTER_DEMUXER (TTY,              tty);
227 
+    REGISTER_DEMUXER (VC1,              vc1);
228 
+    REGISTER_MUXDEMUX(VC1T,             vc1t);
229 
+    REGISTER_DEMUXER (VMD,              vmd);
230 
+    REGISTER_MUXDEMUX(VOC,              voc);
231 
+    REGISTER_DEMUXER (VQF,              vqf);
232 
+    REGISTER_DEMUXER (W64,              w64);
233 
+    REGISTER_MUXDEMUX(WAV,              wav);
234 
+    REGISTER_DEMUXER (WC3,              wc3);
235 
+    REGISTER_MUXER   (WEBM,             webm);
236 
+    REGISTER_DEMUXER (WSAUD,            wsaud);
237 
+    REGISTER_DEMUXER (WSVQA,            wsvqa);
238 
+    REGISTER_DEMUXER (WTV,              wtv);
239 
+    REGISTER_DEMUXER (WV,               wv);
240 
+    REGISTER_DEMUXER (XA,               xa);
241 
+    REGISTER_DEMUXER (XMV,              xmv);
242 
+    REGISTER_DEMUXER (XWMA,             xwma);
243 
+    REGISTER_DEMUXER (YOP,              yop);
244 
+    REGISTER_MUXDEMUX(YUV4MPEGPIPE,     yuv4mpegpipe);
245 245
246 246 
     /* protocols */
247 247 
 #if FF_API_APPLEHTTP_PROTO
248 
-    REGISTER_PROTOCOL (APPLEHTTP, applehttp);
248 
+    REGISTER_PROTOCOL(APPLEHTTP,        applehttp);
249 249 
 #endif
250 
-    REGISTER_PROTOCOL (CONCAT, concat);
251 
-    REGISTER_PROTOCOL (CRYPTO, crypto);
252 
-    REGISTER_PROTOCOL (FFRTMPCRYPT, ffrtmpcrypt);
253 
-    REGISTER_PROTOCOL (FFRTMPHTTP, ffrtmphttp);
254 
-    REGISTER_PROTOCOL (FILE, file);
255 
-    REGISTER_PROTOCOL (GOPHER, gopher);
256 
-    REGISTER_PROTOCOL (HLS, hls);
257 
-    REGISTER_PROTOCOL (HTTP, http);
258 
-    REGISTER_PROTOCOL (HTTPPROXY, httpproxy);
259 
-    REGISTER_PROTOCOL (HTTPS, https);
260 
-    REGISTER_PROTOCOL (MMSH, mmsh);
261 
-    REGISTER_PROTOCOL (MMST, mmst);
262 
-    REGISTER_PROTOCOL (MD5,  md5);
263 
-    REGISTER_PROTOCOL (PIPE, pipe);
264 
-    REGISTER_PROTOCOL (RTMP, rtmp);
265 
-    REGISTER_PROTOCOL (RTMPE, rtmpe);
266 
-    REGISTER_PROTOCOL (RTMPS, rtmps);
267 
-    REGISTER_PROTOCOL (RTMPT, rtmpt);
268 
-    REGISTER_PROTOCOL (RTMPTE, rtmpte);
269 
-    REGISTER_PROTOCOL (RTMPTS, rtmpts);
270 
-    REGISTER_PROTOCOL (RTP, rtp);
271 
-    REGISTER_PROTOCOL (SCTP, sctp);
272 
-    REGISTER_PROTOCOL (TCP, tcp);
273 
-    REGISTER_PROTOCOL (TLS, tls);
274 
-    REGISTER_PROTOCOL (UDP, udp);
250 
+    REGISTER_PROTOCOL(CONCAT,           concat);
251 
+    REGISTER_PROTOCOL(CRYPTO,           crypto);
252 
+    REGISTER_PROTOCOL(FFRTMPCRYPT,      ffrtmpcrypt);
253 
+    REGISTER_PROTOCOL(FFRTMPHTTP,       ffrtmphttp);
254 
+    REGISTER_PROTOCOL(FILE,             file);
255 
+    REGISTER_PROTOCOL(GOPHER,           gopher);
256 
+    REGISTER_PROTOCOL(HLS,              hls);
257 
+    REGISTER_PROTOCOL(HTTP,             http);
258 
+    REGISTER_PROTOCOL(HTTPPROXY,        httpproxy);
259 
+    REGISTER_PROTOCOL(HTTPS,            https);
260 
+    REGISTER_PROTOCOL(MMSH,             mmsh);
261 
+    REGISTER_PROTOCOL(MMST,             mmst);
262 
+    REGISTER_PROTOCOL(MD5,              md5);
263 
+    REGISTER_PROTOCOL(PIPE,             pipe);
264 
+    REGISTER_PROTOCOL(RTMP,             rtmp);
265 
+    REGISTER_PROTOCOL(RTMPE,            rtmpe);
266 
+    REGISTER_PROTOCOL(RTMPS,            rtmps);
267 
+    REGISTER_PROTOCOL(RTMPT,            rtmpt);
268 
+    REGISTER_PROTOCOL(RTMPTE,           rtmpte);
269 
+    REGISTER_PROTOCOL(RTMPTS,           rtmpts);
270 
+    REGISTER_PROTOCOL(RTP,              rtp);
271 
+    REGISTER_PROTOCOL(SCTP,             sctp);
272 
+    REGISTER_PROTOCOL(TCP,              tcp);
273 
+    REGISTER_PROTOCOL(TLS,              tls);
274 
+    REGISTER_PROTOCOL(UDP,              udp);
275 275
276 276 
     /* external libraries */
277 
-    REGISTER_PROTOCOL (LIBRTMP, librtmp);
278 
-    REGISTER_PROTOCOL (LIBRTMPE, librtmpe);
279 
-    REGISTER_PROTOCOL (LIBRTMPS, librtmps);
280 
-    REGISTER_PROTOCOL (LIBRTMPT, librtmpt);
281 
-    REGISTER_PROTOCOL (LIBRTMPTE, librtmpte);
277 
+    REGISTER_PROTOCOL(LIBRTMP,          librtmp);
278 
+    REGISTER_PROTOCOL(LIBRTMPE,         librtmpe);
279 
+    REGISTER_PROTOCOL(LIBRTMPS,         librtmps);
280 
+    REGISTER_PROTOCOL(LIBRTMPT,         librtmpt);
281 
+    REGISTER_PROTOCOL(LIBRTMPTE,        librtmpte);
282 282 
 }