1. ffmpeg
  2. Commit 83d4a8442ca458ad77d77750f90a430040fd0f48
Browse code

Merge remote-tracking branch 'qatar/master'

* qatar/master:
cosmetics: Prettyprint codec/format/filter registration files

Conflicts:
libavcodec/allcodecs.c
libavdevice/alldevices.c
libavfilter/allfilters.c
libavformat/allformats.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>

Michael Niedermayer authored on 2012/12/29 22:27:38
Showing 4 changed files
libavcodec/allcodecs.c
History View file @ 83d4a84
... ... 
@@ -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,468 +75,468 @@ 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 (MPEG1_VDPAU, mpeg1_vdpau);
63 
-    REGISTER_HWACCEL (MPEG2_DXVA2, mpeg2_dxva2);
64 
-    REGISTER_HWACCEL (MPEG2_VAAPI, mpeg2_vaapi);
65 
-    REGISTER_HWACCEL (MPEG2_VDPAU, mpeg2_vdpau);
66 
-    REGISTER_HWACCEL (MPEG4_VAAPI, mpeg4_vaapi);
67 
-    REGISTER_HWACCEL (VC1_DXVA2, vc1_dxva2);
68 
-    REGISTER_HWACCEL (VC1_VAAPI, vc1_vaapi);
69 
-    REGISTER_HWACCEL (WMV3_DXVA2, wmv3_dxva2);
70 
-    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(MPEG1_VDPAU,       mpeg1_vdpau);
63 
+    REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
64 
+    REGISTER_HWACCEL(MPEG2_VAAPI,       mpeg2_vaapi);
65 
+    REGISTER_HWACCEL(MPEG2_VDPAU,       mpeg2_vdpau);
66 
+    REGISTER_HWACCEL(MPEG4_VAAPI,       mpeg4_vaapi);
67 
+    REGISTER_HWACCEL(VC1_DXVA2,         vc1_dxva2);
68 
+    REGISTER_HWACCEL(VC1_VAAPI,         vc1_vaapi);
69 
+    REGISTER_HWACCEL(WMV3_DXVA2,        wmv3_dxva2);
70 
+    REGISTER_HWACCEL(WMV3_VAAPI,        wmv3_vaapi);
71 71
72 72 
     /* video codecs */
73 
-    REGISTER_ENCODER (A64MULTI, a64multi);
74 
-    REGISTER_ENCODER (A64MULTI5, a64multi5);
75 
-    REGISTER_DECODER (AASC, aasc);
76 
-    REGISTER_ENCDEC  (AMV, amv);
77 
-    REGISTER_DECODER (ANM, anm);
78 
-    REGISTER_DECODER (ANSI, ansi);
79 
-    REGISTER_ENCDEC  (ASV1, asv1);
80 
-    REGISTER_ENCDEC  (ASV2, asv2);
81 
-    REGISTER_DECODER (AURA, aura);
82 
-    REGISTER_DECODER (AURA2, aura2);
83 
-    REGISTER_ENCDEC  (AVRP, avrp);
84 
-    REGISTER_DECODER (AVRN, avrn);
85 
-    REGISTER_DECODER (AVS, avs);
86 
-    REGISTER_ENCDEC  (AVUI, avui);
87 
-    REGISTER_ENCDEC  (AYUV, ayuv);
88 
-    REGISTER_DECODER (BETHSOFTVID, bethsoftvid);
89 
-    REGISTER_DECODER (BFI, bfi);
90 
-    REGISTER_DECODER (BINK, bink);
91 
-    REGISTER_ENCDEC  (BMP, bmp);
92 
-    REGISTER_DECODER (BMV_VIDEO, bmv_video);
93 
-    REGISTER_DECODER (BRENDER_PIX, brender_pix);
94 
-    REGISTER_DECODER (C93, c93);
95 
-    REGISTER_DECODER (CAVS, cavs);
96 
-    REGISTER_DECODER (CDGRAPHICS, cdgraphics);
97 
-    REGISTER_DECODER (CDXL, cdxl);
98 
-    REGISTER_DECODER (CINEPAK, cinepak);
99 
-    REGISTER_ENCDEC  (CLJR, cljr);
100 
-    REGISTER_DECODER (CLLC, cllc);
101 
-    REGISTER_ENCDEC  (COMFORTNOISE, comfortnoise);
102 
-    REGISTER_DECODER (CPIA, cpia);
103 
-    REGISTER_DECODER (CSCD, cscd);
104 
-    REGISTER_DECODER (CYUV, cyuv);
105 
-    REGISTER_DECODER (DFA, dfa);
106 
-    REGISTER_DECODER (DIRAC, dirac);
107 
-    REGISTER_ENCDEC  (DNXHD, dnxhd);
108 
-    REGISTER_ENCDEC  (DPX, dpx);
109 
-    REGISTER_DECODER (DSICINVIDEO, dsicinvideo);
110 
-    REGISTER_ENCDEC  (DVVIDEO, dvvideo);
111 
-    REGISTER_DECODER (DXA, dxa);
112 
-    REGISTER_DECODER (DXTORY, dxtory);
113 
-    REGISTER_DECODER (EACMV, eacmv);
114 
-    REGISTER_DECODER (EAMAD, eamad);
115 
-    REGISTER_DECODER (EATGQ, eatgq);
116 
-    REGISTER_DECODER (EATGV, eatgv);
117 
-    REGISTER_DECODER (EATQI, eatqi);
118 
-    REGISTER_DECODER (EIGHTBPS, eightbps);
119 
-    REGISTER_DECODER (EIGHTSVX_EXP, eightsvx_exp);
120 
-    REGISTER_DECODER (EIGHTSVX_FIB, eightsvx_fib);
121 
-    REGISTER_DECODER (ESCAPE124, escape124);
122 
-    REGISTER_DECODER (ESCAPE130, escape130);
123 
-    REGISTER_DECODER (EXR, exr);
124 
-    REGISTER_ENCDEC  (FFV1, ffv1);
125 
-    REGISTER_ENCDEC  (FFVHUFF, ffvhuff);
126 
-    REGISTER_ENCDEC  (FLASHSV, flashsv);
127 
-    REGISTER_ENCDEC  (FLASHSV2, flashsv2);
128 
-    REGISTER_DECODER (FLIC, flic);
129 
-    REGISTER_ENCDEC  (FLV, flv);
130 
-    REGISTER_DECODER (FOURXM, fourxm);
131 
-    REGISTER_DECODER (FRAPS, fraps);
132 
-    REGISTER_DECODER (FRWU, frwu);
133 
-    REGISTER_ENCDEC  (GIF, gif);
134 
-    REGISTER_ENCDEC  (H261, h261);
135 
-    REGISTER_ENCDEC  (H263, h263);
136 
-    REGISTER_DECODER (H263I, h263i);
137 
-    REGISTER_ENCDEC  (H263P, h263p);
138 
-    REGISTER_DECODER (H264, h264);
139 
-    REGISTER_DECODER (H264_CRYSTALHD, h264_crystalhd);
140 
-    REGISTER_DECODER (H264_VDA, h264_vda);
141 
-    REGISTER_DECODER (H264_VDPAU, h264_vdpau);
142 
-    REGISTER_ENCDEC  (HUFFYUV, huffyuv);
143 
-    REGISTER_DECODER (IDCIN, idcin);
144 
-    REGISTER_DECODER (IFF_BYTERUN1, iff_byterun1);
145 
-    REGISTER_DECODER (IFF_ILBM, iff_ilbm);
146 
-    REGISTER_DECODER (INDEO2, indeo2);
147 
-    REGISTER_DECODER (INDEO3, indeo3);
148 
-    REGISTER_DECODER (INDEO4, indeo4);
149 
-    REGISTER_DECODER (INDEO5, indeo5);
150 
-    REGISTER_DECODER (INTERPLAY_VIDEO, interplay_video);
151 
-    REGISTER_ENCDEC  (JPEG2000, jpeg2000);
152 
-    REGISTER_ENCDEC  (JPEGLS, jpegls);
153 
-    REGISTER_DECODER (JV, jv);
154 
-    REGISTER_DECODER (KGV1, kgv1);
155 
-    REGISTER_DECODER (KMVC, kmvc);
156 
-    REGISTER_DECODER (LAGARITH, lagarith);
157 
-    REGISTER_ENCODER (LJPEG, ljpeg);
158 
-    REGISTER_DECODER (LOCO, loco);
159 
-    REGISTER_DECODER (MDEC, mdec);
160 
-    REGISTER_DECODER (MIMIC, mimic);
161 
-    REGISTER_ENCDEC  (MJPEG, mjpeg);
162 
-    REGISTER_DECODER (MJPEGB, mjpegb);
163 
-    REGISTER_DECODER (MMVIDEO, mmvideo);
164 
-    REGISTER_DECODER (MOTIONPIXELS, motionpixels);
165 
-    REGISTER_DECODER (MPEG_XVMC, mpeg_xvmc);
166 
-    REGISTER_ENCDEC  (MPEG1VIDEO, mpeg1video);
167 
-    REGISTER_ENCDEC  (MPEG2VIDEO, mpeg2video);
168 
-    REGISTER_ENCDEC  (MPEG4, mpeg4);
169 
-    REGISTER_DECODER (MPEG4_CRYSTALHD, mpeg4_crystalhd);
170 
-    REGISTER_DECODER (MPEG4_VDPAU, mpeg4_vdpau);
171 
-    REGISTER_DECODER (MPEGVIDEO, mpegvideo);
172 
-    REGISTER_DECODER (MPEG_VDPAU, mpeg_vdpau);
173 
-    REGISTER_DECODER (MPEG1_VDPAU, mpeg1_vdpau);
174 
-    REGISTER_DECODER (MPEG2_CRYSTALHD, mpeg2_crystalhd);
175 
-    REGISTER_DECODER (MSA1, msa1);
176 
-    REGISTER_DECODER (MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
177 
-    REGISTER_DECODER (MSMPEG4V1, msmpeg4v1);
178 
-    REGISTER_ENCDEC  (MSMPEG4V2, msmpeg4v2);
179 
-    REGISTER_ENCDEC  (MSMPEG4V3, msmpeg4v3);
180 
-    REGISTER_DECODER (MSRLE, msrle);
181 
-    REGISTER_DECODER (MSS1, mss1);
182 
-    REGISTER_DECODER (MSS2, mss2);
183 
-    REGISTER_ENCDEC  (MSVIDEO1, msvideo1);
184 
-    REGISTER_DECODER (MSZH, mszh);
185 
-    REGISTER_DECODER (MTS2, mts2);
186 
-    REGISTER_DECODER (MVC1, mvc1);
187 
-    REGISTER_DECODER (MVC2, mvc2);
188 
-    REGISTER_DECODER (MXPEG, mxpeg);
189 
-    REGISTER_DECODER (NUV, nuv);
190 
-    REGISTER_DECODER (PAF_VIDEO, paf_video);
191 
-    REGISTER_ENCDEC  (PAM, pam);
192 
-    REGISTER_ENCDEC  (PBM, pbm);
193 
-    REGISTER_ENCDEC  (PCX, pcx);
194 
-    REGISTER_ENCDEC  (PGM, pgm);
195 
-    REGISTER_ENCDEC  (PGMYUV, pgmyuv);
196 
-    REGISTER_DECODER (PICTOR, pictor);
197 
-    REGISTER_ENCDEC  (PNG, png);
198 
-    REGISTER_ENCDEC  (PPM, ppm);
199 
-    REGISTER_ENCDEC  (PRORES, prores);
200 
-    REGISTER_ENCODER (PRORES_ANATOLIY, prores_anatoliy);
201 
-    REGISTER_ENCODER (PRORES_KOSTYA, prores_kostya);
202 
-    REGISTER_DECODER (PRORES_LGPL, prores_lgpl);
203 
-    REGISTER_DECODER (PTX, ptx);
204 
-    REGISTER_DECODER (QDRAW, qdraw);
205 
-    REGISTER_DECODER (QPEG, qpeg);
206 
-    REGISTER_ENCDEC  (QTRLE, qtrle);
207 
-    REGISTER_ENCDEC  (R10K,  r10k);
208 
-    REGISTER_ENCDEC  (R210,  r210);
209 
-    REGISTER_ENCDEC  (RAWVIDEO, rawvideo);
210 
-    REGISTER_DECODER (RL2, rl2);
211 
-    REGISTER_ENCDEC  (ROQ, roq);
212 
-    REGISTER_DECODER (RPZA, rpza);
213 
-    REGISTER_ENCDEC  (RV10, rv10);
214 
-    REGISTER_ENCDEC  (RV20, rv20);
215 
-    REGISTER_DECODER (RV30, rv30);
216 
-    REGISTER_DECODER (RV40, rv40);
217 
-    REGISTER_DECODER (S302M, s302m);
218 
-    REGISTER_DECODER (SANM, sanm);
219 
-    REGISTER_ENCDEC  (SGI, sgi);
220 
-    REGISTER_DECODER (SGIRLE, sgirle);
221 
-    REGISTER_DECODER (SMACKER, smacker);
222 
-    REGISTER_DECODER (SMC, smc);
223 
-    REGISTER_ENCDEC  (SNOW, snow);
224 
-    REGISTER_DECODER (SP5X, sp5x);
225 
-    REGISTER_ENCDEC  (SUNRAST, sunrast);
226 
-    REGISTER_ENCDEC  (SVQ1, svq1);
227 
-    REGISTER_DECODER (SVQ3, svq3);
228 
-    REGISTER_ENCDEC  (TARGA, targa);
229 
-    REGISTER_DECODER (TARGA_Y216, targa_y216);
230 
-    REGISTER_DECODER (THEORA, theora);
231 
-    REGISTER_DECODER (THP, thp);
232 
-    REGISTER_DECODER (TIERTEXSEQVIDEO, tiertexseqvideo);
233 
-    REGISTER_ENCDEC  (TIFF, tiff);
234 
-    REGISTER_DECODER (TMV, tmv);
235 
-    REGISTER_DECODER (TRUEMOTION1, truemotion1);
236 
-    REGISTER_DECODER (TRUEMOTION2, truemotion2);
237 
-    REGISTER_DECODER (TSCC, tscc);
238 
-    REGISTER_DECODER (TSCC2, tscc2);
239 
-    REGISTER_DECODER (TXD, txd);
240 
-    REGISTER_DECODER (ULTI, ulti);
241 
-    REGISTER_ENCDEC  (UTVIDEO, utvideo);
242 
-    REGISTER_ENCDEC  (V210,  v210);
243 
-    REGISTER_DECODER (V210X, v210x);
244 
-    REGISTER_ENCDEC  (V308, v308);
245 
-    REGISTER_ENCDEC  (V408, v408);
246 
-    REGISTER_ENCDEC  (V410, v410);
247 
-    REGISTER_DECODER (VB, vb);
248 
-    REGISTER_DECODER (VBLE, vble);
249 
-    REGISTER_DECODER (VC1, vc1);
250 
-    REGISTER_DECODER (VC1_CRYSTALHD, vc1_crystalhd);
251 
-    REGISTER_DECODER (VC1_VDPAU, vc1_vdpau);
252 
-    REGISTER_DECODER (VC1IMAGE, vc1image);
253 
-    REGISTER_DECODER (VCR1, vcr1);
254 
-    REGISTER_DECODER (VMDVIDEO, vmdvideo);
255 
-    REGISTER_DECODER (VMNC, vmnc);
256 
-    REGISTER_DECODER (VP3, vp3);
257 
-    REGISTER_DECODER (VP5, vp5);
258 
-    REGISTER_DECODER (VP6, vp6);
259 
-    REGISTER_DECODER (VP6A, vp6a);
260 
-    REGISTER_DECODER (VP6F, vp6f);
261 
-    REGISTER_DECODER (VP8, vp8);
262 
-    REGISTER_DECODER (VQA, vqa);
263 
-    REGISTER_ENCDEC  (WMV1, wmv1);
264 
-    REGISTER_ENCDEC  (WMV2, wmv2);
265 
-    REGISTER_DECODER (WMV3, wmv3);
266 
-    REGISTER_DECODER (WMV3_CRYSTALHD, wmv3_crystalhd);
267 
-    REGISTER_DECODER (WMV3_VDPAU, wmv3_vdpau);
268 
-    REGISTER_DECODER (WMV3IMAGE, wmv3image);
269 
-    REGISTER_DECODER (WNV1, wnv1);
270 
-    REGISTER_DECODER (XAN_WC3, xan_wc3);
271 
-    REGISTER_DECODER (XAN_WC4, xan_wc4);
272 
-    REGISTER_ENCDEC  (XBM, xbm);
273 
-    REGISTER_ENCDEC  (XFACE, xface);
274 
-    REGISTER_DECODER (XL, xl);
275 
-    REGISTER_ENCDEC  (XWD, xwd);
276 
-    REGISTER_ENCDEC  (Y41P, y41p);
277 
-    REGISTER_DECODER (YOP, yop);
278 
-    REGISTER_ENCDEC  (YUV4, yuv4);
279 
-    REGISTER_DECODER (ZEROCODEC, zerocodec);
280 
-    REGISTER_ENCDEC  (ZLIB, zlib);
281 
-    REGISTER_ENCDEC  (ZMBV, zmbv);
73 
+    REGISTER_ENCODER(A64MULTI,          a64multi);
74 
+    REGISTER_ENCODER(A64MULTI5,         a64multi5);
75 
+    REGISTER_DECODER(AASC,              aasc);
76 
+    REGISTER_ENCDEC (AMV,               amv);
77 
+    REGISTER_DECODER(ANM,               anm);
78 
+    REGISTER_DECODER(ANSI,              ansi);
79 
+    REGISTER_ENCDEC (ASV1,              asv1);
80 
+    REGISTER_ENCDEC (ASV2,              asv2);
81 
+    REGISTER_DECODER(AURA,              aura);
82 
+    REGISTER_DECODER(AURA2,             aura2);
83 
+    REGISTER_ENCDEC (AVRP,              avrp);
84 
+    REGISTER_DECODER(AVRN,              avrn);
85 
+    REGISTER_DECODER(AVS,               avs);
86 
+    REGISTER_ENCDEC (AVUI,              avui);
87 
+    REGISTER_ENCDEC (AYUV,              ayuv);
88 
+    REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
89 
+    REGISTER_DECODER(BFI,               bfi);
90 
+    REGISTER_DECODER(BINK,              bink);
91 
+    REGISTER_ENCDEC (BMP,               bmp);
92 
+    REGISTER_DECODER(BMV_VIDEO,         bmv_video);
93 
+    REGISTER_DECODER(BRENDER_PIX,       brender_pix);
94 
+    REGISTER_DECODER(C93,               c93);
95 
+    REGISTER_DECODER(CAVS,              cavs);
96 
+    REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
97 
+    REGISTER_DECODER(CDXL,              cdxl);
98 
+    REGISTER_DECODER(CINEPAK,           cinepak);
99 
+    REGISTER_ENCDEC (CLJR,              cljr);
100 
+    REGISTER_DECODER(CLLC,              cllc);
101 
+    REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
102 
+    REGISTER_DECODER(CPIA,              cpia);
103 
+    REGISTER_DECODER(CSCD,              cscd);
104 
+    REGISTER_DECODER(CYUV,              cyuv);
105 
+    REGISTER_DECODER(DFA,               dfa);
106 
+    REGISTER_DECODER(DIRAC,             dirac);
107 
+    REGISTER_ENCDEC (DNXHD,             dnxhd);
108 
+    REGISTER_ENCDEC (DPX,               dpx);
109 
+    REGISTER_DECODER(DSICINVIDEO,       dsicinvideo);
110 
+    REGISTER_ENCDEC (DVVIDEO,           dvvideo);
111 
+    REGISTER_DECODER(DXA,               dxa);
112 
+    REGISTER_DECODER(DXTORY,            dxtory);
113 
+    REGISTER_DECODER(EACMV,             eacmv);
114 
+    REGISTER_DECODER(EAMAD,             eamad);
115 
+    REGISTER_DECODER(EATGQ,             eatgq);
116 
+    REGISTER_DECODER(EATGV,             eatgv);
117 
+    REGISTER_DECODER(EATQI,             eatqi);
118 
+    REGISTER_DECODER(EIGHTBPS,          eightbps);
119 
+    REGISTER_DECODER(EIGHTSVX_EXP,      eightsvx_exp);
120 
+    REGISTER_DECODER(EIGHTSVX_FIB,      eightsvx_fib);
121 
+    REGISTER_DECODER(ESCAPE124,         escape124);
122 
+    REGISTER_DECODER(ESCAPE130,         escape130);
123 
+    REGISTER_DECODER(EXR,               exr);
124 
+    REGISTER_ENCDEC (FFV1,              ffv1);
125 
+    REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
126 
+    REGISTER_ENCDEC (FLASHSV,           flashsv);
127 
+    REGISTER_ENCDEC (FLASHSV2,          flashsv2);
128 
+    REGISTER_DECODER(FLIC,              flic);
129 
+    REGISTER_ENCDEC (FLV,               flv);
130 
+    REGISTER_DECODER(FOURXM,            fourxm);
131 
+    REGISTER_DECODER(FRAPS,             fraps);
132 
+    REGISTER_DECODER(FRWU,              frwu);
133 
+    REGISTER_ENCDEC (GIF,               gif);
134 
+    REGISTER_ENCDEC (H261,              h261);
135 
+    REGISTER_ENCDEC (H263,              h263);
136 
+    REGISTER_DECODER(H263I,             h263i);
137 
+    REGISTER_ENCDEC (H263P,             h263p);
138 
+    REGISTER_DECODER(H264,              h264);
139 
+    REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);
140 
+    REGISTER_DECODER(H264_VDA,          h264_vda);
141 
+    REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
142 
+    REGISTER_ENCDEC (HUFFYUV,           huffyuv);
143 
+    REGISTER_DECODER(IDCIN,             idcin);
144 
+    REGISTER_DECODER(IFF_BYTERUN1,      iff_byterun1);
145 
+    REGISTER_DECODER(IFF_ILBM,          iff_ilbm);
146 
+    REGISTER_DECODER(INDEO2,            indeo2);
147 
+    REGISTER_DECODER(INDEO3,            indeo3);
148 
+    REGISTER_DECODER(INDEO4,            indeo4);
149 
+    REGISTER_DECODER(INDEO5,            indeo5);
150 
+    REGISTER_DECODER(INTERPLAY_VIDEO,   interplay_video);
151 
+    REGISTER_ENCDEC (JPEG2000,          jpeg2000);
152 
+    REGISTER_ENCDEC (JPEGLS,            jpegls);
153 
+    REGISTER_DECODER(JV,                jv);
154 
+    REGISTER_DECODER(KGV1,              kgv1);
155 
+    REGISTER_DECODER(KMVC,              kmvc);
156 
+    REGISTER_DECODER(LAGARITH,          lagarith);
157 
+    REGISTER_ENCODER(LJPEG,             ljpeg);
158 
+    REGISTER_DECODER(LOCO,              loco);
159 
+    REGISTER_DECODER(MDEC,              mdec);
160 
+    REGISTER_DECODER(MIMIC,             mimic);
161 
+    REGISTER_ENCDEC (MJPEG,             mjpeg);
162 
+    REGISTER_DECODER(MJPEGB,            mjpegb);
163 
+    REGISTER_DECODER(MMVIDEO,           mmvideo);
164 
+    REGISTER_DECODER(MOTIONPIXELS,      motionpixels);
165 
+    REGISTER_DECODER(MPEG_XVMC,         mpeg_xvmc);
166 
+    REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
167 
+    REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
168 
+    REGISTER_ENCDEC (MPEG4,             mpeg4);
169 
+    REGISTER_DECODER(MPEG4_CRYSTALHD,   mpeg4_crystalhd);
170 
+    REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);
171 
+    REGISTER_DECODER(MPEGVIDEO,         mpegvideo);
172 
+    REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);
173 
+    REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);
174 
+    REGISTER_DECODER(MPEG2_CRYSTALHD,   mpeg2_crystalhd);
175 
+    REGISTER_DECODER(MSA1,              msa1);
176 
+    REGISTER_DECODER(MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
177 
+    REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
178 
+    REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
179 
+    REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
180 
+    REGISTER_DECODER(MSRLE,             msrle);
181 
+    REGISTER_DECODER(MSS1,              mss1);
182 
+    REGISTER_DECODER(MSS2,              mss2);
183 
+    REGISTER_ENCDEC (MSVIDEO1,          msvideo1);
184 
+    REGISTER_DECODER(MSZH,              mszh);
185 
+    REGISTER_DECODER(MTS2,              mts2);
186 
+    REGISTER_DECODER(MVC1,              mvc1);
187 
+    REGISTER_DECODER(MVC2,              mvc2);
188 
+    REGISTER_DECODER(MXPEG,             mxpeg);
189 
+    REGISTER_DECODER(NUV,               nuv);
190 
+    REGISTER_DECODER(PAF_VIDEO,         paf_video);
191 
+    REGISTER_ENCDEC (PAM,               pam);
192 
+    REGISTER_ENCDEC (PBM,               pbm);
193 
+    REGISTER_ENCDEC (PCX,               pcx);
194 
+    REGISTER_ENCDEC (PGM,               pgm);
195 
+    REGISTER_ENCDEC (PGMYUV,            pgmyuv);
196 
+    REGISTER_DECODER(PICTOR,            pictor);
197 
+    REGISTER_ENCDEC (PNG,               png);
198 
+    REGISTER_ENCDEC (PPM,               ppm);
199 
+    REGISTER_ENCDEC (PRORES,            prores);
200 
+    REGISTER_ENCODER(PRORES_ANATOLIY,   prores_anatoliy);
201 
+    REGISTER_ENCODER(PRORES_KOSTYA,     prores_kostya);
202 
+    REGISTER_DECODER(PRORES_LGPL,       prores_lgpl);
203 
+    REGISTER_DECODER(PTX,               ptx);
204 
+    REGISTER_DECODER(QDRAW,             qdraw);
205 
+    REGISTER_DECODER(QPEG,              qpeg);
206 
+    REGISTER_ENCDEC (QTRLE,             qtrle);
207 
+    REGISTER_ENCDEC (R10K,              r10k);
208 
+    REGISTER_ENCDEC (R210,              r210);
209 
+    REGISTER_ENCDEC (RAWVIDEO,          rawvideo);
210 
+    REGISTER_DECODER(RL2,               rl2);
211 
+    REGISTER_ENCDEC (ROQ,               roq);
212 
+    REGISTER_DECODER(RPZA,              rpza);
213 
+    REGISTER_ENCDEC (RV10,              rv10);
214 
+    REGISTER_ENCDEC (RV20,              rv20);
215 
+    REGISTER_DECODER(RV30,              rv30);
216 
+    REGISTER_DECODER(RV40,              rv40);
217 
+    REGISTER_DECODER(S302M,             s302m);
218 
+    REGISTER_DECODER(SANM,              sanm);
219 
+    REGISTER_ENCDEC (SGI,               sgi);
220 
+    REGISTER_DECODER(SGIRLE,            sgirle);
221 
+    REGISTER_DECODER(SMACKER,           smacker);
222 
+    REGISTER_DECODER(SMC,               smc);
223 
+    REGISTER_ENCDEC (SNOW,              snow);
224 
+    REGISTER_DECODER(SP5X,              sp5x);
225 
+    REGISTER_ENCDEC (SUNRAST,           sunrast);
226 
+    REGISTER_ENCDEC (SVQ1,              svq1);
227 
+    REGISTER_DECODER(SVQ3,              svq3);
228 
+    REGISTER_ENCDEC (TARGA,             targa);
229 
+    REGISTER_DECODER(TARGA_Y216,        targa_y216);
230 
+    REGISTER_DECODER(THEORA,            theora);
231 
+    REGISTER_DECODER(THP,               thp);
232 
+    REGISTER_DECODER(TIERTEXSEQVIDEO,   tiertexseqvideo);
233 
+    REGISTER_ENCDEC (TIFF,              tiff);
234 
+    REGISTER_DECODER(TMV,               tmv);
235 
+    REGISTER_DECODER(TRUEMOTION1,       truemotion1);
236 
+    REGISTER_DECODER(TRUEMOTION2,       truemotion2);
237 
+    REGISTER_DECODER(TSCC,              tscc);
238 
+    REGISTER_DECODER(TSCC2,             tscc2);
239 
+    REGISTER_DECODER(TXD,               txd);
240 
+    REGISTER_DECODER(ULTI,              ulti);
241 
+    REGISTER_ENCDEC (UTVIDEO,           utvideo);
242 
+    REGISTER_ENCDEC (V210,              v210);
243 
+    REGISTER_DECODER(V210X,             v210x);
244 
+    REGISTER_ENCDEC (V308,              v308);
245 
+    REGISTER_ENCDEC (V408,              v408);
246 
+    REGISTER_ENCDEC (V410,              v410);
247 
+    REGISTER_DECODER(VB,                vb);
248 
+    REGISTER_DECODER(VBLE,              vble);
249 
+    REGISTER_DECODER(VC1,               vc1);
250 
+    REGISTER_DECODER(VC1_CRYSTALHD,     vc1_crystalhd);
251 
+    REGISTER_DECODER(VC1_VDPAU,         vc1_vdpau);
252 
+    REGISTER_DECODER(VC1IMAGE,          vc1image);
253 
+    REGISTER_DECODER(VCR1,              vcr1);
254 
+    REGISTER_DECODER(VMDVIDEO,          vmdvideo);
255 
+    REGISTER_DECODER(VMNC,              vmnc);
256 
+    REGISTER_DECODER(VP3,               vp3);
257 
+    REGISTER_DECODER(VP5,               vp5);
258 
+    REGISTER_DECODER(VP6,               vp6);
259 
+    REGISTER_DECODER(VP6A,              vp6a);
260 
+    REGISTER_DECODER(VP6F,              vp6f);
261 
+    REGISTER_DECODER(VP8,               vp8);
262 
+    REGISTER_DECODER(VQA,               vqa);
263 
+    REGISTER_ENCDEC (WMV1,              wmv1);
264 
+    REGISTER_ENCDEC (WMV2,              wmv2);
265 
+    REGISTER_DECODER(WMV3,              wmv3);
266 
+    REGISTER_DECODER(WMV3_CRYSTALHD,    wmv3_crystalhd);
267 
+    REGISTER_DECODER(WMV3_VDPAU,        wmv3_vdpau);
268 
+    REGISTER_DECODER(WMV3IMAGE,         wmv3image);
269 
+    REGISTER_DECODER(WNV1,              wnv1);
270 
+    REGISTER_DECODER(XAN_WC3,           xan_wc3);
271 
+    REGISTER_DECODER(XAN_WC4,           xan_wc4);
272 
+    REGISTER_ENCDEC (XBM,               xbm);
273 
+    REGISTER_ENCDEC (XFACE,             xface);
274 
+    REGISTER_DECODER(XL,                xl);
275 
+    REGISTER_ENCDEC (XWD,               xwd);
276 
+    REGISTER_ENCDEC (Y41P,              y41p);
277 
+    REGISTER_DECODER(YOP,               yop);
278 
+    REGISTER_ENCDEC (YUV4,              yuv4);
279 
+    REGISTER_DECODER(ZEROCODEC,         zerocodec);
280 
+    REGISTER_ENCDEC (ZLIB,              zlib);
281 
+    REGISTER_ENCDEC (ZMBV,              zmbv);
282 282
283 283 
     /* audio codecs */
284 
-    REGISTER_ENCDEC  (AAC, aac);
285 
-    REGISTER_DECODER (AAC_LATM, aac_latm);
286 
-    REGISTER_ENCDEC  (AC3, ac3);
287 
-    REGISTER_ENCODER (AC3_FIXED, ac3_fixed);
288 
-    REGISTER_ENCDEC  (ALAC, alac);
289 
-    REGISTER_DECODER (ALS, als);
290 
-    REGISTER_DECODER (AMRNB, amrnb);
291 
-    REGISTER_DECODER (AMRWB, amrwb);
292 
-    REGISTER_DECODER (APE, ape);
293 
-    REGISTER_DECODER (ATRAC1, atrac1);
294 
-    REGISTER_DECODER (ATRAC3, atrac3);
295 
-    REGISTER_DECODER (BINKAUDIO_DCT, binkaudio_dct);
296 
-    REGISTER_DECODER (BINKAUDIO_RDFT, binkaudio_rdft);
297 
-    REGISTER_DECODER (BMV_AUDIO, bmv_audio);
298 
-    REGISTER_DECODER (COOK, cook);
299 
-    REGISTER_ENCDEC  (DCA, dca);
300 
-    REGISTER_DECODER (DSICINAUDIO, dsicinaudio);
301 
-    REGISTER_ENCDEC  (EAC3, eac3);
302 
-    REGISTER_DECODER (FFWAVESYNTH, ffwavesynth);
303 
-    REGISTER_ENCDEC  (FLAC, flac);
304 
-    REGISTER_ENCDEC  (G723_1, g723_1);
305 
-    REGISTER_DECODER (G729, g729);
306 
-    REGISTER_DECODER (GSM, gsm);
307 
-    REGISTER_DECODER (GSM_MS, gsm_ms);
308 
-    REGISTER_DECODER (IAC, iac);
309 
-    REGISTER_DECODER (IMC, imc);
310 
-    REGISTER_DECODER (MACE3, mace3);
311 
-    REGISTER_DECODER (MACE6, mace6);
312 
-    REGISTER_DECODER (MLP, mlp);
313 
-    REGISTER_DECODER (MP1, mp1);
314 
-    REGISTER_DECODER (MP1FLOAT, mp1float);
315 
-    REGISTER_ENCDEC  (MP2, mp2);
316 
-    REGISTER_DECODER (MP2FLOAT, mp2float);
317 
-    REGISTER_DECODER (MP3, mp3);
318 
-    REGISTER_DECODER (MP3FLOAT, mp3float);
319 
-    REGISTER_DECODER (MP3ADU, mp3adu);
320 
-    REGISTER_DECODER (MP3ADUFLOAT, mp3adufloat);
321 
-    REGISTER_DECODER (MP3ON4, mp3on4);
322 
-    REGISTER_DECODER (MP3ON4FLOAT, mp3on4float);
323 
-    REGISTER_DECODER (MPC7, mpc7);
324 
-    REGISTER_DECODER (MPC8, mpc8);
325 
-    REGISTER_ENCDEC  (NELLYMOSER, nellymoser);
326 
-    REGISTER_DECODER (PAF_AUDIO, paf_audio);
327 
-    REGISTER_DECODER (QCELP, qcelp);
328 
-    REGISTER_DECODER (QDM2, qdm2);
329 
-    REGISTER_ENCDEC  (RA_144, ra_144);
330 
-    REGISTER_DECODER (RA_288, ra_288);
331 
-    REGISTER_DECODER (RALF, ralf);
332 
-    REGISTER_DECODER (SHORTEN, shorten);
333 
-    REGISTER_DECODER (SIPR, sipr);
334 
-    REGISTER_DECODER (SMACKAUD, smackaud);
335 
-    REGISTER_ENCDEC  (SONIC, sonic);
336 
-    REGISTER_ENCODER (SONIC_LS, sonic_ls);
337 
-    REGISTER_DECODER (TAK, tak);
338 
-    REGISTER_DECODER (TRUEHD, truehd);
339 
-    REGISTER_DECODER (TRUESPEECH, truespeech);
340 
-    REGISTER_DECODER (TTA, tta);
341 
-    REGISTER_DECODER (TWINVQ, twinvq);
342 
-    REGISTER_DECODER (VMDAUDIO, vmdaudio);
343 
-    REGISTER_ENCDEC  (VORBIS, vorbis);
344 
-    REGISTER_DECODER (WAVPACK, wavpack);
345 
-    REGISTER_DECODER (WMALOSSLESS, wmalossless);
346 
-    REGISTER_DECODER (WMAPRO, wmapro);
347 
-    REGISTER_ENCDEC  (WMAV1, wmav1);
348 
-    REGISTER_ENCDEC  (WMAV2, wmav2);
349 
-    REGISTER_DECODER (WMAVOICE, wmavoice);
350 
-    REGISTER_DECODER (WS_SND1, ws_snd1);
284 
+    REGISTER_ENCDEC (AAC,               aac);
285 
+    REGISTER_DECODER(AAC_LATM,          aac_latm);
286 
+    REGISTER_ENCDEC (AC3,               ac3);
287 
+    REGISTER_ENCODER(AC3_FIXED,         ac3_fixed);
288 
+    REGISTER_ENCDEC (ALAC,              alac);
289 
+    REGISTER_DECODER(ALS,               als);
290 
+    REGISTER_DECODER(AMRNB,             amrnb);
291 
+    REGISTER_DECODER(AMRWB,             amrwb);
292 
+    REGISTER_DECODER(APE,               ape);
293 
+    REGISTER_DECODER(ATRAC1,            atrac1);
294 
+    REGISTER_DECODER(ATRAC3,            atrac3);
295 
+    REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
296 
+    REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
297 
+    REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
298 
+    REGISTER_DECODER(COOK,              cook);
299 
+    REGISTER_ENCDEC (DCA,               dca);
300 
+    REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
301 
+    REGISTER_ENCDEC (EAC3,              eac3);
302 
+    REGISTER_DECODER(FFWAVESYNTH,       ffwavesynth);
303 
+    REGISTER_ENCDEC (FLAC,              flac);
304 
+    REGISTER_ENCDEC (G723_1,            g723_1);
305 
+    REGISTER_DECODER(G729,              g729);
306 
+    REGISTER_DECODER(GSM,               gsm);
307 
+    REGISTER_DECODER(GSM_MS,            gsm_ms);
308 
+    REGISTER_DECODER(IAC,               iac);
309 
+    REGISTER_DECODER(IMC,               imc);
310 
+    REGISTER_DECODER(MACE3,             mace3);
311 
+    REGISTER_DECODER(MACE6,             mace6);
312 
+    REGISTER_DECODER(MLP,               mlp);
313 
+    REGISTER_DECODER(MP1,               mp1);
314 
+    REGISTER_DECODER(MP1FLOAT,          mp1float);
315 
+    REGISTER_ENCDEC (MP2,               mp2);
316 
+    REGISTER_DECODER(MP2FLOAT,          mp2float);
317 
+    REGISTER_DECODER(MP3,               mp3);
318 
+    REGISTER_DECODER(MP3FLOAT,          mp3float);
319 
+    REGISTER_DECODER(MP3ADU,            mp3adu);
320 
+    REGISTER_DECODER(MP3ADUFLOAT,       mp3adufloat);
321 
+    REGISTER_DECODER(MP3ON4,            mp3on4);
322 
+    REGISTER_DECODER(MP3ON4FLOAT,       mp3on4float);
323 
+    REGISTER_DECODER(MPC7,              mpc7);
324 
+    REGISTER_DECODER(MPC8,              mpc8);
325 
+    REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
326 
+    REGISTER_DECODER(PAF_AUDIO,         paf_audio);
327 
+    REGISTER_DECODER(QCELP,             qcelp);
328 
+    REGISTER_DECODER(QDM2,              qdm2);
329 
+    REGISTER_ENCDEC (RA_144,            ra_144);
330 
+    REGISTER_DECODER(RA_288,            ra_288);
331 
+    REGISTER_DECODER(RALF,              ralf);
332 
+    REGISTER_DECODER(SHORTEN,           shorten);
333 
+    REGISTER_DECODER(SIPR,              sipr);
334 
+    REGISTER_DECODER(SMACKAUD,          smackaud);
335 
+    REGISTER_ENCDEC (SONIC,             sonic);
336 
+    REGISTER_ENCODER(SONIC_LS,          sonic_ls);
337 
+    REGISTER_DECODER(TAK,               tak);
338 
+    REGISTER_DECODER(TRUEHD,            truehd);
339 
+    REGISTER_DECODER(TRUESPEECH,        truespeech);
340 
+    REGISTER_DECODER(TTA,               tta);
341 
+    REGISTER_DECODER(TWINVQ,            twinvq);
342 
+    REGISTER_DECODER(VMDAUDIO,          vmdaudio);
343 
+    REGISTER_ENCDEC (VORBIS,            vorbis);
344 
+    REGISTER_DECODER(WAVPACK,           wavpack);
345 
+    REGISTER_DECODER(WMALOSSLESS,       wmalossless);
346 
+    REGISTER_DECODER(WMAPRO,            wmapro);
347 
+    REGISTER_ENCDEC (WMAV1,             wmav1);
348 
+    REGISTER_ENCDEC (WMAV2,             wmav2);
349 
+    REGISTER_DECODER(WMAVOICE,          wmavoice);
350 
+    REGISTER_DECODER(WS_SND1,           ws_snd1);
351 351
352 352 
     /* PCM codecs */
353 
-    REGISTER_ENCDEC  (PCM_ALAW, pcm_alaw);
354 
-    REGISTER_DECODER (PCM_BLURAY, pcm_bluray);
355 
-    REGISTER_DECODER (PCM_DVD, pcm_dvd);
356 
-    REGISTER_ENCDEC  (PCM_F32BE, pcm_f32be);
357 
-    REGISTER_ENCDEC  (PCM_F32LE, pcm_f32le);
358 
-    REGISTER_ENCDEC  (PCM_F64BE, pcm_f64be);
359 
-    REGISTER_ENCDEC  (PCM_F64LE, pcm_f64le);
360 
-    REGISTER_DECODER (PCM_LXF, pcm_lxf);
361 
-    REGISTER_ENCDEC  (PCM_MULAW, pcm_mulaw);
362 
-    REGISTER_ENCDEC  (PCM_S8, pcm_s8);
363 
-    REGISTER_ENCDEC  (PCM_S8_PLANAR, pcm_s8_planar);
364 
-    REGISTER_ENCDEC  (PCM_S16BE, pcm_s16be);
365 
-    REGISTER_ENCDEC  (PCM_S16BE_PLANAR, pcm_s16be_planar);
366 
-    REGISTER_ENCDEC  (PCM_S16LE, pcm_s16le);
367 
-    REGISTER_ENCDEC  (PCM_S16LE_PLANAR, pcm_s16le_planar);
368 
-    REGISTER_ENCDEC  (PCM_S24BE, pcm_s24be);
369 
-    REGISTER_ENCDEC  (PCM_S24DAUD, pcm_s24daud);
370 
-    REGISTER_ENCDEC  (PCM_S24LE, pcm_s24le);
371 
-    REGISTER_ENCDEC  (PCM_S24LE_PLANAR, pcm_s24le_planar);
372 
-    REGISTER_ENCDEC  (PCM_S32BE, pcm_s32be);
373 
-    REGISTER_ENCDEC  (PCM_S32LE, pcm_s32le);
374 
-    REGISTER_ENCDEC  (PCM_S32LE_PLANAR, pcm_s32le_planar);
375 
-    REGISTER_ENCDEC  (PCM_U8, pcm_u8);
376 
-    REGISTER_ENCDEC  (PCM_U16BE, pcm_u16be);
377 
-    REGISTER_ENCDEC  (PCM_U16LE, pcm_u16le);
378 
-    REGISTER_ENCDEC  (PCM_U24BE, pcm_u24be);
379 
-    REGISTER_ENCDEC  (PCM_U24LE, pcm_u24le);
380 
-    REGISTER_ENCDEC  (PCM_U32BE, pcm_u32be);
381 
-    REGISTER_ENCDEC  (PCM_U32LE, pcm_u32le);
382 
-    REGISTER_DECODER (PCM_ZORK , pcm_zork);
353 
+    REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
354 
+    REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
355 
+    REGISTER_DECODER(PCM_DVD,           pcm_dvd);
356 
+    REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
357 
+    REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
358 
+    REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
359 
+    REGISTER_ENCDEC (PCM_F64LE,         pcm_f64le);
360 
+    REGISTER_DECODER(PCM_LXF,           pcm_lxf);
361 
+    REGISTER_ENCDEC (PCM_MULAW,         pcm_mulaw);
362 
+    REGISTER_ENCDEC (PCM_S8,            pcm_s8);
363 
+    REGISTER_ENCDEC (PCM_S8_PLANAR,     pcm_s8_planar);
364 
+    REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
365 
+    REGISTER_ENCDEC (PCM_S16BE_PLANAR,  pcm_s16be_planar);
366 
+    REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
367 
+    REGISTER_ENCDEC (PCM_S16LE_PLANAR,  pcm_s16le_planar);
368 
+    REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
369 
+    REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
370 
+    REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
371 
+    REGISTER_ENCDEC (PCM_S24LE_PLANAR,  pcm_s24le_planar);
372 
+    REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
373 
+    REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
374 
+    REGISTER_ENCDEC (PCM_S32LE_PLANAR,  pcm_s32le_planar);
375 
+    REGISTER_ENCDEC (PCM_U8,            pcm_u8);
376 
+    REGISTER_ENCDEC (PCM_U16BE,         pcm_u16be);
377 
+    REGISTER_ENCDEC (PCM_U16LE,         pcm_u16le);
378 
+    REGISTER_ENCDEC (PCM_U24BE,         pcm_u24be);
379 
+    REGISTER_ENCDEC (PCM_U24LE,         pcm_u24le);
380 
+    REGISTER_ENCDEC (PCM_U32BE,         pcm_u32be);
381 
+    REGISTER_ENCDEC (PCM_U32LE,         pcm_u32le);
382 
+    REGISTER_DECODER(PCM_ZORK,          pcm_zork);
383 383
384 384 
     /* DPCM codecs */
385 
-    REGISTER_DECODER (INTERPLAY_DPCM, interplay_dpcm);
386 
-    REGISTER_ENCDEC  (ROQ_DPCM, roq_dpcm);
387 
-    REGISTER_DECODER (SOL_DPCM, sol_dpcm);
388 
-    REGISTER_DECODER (XAN_DPCM, xan_dpcm);
385 
+    REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
386 
+    REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
387 
+    REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
388 
+    REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
389 389
390 390 
     /* ADPCM codecs */
391 
-    REGISTER_DECODER (ADPCM_4XM, adpcm_4xm);
392 
-    REGISTER_ENCDEC  (ADPCM_ADX, adpcm_adx);
393 
-    REGISTER_DECODER (ADPCM_AFC, adpcm_afc);
394 
-    REGISTER_DECODER (ADPCM_CT, adpcm_ct);
395 
-    REGISTER_DECODER (ADPCM_EA, adpcm_ea);
396 
-    REGISTER_DECODER (ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
397 
-    REGISTER_DECODER (ADPCM_EA_R1, adpcm_ea_r1);
398 
-    REGISTER_DECODER (ADPCM_EA_R2, adpcm_ea_r2);
399 
-    REGISTER_DECODER (ADPCM_EA_R3, adpcm_ea_r3);
400 
-    REGISTER_DECODER (ADPCM_EA_XAS, adpcm_ea_xas);
401 
-    REGISTER_ENCDEC  (ADPCM_G722, adpcm_g722);
402 
-    REGISTER_ENCDEC  (ADPCM_G726, adpcm_g726);
403 
-    REGISTER_DECODER (ADPCM_IMA_AMV, adpcm_ima_amv);
404 
-    REGISTER_DECODER (ADPCM_IMA_APC, adpcm_ima_apc);
405 
-    REGISTER_DECODER (ADPCM_IMA_DK3, adpcm_ima_dk3);
406 
-    REGISTER_DECODER (ADPCM_IMA_DK4, adpcm_ima_dk4);
407 
-    REGISTER_DECODER (ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
408 
-    REGISTER_DECODER (ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
409 
-    REGISTER_DECODER (ADPCM_IMA_ISS, adpcm_ima_iss);
410 
-    REGISTER_DECODER (ADPCM_IMA_OKI, adpcm_ima_oki);
411 
-    REGISTER_ENCDEC  (ADPCM_IMA_QT, adpcm_ima_qt);
412 
-    REGISTER_DECODER (ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
413 
-    REGISTER_ENCDEC  (ADPCM_IMA_WAV, adpcm_ima_wav);
414 
-    REGISTER_DECODER (ADPCM_IMA_WS, adpcm_ima_ws);
415 
-    REGISTER_ENCDEC  (ADPCM_MS, adpcm_ms);
416 
-    REGISTER_DECODER (ADPCM_SBPRO_2, adpcm_sbpro_2);
417 
-    REGISTER_DECODER (ADPCM_SBPRO_3, adpcm_sbpro_3);
418 
-    REGISTER_DECODER (ADPCM_SBPRO_4, adpcm_sbpro_4);
419 
-    REGISTER_ENCDEC  (ADPCM_SWF, adpcm_swf);
420 
-    REGISTER_DECODER (ADPCM_THP, adpcm_thp);
421 
-    REGISTER_DECODER (ADPCM_XA, adpcm_xa);
422 
-    REGISTER_ENCDEC  (ADPCM_YAMAHA, adpcm_yamaha);
423 
-    REGISTER_DECODER (VIMA, vima);
391 
+    REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
392 
+    REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
393 
+    REGISTER_DECODER(ADPCM_AFC,         adpcm_afc);
394 
+    REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
395 
+    REGISTER_DECODER(ADPCM_EA,          adpcm_ea);
396 
+    REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
397 
+    REGISTER_DECODER(ADPCM_EA_R1,       adpcm_ea_r1);
398 
+    REGISTER_DECODER(ADPCM_EA_R2,       adpcm_ea_r2);
399 
+    REGISTER_DECODER(ADPCM_EA_R3,       adpcm_ea_r3);
400 
+    REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
401 
+    REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
402 
+    REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
403 
+    REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
404 
+    REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
405 
+    REGISTER_DECODER(ADPCM_IMA_DK3,     adpcm_ima_dk3);
406 
+    REGISTER_DECODER(ADPCM_IMA_DK4,     adpcm_ima_dk4);
407 
+    REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
408 
+    REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
409 
+    REGISTER_DECODER(ADPCM_IMA_ISS,     adpcm_ima_iss);
410 
+    REGISTER_DECODER(ADPCM_IMA_OKI,     adpcm_ima_oki);
411 
+    REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
412 
+    REGISTER_DECODER(ADPCM_IMA_SMJPEG,  adpcm_ima_smjpeg);
413 
+    REGISTER_ENCDEC (ADPCM_IMA_WAV,     adpcm_ima_wav);
414 
+    REGISTER_DECODER(ADPCM_IMA_WS,      adpcm_ima_ws);
415 
+    REGISTER_ENCDEC (ADPCM_MS,          adpcm_ms);
416 
+    REGISTER_DECODER(ADPCM_SBPRO_2,     adpcm_sbpro_2);
417 
+    REGISTER_DECODER(ADPCM_SBPRO_3,     adpcm_sbpro_3);
418 
+    REGISTER_DECODER(ADPCM_SBPRO_4,     adpcm_sbpro_4);
419 
+    REGISTER_ENCDEC (ADPCM_SWF,         adpcm_swf);
420 
+    REGISTER_DECODER(ADPCM_THP,         adpcm_thp);
421 
+    REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
422 
+    REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
423 
+    REGISTER_DECODER(VIMA,              vima);
424 424
425 425 
     /* subtitles */
426 
-    REGISTER_ENCDEC  (ASS, ass);
427 
-    REGISTER_ENCDEC  (DVBSUB, dvbsub);
428 
-    REGISTER_ENCDEC  (DVDSUB, dvdsub);
429 
-    REGISTER_DECODER (JACOSUB, jacosub);
430 
-    REGISTER_DECODER (MICRODVD, microdvd);
431 
-    REGISTER_ENCDEC  (MOVTEXT, movtext);
432 
-    REGISTER_DECODER (PGSSUB, pgssub);
433 
-    REGISTER_DECODER (REALTEXT, realtext);
434 
-    REGISTER_DECODER (SAMI, sami);
435 
-    REGISTER_ENCDEC  (SRT, srt);
436 
-    REGISTER_ENCDEC  (SUBRIP, subrip);
437 
-    REGISTER_DECODER (SUBVIEWER, subviewer);
438 
-    REGISTER_DECODER (TEXT, text);
439 
-    REGISTER_DECODER (WEBVTT, webvtt);
440 
-    REGISTER_ENCDEC  (XSUB, xsub);
426 
+    REGISTER_ENCDEC (ASS,               ass);
427 
+    REGISTER_ENCDEC (DVBSUB,            dvbsub);
428 
+    REGISTER_ENCDEC (DVDSUB,            dvdsub);
429 
+    REGISTER_DECODER(JACOSUB,           jacosub);
430 
+    REGISTER_DECODER(MICRODVD,          microdvd);
431 
+    REGISTER_ENCDEC (MOVTEXT,           movtext);
432 
+    REGISTER_DECODER(PGSSUB,            pgssub);
433 
+    REGISTER_DECODER(REALTEXT,          realtext);
434 
+    REGISTER_DECODER(SAMI,              sami);
435 
+    REGISTER_ENCDEC (SRT,               srt);
436 
+    REGISTER_ENCDEC (SUBRIP,            subrip);
437 
+    REGISTER_DECODER(SUBVIEWER,         subviewer);
438 
+    REGISTER_DECODER(TEXT,              text);
439 
+    REGISTER_DECODER(WEBVTT,            webvtt);
440 
+    REGISTER_ENCDEC (XSUB,              xsub);
441 441
442 442 
     /* external libraries */
443 
-    REGISTER_DECODER (LIBCELT, libcelt);
444 
-    REGISTER_ENCODER (LIBFAAC, libfaac);
445 
-    REGISTER_ENCODER (LIBFDK_AAC, libfdk_aac);
446 
-    REGISTER_ENCDEC  (LIBGSM, libgsm);
447 
-    REGISTER_ENCDEC  (LIBGSM_MS, libgsm_ms);
448 
-    REGISTER_ENCDEC  (LIBILBC, libilbc);
449 
-    REGISTER_ENCODER (LIBMP3LAME, libmp3lame);
450 
-    REGISTER_ENCDEC  (LIBOPENCORE_AMRNB, libopencore_amrnb);
451 
-    REGISTER_DECODER (LIBOPENCORE_AMRWB, libopencore_amrwb);
452 
-    REGISTER_ENCDEC  (LIBOPENJPEG, libopenjpeg);
453 
-    REGISTER_ENCDEC  (LIBOPUS, libopus);
454 
-    REGISTER_ENCDEC  (LIBSCHROEDINGER, libschroedinger);
455 
-    REGISTER_ENCDEC  (LIBSPEEX, libspeex);
456 
-    REGISTER_DECODER (LIBSTAGEFRIGHT_H264, libstagefright_h264);
457 
-    REGISTER_ENCODER (LIBTHEORA, libtheora);
458 
-    REGISTER_ENCODER (LIBTWOLAME, libtwolame);
459 
-    REGISTER_ENCDEC  (LIBUTVIDEO, libutvideo);
460 
-    REGISTER_ENCODER (LIBVO_AACENC, libvo_aacenc);
461 
-    REGISTER_ENCODER (LIBVO_AMRWBENC, libvo_amrwbenc);
462 
-    REGISTER_ENCDEC  (LIBVORBIS, libvorbis);
463 
-    REGISTER_ENCDEC  (LIBVPX, libvpx);
464 
-    REGISTER_ENCODER (LIBX264, libx264);
465 
-    REGISTER_ENCODER (LIBX264RGB, libx264rgb);
466 
-    REGISTER_ENCODER (LIBXAVS, libxavs);
467 
-    REGISTER_ENCODER (LIBXVID, libxvid);
468 
-    REGISTER_ENCODER (LIBAACPLUS, libaacplus);
443 
+    REGISTER_DECODER(LIBCELT,           libcelt);
444 
+    REGISTER_ENCODER(LIBFAAC,           libfaac);
445 
+    REGISTER_ENCODER(LIBFDK_AAC,        libfdk_aac);
446 
+    REGISTER_ENCDEC (LIBGSM,            libgsm);
447 
+    REGISTER_ENCDEC (LIBGSM_MS,         libgsm_ms);
448 
+    REGISTER_ENCDEC (LIBILBC,           libilbc);
449 
+    REGISTER_ENCODER(LIBMP3LAME,        libmp3lame);
450 
+    REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
451 
+    REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
452 
+    REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
453 
+    REGISTER_ENCDEC (LIBOPUS,           libopus);
454 
+    REGISTER_ENCDEC (LIBSCHROEDINGER,   libschroedinger);
455 
+    REGISTER_ENCDEC (LIBSPEEX,          libspeex);
456 
+    REGISTER_DECODER(LIBSTAGEFRIGHT_H264, libstagefright_h264);
457 
+    REGISTER_ENCODER(LIBTHEORA,         libtheora);
458 
+    REGISTER_ENCODER(LIBTWOLAME,        libtwolame);
459 
+    REGISTER_ENCDEC (LIBUTVIDEO,        libutvideo);
460 
+    REGISTER_ENCODER(LIBVO_AACENC,      libvo_aacenc);
461 
+    REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
462 
+    REGISTER_ENCDEC (LIBVORBIS,         libvorbis);
463 
+    REGISTER_ENCDEC (LIBVPX,            libvpx);
464 
+    REGISTER_ENCODER(LIBX264,           libx264);
465 
+    REGISTER_ENCODER(LIBX264RGB,        libx264rgb);
466 
+    REGISTER_ENCODER(LIBXAVS,           libxavs);
467 
+    REGISTER_ENCODER(LIBXVID,           libxvid);
468 
+    REGISTER_ENCODER(LIBAACPLUS,        libaacplus);
469 469
470 470 
     /* text */
471 
-    REGISTER_DECODER (BINTEXT, bintext);
472 
-    REGISTER_DECODER (XBIN, xbin);
473 
-    REGISTER_DECODER (IDF, idf);
471 
+    REGISTER_DECODER(BINTEXT,           bintext);
472 
+    REGISTER_DECODER(XBIN,              xbin);
473 
+    REGISTER_DECODER(IDF,               idf);
474 474
475 475 
     /* parsers */
476 
-    REGISTER_PARSER  (AAC, aac);
477 
-    REGISTER_PARSER  (AAC_LATM, aac_latm);
478 
-    REGISTER_PARSER  (AC3, ac3);
479 
-    REGISTER_PARSER  (ADX, adx);
480 
-    REGISTER_PARSER  (BMP, bmp);
481 
-    REGISTER_PARSER  (CAVSVIDEO, cavsvideo);
482 
-    REGISTER_PARSER  (COOK, cook);
483 
-    REGISTER_PARSER  (DCA, dca);
484 
-    REGISTER_PARSER  (DIRAC, dirac);
485 
-    REGISTER_PARSER  (DNXHD, dnxhd);
486 
-    REGISTER_PARSER  (DVBSUB, dvbsub);
487 
-    REGISTER_PARSER  (DVDSUB, dvdsub);
488 
-    REGISTER_PARSER  (FLAC, flac);
489 
-    REGISTER_PARSER  (GSM, gsm);
490 
-    REGISTER_PARSER  (H261, h261);
491 
-    REGISTER_PARSER  (H263, h263);
492 
-    REGISTER_PARSER  (H264, h264);
493 
-    REGISTER_PARSER  (MJPEG, mjpeg);
494 
-    REGISTER_PARSER  (MLP, mlp);
495 
-    REGISTER_PARSER  (MPEG4VIDEO, mpeg4video);
496 
-    REGISTER_PARSER  (MPEGAUDIO, mpegaudio);
497 
-    REGISTER_PARSER  (MPEGVIDEO, mpegvideo);
498 
-    REGISTER_PARSER  (PNG, png);
499 
-    REGISTER_PARSER  (PNM, pnm);
500 
-    REGISTER_PARSER  (RV30, rv30);
501 
-    REGISTER_PARSER  (RV40, rv40);
502 
-    REGISTER_PARSER  (TAK, tak);
503 
-    REGISTER_PARSER  (VC1, vc1);
504 
-    REGISTER_PARSER  (VORBIS, vorbis);
505 
-    REGISTER_PARSER  (VP3, vp3);
506 
-    REGISTER_PARSER  (VP8, vp8);
476 
+    REGISTER_PARSER(AAC,                aac);
477 
+    REGISTER_PARSER(AAC_LATM,           aac_latm);
478 
+    REGISTER_PARSER(AC3,                ac3);
479 
+    REGISTER_PARSER(ADX,                adx);
480 
+    REGISTER_PARSER(BMP,                bmp);
481 
+    REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
482 
+    REGISTER_PARSER(COOK,               cook);
483 
+    REGISTER_PARSER(DCA,                dca);
484 
+    REGISTER_PARSER(DIRAC,              dirac);
485 
+    REGISTER_PARSER(DNXHD,              dnxhd);
486 
+    REGISTER_PARSER(DVBSUB,             dvbsub);
487 
+    REGISTER_PARSER(DVDSUB,             dvdsub);
488 
+    REGISTER_PARSER(FLAC,               flac);
489 
+    REGISTER_PARSER(GSM,                gsm);
490 
+    REGISTER_PARSER(H261,               h261);
491 
+    REGISTER_PARSER(H263,               h263);
492 
+    REGISTER_PARSER(H264,               h264);
493 
+    REGISTER_PARSER(MJPEG,              mjpeg);
494 
+    REGISTER_PARSER(MLP,                mlp);
495 
+    REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
496 
+    REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
497 
+    REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
498 
+    REGISTER_PARSER(PNG,                png);
499 
+    REGISTER_PARSER(PNM,                pnm);
500 
+    REGISTER_PARSER(RV30,               rv30);
501 
+    REGISTER_PARSER(RV40,               rv40);
502 
+    REGISTER_PARSER(TAK,                tak);
503 
+    REGISTER_PARSER(VC1,                vc1);
504 
+    REGISTER_PARSER(VORBIS,             vorbis);
505 
+    REGISTER_PARSER(VP3,                vp3);
506 
+    REGISTER_PARSER(VP8,                vp8);
507 507
508 508 
     /* bitstream filters */
509 
-    REGISTER_BSF     (AAC_ADTSTOASC, aac_adtstoasc);
510 
-    REGISTER_BSF     (CHOMP, chomp);
511 
-    REGISTER_BSF     (DUMP_EXTRADATA, dump_extradata);
512 
-    REGISTER_BSF     (H264_MP4TOANNEXB, h264_mp4toannexb);
513 
-    REGISTER_BSF     (IMX_DUMP_HEADER, imx_dump_header);
514 
-    REGISTER_BSF     (MJPEG2JPEG, mjpeg2jpeg);
515 
-    REGISTER_BSF     (MJPEGA_DUMP_HEADER, mjpega_dump_header);
516 
-    REGISTER_BSF     (MP3_HEADER_COMPRESS, mp3_header_compress);
517 
-    REGISTER_BSF     (MP3_HEADER_DECOMPRESS, mp3_header_decompress);
518 
-    REGISTER_BSF     (MOV2TEXTSUB, mov2textsub);
519 
-    REGISTER_BSF     (NOISE, noise);
520 
-    REGISTER_BSF     (REMOVE_EXTRADATA, remove_extradata);
521 
-    REGISTER_BSF     (TEXT2MOVSUB, text2movsub);
509 
+    REGISTER_BSF(AAC_ADTSTOASC,         aac_adtstoasc);
510 
+    REGISTER_BSF(CHOMP,                 chomp);
511 
+    REGISTER_BSF(DUMP_EXTRADATA,        dump_extradata);
512 
+    REGISTER_BSF(H264_MP4TOANNEXB,      h264_mp4toannexb);
513 
+    REGISTER_BSF(IMX_DUMP_HEADER,       imx_dump_header);
514 
+    REGISTER_BSF(MJPEG2JPEG,            mjpeg2jpeg);
515 
+    REGISTER_BSF(MJPEGA_DUMP_HEADER,    mjpega_dump_header);
516 
+    REGISTER_BSF(MP3_HEADER_COMPRESS,   mp3_header_compress);
517 
+    REGISTER_BSF(MP3_HEADER_DECOMPRESS, mp3_header_decompress);
518 
+    REGISTER_BSF(MOV2TEXTSUB,           mov2textsub);
519 
+    REGISTER_BSF(NOISE,                 noise);
520 
+    REGISTER_BSF(REMOVE_EXTRADATA,      remove_extradata);
521 
+    REGISTER_BSF(TEXT2MOVSUB,           text2movsub);
522 522 
 }
libavdevice/alldevices.c
History View file @ 83d4a84
... ... 
@@ -21,13 +21,23 @@
21 21 
 #include "config.h"
22 22 
 #include "avdevice.h"
23 23
24 
-#define REGISTER_OUTDEV(X,x) { \
25 
-          extern AVOutputFormat ff_##x##_muxer; \
26 
-          if(CONFIG_##X##_OUTDEV)  av_register_output_format(&ff_##x##_muxer); }
27 
-#define REGISTER_INDEV(X,x) { \
28 
-          extern AVInputFormat ff_##x##_demuxer; \
29 
-          if(CONFIG_##X##_INDEV)   av_register_input_format(&ff_##x##_demuxer); }
30 
-#define REGISTER_INOUTDEV(X,x)  REGISTER_OUTDEV(X,x); REGISTER_INDEV(X,x)
24 
+#define REGISTER_OUTDEV(X, x)                                           \
25 
+    {                                                                   \
26 
+        extern AVOutputFormat ff_##x##_muxer;                           \
27 
+        if (CONFIG_##X##_OUTDEV)                                        \
28 
+            av_register_output_format(&ff_##x##_muxer);                 \
29 
+    }
30 
+
31 
+#define REGISTER_INDEV(X, x)                                            \
32 
+    {                                                                   \
33 
+        extern AVInputFormat ff_##x##_demuxer;                          \
34 
+        if (CONFIG_##X##_INDEV)                                         \
35 
+            av_register_input_format(&ff_##x##_demuxer);                \
36 
+    }
37 
+
38 
+#define REGISTER_INOUTDEV(X, x)                                         \
39 
+    REGISTER_OUTDEV(X, x);                                              \
40 
+    REGISTER_INDEV(X, x)
31 41
32 42 
 void avdevice_register_all(void)
33 43 
 {
... ... 
@@ -38,26 +48,26 @@ void avdevice_register_all(void)
38 38 
     initialized = 1;
39 39
40 40 
     /* devices */
41 
-    REGISTER_INOUTDEV (ALSA, alsa);
42 
-    REGISTER_INDEV    (BKTR, bktr);
43 
-    REGISTER_OUTDEV   (CACA, caca);
44 
-    REGISTER_INDEV    (DSHOW, dshow);
45 
-    REGISTER_INDEV    (DV1394, dv1394);
46 
-    REGISTER_INDEV    (FBDEV, fbdev);
47 
-    REGISTER_INDEV    (IEC61883, iec61883);
48 
-    REGISTER_INDEV    (JACK, jack);
49 
-    REGISTER_INDEV    (LAVFI, lavfi);
50 
-    REGISTER_INDEV    (OPENAL, openal);
51 
-    REGISTER_INOUTDEV (OSS, oss);
52 
-    REGISTER_INDEV    (PULSE, pulse);
53 
-    REGISTER_OUTDEV   (SDL, sdl);
54 
-    REGISTER_INOUTDEV (SNDIO, sndio);
55 
-    REGISTER_INDEV    (V4L2, v4l2);
56 
-//    REGISTER_INDEV    (V4L, v4l
57 
-    REGISTER_INDEV    (VFWCAP, vfwcap);
58 
-    REGISTER_INDEV    (X11GRAB, x11grab);
41 
+    REGISTER_INOUTDEV(ALSA,             alsa);
42 
+    REGISTER_INDEV   (BKTR,             bktr);
43 
+    REGISTER_OUTDEV  (CACA,             caca);
44 
+    REGISTER_INDEV   (DSHOW,            dshow);
45 
+    REGISTER_INDEV   (DV1394,           dv1394);
46 
+    REGISTER_INDEV   (FBDEV,            fbdev);
47 
+    REGISTER_INDEV   (IEC61883,         iec61883);
48 
+    REGISTER_INDEV   (JACK,             jack);
49 
+    REGISTER_INDEV   (LAVFI,            lavfi);
50 
+    REGISTER_INDEV   (OPENAL,           openal);
51 
+    REGISTER_INOUTDEV(OSS,              oss);
52 
+    REGISTER_INDEV   (PULSE,            pulse);
53 
+    REGISTER_OUTDEV  (SDL,              sdl);
54 
+    REGISTER_INOUTDEV(SNDIO,            sndio);
55 
+    REGISTER_INDEV   (V4L2,             v4l2);
56 
+//    REGISTER_INDEV   (V4L,              v4l
57 
+    REGISTER_INDEV   (VFWCAP,           vfwcap);
58 
+    REGISTER_INDEV   (X11GRAB,          x11grab);
59 59
60 60 
     /* external libraries */
61 
-    REGISTER_INDEV    (LIBCDIO, libcdio);
62 
-    REGISTER_INDEV    (LIBDC1394, libdc1394);
61 
+    REGISTER_INDEV   (LIBCDIO,          libcdio);
62 
+    REGISTER_INDEV   (LIBDC1394,        libdc1394);
63 63 
 }
libavfilter/allfilters.c
History View file @ 83d4a84
... ... 
@@ -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_BUILTIN_FILTER(x,y) { \
31 34 
           extern AVFilter avfilter_##y##_##x ; \
... ... 
@@ -45,126 +48,126 @@ void avfilter_register_all(void)
45 45 
         return;
46 46 
     initialized = 1;
47 47
48 
-    REGISTER_FILTER (ACONVERT,    aconvert,    af);
49 
-    REGISTER_FILTER (AFORMAT,     aformat,     af);
50 
-    REGISTER_FILTER (AMERGE,      amerge,      af);
51 
-    REGISTER_FILTER (AMIX,        amix,        af);
52 
-    REGISTER_FILTER (ANULL,       anull,       af);
53 
-    REGISTER_FILTER (APAD,        apad,        af);
54 
-    REGISTER_FILTER (ARESAMPLE,   aresample,   af);
55 
-    REGISTER_FILTER (ASELECT,     aselect,     af);
56 
-    REGISTER_FILTER (ASENDCMD,    asendcmd,    af);
57 
-    REGISTER_FILTER (ASETNSAMPLES, asetnsamples, af);
58 
-    REGISTER_FILTER (ASETPTS,     asetpts,     af);
59 
-    REGISTER_FILTER (ASETTB,      asettb,      af);
60 
-    REGISTER_FILTER (ASHOWINFO,   ashowinfo,   af);
61 
-    REGISTER_FILTER (ASPLIT,      asplit,      af);
62 
-    REGISTER_FILTER (ASTREAMSYNC, astreamsync, af);
63 
-    REGISTER_FILTER (ASYNCTS,     asyncts,     af);
64 
-    REGISTER_FILTER (ATEMPO,      atempo,      af);
65 
-    REGISTER_FILTER (CHANNELMAP,  channelmap,  af);
66 
-    REGISTER_FILTER (CHANNELSPLIT,channelsplit,af);
67 
-    REGISTER_FILTER (EARWAX,      earwax,      af);
68 
-    REGISTER_FILTER (EBUR128,     ebur128,     af);
69 
-    REGISTER_FILTER (JOIN,        join,        af);
70 
-    REGISTER_FILTER (PAN,         pan,         af);
71 
-    REGISTER_FILTER (RESAMPLE,    resample,    af);
72 
-    REGISTER_FILTER (SILENCEDETECT, silencedetect, af);
73 
-    REGISTER_FILTER (VOLUME,      volume,      af);
74 
-    REGISTER_FILTER (VOLUMEDETECT,volumedetect,af);
75 
-
76 
-    REGISTER_FILTER (AEVALSRC,    aevalsrc,    asrc);
77 
-    REGISTER_FILTER (ANULLSRC,    anullsrc,    asrc);
78 
-    REGISTER_FILTER (FLITE,       flite,       asrc);
79 
-
80 
-    REGISTER_FILTER (ANULLSINK,   anullsink,   asink);
81 
-
82 
-    REGISTER_FILTER (ALPHAEXTRACT, alphaextract, vf);
83 
-    REGISTER_FILTER (ALPHAMERGE,  alphamerge,  vf);
84 
-    REGISTER_FILTER (ASS,         ass,         vf);
85 
-    REGISTER_FILTER (BBOX,        bbox,        vf);
86 
-    REGISTER_FILTER (BLACKDETECT, blackdetect, vf);
87 
-    REGISTER_FILTER (BLACKFRAME,  blackframe,  vf);
88 
-    REGISTER_FILTER (BOXBLUR,     boxblur,     vf);
89 
-    REGISTER_FILTER (COLORMATRIX, colormatrix, vf);
90 
-    REGISTER_FILTER (COPY,        copy,        vf);
91 
-    REGISTER_FILTER (CROP,        crop,        vf);
92 
-    REGISTER_FILTER (CROPDETECT,  cropdetect,  vf);
93 
-    REGISTER_FILTER (DECIMATE,    decimate,    vf);
94 
-    REGISTER_FILTER (DELOGO,      delogo,      vf);
95 
-    REGISTER_FILTER (DESHAKE,     deshake,     vf);
96 
-    REGISTER_FILTER (DRAWBOX,     drawbox,     vf);
97 
-    REGISTER_FILTER (DRAWTEXT,    drawtext,    vf);
98 
-    REGISTER_FILTER (EDGEDETECT,  edgedetect,  vf);
99 
-    REGISTER_FILTER (FADE,        fade,        vf);
100 
-    REGISTER_FILTER (FIELD,       field,       vf);
101 
-    REGISTER_FILTER (FIELDORDER,  fieldorder,  vf);
102 
-    REGISTER_FILTER (FORMAT,      format,      vf);
103 
-    REGISTER_FILTER (FPS,         fps,         vf);
104 
-    REGISTER_FILTER (FRAMESTEP,   framestep,   vf);
105 
-    REGISTER_FILTER (FREI0R,      frei0r,      vf);
106 
-    REGISTER_FILTER (GEQ,         geq,         vf);
107 
-    REGISTER_FILTER (GRADFUN,     gradfun,     vf);
108 
-    REGISTER_FILTER (HFLIP,       hflip,       vf);
109 
-    REGISTER_FILTER (HQDN3D,      hqdn3d,      vf);
110 
-    REGISTER_FILTER (HUE,         hue,         vf);
111 
-    REGISTER_FILTER (IDET,        idet,        vf);
112 
-    REGISTER_FILTER (LUT,         lut,         vf);
113 
-    REGISTER_FILTER (LUTRGB,      lutrgb,      vf);
114 
-    REGISTER_FILTER (LUTYUV,      lutyuv,      vf);
115 
-    REGISTER_FILTER (MP,          mp,          vf);
116 
-    REGISTER_FILTER (NEGATE,      negate,      vf);
117 
-    REGISTER_FILTER (NOFORMAT,    noformat,    vf);
118 
-    REGISTER_FILTER (NULL,        null,        vf);
119 
-    REGISTER_FILTER (OCV,         ocv,         vf);
120 
-    REGISTER_FILTER (OVERLAY,     overlay,     vf);
121 
-    REGISTER_FILTER (PAD,         pad,         vf);
122 
-    REGISTER_FILTER (PIXDESCTEST, pixdesctest, vf);
123 
-    REGISTER_FILTER (PP,          pp,          vf);
124 
-    REGISTER_FILTER (REMOVELOGO,  removelogo,  vf);
125 
-    REGISTER_FILTER (SCALE,       scale,       vf);
126 
-    REGISTER_FILTER (SELECT,      select,      vf);
127 
-    REGISTER_FILTER (SENDCMD,     sendcmd,     vf);
128 
-    REGISTER_FILTER (SETDAR,      setdar,      vf);
129 
-    REGISTER_FILTER (SETFIELD,    setfield,    vf);
130 
-    REGISTER_FILTER (SETPTS,      setpts,      vf);
131 
-    REGISTER_FILTER (SETSAR,      setsar,      vf);
132 
-    REGISTER_FILTER (SETTB,       settb,       vf);
133 
-    REGISTER_FILTER (SHOWINFO,    showinfo,    vf);
134 
-    REGISTER_FILTER (SMARTBLUR,   smartblur,   vf);
135 
-    REGISTER_FILTER (SPLIT,       split,       vf);
136 
-    REGISTER_FILTER (SUBTITLES,   subtitles,   vf);
137 
-    REGISTER_FILTER (SUPER2XSAI,  super2xsai,  vf);
138 
-    REGISTER_FILTER (SWAPUV,      swapuv,      vf);
139 
-    REGISTER_FILTER (THUMBNAIL,   thumbnail,   vf);
140 
-    REGISTER_FILTER (TILE,        tile,        vf);
141 
-    REGISTER_FILTER (TINTERLACE,  tinterlace,  vf);
142 
-    REGISTER_FILTER (TRANSPOSE,   transpose,   vf);
143 
-    REGISTER_FILTER (UNSHARP,     unsharp,     vf);
144 
-    REGISTER_FILTER (VFLIP,       vflip,       vf);
145 
-    REGISTER_FILTER (YADIF,       yadif,       vf);
146 
-
147 
-    REGISTER_FILTER (CELLAUTO,    cellauto,    vsrc);
148 
-    REGISTER_FILTER (COLOR,       color,       vsrc);
149 
-    REGISTER_FILTER (FREI0R,      frei0r_src,  vsrc);
150 
-    REGISTER_FILTER (LIFE,        life,        vsrc);
151 
-    REGISTER_FILTER (MANDELBROT,  mandelbrot,  vsrc);
152 
-    REGISTER_FILTER (MPTESTSRC,   mptestsrc,   vsrc);
153 
-    REGISTER_FILTER (NULLSRC,     nullsrc,     vsrc);
154 
-    REGISTER_FILTER (RGBTESTSRC,  rgbtestsrc,  vsrc);
155 
-    REGISTER_FILTER (SMPTEBARS,   smptebars,   vsrc);
156 
-    REGISTER_FILTER (TESTSRC,     testsrc,     vsrc);
157 
-
158 
-    REGISTER_FILTER (NULLSINK,    nullsink,    vsink);
48 
+    REGISTER_FILTER(ACONVERT,       aconvert,       af);
49 
+    REGISTER_FILTER(AFORMAT,        aformat,        af);
50 
+    REGISTER_FILTER(AMERGE,         amerge,         af);
51 
+    REGISTER_FILTER(AMIX,           amix,           af);
52 
+    REGISTER_FILTER(ANULL,          anull,          af);
53 
+    REGISTER_FILTER(APAD,           apad,           af);
54 
+    REGISTER_FILTER(ARESAMPLE,      aresample,      af);
55 
+    REGISTER_FILTER(ASELECT,        aselect,        af);
56 
+    REGISTER_FILTER(ASENDCMD,       asendcmd,       af);
57 
+    REGISTER_FILTER(ASETNSAMPLES,   asetnsamples,   af);
58 
+    REGISTER_FILTER(ASETPTS,        asetpts,        af);
59 
+    REGISTER_FILTER(ASETTB,         asettb,         af);
60 
+    REGISTER_FILTER(ASHOWINFO,      ashowinfo,      af);
61 
+    REGISTER_FILTER(ASPLIT,         asplit,         af);
62 
+    REGISTER_FILTER(ASTREAMSYNC,    astreamsync,    af);
63 
+    REGISTER_FILTER(ASYNCTS,        asyncts,        af);
64 
+    REGISTER_FILTER(ATEMPO,         atempo,         af);
65 
+    REGISTER_FILTER(CHANNELMAP,     channelmap,     af);
66 
+    REGISTER_FILTER(CHANNELSPLIT,   channelsplit,   af);
67 
+    REGISTER_FILTER(EARWAX,         earwax,         af);
68 
+    REGISTER_FILTER(EBUR128,        ebur128,        af);
69 
+    REGISTER_FILTER(JOIN,           join,           af);
70 
+    REGISTER_FILTER(PAN,            pan,            af);
71 
+    REGISTER_FILTER(RESAMPLE,       resample,       af);
72 
+    REGISTER_FILTER(SILENCEDETECT,  silencedetect,  af);
73 
+    REGISTER_FILTER(VOLUME,         volume,         af);
74 
+    REGISTER_FILTER(VOLUMEDETECT,   volumedetect,   af);
75 
+
76 
+    REGISTER_FILTER(AEVALSRC,       aevalsrc,       asrc);
77 
+    REGISTER_FILTER(ANULLSRC,       anullsrc,       asrc);
78 
+    REGISTER_FILTER(FLITE,          flite,          asrc);
79 
+
80 
+    REGISTER_FILTER(ANULLSINK,      anullsink,      asink);
81 
+
82 
+    REGISTER_FILTER(ALPHAEXTRACT,   alphaextract,   vf);
83 
+    REGISTER_FILTER(ALPHAMERGE,     alphamerge,     vf);
84 
+    REGISTER_FILTER(ASS,            ass,            vf);
85 
+    REGISTER_FILTER(BBOX,           bbox,           vf);
86 
+    REGISTER_FILTER(BLACKDETECT,    blackdetect,    vf);
87 
+    REGISTER_FILTER(BLACKFRAME,     blackframe,     vf);
88 
+    REGISTER_FILTER(BOXBLUR,        boxblur,        vf);
89 
+    REGISTER_FILTER(COLORMATRIX,    colormatrix,    vf);
90 
+    REGISTER_FILTER(COPY,           copy,           vf);
91 
+    REGISTER_FILTER(CROP,           crop,           vf);
92 
+    REGISTER_FILTER(CROPDETECT,     cropdetect,     vf);
93 
+    REGISTER_FILTER(DECIMATE,       decimate,       vf);
94 
+    REGISTER_FILTER(DELOGO,         delogo,         vf);
95 
+    REGISTER_FILTER(DESHAKE,        deshake,        vf);
96 
+    REGISTER_FILTER(DRAWBOX,        drawbox,        vf);
97 
+    REGISTER_FILTER(DRAWTEXT,       drawtext,       vf);
98 
+    REGISTER_FILTER(EDGEDETECT,     edgedetect,     vf);
99 
+    REGISTER_FILTER(FADE,           fade,           vf);
100 
+    REGISTER_FILTER(FIELD,          field,          vf);
101 
+    REGISTER_FILTER(FIELDORDER,     fieldorder,     vf);
102 
+    REGISTER_FILTER(FORMAT,         format,         vf);
103 
+    REGISTER_FILTER(FPS,            fps,            vf);
104 
+    REGISTER_FILTER(FRAMESTEP,      framestep,      vf);
105 
+    REGISTER_FILTER(FREI0R,         frei0r,         vf);
106 
+    REGISTER_FILTER(GEQ,            geq,            vf);
107 
+    REGISTER_FILTER(GRADFUN,        gradfun,        vf);
108 
+    REGISTER_FILTER(HFLIP,          hflip,          vf);
109 
+    REGISTER_FILTER(HQDN3D,         hqdn3d,         vf);
110 
+    REGISTER_FILTER(HUE,            hue,            vf);
111 
+    REGISTER_FILTER(IDET,           idet,           vf);
112 
+    REGISTER_FILTER(LUT,            lut,            vf);
113 
+    REGISTER_FILTER(LUTRGB,         lutrgb,         vf);
114 
+    REGISTER_FILTER(LUTYUV,         lutyuv,         vf);
115 
+    REGISTER_FILTER(MP,             mp,             vf);
116 
+    REGISTER_FILTER(NEGATE,         negate,         vf);
117 
+    REGISTER_FILTER(NOFORMAT,       noformat,       vf);
118 
+    REGISTER_FILTER(NULL,           null,           vf);
119 
+    REGISTER_FILTER(OCV,            ocv,            vf);
120 
+    REGISTER_FILTER(OVERLAY,        overlay,        vf);
121 
+    REGISTER_FILTER(PAD,            pad,            vf);
122 
+    REGISTER_FILTER(PIXDESCTEST,    pixdesctest,    vf);
123 
+    REGISTER_FILTER(PP,             pp,             vf);
124 
+    REGISTER_FILTER(REMOVELOGO,     removelogo,     vf);
125 
+    REGISTER_FILTER(SCALE,          scale,          vf);
126 
+    REGISTER_FILTER(SELECT,         select,         vf);
127 
+    REGISTER_FILTER(SENDCMD,        sendcmd,        vf);
128 
+    REGISTER_FILTER(SETDAR,         setdar,         vf);
129 
+    REGISTER_FILTER(SETFIELD,       setfield,       vf);
130 
+    REGISTER_FILTER(SETPTS,         setpts,         vf);
131 
+    REGISTER_FILTER(SETSAR,         setsar,         vf);
132 
+    REGISTER_FILTER(SETTB,          settb,          vf);
133 
+    REGISTER_FILTER(SHOWINFO,       showinfo,       vf);
134 
+    REGISTER_FILTER(SMARTBLUR,      smartblur,      vf);
135 
+    REGISTER_FILTER(SPLIT,          split,          vf);
136 
+    REGISTER_FILTER(SUBTITLES,      subtitles,      vf);
137 
+    REGISTER_FILTER(SUPER2XSAI,     super2xsai,     vf);
138 
+    REGISTER_FILTER(SWAPUV,         swapuv,         vf);
139 
+    REGISTER_FILTER(THUMBNAIL,      thumbnail,      vf);
140 
+    REGISTER_FILTER(TILE,           tile,           vf);
141 
+    REGISTER_FILTER(TINTERLACE,     tinterlace,     vf);
142 
+    REGISTER_FILTER(TRANSPOSE,      transpose,      vf);
143 
+    REGISTER_FILTER(UNSHARP,        unsharp,        vf);
144 
+    REGISTER_FILTER(VFLIP,          vflip,          vf);
145 
+    REGISTER_FILTER(YADIF,          yadif,          vf);
146 
+
147 
+    REGISTER_FILTER(CELLAUTO,       cellauto,       vsrc);
148 
+    REGISTER_FILTER(COLOR,          color,          vsrc);
149 
+    REGISTER_FILTER(FREI0R,         frei0r_src,     vsrc);
150 
+    REGISTER_FILTER(LIFE,           life,           vsrc);
151 
+    REGISTER_FILTER(MANDELBROT,     mandelbrot,     vsrc);
152 
+    REGISTER_FILTER(MPTESTSRC,      mptestsrc,      vsrc);
153 
+    REGISTER_FILTER(NULLSRC,        nullsrc,        vsrc);
154 
+    REGISTER_FILTER(RGBTESTSRC,     rgbtestsrc,     vsrc);
155 
+    REGISTER_FILTER(SMPTEBARS,      smptebars,      vsrc);
156 
+    REGISTER_FILTER(TESTSRC,        testsrc,        vsrc);
157 
+
158 
+    REGISTER_FILTER(NULLSINK,       nullsink,       vsink);
159 159
160 160 
     /* multimedia filters */
161 
-    REGISTER_FILTER (CONCAT,      concat,      avf);
162 
-    REGISTER_FILTER (SHOWSPECTRUM,showspectrum,avf);
163 
-    REGISTER_FILTER (SHOWWAVES,   showwaves,   avf);
161 
+    REGISTER_FILTER(CONCAT,         concat,         avf);
162 
+    REGISTER_FILTER(SHOWSPECTRUM,   showspectrum,   avf);
163 
+    REGISTER_FILTER(SHOWWAVES,      showwaves,      avf);
164 164
165 165 
     /* multimedia sources */
166 
-    REGISTER_FILTER (AMOVIE,      amovie,      avsrc);
167 
-    REGISTER_FILTER (MOVIE,       movie,       avsrc);
166 
+    REGISTER_FILTER(AMOVIE,         amovie,         avsrc);
167 
+    REGISTER_FILTER(MOVIE,          movie,          avsrc);
168 168
169 169 
     REGISTER_BUILTIN_FILTER (ffbuffersink,  vsink);
170 170 
     REGISTER_BUILTIN_FILTER (ffabuffersink, asink);
libavformat/allformats.c
History View file @ 83d4a84
... ... 
@@ -18,25 +18,38 @@
18 18 
  * License along with FFmpeg; 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,275 +62,275 @@ 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_DEMUXER  (ACT, act);
56 
-    REGISTER_DEMUXER  (ADF, adf);
57 
-    REGISTER_MUXER    (ADTS, adts);
58 
-    REGISTER_MUXDEMUX (ADX, adx);
59 
-    REGISTER_DEMUXER  (AEA, aea);
60 
-    REGISTER_DEMUXER  (AFC, afc);
61 
-    REGISTER_MUXDEMUX (AIFF, aiff);
62 
-    REGISTER_MUXDEMUX (AMR, amr);
63 
-    REGISTER_DEMUXER  (ANM, anm);
64 
-    REGISTER_DEMUXER  (APC, apc);
65 
-    REGISTER_DEMUXER  (APE, ape);
66 
-    REGISTER_MUXDEMUX (ASF, asf);
67 
-    REGISTER_MUXDEMUX (ASS, ass);
68 
-    REGISTER_MUXDEMUX (AST, ast);
69 
-    REGISTER_MUXER    (ASF_STREAM, asf_stream);
70 
-    REGISTER_MUXDEMUX (AU, au);
71 
-    REGISTER_MUXDEMUX (AVI, avi);
72 
-    REGISTER_DEMUXER  (AVISYNTH, avisynth);
73 
-    REGISTER_MUXER    (AVM2, avm2);
74 
-    REGISTER_DEMUXER  (AVR, avr);
75 
-    REGISTER_DEMUXER  (AVS, avs);
76 
-    REGISTER_DEMUXER  (BETHSOFTVID, bethsoftvid);
77 
-    REGISTER_DEMUXER  (BFI, bfi);
78 
-    REGISTER_DEMUXER  (BINTEXT, bintext);
79 
-    REGISTER_DEMUXER  (BINK, bink);
80 
-    REGISTER_MUXDEMUX (BIT, bit);
81 
-    REGISTER_DEMUXER  (BMV, bmv);
82 
-    REGISTER_DEMUXER  (BRSTM, brstm);
83 
-    REGISTER_DEMUXER  (C93, c93);
84 
-    REGISTER_MUXDEMUX (CAF, caf);
85 
-    REGISTER_MUXDEMUX (CAVSVIDEO, cavsvideo);
86 
-    REGISTER_DEMUXER  (CDG, cdg);
87 
-    REGISTER_DEMUXER  (CDXL, cdxl);
88 
-    REGISTER_DEMUXER  (CONCAT, concat);
89 
-    REGISTER_MUXER    (CRC, crc);
90 
-    REGISTER_MUXDEMUX (DAUD, daud);
91 
-    REGISTER_DEMUXER  (DFA, dfa);
92 
-    REGISTER_MUXDEMUX (DIRAC, dirac);
93 
-    REGISTER_MUXDEMUX (DNXHD, dnxhd);
94 
-    REGISTER_DEMUXER  (DSICIN, dsicin);
95 
-    REGISTER_MUXDEMUX (DTS, dts);
96 
-    REGISTER_DEMUXER  (DTSHD, dtshd);
97 
-    REGISTER_MUXDEMUX (DV, dv);
98 
-    REGISTER_DEMUXER  (DXA, dxa);
99 
-    REGISTER_DEMUXER  (EA, ea);
100 
-    REGISTER_DEMUXER  (EA_CDATA, ea_cdata);
101 
-    REGISTER_MUXDEMUX (EAC3, eac3);
102 
-    REGISTER_DEMUXER  (EPAF, epaf);
103 
-    REGISTER_MUXER    (F4V, f4v);
104 
-    REGISTER_MUXDEMUX (FFM, ffm);
105 
-    REGISTER_MUXDEMUX (FFMETADATA, ffmetadata);
106 
-    REGISTER_MUXDEMUX (FILMSTRIP, filmstrip);
107 
-    REGISTER_MUXDEMUX (FLAC, flac);
108 
-    REGISTER_DEMUXER  (FLIC, flic);
109 
-    REGISTER_MUXDEMUX (FLV, flv);
110 
-    REGISTER_DEMUXER  (FOURXM, fourxm);
111 
-    REGISTER_MUXER    (FRAMECRC, framecrc);
112 
-    REGISTER_MUXER    (FRAMEMD5, framemd5);
113 
-    REGISTER_MUXDEMUX (G722, g722);
114 
-    REGISTER_MUXDEMUX (G723_1, g723_1);
115 
-    REGISTER_DEMUXER  (G729, g729);
116 
-    REGISTER_MUXDEMUX (GIF, gif);
117 
-    REGISTER_DEMUXER  (GSM, gsm);
118 
-    REGISTER_MUXDEMUX (GXF, gxf);
119 
-    REGISTER_MUXDEMUX (H261, h261);
120 
-    REGISTER_MUXDEMUX (H263, h263);
121 
-    REGISTER_MUXDEMUX (H264, h264);
122 
-    REGISTER_MUXDEMUX (HLS, hls);
123 
-    REGISTER_MUXDEMUX (ICO, ico);
124 
-    REGISTER_DEMUXER  (IDCIN, idcin);
125 
-    REGISTER_DEMUXER  (IDF, idf);
126 
-    REGISTER_DEMUXER  (IFF, iff);
127 
-    REGISTER_MUXDEMUX (ILBC, ilbc);
128 
-    REGISTER_MUXDEMUX (IMAGE2, image2);
129 
-    REGISTER_MUXDEMUX (IMAGE2PIPE, image2pipe);
130 
-    REGISTER_DEMUXER  (INGENIENT, ingenient);
131 
-    REGISTER_DEMUXER  (IPMOVIE, ipmovie);
132 
-    REGISTER_MUXER    (IPOD, ipod);
133 
-    REGISTER_MUXDEMUX (IRCAM, ircam);
134 
-    REGISTER_MUXER    (ISMV, ismv);
135 
-    REGISTER_DEMUXER  (ISS, iss);
136 
-    REGISTER_DEMUXER  (IV8, iv8);
137 
-    REGISTER_MUXDEMUX (IVF, ivf);
138 
-    REGISTER_MUXDEMUX (JACOSUB, jacosub);
139 
-    REGISTER_DEMUXER  (JV, jv);
140 
-    REGISTER_MUXDEMUX (LATM, latm);
141 
-    REGISTER_DEMUXER  (LMLM4, lmlm4);
142 
-    REGISTER_DEMUXER  (LOAS, loas);
143 
-    REGISTER_DEMUXER  (LVF, lvf);
144 
-    REGISTER_DEMUXER  (LXF, lxf);
145 
-    REGISTER_MUXDEMUX (M4V, m4v);
146 
-    REGISTER_MUXER    (MD5, md5);
147 
-    REGISTER_MUXDEMUX (MATROSKA, matroska);
148 
-    REGISTER_MUXER    (MATROSKA_AUDIO, matroska_audio);
149 
-    REGISTER_DEMUXER  (MGSTS, mgsts);
150 
-    REGISTER_MUXDEMUX (MICRODVD, microdvd);
151 
-    REGISTER_MUXDEMUX (MJPEG, mjpeg);
152 
-    REGISTER_MUXDEMUX (MLP, mlp);
153 
-    REGISTER_DEMUXER  (MM, mm);
154 
-    REGISTER_MUXDEMUX (MMF, mmf);
155 
-    REGISTER_MUXDEMUX (MOV, mov);
156 
-    REGISTER_MUXER    (MP2, mp2);
157 
-    REGISTER_MUXDEMUX (MP3, mp3);
158 
-    REGISTER_MUXER    (MP4, mp4);
159 
-    REGISTER_DEMUXER  (MPC, mpc);
160 
-    REGISTER_DEMUXER  (MPC8, mpc8);
161 
-    REGISTER_MUXER    (MPEG1SYSTEM, mpeg1system);
162 
-    REGISTER_MUXER    (MPEG1VCD, mpeg1vcd);
163 
-    REGISTER_MUXER    (MPEG1VIDEO, mpeg1video);
164 
-    REGISTER_MUXER    (MPEG2DVD, mpeg2dvd);
165 
-    REGISTER_MUXER    (MPEG2SVCD, mpeg2svcd);
166 
-    REGISTER_MUXER    (MPEG2VIDEO, mpeg2video);
167 
-    REGISTER_MUXER    (MPEG2VOB, mpeg2vob);
168 
-    REGISTER_DEMUXER  (MPEGPS, mpegps);
169 
-    REGISTER_MUXDEMUX (MPEGTS, mpegts);
170 
-    REGISTER_DEMUXER  (MPEGTSRAW, mpegtsraw);
171 
-    REGISTER_DEMUXER  (MPEGVIDEO, mpegvideo);
172 
-    REGISTER_MUXER    (MPJPEG, mpjpeg);
173 
-    REGISTER_DEMUXER  (MSNWC_TCP, msnwc_tcp);
174 
-    REGISTER_DEMUXER  (MTV, mtv);
175 
-    REGISTER_DEMUXER  (MV, mv);
176 
-    REGISTER_DEMUXER  (MVI, mvi);
177 
-    REGISTER_MUXDEMUX (MXF, mxf);
178 
-    REGISTER_MUXER    (MXF_D10, mxf_d10);
179 
-    REGISTER_DEMUXER  (MXG, mxg);
180 
-    REGISTER_DEMUXER  (NC, nc);
181 
-    REGISTER_DEMUXER  (NISTSPHERE, nistsphere);
182 
-    REGISTER_DEMUXER  (NSV, nsv);
183 
-    REGISTER_MUXER    (NULL, null);
184 
-    REGISTER_MUXDEMUX (NUT, nut);
185 
-    REGISTER_DEMUXER  (NUV, nuv);
186 
-    REGISTER_MUXDEMUX (OGG, ogg);
187 
-    REGISTER_MUXDEMUX (OMA, oma);
188 
-    REGISTER_DEMUXER  (PAF, paf);
189 
-    REGISTER_MUXDEMUX (PCM_ALAW,  pcm_alaw);
190 
-    REGISTER_MUXDEMUX (PCM_MULAW, pcm_mulaw);
191 
-    REGISTER_MUXDEMUX (PCM_F64BE, pcm_f64be);
192 
-    REGISTER_MUXDEMUX (PCM_F64LE, pcm_f64le);
193 
-    REGISTER_MUXDEMUX (PCM_F32BE, pcm_f32be);
194 
-    REGISTER_MUXDEMUX (PCM_F32LE, pcm_f32le);
195 
-    REGISTER_MUXDEMUX (PCM_S32BE, pcm_s32be);
196 
-    REGISTER_MUXDEMUX (PCM_S32LE, pcm_s32le);
197 
-    REGISTER_MUXDEMUX (PCM_S24BE, pcm_s24be);
198 
-    REGISTER_MUXDEMUX (PCM_S24LE, pcm_s24le);
199 
-    REGISTER_MUXDEMUX (PCM_S16BE, pcm_s16be);
200 
-    REGISTER_MUXDEMUX (PCM_S16LE, pcm_s16le);
201 
-    REGISTER_MUXDEMUX (PCM_S8,    pcm_s8);
202 
-    REGISTER_MUXDEMUX (PCM_U32BE, pcm_u32be);
203 
-    REGISTER_MUXDEMUX (PCM_U32LE, pcm_u32le);
204 
-    REGISTER_MUXDEMUX (PCM_U24BE, pcm_u24be);
205 
-    REGISTER_MUXDEMUX (PCM_U24LE, pcm_u24le);
206 
-    REGISTER_MUXDEMUX (PCM_U16BE, pcm_u16be);
207 
-    REGISTER_MUXDEMUX (PCM_U16LE, pcm_u16le);
208 
-    REGISTER_MUXDEMUX (PCM_U8,    pcm_u8);
209 
-    REGISTER_DEMUXER  (PMP, pmp);
210 
-    REGISTER_MUXER    (PSP, psp);
211 
-    REGISTER_DEMUXER  (PVA, pva);
212 
-    REGISTER_DEMUXER  (PVF, pvf);
213 
-    REGISTER_DEMUXER  (QCP, qcp);
214 
-    REGISTER_DEMUXER  (R3D, r3d);
215 
-    REGISTER_MUXDEMUX (RAWVIDEO, rawvideo);
216 
-    REGISTER_DEMUXER  (REALTEXT, realtext);
217 
-    REGISTER_DEMUXER  (RL2, rl2);
218 
-    REGISTER_MUXDEMUX (RM, rm);
219 
-    REGISTER_MUXDEMUX (ROQ, roq);
220 
-    REGISTER_DEMUXER  (RPL, rpl);
221 
-    REGISTER_MUXDEMUX (RSO, rso);
222 
-    REGISTER_MUXDEMUX (RTP, rtp);
223 
-    REGISTER_MUXDEMUX (RTSP, rtsp);
224 
-    REGISTER_DEMUXER  (SAMI, sami);
225 
-    REGISTER_MUXDEMUX (SAP, sap);
226 
-    REGISTER_DEMUXER  (SBG, sbg);
227 
-    REGISTER_DEMUXER  (SDP, sdp);
52 
+    REGISTER_MUXER   (A64,              a64);
53 
+    REGISTER_DEMUXER (AAC,              aac);
54 
+    REGISTER_MUXDEMUX(AC3,              ac3);
55 
+    REGISTER_DEMUXER (ACT,              act);
56 
+    REGISTER_DEMUXER (ADF,              adf);
57 
+    REGISTER_MUXER   (ADTS,             adts);
58 
+    REGISTER_MUXDEMUX(ADX,              adx);
59 
+    REGISTER_DEMUXER (AEA,              aea);
60 
+    REGISTER_DEMUXER (AFC,              afc);
61 
+    REGISTER_MUXDEMUX(AIFF,             aiff);
62 
+    REGISTER_MUXDEMUX(AMR,              amr);
63 
+    REGISTER_DEMUXER (ANM,              anm);
64 
+    REGISTER_DEMUXER (APC,              apc);
65 
+    REGISTER_DEMUXER (APE,              ape);
66 
+    REGISTER_MUXDEMUX(ASF,              asf);
67 
+    REGISTER_MUXDEMUX(ASS,              ass);
68 
+    REGISTER_MUXDEMUX(AST,              ast);
69 
+    REGISTER_MUXER   (ASF_STREAM,       asf_stream);
70 
+    REGISTER_MUXDEMUX(AU,               au);
71 
+    REGISTER_MUXDEMUX(AVI,              avi);
72 
+    REGISTER_DEMUXER (AVISYNTH,         avisynth);
73 
+    REGISTER_MUXER   (AVM2,             avm2);
74 
+    REGISTER_DEMUXER (AVR,              avr);
75 
+    REGISTER_DEMUXER (AVS,              avs);
76 
+    REGISTER_DEMUXER (BETHSOFTVID,      bethsoftvid);
77 
+    REGISTER_DEMUXER (BFI,              bfi);
78 
+    REGISTER_DEMUXER (BINTEXT,          bintext);
79 
+    REGISTER_DEMUXER (BINK,             bink);
80 
+    REGISTER_MUXDEMUX(BIT,              bit);
81 
+    REGISTER_DEMUXER (BMV,              bmv);
82 
+    REGISTER_DEMUXER (BRSTM,            brstm);
83 
+    REGISTER_DEMUXER (C93,              c93);
84 
+    REGISTER_MUXDEMUX(CAF,              caf);
85 
+    REGISTER_MUXDEMUX(CAVSVIDEO,        cavsvideo);
86 
+    REGISTER_DEMUXER (CDG,              cdg);
87 
+    REGISTER_DEMUXER (CDXL,             cdxl);
88 
+    REGISTER_DEMUXER (CONCAT,           concat);
89 
+    REGISTER_MUXER   (CRC,              crc);
90 
+    REGISTER_MUXDEMUX(DAUD,             daud);
91 
+    REGISTER_DEMUXER (DFA,              dfa);
92 
+    REGISTER_MUXDEMUX(DIRAC,            dirac);
93 
+    REGISTER_MUXDEMUX(DNXHD,            dnxhd);
94 
+    REGISTER_DEMUXER (DSICIN,           dsicin);
95 
+    REGISTER_MUXDEMUX(DTS,              dts);
96 
+    REGISTER_DEMUXER (DTSHD,            dtshd);
97 
+    REGISTER_MUXDEMUX(DV,               dv);
98 
+    REGISTER_DEMUXER (DXA,              dxa);
99 
+    REGISTER_DEMUXER (EA,               ea);
100 
+    REGISTER_DEMUXER (EA_CDATA,         ea_cdata);
101 
+    REGISTER_MUXDEMUX(EAC3,             eac3);
102 
+    REGISTER_DEMUXER (EPAF,             epaf);
103 
+    REGISTER_MUXER   (F4V,              f4v);
104 
+    REGISTER_MUXDEMUX(FFM,              ffm);
105 
+    REGISTER_MUXDEMUX(FFMETADATA,       ffmetadata);
106 
+    REGISTER_MUXDEMUX(FILMSTRIP,        filmstrip);
107 
+    REGISTER_MUXDEMUX(FLAC,             flac);
108 
+    REGISTER_DEMUXER (FLIC,             flic);
109 
+    REGISTER_MUXDEMUX(FLV,              flv);
110 
+    REGISTER_DEMUXER (FOURXM,           fourxm);
111 
+    REGISTER_MUXER   (FRAMECRC,         framecrc);
112 
+    REGISTER_MUXER   (FRAMEMD5,         framemd5);
113 
+    REGISTER_MUXDEMUX(G722,             g722);
114 
+    REGISTER_MUXDEMUX(G723_1,           g723_1);
115 
+    REGISTER_DEMUXER (G729,             g729);
116 
+    REGISTER_MUXDEMUX(GIF,              gif);
117 
+    REGISTER_DEMUXER (GSM,              gsm);
118 
+    REGISTER_MUXDEMUX(GXF,              gxf);
119 
+    REGISTER_MUXDEMUX(H261,             h261);
120 
+    REGISTER_MUXDEMUX(H263,             h263);
121 
+    REGISTER_MUXDEMUX(H264,             h264);
122 
+    REGISTER_MUXDEMUX(HLS,              hls);
123 
+    REGISTER_MUXDEMUX(ICO,              ico);
124 
+    REGISTER_DEMUXER (IDCIN,            idcin);
125 
+    REGISTER_DEMUXER (IDF,              idf);
126 
+    REGISTER_DEMUXER (IFF,              iff);
127 
+    REGISTER_MUXDEMUX(ILBC,             ilbc);
128 
+    REGISTER_MUXDEMUX(IMAGE2,           image2);
129 
+    REGISTER_MUXDEMUX(IMAGE2PIPE,       image2pipe);
130 
+    REGISTER_DEMUXER (INGENIENT,        ingenient);
131 
+    REGISTER_DEMUXER (IPMOVIE,          ipmovie);
132 
+    REGISTER_MUXER   (IPOD,             ipod);
133 
+    REGISTER_MUXDEMUX(IRCAM,            ircam);
134 
+    REGISTER_MUXER   (ISMV,             ismv);
135 
+    REGISTER_DEMUXER (ISS,              iss);
136 
+    REGISTER_DEMUXER (IV8,              iv8);
137 
+    REGISTER_MUXDEMUX(IVF,              ivf);
138 
+    REGISTER_MUXDEMUX(JACOSUB,          jacosub);
139 
+    REGISTER_DEMUXER (JV,               jv);
140 
+    REGISTER_MUXDEMUX(LATM,             latm);
141 
+    REGISTER_DEMUXER (LMLM4,            lmlm4);
142 
+    REGISTER_DEMUXER (LOAS,             loas);
143 
+    REGISTER_DEMUXER (LVF,              lvf);
144 
+    REGISTER_DEMUXER (LXF,              lxf);
145 
+    REGISTER_MUXDEMUX(M4V,              m4v);
146 
+    REGISTER_MUXER   (MD5,              md5);
147 
+    REGISTER_MUXDEMUX(MATROSKA,         matroska);
148 
+    REGISTER_MUXER   (MATROSKA_AUDIO,   matroska_audio);
149 
+    REGISTER_DEMUXER (MGSTS,            mgsts);
150 
+    REGISTER_MUXDEMUX(MICRODVD,         microdvd);
151 
+    REGISTER_MUXDEMUX(MJPEG,            mjpeg);
152 
+    REGISTER_MUXDEMUX(MLP,              mlp);
153 
+    REGISTER_DEMUXER (MM,               mm);
154 
+    REGISTER_MUXDEMUX(MMF,              mmf);
155 
+    REGISTER_MUXDEMUX(MOV,              mov);
156 
+    REGISTER_MUXER   (MP2,              mp2);
157 
+    REGISTER_MUXDEMUX(MP3,              mp3);
158 
+    REGISTER_MUXER   (MP4,              mp4);
159 
+    REGISTER_DEMUXER (MPC,              mpc);
160 
+    REGISTER_DEMUXER (MPC8,             mpc8);
161 
+    REGISTER_MUXER   (MPEG1SYSTEM,      mpeg1system);
162 
+    REGISTER_MUXER   (MPEG1VCD,         mpeg1vcd);
163 
+    REGISTER_MUXER   (MPEG1VIDEO,       mpeg1video);
164 
+    REGISTER_MUXER   (MPEG2DVD,         mpeg2dvd);
165 
+    REGISTER_MUXER   (MPEG2SVCD,        mpeg2svcd);
166 
+    REGISTER_MUXER   (MPEG2VIDEO,       mpeg2video);
167 
+    REGISTER_MUXER   (MPEG2VOB,         mpeg2vob);
168 
+    REGISTER_DEMUXER (MPEGPS,           mpegps);
169 
+    REGISTER_MUXDEMUX(MPEGTS,           mpegts);
170 
+    REGISTER_DEMUXER (MPEGTSRAW,        mpegtsraw);
171 
+    REGISTER_DEMUXER (MPEGVIDEO,        mpegvideo);
172 
+    REGISTER_MUXER   (MPJPEG,           mpjpeg);
173 
+    REGISTER_DEMUXER (MSNWC_TCP,        msnwc_tcp);
174 
+    REGISTER_DEMUXER (MTV,              mtv);
175 
+    REGISTER_DEMUXER (MV,               mv);
176 
+    REGISTER_DEMUXER (MVI,              mvi);
177 
+    REGISTER_MUXDEMUX(MXF,              mxf);
178 
+    REGISTER_MUXER   (MXF_D10,          mxf_d10);
179 
+    REGISTER_DEMUXER (MXG,              mxg);
180 
+    REGISTER_DEMUXER (NC,               nc);
181 
+    REGISTER_DEMUXER (NISTSPHERE,       nistsphere);
182 
+    REGISTER_DEMUXER (NSV,              nsv);
183 
+    REGISTER_MUXER   (NULL,             null);
184 
+    REGISTER_MUXDEMUX(NUT,              nut);
185 
+    REGISTER_DEMUXER (NUV,              nuv);
186 
+    REGISTER_MUXDEMUX(OGG,              ogg);
187 
+    REGISTER_MUXDEMUX(OMA,              oma);
188 
+    REGISTER_DEMUXER (PAF,              paf);
189 
+    REGISTER_MUXDEMUX(PCM_ALAW,         pcm_alaw);
190 
+    REGISTER_MUXDEMUX(PCM_MULAW,        pcm_mulaw);
191 
+    REGISTER_MUXDEMUX(PCM_F64BE,        pcm_f64be);
192 
+    REGISTER_MUXDEMUX(PCM_F64LE,        pcm_f64le);
193 
+    REGISTER_MUXDEMUX(PCM_F32BE,        pcm_f32be);
194 
+    REGISTER_MUXDEMUX(PCM_F32LE,        pcm_f32le);
195 
+    REGISTER_MUXDEMUX(PCM_S32BE,        pcm_s32be);
196 
+    REGISTER_MUXDEMUX(PCM_S32LE,        pcm_s32le);
197 
+    REGISTER_MUXDEMUX(PCM_S24BE,        pcm_s24be);
198 
+    REGISTER_MUXDEMUX(PCM_S24LE,        pcm_s24le);
199 
+    REGISTER_MUXDEMUX(PCM_S16BE,        pcm_s16be);
200 
+    REGISTER_MUXDEMUX(PCM_S16LE,        pcm_s16le);
201 
+    REGISTER_MUXDEMUX(PCM_S8,           pcm_s8);
202 
+    REGISTER_MUXDEMUX(PCM_U32BE,        pcm_u32be);
203 
+    REGISTER_MUXDEMUX(PCM_U32LE,        pcm_u32le);
204 
+    REGISTER_MUXDEMUX(PCM_U24BE,        pcm_u24be);
205 
+    REGISTER_MUXDEMUX(PCM_U24LE,        pcm_u24le);
206 
+    REGISTER_MUXDEMUX(PCM_U16BE,        pcm_u16be);
207 
+    REGISTER_MUXDEMUX(PCM_U16LE,        pcm_u16le);
208 
+    REGISTER_MUXDEMUX(PCM_U8,           pcm_u8);
209 
+    REGISTER_DEMUXER (PMP,              pmp);
210 
+    REGISTER_MUXER   (PSP,              psp);
211 
+    REGISTER_DEMUXER (PVA,              pva);
212 
+    REGISTER_DEMUXER (PVF,              pvf);
213 
+    REGISTER_DEMUXER (QCP,              qcp);
214 
+    REGISTER_DEMUXER (R3D,              r3d);
215 
+    REGISTER_MUXDEMUX(RAWVIDEO,         rawvideo);
216 
+    REGISTER_DEMUXER (REALTEXT,         realtext);
217 
+    REGISTER_DEMUXER (RL2,              rl2);
218 
+    REGISTER_MUXDEMUX(RM,               rm);
219 
+    REGISTER_MUXDEMUX(ROQ,              roq);
220 
+    REGISTER_DEMUXER (RPL,              rpl);
221 
+    REGISTER_MUXDEMUX(RSO,              rso);
222 
+    REGISTER_MUXDEMUX(RTP,              rtp);
223 
+    REGISTER_MUXDEMUX(RTSP,             rtsp);
224 
+    REGISTER_DEMUXER (SAMI,             sami);
225 
+    REGISTER_MUXDEMUX(SAP,              sap);
226 
+    REGISTER_DEMUXER (SBG,              sbg);
227 
+    REGISTER_DEMUXER (SDP,              sdp);
228 228 
 #if CONFIG_RTPDEC
229 229 
     av_register_rtp_dynamic_payload_handlers();
230 230 
     av_register_rdt_dynamic_payload_handlers();
231 231 
 #endif
232 
-    REGISTER_DEMUXER  (SEGAFILM, segafilm);
233 
-    REGISTER_MUXER    (SEGMENT, segment);
234 
-    REGISTER_MUXER    (SEGMENT, stream_segment);
235 
-    REGISTER_DEMUXER  (SHORTEN, shorten);
236 
-    REGISTER_DEMUXER  (SIFF, siff);
237 
-    REGISTER_DEMUXER  (SMACKER, smacker);
238 
-    REGISTER_MUXDEMUX (SMJPEG, smjpeg);
239 
-    REGISTER_MUXER    (SMOOTHSTREAMING, smoothstreaming);
240 
-    REGISTER_DEMUXER  (SMUSH, smush);
241 
-    REGISTER_DEMUXER  (SOL, sol);
242 
-    REGISTER_MUXDEMUX (SOX, sox);
243 
-    REGISTER_MUXDEMUX (SPDIF, spdif);
244 
-    REGISTER_MUXDEMUX (SRT, srt);
245 
-    REGISTER_DEMUXER  (STR, str);
246 
-    REGISTER_DEMUXER  (SUBVIEWER, subviewer);
247 
-    REGISTER_MUXDEMUX (SWF, swf);
248 
-    REGISTER_DEMUXER  (TAK, tak);
249 
-    REGISTER_DEMUXER  (TEDCAPTIONS, tedcaptions);
250 
-    REGISTER_MUXER    (TG2, tg2);
251 
-    REGISTER_MUXER    (TGP, tgp);
252 
-    REGISTER_DEMUXER  (THP, thp);
253 
-    REGISTER_DEMUXER  (TIERTEXSEQ, tiertexseq);
254 
-    REGISTER_MUXER    (MKVTIMESTAMP_V2, mkvtimestamp_v2);
255 
-    REGISTER_DEMUXER  (TMV, tmv);
256 
-    REGISTER_MUXDEMUX (TRUEHD, truehd);
257 
-    REGISTER_DEMUXER  (TTA, tta);
258 
-    REGISTER_DEMUXER  (TXD, txd);
259 
-    REGISTER_DEMUXER  (TTY, tty);
260 
-    REGISTER_DEMUXER  (VC1, vc1);
261 
-    REGISTER_MUXDEMUX (VC1T, vc1t);
262 
-    REGISTER_DEMUXER  (VIVO, vivo);
263 
-    REGISTER_DEMUXER  (VMD, vmd);
264 
-    REGISTER_DEMUXER  (VOBSUB, vobsub);
265 
-    REGISTER_MUXDEMUX (VOC, voc);
266 
-    REGISTER_DEMUXER  (VQF, vqf);
267 
-    REGISTER_DEMUXER  (W64, w64);
268 
-    REGISTER_MUXDEMUX (WAV, wav);
269 
-    REGISTER_DEMUXER  (WC3, wc3);
270 
-    REGISTER_MUXER    (WEBM, webm);
271 
-    REGISTER_DEMUXER  (WEBVTT, webvtt);
272 
-    REGISTER_DEMUXER  (WSAUD, wsaud);
273 
-    REGISTER_DEMUXER  (WSVQA, wsvqa);
274 
-    REGISTER_MUXDEMUX (WTV, wtv);
275 
-    REGISTER_MUXDEMUX (WV, wv);
276 
-    REGISTER_DEMUXER  (XA, xa);
277 
-    REGISTER_DEMUXER  (XBIN, xbin);
278 
-    REGISTER_DEMUXER  (XMV, xmv);
279 
-    REGISTER_DEMUXER  (XWMA, xwma);
280 
-    REGISTER_DEMUXER  (YOP, yop);
281 
-    REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe);
232 
+    REGISTER_DEMUXER (SEGAFILM,         segafilm);
233 
+    REGISTER_MUXER   (SEGMENT,          segment);
234 
+    REGISTER_MUXER   (SEGMENT,          stream_segment);
235 
+    REGISTER_DEMUXER (SHORTEN,          shorten);
236 
+    REGISTER_DEMUXER (SIFF,             siff);
237 
+    REGISTER_DEMUXER (SMACKER,          smacker);
238 
+    REGISTER_MUXDEMUX(SMJPEG,           smjpeg);
239 
+    REGISTER_MUXER   (SMOOTHSTREAMING,  smoothstreaming);
240 
+    REGISTER_DEMUXER (SMUSH,            smush);
241 
+    REGISTER_DEMUXER (SOL,              sol);
242 
+    REGISTER_MUXDEMUX(SOX,              sox);
243 
+    REGISTER_MUXDEMUX(SPDIF,            spdif);
244 
+    REGISTER_MUXDEMUX(SRT,              srt);
245 
+    REGISTER_DEMUXER (STR,              str);
246 
+    REGISTER_DEMUXER (SUBVIEWER,        subviewer);
247 
+    REGISTER_MUXDEMUX(SWF,              swf);
248 
+    REGISTER_DEMUXER (TAK,              tak);
249 
+    REGISTER_DEMUXER (TEDCAPTIONS,      tedcaptions);
250 
+    REGISTER_MUXER   (TG2,              tg2);
251 
+    REGISTER_MUXER   (TGP,              tgp);
252 
+    REGISTER_DEMUXER (THP,              thp);
253 
+    REGISTER_DEMUXER (TIERTEXSEQ,       tiertexseq);
254 
+    REGISTER_MUXER   (MKVTIMESTAMP_V2,  mkvtimestamp_v2);
255 
+    REGISTER_DEMUXER (TMV,              tmv);
256 
+    REGISTER_MUXDEMUX(TRUEHD,           truehd);
257 
+    REGISTER_DEMUXER (TTA,              tta);
258 
+    REGISTER_DEMUXER (TXD,              txd);
259 
+    REGISTER_DEMUXER (TTY,              tty);
260 
+    REGISTER_DEMUXER (VC1,              vc1);
261 
+    REGISTER_MUXDEMUX(VC1T,             vc1t);
262 
+    REGISTER_DEMUXER (VIVO,             vivo);
263 
+    REGISTER_DEMUXER (VMD,              vmd);
264 
+    REGISTER_DEMUXER (VOBSUB,           vobsub);
265 
+    REGISTER_MUXDEMUX(VOC,              voc);
266 
+    REGISTER_DEMUXER (VQF,              vqf);
267 
+    REGISTER_DEMUXER (W64,              w64);
268 
+    REGISTER_MUXDEMUX(WAV,              wav);
269 
+    REGISTER_DEMUXER (WC3,              wc3);
270 
+    REGISTER_MUXER   (WEBM,             webm);
271 
+    REGISTER_DEMUXER (WEBVTT,           webvtt);
272 
+    REGISTER_DEMUXER (WSAUD,            wsaud);
273 
+    REGISTER_DEMUXER (WSVQA,            wsvqa);
274 
+    REGISTER_MUXDEMUX(WTV,              wtv);
275 
+    REGISTER_MUXDEMUX(WV,               wv);
276 
+    REGISTER_DEMUXER (XA,               xa);
277 
+    REGISTER_DEMUXER (XBIN,             xbin);
278 
+    REGISTER_DEMUXER (XMV,              xmv);
279 
+    REGISTER_DEMUXER (XWMA,             xwma);
280 
+    REGISTER_DEMUXER (YOP,              yop);
281 
+    REGISTER_MUXDEMUX(YUV4MPEGPIPE,     yuv4mpegpipe);
282 282
283 283 
     /* protocols */
284 284 
 #if FF_API_APPLEHTTP_PROTO
285 
-    REGISTER_PROTOCOL (APPLEHTTP, applehttp);
285 
+    REGISTER_PROTOCOL(APPLEHTTP,        applehttp);
286 286 
 #endif
287 
-    REGISTER_PROTOCOL (BLURAY, bluray);
288 
-    REGISTER_PROTOCOL (CACHE, cache);
289 
-    REGISTER_PROTOCOL (CONCAT, concat);
290 
-    REGISTER_PROTOCOL (CRYPTO, crypto);
291 
-    REGISTER_PROTOCOL (FFRTMPCRYPT, ffrtmpcrypt);
292 
-    REGISTER_PROTOCOL (FFRTMPHTTP, ffrtmphttp);
293 
-    REGISTER_PROTOCOL (FILE, file);
294 
-    REGISTER_PROTOCOL (GOPHER, gopher);
295 
-    REGISTER_PROTOCOL (HLS, hls);
296 
-    REGISTER_PROTOCOL (HTTP, http);
297 
-    REGISTER_PROTOCOL (HTTPPROXY, httpproxy);
298 
-    REGISTER_PROTOCOL (HTTPS, https);
299 
-    REGISTER_PROTOCOL (MMSH, mmsh);
300 
-    REGISTER_PROTOCOL (MMST, mmst);
301 
-    REGISTER_PROTOCOL (MD5,  md5);
302 
-    REGISTER_PROTOCOL (PIPE, pipe);
303 
-    REGISTER_PROTOCOL (RTMP, rtmp);
304 
-    REGISTER_PROTOCOL (RTMPE, rtmpe);
305 
-    REGISTER_PROTOCOL (RTMPS, rtmps);
306 
-    REGISTER_PROTOCOL (RTMPT, rtmpt);
307 
-    REGISTER_PROTOCOL (RTMPTE, rtmpte);
308 
-    REGISTER_PROTOCOL (RTMPTS, rtmpts);
309 
-    REGISTER_PROTOCOL (RTP, rtp);
310 
-    REGISTER_PROTOCOL (SCTP, sctp);
311 
-    REGISTER_PROTOCOL (TCP, tcp);
312 
-    REGISTER_PROTOCOL (TLS, tls);
313 
-    REGISTER_PROTOCOL (UDP, udp);
287 
+    REGISTER_PROTOCOL(BLURAY,           bluray);
288 
+    REGISTER_PROTOCOL(CACHE,            cache);
289 
+    REGISTER_PROTOCOL(CONCAT,           concat);
290 
+    REGISTER_PROTOCOL(CRYPTO,           crypto);
291 
+    REGISTER_PROTOCOL(FFRTMPCRYPT,      ffrtmpcrypt);
292 
+    REGISTER_PROTOCOL(FFRTMPHTTP,       ffrtmphttp);
293 
+    REGISTER_PROTOCOL(FILE,             file);
294 
+    REGISTER_PROTOCOL(GOPHER,           gopher);
295 
+    REGISTER_PROTOCOL(HLS,              hls);
296 
+    REGISTER_PROTOCOL(HTTP,             http);
297 
+    REGISTER_PROTOCOL(HTTPPROXY,        httpproxy);
298 
+    REGISTER_PROTOCOL(HTTPS,            https);
299 
+    REGISTER_PROTOCOL(MMSH,             mmsh);
300 
+    REGISTER_PROTOCOL(MMST,             mmst);
301 
+    REGISTER_PROTOCOL(MD5,              md5);
302 
+    REGISTER_PROTOCOL(PIPE,             pipe);
303 
+    REGISTER_PROTOCOL(RTMP,             rtmp);
304 
+    REGISTER_PROTOCOL(RTMPE,            rtmpe);
305 
+    REGISTER_PROTOCOL(RTMPS,            rtmps);
306 
+    REGISTER_PROTOCOL(RTMPT,            rtmpt);
307 
+    REGISTER_PROTOCOL(RTMPTE,           rtmpte);
308 
+    REGISTER_PROTOCOL(RTMPTS,           rtmpts);
309 
+    REGISTER_PROTOCOL(RTP,              rtp);
310 
+    REGISTER_PROTOCOL(SCTP,             sctp);
311 
+    REGISTER_PROTOCOL(TCP,              tcp);
312 
+    REGISTER_PROTOCOL(TLS,              tls);
313 
+    REGISTER_PROTOCOL(UDP,              udp);
314 314
315 315 
     /* external libraries */
316 
-    REGISTER_DEMUXER  (LIBMODPLUG, libmodplug);
317 
-    REGISTER_MUXDEMUX (LIBNUT, libnut);
318 
-    REGISTER_PROTOCOL (LIBRTMP, librtmp);
319 
-    REGISTER_PROTOCOL (LIBRTMPE, librtmpe);
320 
-    REGISTER_PROTOCOL (LIBRTMPS, librtmps);
321 
-    REGISTER_PROTOCOL (LIBRTMPT, librtmpt);
322 
-    REGISTER_PROTOCOL (LIBRTMPTE, librtmpte);
316 
+    REGISTER_DEMUXER (LIBMODPLUG,       libmodplug);
317 
+    REGISTER_MUXDEMUX(LIBNUT,           libnut);
318 
+    REGISTER_PROTOCOL(LIBRTMP,          librtmp);
319 
+    REGISTER_PROTOCOL(LIBRTMPE,         librtmpe);
320 
+    REGISTER_PROTOCOL(LIBRTMPS,         librtmps);
321 
+    REGISTER_PROTOCOL(LIBRTMPT,         librtmpt);
322 
+    REGISTER_PROTOCOL(LIBRTMPTE,        librtmpte);
323 323 
 }