Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

cosmetics: Prettyprint codec/format/filter registration files

Browse Source
pull/8/head
Diego Biurrun 12 years ago
parent 69583bd3b1
commit c73c87b412
4 changed files with 752 additions and 706 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 810
      libavcodec/allcodecs.c
  2. 50
      libavdevice/alldevices.c
  3. 125
      libavfilter/allfilters.c
  4. 473
      libavformat/allformats.c

810
libavcodec/allcodecs.c
Unescape View File

@ -27,24 +27,44 @@
#include "avcodec.h" #include "avcodec.h"
#include "config.h" #include "config.h"
#define REGISTER_HWACCEL(X,x) { \ #define REGISTER_HWACCEL(X, x) \
extern AVHWAccel ff_##x##_hwaccel; \ { \
if(CONFIG_##X##_HWACCEL) av_register_hwaccel(&ff_##x##_hwaccel); } extern AVHWAccel ff_##x##_hwaccel; \
if (CONFIG_##X##_HWACCEL) \
av_register_hwaccel(&ff_##x##_hwaccel); \
}
#define REGISTER_ENCODER(X,x) { \ #define REGISTER_ENCODER(X, x) \
extern AVCodec ff_##x##_encoder; \ { \
if(CONFIG_##X##_ENCODER) avcodec_register(&ff_##x##_encoder); } extern AVCodec ff_##x##_encoder; \
#define REGISTER_DECODER(X,x) { \ if (CONFIG_##X##_ENCODER) \
extern AVCodec ff_##x##_decoder; \ avcodec_register(&ff_##x##_encoder); \
if(CONFIG_##X##_DECODER) avcodec_register(&ff_##x##_decoder); } }
#define REGISTER_ENCDEC(X,x) REGISTER_ENCODER(X,x); REGISTER_DECODER(X,x)
#define REGISTER_PARSER(X,x) { \ #define REGISTER_DECODER(X, x) \
extern AVCodecParser ff_##x##_parser; \ { \
if(CONFIG_##X##_PARSER) av_register_codec_parser(&ff_##x##_parser); } extern AVCodec ff_##x##_decoder; \
#define REGISTER_BSF(X,x) { \ if (CONFIG_##X##_DECODER) \
extern AVBitStreamFilter ff_##x##_bsf; \ avcodec_register(&ff_##x##_decoder); \
if(CONFIG_##X##_BSF) av_register_bitstream_filter(&ff_##x##_bsf); } }
#define REGISTER_ENCDEC(X, x) \
REGISTER_ENCODER(X, x); \
REGISTER_DECODER(X,x)
#define REGISTER_PARSER(X, x) \
{ \
extern AVCodecParser ff_##x##_parser; \
if (CONFIG_##X##_PARSER) \
av_register_codec_parser(&ff_##x##_parser); \
}
#define REGISTER_BSF(X, x) \
{ \
extern AVBitStreamFilter ff_##x##_bsf; \
if (CONFIG_##X##_BSF) \
av_register_bitstream_filter(&ff_##x##_bsf); \
}
void avcodec_register_all(void) void avcodec_register_all(void)
{ {
@ -55,401 +75,401 @@ void avcodec_register_all(void)
initialized = 1; initialized = 1;
/* hardware accelerators */ /* hardware accelerators */
REGISTER_HWACCEL (H263_VAAPI, h263_vaapi); REGISTER_HWACCEL(H263_VAAPI, h263_vaapi);
REGISTER_HWACCEL (H264_DXVA2, h264_dxva2); REGISTER_HWACCEL(H264_DXVA2, h264_dxva2);
REGISTER_HWACCEL (H264_VAAPI, h264_vaapi); REGISTER_HWACCEL(H264_VAAPI, h264_vaapi);
REGISTER_HWACCEL (H264_VDA, h264_vda); REGISTER_HWACCEL(H264_VDA, h264_vda);
REGISTER_HWACCEL (MPEG2_DXVA2, mpeg2_dxva2); REGISTER_HWACCEL(MPEG2_DXVA2, mpeg2_dxva2);
REGISTER_HWACCEL (MPEG2_VAAPI, mpeg2_vaapi); REGISTER_HWACCEL(MPEG2_VAAPI, mpeg2_vaapi);
REGISTER_HWACCEL (MPEG4_VAAPI, mpeg4_vaapi); REGISTER_HWACCEL(MPEG4_VAAPI, mpeg4_vaapi);
REGISTER_HWACCEL (VC1_DXVA2, vc1_dxva2); REGISTER_HWACCEL(VC1_DXVA2, vc1_dxva2);
REGISTER_HWACCEL (VC1_VAAPI, vc1_vaapi); REGISTER_HWACCEL(VC1_VAAPI, vc1_vaapi);
REGISTER_HWACCEL (WMV3_DXVA2, wmv3_dxva2); REGISTER_HWACCEL(WMV3_DXVA2, wmv3_dxva2);
REGISTER_HWACCEL (WMV3_VAAPI, wmv3_vaapi); REGISTER_HWACCEL(WMV3_VAAPI, wmv3_vaapi);
/* video codecs */ /* video codecs */
REGISTER_ENCODER (A64MULTI, a64multi); REGISTER_ENCODER(A64MULTI, a64multi);
REGISTER_ENCODER (A64MULTI5, a64multi5); REGISTER_ENCODER(A64MULTI5, a64multi5);
REGISTER_DECODER (AASC, aasc); REGISTER_DECODER(AASC, aasc);
REGISTER_DECODER (AMV, amv); REGISTER_DECODER(AMV, amv);
REGISTER_DECODER (ANM, anm); REGISTER_DECODER(ANM, anm);
REGISTER_DECODER (ANSI, ansi); REGISTER_DECODER(ANSI, ansi);
REGISTER_ENCDEC (ASV1, asv1); REGISTER_ENCDEC (ASV1, asv1);
REGISTER_ENCDEC (ASV2, asv2); REGISTER_ENCDEC (ASV2, asv2);
REGISTER_DECODER (AURA, aura); REGISTER_DECODER(AURA, aura);
REGISTER_DECODER (AURA2, aura2); REGISTER_DECODER(AURA2, aura2);
REGISTER_DECODER (AVS, avs); REGISTER_DECODER(AVS, avs);
REGISTER_DECODER (BETHSOFTVID, bethsoftvid); REGISTER_DECODER(BETHSOFTVID, bethsoftvid);
REGISTER_DECODER (BFI, bfi); REGISTER_DECODER(BFI, bfi);
REGISTER_DECODER (BINK, bink); REGISTER_DECODER(BINK, bink);
REGISTER_ENCDEC (BMP, bmp); REGISTER_ENCDEC (BMP, bmp);
REGISTER_DECODER (BMV_VIDEO, bmv_video); REGISTER_DECODER(BMV_VIDEO, bmv_video);
REGISTER_DECODER (C93, c93); REGISTER_DECODER(C93, c93);
REGISTER_DECODER (CAVS, cavs); REGISTER_DECODER(CAVS, cavs);
REGISTER_DECODER (CDGRAPHICS, cdgraphics); REGISTER_DECODER(CDGRAPHICS, cdgraphics);
REGISTER_DECODER (CDXL, cdxl); REGISTER_DECODER(CDXL, cdxl);
REGISTER_DECODER (CINEPAK, cinepak); REGISTER_DECODER(CINEPAK, cinepak);
REGISTER_ENCDEC (CLJR, cljr); REGISTER_ENCDEC (CLJR, cljr);
REGISTER_DECODER (CLLC, cllc); REGISTER_DECODER(CLLC, cllc);
REGISTER_ENCDEC (COMFORTNOISE, comfortnoise); REGISTER_ENCDEC (COMFORTNOISE, comfortnoise);
REGISTER_DECODER (CSCD, cscd); REGISTER_DECODER(CSCD, cscd);
REGISTER_DECODER (CYUV, cyuv); REGISTER_DECODER(CYUV, cyuv);
REGISTER_DECODER (DFA, dfa); REGISTER_DECODER(DFA, dfa);
REGISTER_ENCDEC (DNXHD, dnxhd); REGISTER_ENCDEC (DNXHD, dnxhd);
REGISTER_ENCDEC (DPX, dpx); REGISTER_ENCDEC (DPX, dpx);
REGISTER_DECODER (DSICINVIDEO, dsicinvideo); REGISTER_DECODER(DSICINVIDEO, dsicinvideo);
REGISTER_ENCDEC (DVVIDEO, dvvideo); REGISTER_ENCDEC (DVVIDEO, dvvideo);
REGISTER_DECODER (DXA, dxa); REGISTER_DECODER(DXA, dxa);
REGISTER_DECODER (DXTORY, dxtory); REGISTER_DECODER(DXTORY, dxtory);
REGISTER_DECODER (EACMV, eacmv); REGISTER_DECODER(EACMV, eacmv);
REGISTER_DECODER (EAMAD, eamad); REGISTER_DECODER(EAMAD, eamad);
REGISTER_DECODER (EATGQ, eatgq); REGISTER_DECODER(EATGQ, eatgq);
REGISTER_DECODER (EATGV, eatgv); REGISTER_DECODER(EATGV, eatgv);
REGISTER_DECODER (EATQI, eatqi); REGISTER_DECODER(EATQI, eatqi);
REGISTER_DECODER (EIGHTBPS, eightbps); REGISTER_DECODER(EIGHTBPS, eightbps);
REGISTER_DECODER (EIGHTSVX_EXP, eightsvx_exp); REGISTER_DECODER(EIGHTSVX_EXP, eightsvx_exp);
REGISTER_DECODER (EIGHTSVX_FIB, eightsvx_fib); REGISTER_DECODER(EIGHTSVX_FIB, eightsvx_fib);
REGISTER_DECODER (ESCAPE124, escape124); REGISTER_DECODER(ESCAPE124, escape124);
REGISTER_ENCDEC (FFV1, ffv1); REGISTER_ENCDEC (FFV1, ffv1);
REGISTER_ENCDEC (FFVHUFF, ffvhuff); REGISTER_ENCDEC (FFVHUFF, ffvhuff);
REGISTER_ENCDEC (FLASHSV, flashsv); REGISTER_ENCDEC (FLASHSV, flashsv);
REGISTER_DECODER (FLASHSV2, flashsv2); REGISTER_DECODER(FLASHSV2, flashsv2);
REGISTER_DECODER (FLIC, flic); REGISTER_DECODER(FLIC, flic);
REGISTER_ENCDEC (FLV, flv); REGISTER_ENCDEC (FLV, flv);
REGISTER_DECODER (FOURXM, fourxm); REGISTER_DECODER(FOURXM, fourxm);
REGISTER_DECODER (FRAPS, fraps); REGISTER_DECODER(FRAPS, fraps);
REGISTER_DECODER (FRWU, frwu); REGISTER_DECODER(FRWU, frwu);
REGISTER_ENCDEC (GIF, gif); REGISTER_ENCDEC (GIF, gif);
REGISTER_ENCDEC (H261, h261); REGISTER_ENCDEC (H261, h261);
REGISTER_ENCDEC (H263, h263); REGISTER_ENCDEC (H263, h263);
REGISTER_DECODER (H263I, h263i); REGISTER_DECODER(H263I, h263i);
REGISTER_ENCODER (H263P, h263p); REGISTER_ENCODER(H263P, h263p);
REGISTER_DECODER (H264, h264); REGISTER_DECODER(H264, h264);
REGISTER_DECODER (H264_VDPAU, h264_vdpau); REGISTER_DECODER(H264_VDPAU, h264_vdpau);
REGISTER_ENCDEC (HUFFYUV, huffyuv); REGISTER_ENCDEC (HUFFYUV, huffyuv);
REGISTER_DECODER (IDCIN, idcin); REGISTER_DECODER(IDCIN, idcin);
REGISTER_DECODER (IFF_BYTERUN1, iff_byterun1); REGISTER_DECODER(IFF_BYTERUN1, iff_byterun1);
REGISTER_DECODER (IFF_ILBM, iff_ilbm); REGISTER_DECODER(IFF_ILBM, iff_ilbm);
REGISTER_DECODER (INDEO2, indeo2); REGISTER_DECODER(INDEO2, indeo2);
REGISTER_DECODER (INDEO3, indeo3); REGISTER_DECODER(INDEO3, indeo3);
REGISTER_DECODER (INDEO4, indeo4); REGISTER_DECODER(INDEO4, indeo4);
REGISTER_DECODER (INDEO5, indeo5); REGISTER_DECODER(INDEO5, indeo5);
REGISTER_DECODER (INTERPLAY_VIDEO, interplay_video); REGISTER_DECODER(INTERPLAY_VIDEO, interplay_video);
REGISTER_ENCDEC (JPEGLS, jpegls); REGISTER_ENCDEC (JPEGLS, jpegls);
REGISTER_DECODER (JV, jv); REGISTER_DECODER(JV, jv);
REGISTER_DECODER (KGV1, kgv1); REGISTER_DECODER(KGV1, kgv1);
REGISTER_DECODER (KMVC, kmvc); REGISTER_DECODER(KMVC, kmvc);
REGISTER_DECODER (LAGARITH, lagarith); REGISTER_DECODER(LAGARITH, lagarith);
REGISTER_ENCODER (LJPEG, ljpeg); REGISTER_ENCODER(LJPEG, ljpeg);
REGISTER_DECODER (LOCO, loco); REGISTER_DECODER(LOCO, loco);
REGISTER_DECODER (MDEC, mdec); REGISTER_DECODER(MDEC, mdec);
REGISTER_DECODER (MIMIC, mimic); REGISTER_DECODER(MIMIC, mimic);
REGISTER_ENCDEC (MJPEG, mjpeg); REGISTER_ENCDEC (MJPEG, mjpeg);
REGISTER_DECODER (MJPEGB, mjpegb); REGISTER_DECODER(MJPEGB, mjpegb);
REGISTER_DECODER (MMVIDEO, mmvideo); REGISTER_DECODER(MMVIDEO, mmvideo);
REGISTER_DECODER (MOTIONPIXELS, motionpixels); REGISTER_DECODER(MOTIONPIXELS, motionpixels);
REGISTER_DECODER (MPEG_XVMC, mpeg_xvmc); REGISTER_DECODER(MPEG_XVMC, mpeg_xvmc);
REGISTER_ENCDEC (MPEG1VIDEO, mpeg1video); REGISTER_ENCDEC (MPEG1VIDEO, mpeg1video);
REGISTER_ENCDEC (MPEG2VIDEO, mpeg2video); REGISTER_ENCDEC (MPEG2VIDEO, mpeg2video);
REGISTER_ENCDEC (MPEG4, mpeg4); REGISTER_ENCDEC (MPEG4, mpeg4);
REGISTER_DECODER (MPEG4_VDPAU, mpeg4_vdpau); REGISTER_DECODER(MPEG4_VDPAU, mpeg4_vdpau);
REGISTER_DECODER (MPEG_VDPAU, mpeg_vdpau); REGISTER_DECODER(MPEG_VDPAU, mpeg_vdpau);
REGISTER_DECODER (MPEG1_VDPAU, mpeg1_vdpau); REGISTER_DECODER(MPEG1_VDPAU, mpeg1_vdpau);
REGISTER_DECODER (MSA1, msa1); REGISTER_DECODER(MSA1, msa1);
REGISTER_DECODER (MSMPEG4V1, msmpeg4v1); REGISTER_DECODER(MSMPEG4V1, msmpeg4v1);
REGISTER_ENCDEC (MSMPEG4V2, msmpeg4v2); REGISTER_ENCDEC (MSMPEG4V2, msmpeg4v2);
REGISTER_ENCDEC (MSMPEG4V3, msmpeg4v3); REGISTER_ENCDEC (MSMPEG4V3, msmpeg4v3);
REGISTER_DECODER (MSRLE, msrle); REGISTER_DECODER(MSRLE, msrle);
REGISTER_DECODER (MSS1, mss1); REGISTER_DECODER(MSS1, mss1);
REGISTER_DECODER (MSS2, mss2); REGISTER_DECODER(MSS2, mss2);
REGISTER_DECODER (MSVIDEO1, msvideo1); REGISTER_DECODER(MSVIDEO1, msvideo1);
REGISTER_DECODER (MSZH, mszh); REGISTER_DECODER(MSZH, mszh);
REGISTER_DECODER (MTS2, mts2); REGISTER_DECODER(MTS2, mts2);
REGISTER_DECODER (MXPEG, mxpeg); REGISTER_DECODER(MXPEG, mxpeg);
REGISTER_DECODER (NUV, nuv); REGISTER_DECODER(NUV, nuv);
REGISTER_ENCDEC (PAM, pam); REGISTER_ENCDEC (PAM, pam);
REGISTER_ENCDEC (PBM, pbm); REGISTER_ENCDEC (PBM, pbm);
REGISTER_ENCDEC (PCX, pcx); REGISTER_ENCDEC (PCX, pcx);
REGISTER_ENCDEC (PGM, pgm); REGISTER_ENCDEC (PGM, pgm);
REGISTER_ENCDEC (PGMYUV, pgmyuv); REGISTER_ENCDEC (PGMYUV, pgmyuv);
REGISTER_DECODER (PICTOR, pictor); REGISTER_DECODER(PICTOR, pictor);
REGISTER_ENCDEC (PNG, png); REGISTER_ENCDEC (PNG, png);
REGISTER_ENCDEC (PPM, ppm); REGISTER_ENCDEC (PPM, ppm);
REGISTER_ENCDEC (PRORES, prores); REGISTER_ENCDEC (PRORES, prores);
REGISTER_DECODER (PTX, ptx); REGISTER_DECODER(PTX, ptx);
REGISTER_DECODER (QDRAW, qdraw); REGISTER_DECODER(QDRAW, qdraw);
REGISTER_DECODER (QPEG, qpeg); REGISTER_DECODER(QPEG, qpeg);
REGISTER_ENCDEC (QTRLE, qtrle); REGISTER_ENCDEC (QTRLE, qtrle);
REGISTER_DECODER (R10K, r10k); REGISTER_DECODER(R10K, r10k);
REGISTER_DECODER (R210, r210); REGISTER_DECODER(R210, r210);
REGISTER_ENCDEC (RAWVIDEO, rawvideo); REGISTER_ENCDEC (RAWVIDEO, rawvideo);
REGISTER_DECODER (RL2, rl2); REGISTER_DECODER(RL2, rl2);
REGISTER_ENCDEC (ROQ, roq); REGISTER_ENCDEC (ROQ, roq);
REGISTER_DECODER (RPZA, rpza); REGISTER_DECODER(RPZA, rpza);
REGISTER_ENCDEC (RV10, rv10); REGISTER_ENCDEC (RV10, rv10);
REGISTER_ENCDEC (RV20, rv20); REGISTER_ENCDEC (RV20, rv20);
REGISTER_DECODER (RV30, rv30); REGISTER_DECODER(RV30, rv30);
REGISTER_DECODER (RV40, rv40); REGISTER_DECODER(RV40, rv40);
REGISTER_DECODER (S302M, s302m); REGISTER_DECODER(S302M, s302m);
REGISTER_ENCDEC (SGI, sgi); REGISTER_ENCDEC (SGI, sgi);
REGISTER_DECODER (SMACKER, smacker); REGISTER_DECODER(SMACKER, smacker);
REGISTER_DECODER (SMC, smc); REGISTER_DECODER(SMC, smc);
REGISTER_ENCDEC (SNOW, snow); REGISTER_ENCDEC (SNOW, snow);
REGISTER_DECODER (SP5X, sp5x); REGISTER_DECODER(SP5X, sp5x);
REGISTER_ENCDEC (SUNRAST, sunrast); REGISTER_ENCDEC (SUNRAST, sunrast);
REGISTER_ENCDEC (SVQ1, svq1); REGISTER_ENCDEC (SVQ1, svq1);
REGISTER_DECODER (SVQ3, svq3); REGISTER_DECODER(SVQ3, svq3);
REGISTER_ENCDEC (TARGA, targa); REGISTER_ENCDEC (TARGA, targa);
REGISTER_DECODER (THEORA, theora); REGISTER_DECODER(THEORA, theora);
REGISTER_DECODER (THP, thp); REGISTER_DECODER(THP, thp);
REGISTER_DECODER (TIERTEXSEQVIDEO, tiertexseqvideo); REGISTER_DECODER(TIERTEXSEQVIDEO, tiertexseqvideo);
REGISTER_ENCDEC (TIFF, tiff); REGISTER_ENCDEC (TIFF, tiff);
REGISTER_DECODER (TMV, tmv); REGISTER_DECODER(TMV, tmv);
REGISTER_DECODER (TRUEMOTION1, truemotion1); REGISTER_DECODER(TRUEMOTION1, truemotion1);
REGISTER_DECODER (TRUEMOTION2, truemotion2); REGISTER_DECODER(TRUEMOTION2, truemotion2);
REGISTER_DECODER (TSCC, tscc); REGISTER_DECODER(TSCC, tscc);
REGISTER_DECODER (TSCC2, tscc2); REGISTER_DECODER(TSCC2, tscc2);
REGISTER_DECODER (TXD, txd); REGISTER_DECODER(TXD, txd);
REGISTER_DECODER (ULTI, ulti); REGISTER_DECODER(ULTI, ulti);
REGISTER_ENCDEC (UTVIDEO, utvideo); REGISTER_ENCDEC (UTVIDEO, utvideo);
REGISTER_ENCDEC (V210, v210); REGISTER_ENCDEC (V210, v210);
REGISTER_DECODER (V210X, v210x); REGISTER_DECODER(V210X, v210x);
REGISTER_ENCDEC (V410, v410); REGISTER_ENCDEC (V410, v410);
REGISTER_DECODER (VB, vb); REGISTER_DECODER(VB, vb);
REGISTER_DECODER (VBLE, vble); REGISTER_DECODER(VBLE, vble);
REGISTER_DECODER (VC1, vc1); REGISTER_DECODER(VC1, vc1);
REGISTER_DECODER (VC1_VDPAU, vc1_vdpau); REGISTER_DECODER(VC1_VDPAU, vc1_vdpau);
REGISTER_DECODER (VC1IMAGE, vc1image); REGISTER_DECODER(VC1IMAGE, vc1image);
REGISTER_DECODER (VCR1, vcr1); REGISTER_DECODER(VCR1, vcr1);
REGISTER_DECODER (VMDVIDEO, vmdvideo); REGISTER_DECODER(VMDVIDEO, vmdvideo);
REGISTER_DECODER (VMNC, vmnc); REGISTER_DECODER(VMNC, vmnc);
REGISTER_DECODER (VP3, vp3); REGISTER_DECODER(VP3, vp3);
REGISTER_DECODER (VP5, vp5); REGISTER_DECODER(VP5, vp5);
REGISTER_DECODER (VP6, vp6); REGISTER_DECODER(VP6, vp6);
REGISTER_DECODER (VP6A, vp6a); REGISTER_DECODER(VP6A, vp6a);
REGISTER_DECODER (VP6F, vp6f); REGISTER_DECODER(VP6F, vp6f);
REGISTER_DECODER (VP8, vp8); REGISTER_DECODER(VP8, vp8);
REGISTER_DECODER (VQA, vqa); REGISTER_DECODER(VQA, vqa);
REGISTER_ENCDEC (WMV1, wmv1); REGISTER_ENCDEC (WMV1, wmv1);
REGISTER_ENCDEC (WMV2, wmv2); REGISTER_ENCDEC (WMV2, wmv2);
REGISTER_DECODER (WMV3, wmv3); REGISTER_DECODER(WMV3, wmv3);
REGISTER_DECODER (WMV3_VDPAU, wmv3_vdpau); REGISTER_DECODER(WMV3_VDPAU, wmv3_vdpau);
REGISTER_DECODER (WMV3IMAGE, wmv3image); REGISTER_DECODER(WMV3IMAGE, wmv3image);
REGISTER_DECODER (WNV1, wnv1); REGISTER_DECODER(WNV1, wnv1);
REGISTER_DECODER (XAN_WC3, xan_wc3); REGISTER_DECODER(XAN_WC3, xan_wc3);
REGISTER_DECODER (XAN_WC4, xan_wc4); REGISTER_DECODER(XAN_WC4, xan_wc4);
REGISTER_ENCODER (XBM, xbm); REGISTER_ENCODER(XBM, xbm);
REGISTER_DECODER (XL, xl); REGISTER_DECODER(XL, xl);
REGISTER_ENCDEC (XWD, xwd); REGISTER_ENCDEC (XWD, xwd);
REGISTER_DECODER (YOP, yop); REGISTER_DECODER(YOP, yop);
REGISTER_DECODER (ZEROCODEC, zerocodec); REGISTER_DECODER(ZEROCODEC, zerocodec);
REGISTER_ENCDEC (ZLIB, zlib); REGISTER_ENCDEC (ZLIB, zlib);
REGISTER_ENCDEC (ZMBV, zmbv); REGISTER_ENCDEC (ZMBV, zmbv);
/* audio codecs */ /* audio codecs */
REGISTER_ENCDEC (AAC, aac); REGISTER_ENCDEC (AAC, aac);
REGISTER_DECODER (AAC_LATM, aac_latm); REGISTER_DECODER(AAC_LATM, aac_latm);
REGISTER_ENCDEC (AC3, ac3); REGISTER_ENCDEC (AC3, ac3);
REGISTER_ENCODER (AC3_FIXED, ac3_fixed); REGISTER_ENCODER(AC3_FIXED, ac3_fixed);
REGISTER_ENCDEC (ALAC, alac); REGISTER_ENCDEC (ALAC, alac);
REGISTER_DECODER (ALS, als); REGISTER_DECODER(ALS, als);
REGISTER_DECODER (AMRNB, amrnb); REGISTER_DECODER(AMRNB, amrnb);
REGISTER_DECODER (AMRWB, amrwb); REGISTER_DECODER(AMRWB, amrwb);
REGISTER_DECODER (APE, ape); REGISTER_DECODER(APE, ape);
REGISTER_DECODER (ATRAC1, atrac1); REGISTER_DECODER(ATRAC1, atrac1);
REGISTER_DECODER (ATRAC3, atrac3); REGISTER_DECODER(ATRAC3, atrac3);
REGISTER_DECODER (BINKAUDIO_DCT, binkaudio_dct); REGISTER_DECODER(BINKAUDIO_DCT, binkaudio_dct);
REGISTER_DECODER (BINKAUDIO_RDFT, binkaudio_rdft); REGISTER_DECODER(BINKAUDIO_RDFT, binkaudio_rdft);
REGISTER_DECODER (BMV_AUDIO, bmv_audio); REGISTER_DECODER(BMV_AUDIO, bmv_audio);
REGISTER_DECODER (COOK, cook); REGISTER_DECODER(COOK, cook);
REGISTER_DECODER (DCA, dca); REGISTER_DECODER(DCA, dca);
REGISTER_DECODER (DSICINAUDIO, dsicinaudio); REGISTER_DECODER(DSICINAUDIO, dsicinaudio);
REGISTER_ENCDEC (EAC3, eac3); REGISTER_ENCDEC (EAC3, eac3);
REGISTER_ENCDEC (FLAC, flac); REGISTER_ENCDEC (FLAC, flac);
REGISTER_DECODER (G723_1, g723_1); REGISTER_DECODER(G723_1, g723_1);
REGISTER_DECODER (GSM, gsm); REGISTER_DECODER(GSM, gsm);
REGISTER_DECODER (GSM_MS, gsm_ms); REGISTER_DECODER(GSM_MS, gsm_ms);
REGISTER_DECODER (IAC, iac); REGISTER_DECODER(IAC, iac);
REGISTER_DECODER (IMC, imc); REGISTER_DECODER(IMC, imc);
REGISTER_DECODER (MACE3, mace3); REGISTER_DECODER(MACE3, mace3);
REGISTER_DECODER (MACE6, mace6); REGISTER_DECODER(MACE6, mace6);
REGISTER_DECODER (MLP, mlp); REGISTER_DECODER(MLP, mlp);
REGISTER_DECODER (MP1, mp1); REGISTER_DECODER(MP1, mp1);
REGISTER_DECODER (MP1FLOAT, mp1float); REGISTER_DECODER(MP1FLOAT, mp1float);
REGISTER_ENCDEC (MP2, mp2); REGISTER_ENCDEC (MP2, mp2);
REGISTER_DECODER (MP2FLOAT, mp2float); REGISTER_DECODER(MP2FLOAT, mp2float);
REGISTER_DECODER (MP3, mp3); REGISTER_DECODER(MP3, mp3);
REGISTER_DECODER (MP3FLOAT, mp3float); REGISTER_DECODER(MP3FLOAT, mp3float);
REGISTER_DECODER (MP3ADU, mp3adu); REGISTER_DECODER(MP3ADU, mp3adu);
REGISTER_DECODER (MP3ADUFLOAT, mp3adufloat); REGISTER_DECODER(MP3ADUFLOAT, mp3adufloat);
REGISTER_DECODER (MP3ON4, mp3on4); REGISTER_DECODER(MP3ON4, mp3on4);
REGISTER_DECODER (MP3ON4FLOAT, mp3on4float); REGISTER_DECODER(MP3ON4FLOAT, mp3on4float);
REGISTER_DECODER (MPC7, mpc7); REGISTER_DECODER(MPC7, mpc7);
REGISTER_DECODER (MPC8, mpc8); REGISTER_DECODER(MPC8, mpc8);
REGISTER_ENCDEC (NELLYMOSER, nellymoser); REGISTER_ENCDEC (NELLYMOSER, nellymoser);
REGISTER_DECODER (QCELP, qcelp); REGISTER_DECODER(QCELP, qcelp);
REGISTER_DECODER (QDM2, qdm2); REGISTER_DECODER(QDM2, qdm2);
REGISTER_ENCDEC (RA_144, ra_144); REGISTER_ENCDEC (RA_144, ra_144);
REGISTER_DECODER (RA_288, ra_288); REGISTER_DECODER(RA_288, ra_288);
REGISTER_DECODER (RALF, ralf); REGISTER_DECODER(RALF, ralf);
REGISTER_DECODER (SHORTEN, shorten); REGISTER_DECODER(SHORTEN, shorten);
REGISTER_DECODER (SIPR, sipr); REGISTER_DECODER(SIPR, sipr);
REGISTER_DECODER (SMACKAUD, smackaud); REGISTER_DECODER(SMACKAUD, smackaud);
REGISTER_DECODER (TAK, tak); REGISTER_DECODER(TAK, tak);
REGISTER_DECODER (TRUEHD, truehd); REGISTER_DECODER(TRUEHD, truehd);
REGISTER_DECODER (TRUESPEECH, truespeech); REGISTER_DECODER(TRUESPEECH, truespeech);
REGISTER_DECODER (TTA, tta); REGISTER_DECODER(TTA, tta);
REGISTER_DECODER (TWINVQ, twinvq); REGISTER_DECODER(TWINVQ, twinvq);
REGISTER_DECODER (VMDAUDIO, vmdaudio); REGISTER_DECODER(VMDAUDIO, vmdaudio);
REGISTER_ENCDEC (VORBIS, vorbis); REGISTER_ENCDEC (VORBIS, vorbis);
REGISTER_DECODER (WAVPACK, wavpack); REGISTER_DECODER(WAVPACK, wavpack);
REGISTER_DECODER (WMALOSSLESS, wmalossless); REGISTER_DECODER(WMALOSSLESS, wmalossless);
REGISTER_DECODER (WMAPRO, wmapro); REGISTER_DECODER(WMAPRO, wmapro);
REGISTER_ENCDEC (WMAV1, wmav1); REGISTER_ENCDEC (WMAV1, wmav1);
REGISTER_ENCDEC (WMAV2, wmav2); REGISTER_ENCDEC (WMAV2, wmav2);
REGISTER_DECODER (WMAVOICE, wmavoice); REGISTER_DECODER(WMAVOICE, wmavoice);
REGISTER_DECODER (WS_SND1, ws_snd1); REGISTER_DECODER(WS_SND1, ws_snd1);
/* PCM codecs */ /* PCM codecs */
REGISTER_ENCDEC (PCM_ALAW, pcm_alaw); REGISTER_ENCDEC (PCM_ALAW, pcm_alaw);
REGISTER_DECODER (PCM_BLURAY, pcm_bluray); REGISTER_DECODER(PCM_BLURAY, pcm_bluray);
REGISTER_DECODER (PCM_DVD, pcm_dvd); REGISTER_DECODER(PCM_DVD, pcm_dvd);
REGISTER_ENCDEC (PCM_F32BE, pcm_f32be); REGISTER_ENCDEC (PCM_F32BE, pcm_f32be);
REGISTER_ENCDEC (PCM_F32LE, pcm_f32le); REGISTER_ENCDEC (PCM_F32LE, pcm_f32le);
REGISTER_ENCDEC (PCM_F64BE, pcm_f64be); REGISTER_ENCDEC (PCM_F64BE, pcm_f64be);
REGISTER_ENCDEC (PCM_F64LE, pcm_f64le); REGISTER_ENCDEC (PCM_F64LE, pcm_f64le);
REGISTER_DECODER (PCM_LXF, pcm_lxf); REGISTER_DECODER(PCM_LXF, pcm_lxf);
REGISTER_ENCDEC (PCM_MULAW, pcm_mulaw); REGISTER_ENCDEC (PCM_MULAW, pcm_mulaw);
REGISTER_ENCDEC (PCM_S8, pcm_s8); REGISTER_ENCDEC (PCM_S8, pcm_s8);
REGISTER_DECODER (PCM_S8_PLANAR, pcm_s8_planar); REGISTER_DECODER(PCM_S8_PLANAR, pcm_s8_planar);
REGISTER_ENCDEC (PCM_S16BE, pcm_s16be); REGISTER_ENCDEC (PCM_S16BE, pcm_s16be);
REGISTER_ENCDEC (PCM_S16LE, pcm_s16le); REGISTER_ENCDEC (PCM_S16LE, pcm_s16le);
REGISTER_DECODER (PCM_S16LE_PLANAR, pcm_s16le_planar); REGISTER_DECODER(PCM_S16LE_PLANAR, pcm_s16le_planar);
REGISTER_ENCDEC (PCM_S24BE, pcm_s24be); REGISTER_ENCDEC (PCM_S24BE, pcm_s24be);
REGISTER_ENCDEC (PCM_S24DAUD, pcm_s24daud); REGISTER_ENCDEC (PCM_S24DAUD, pcm_s24daud);
REGISTER_ENCDEC (PCM_S24LE, pcm_s24le); REGISTER_ENCDEC (PCM_S24LE, pcm_s24le);
REGISTER_ENCDEC (PCM_S32BE, pcm_s32be); REGISTER_ENCDEC (PCM_S32BE, pcm_s32be);
REGISTER_ENCDEC (PCM_S32LE, pcm_s32le); REGISTER_ENCDEC (PCM_S32LE, pcm_s32le);
REGISTER_ENCDEC (PCM_U8, pcm_u8); REGISTER_ENCDEC (PCM_U8, pcm_u8);
REGISTER_ENCDEC (PCM_U16BE, pcm_u16be); REGISTER_ENCDEC (PCM_U16BE, pcm_u16be);
REGISTER_ENCDEC (PCM_U16LE, pcm_u16le); REGISTER_ENCDEC (PCM_U16LE, pcm_u16le);
REGISTER_ENCDEC (PCM_U24BE, pcm_u24be); REGISTER_ENCDEC (PCM_U24BE, pcm_u24be);
REGISTER_ENCDEC (PCM_U24LE, pcm_u24le); REGISTER_ENCDEC (PCM_U24LE, pcm_u24le);
REGISTER_ENCDEC (PCM_U32BE, pcm_u32be); REGISTER_ENCDEC (PCM_U32BE, pcm_u32be);
REGISTER_ENCDEC (PCM_U32LE, pcm_u32le); REGISTER_ENCDEC (PCM_U32LE, pcm_u32le);
REGISTER_DECODER (PCM_ZORK , pcm_zork); REGISTER_DECODER(PCM_ZORK , pcm_zork);
/* DPCM codecs */ /* DPCM codecs */
REGISTER_DECODER (INTERPLAY_DPCM, interplay_dpcm); REGISTER_DECODER(INTERPLAY_DPCM, interplay_dpcm);
REGISTER_ENCDEC (ROQ_DPCM, roq_dpcm); REGISTER_ENCDEC (ROQ_DPCM, roq_dpcm);
REGISTER_DECODER (SOL_DPCM, sol_dpcm); REGISTER_DECODER(SOL_DPCM, sol_dpcm);
REGISTER_DECODER (XAN_DPCM, xan_dpcm); REGISTER_DECODER(XAN_DPCM, xan_dpcm);
/* ADPCM codecs */ /* ADPCM codecs */
REGISTER_DECODER (ADPCM_4XM, adpcm_4xm); REGISTER_DECODER(ADPCM_4XM, adpcm_4xm);
REGISTER_ENCDEC (ADPCM_ADX, adpcm_adx); REGISTER_ENCDEC (ADPCM_ADX, adpcm_adx);
REGISTER_DECODER (ADPCM_CT, adpcm_ct); REGISTER_DECODER(ADPCM_CT, adpcm_ct);
REGISTER_DECODER (ADPCM_EA, adpcm_ea); REGISTER_DECODER(ADPCM_EA, adpcm_ea);
REGISTER_DECODER (ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa); REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
REGISTER_DECODER (ADPCM_EA_R1, adpcm_ea_r1); REGISTER_DECODER(ADPCM_EA_R1, adpcm_ea_r1);
REGISTER_DECODER (ADPCM_EA_R2, adpcm_ea_r2); REGISTER_DECODER(ADPCM_EA_R2, adpcm_ea_r2);
REGISTER_DECODER (ADPCM_EA_R3, adpcm_ea_r3); REGISTER_DECODER(ADPCM_EA_R3, adpcm_ea_r3);
REGISTER_DECODER (ADPCM_EA_XAS, adpcm_ea_xas); REGISTER_DECODER(ADPCM_EA_XAS, adpcm_ea_xas);
REGISTER_ENCDEC (ADPCM_G722, adpcm_g722); REGISTER_ENCDEC (ADPCM_G722, adpcm_g722);
REGISTER_ENCDEC (ADPCM_G726, adpcm_g726); REGISTER_ENCDEC (ADPCM_G726, adpcm_g726);
REGISTER_DECODER (ADPCM_IMA_AMV, adpcm_ima_amv); REGISTER_DECODER(ADPCM_IMA_AMV, adpcm_ima_amv);
REGISTER_DECODER (ADPCM_IMA_APC, adpcm_ima_apc); REGISTER_DECODER(ADPCM_IMA_APC, adpcm_ima_apc);
REGISTER_DECODER (ADPCM_IMA_DK3, adpcm_ima_dk3); REGISTER_DECODER(ADPCM_IMA_DK3, adpcm_ima_dk3);
REGISTER_DECODER (ADPCM_IMA_DK4, adpcm_ima_dk4); REGISTER_DECODER(ADPCM_IMA_DK4, adpcm_ima_dk4);
REGISTER_DECODER (ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs); REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
REGISTER_DECODER (ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead); REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
REGISTER_DECODER (ADPCM_IMA_ISS, adpcm_ima_iss); REGISTER_DECODER(ADPCM_IMA_ISS, adpcm_ima_iss);
REGISTER_ENCDEC (ADPCM_IMA_QT, adpcm_ima_qt); REGISTER_ENCDEC (ADPCM_IMA_QT, adpcm_ima_qt);
REGISTER_DECODER (ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg); REGISTER_DECODER(ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
REGISTER_ENCDEC (ADPCM_IMA_WAV, adpcm_ima_wav); REGISTER_ENCDEC (ADPCM_IMA_WAV, adpcm_ima_wav);
REGISTER_DECODER (ADPCM_IMA_WS, adpcm_ima_ws); REGISTER_DECODER(ADPCM_IMA_WS, adpcm_ima_ws);
REGISTER_ENCDEC (ADPCM_MS, adpcm_ms); REGISTER_ENCDEC (ADPCM_MS, adpcm_ms);
REGISTER_DECODER (ADPCM_SBPRO_2, adpcm_sbpro_2); REGISTER_DECODER(ADPCM_SBPRO_2, adpcm_sbpro_2);
REGISTER_DECODER (ADPCM_SBPRO_3, adpcm_sbpro_3); REGISTER_DECODER(ADPCM_SBPRO_3, adpcm_sbpro_3);
REGISTER_DECODER (ADPCM_SBPRO_4, adpcm_sbpro_4); REGISTER_DECODER(ADPCM_SBPRO_4, adpcm_sbpro_4);
REGISTER_ENCDEC (ADPCM_SWF, adpcm_swf); REGISTER_ENCDEC (ADPCM_SWF, adpcm_swf);
REGISTER_DECODER (ADPCM_THP, adpcm_thp); REGISTER_DECODER(ADPCM_THP, adpcm_thp);
REGISTER_DECODER (ADPCM_XA, adpcm_xa); REGISTER_DECODER(ADPCM_XA, adpcm_xa);
REGISTER_ENCDEC (ADPCM_YAMAHA, adpcm_yamaha); REGISTER_ENCDEC (ADPCM_YAMAHA, adpcm_yamaha);
/* subtitles */ /* subtitles */
REGISTER_ENCDEC (ASS, ass); REGISTER_ENCDEC (ASS, ass);
REGISTER_ENCDEC (DVBSUB, dvbsub); REGISTER_ENCDEC (DVBSUB, dvbsub);
REGISTER_ENCDEC (DVDSUB, dvdsub); REGISTER_ENCDEC (DVDSUB, dvdsub);
REGISTER_DECODER (PGSSUB, pgssub); REGISTER_DECODER(PGSSUB, pgssub);
REGISTER_DECODER (SRT, srt); REGISTER_DECODER(SRT, srt);
REGISTER_ENCDEC (XSUB, xsub); REGISTER_ENCDEC (XSUB, xsub);
/* external libraries */ /* external libraries */
REGISTER_ENCODER (LIBFAAC, libfaac); REGISTER_ENCODER(LIBFAAC, libfaac);
REGISTER_ENCODER (LIBFDK_AAC, libfdk_aac); REGISTER_ENCODER(LIBFDK_AAC, libfdk_aac);
REGISTER_ENCDEC (LIBGSM, libgsm); REGISTER_ENCDEC (LIBGSM, libgsm);
REGISTER_ENCDEC (LIBGSM_MS, libgsm_ms); REGISTER_ENCDEC (LIBGSM_MS, libgsm_ms);
REGISTER_ENCDEC (LIBILBC, libilbc); REGISTER_ENCDEC (LIBILBC, libilbc);
REGISTER_ENCODER (LIBMP3LAME, libmp3lame); REGISTER_ENCODER(LIBMP3LAME, libmp3lame);
REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb); REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
REGISTER_DECODER (LIBOPENCORE_AMRWB, libopencore_amrwb); REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
REGISTER_ENCDEC (LIBOPENJPEG, libopenjpeg); REGISTER_ENCDEC (LIBOPENJPEG, libopenjpeg);
REGISTER_ENCDEC (LIBOPUS, libopus); REGISTER_ENCDEC (LIBOPUS, libopus);
REGISTER_ENCDEC (LIBSCHROEDINGER, libschroedinger); REGISTER_ENCDEC (LIBSCHROEDINGER, libschroedinger);
REGISTER_ENCDEC (LIBSPEEX, libspeex); REGISTER_ENCDEC (LIBSPEEX, libspeex);
REGISTER_ENCODER (LIBTHEORA, libtheora); REGISTER_ENCODER(LIBTHEORA, libtheora);
REGISTER_ENCODER (LIBVO_AACENC, libvo_aacenc); REGISTER_ENCODER(LIBVO_AACENC, libvo_aacenc);
REGISTER_ENCODER (LIBVO_AMRWBENC, libvo_amrwbenc); REGISTER_ENCODER(LIBVO_AMRWBENC, libvo_amrwbenc);
REGISTER_ENCODER (LIBVORBIS, libvorbis); REGISTER_ENCODER(LIBVORBIS, libvorbis);
REGISTER_ENCDEC (LIBVPX, libvpx); REGISTER_ENCDEC (LIBVPX, libvpx);
REGISTER_ENCODER (LIBX264, libx264); REGISTER_ENCODER(LIBX264, libx264);
REGISTER_ENCODER (LIBXAVS, libxavs); REGISTER_ENCODER(LIBXAVS, libxavs);
REGISTER_ENCODER (LIBXVID, libxvid); REGISTER_ENCODER(LIBXVID, libxvid);
/* parsers */ /* parsers */
REGISTER_PARSER (AAC, aac); REGISTER_PARSER(AAC, aac);
REGISTER_PARSER (AAC_LATM, aac_latm); REGISTER_PARSER(AAC_LATM, aac_latm);
REGISTER_PARSER (AC3, ac3); REGISTER_PARSER(AC3, ac3);
REGISTER_PARSER (ADX, adx); REGISTER_PARSER(ADX, adx);
REGISTER_PARSER (CAVSVIDEO, cavsvideo); REGISTER_PARSER(CAVSVIDEO, cavsvideo);
REGISTER_PARSER (COOK, cook); REGISTER_PARSER(COOK, cook);
REGISTER_PARSER (DCA, dca); REGISTER_PARSER(DCA, dca);
REGISTER_PARSER (DIRAC, dirac); REGISTER_PARSER(DIRAC, dirac);
REGISTER_PARSER (DNXHD, dnxhd); REGISTER_PARSER(DNXHD, dnxhd);
REGISTER_PARSER (DVBSUB, dvbsub); REGISTER_PARSER(DVBSUB, dvbsub);
REGISTER_PARSER (DVDSUB, dvdsub); REGISTER_PARSER(DVDSUB, dvdsub);
REGISTER_PARSER (FLAC, flac); REGISTER_PARSER(FLAC, flac);
REGISTER_PARSER (GSM, gsm); REGISTER_PARSER(GSM, gsm);
REGISTER_PARSER (H261, h261); REGISTER_PARSER(H261, h261);
REGISTER_PARSER (H263, h263); REGISTER_PARSER(H263, h263);
REGISTER_PARSER (H264, h264); REGISTER_PARSER(H264, h264);
REGISTER_PARSER (MJPEG, mjpeg); REGISTER_PARSER(MJPEG, mjpeg);
REGISTER_PARSER (MLP, mlp); REGISTER_PARSER(MLP, mlp);
REGISTER_PARSER (MPEG4VIDEO, mpeg4video); REGISTER_PARSER(MPEG4VIDEO, mpeg4video);
REGISTER_PARSER (MPEGAUDIO, mpegaudio); REGISTER_PARSER(MPEGAUDIO, mpegaudio);
REGISTER_PARSER (MPEGVIDEO, mpegvideo); REGISTER_PARSER(MPEGVIDEO, mpegvideo);
REGISTER_PARSER (PNM, pnm); REGISTER_PARSER(PNM, pnm);
REGISTER_PARSER (RV30, rv30); REGISTER_PARSER(RV30, rv30);
REGISTER_PARSER (RV40, rv40); REGISTER_PARSER(RV40, rv40);
REGISTER_PARSER (TAK, tak); REGISTER_PARSER(TAK, tak);
REGISTER_PARSER (VC1, vc1); REGISTER_PARSER(VC1, vc1);
REGISTER_PARSER (VORBIS, vorbis); REGISTER_PARSER(VORBIS, vorbis);
REGISTER_PARSER (VP3, vp3); REGISTER_PARSER(VP3, vp3);
REGISTER_PARSER (VP8, vp8); REGISTER_PARSER(VP8, vp8);
/* bitstream filters */ /* bitstream filters */
REGISTER_BSF (AAC_ADTSTOASC, aac_adtstoasc); REGISTER_BSF(AAC_ADTSTOASC, aac_adtstoasc);
REGISTER_BSF (CHOMP, chomp); REGISTER_BSF(CHOMP, chomp);
REGISTER_BSF (DUMP_EXTRADATA, dump_extradata); REGISTER_BSF(DUMP_EXTRADATA, dump_extradata);
REGISTER_BSF (H264_MP4TOANNEXB, h264_mp4toannexb); REGISTER_BSF(H264_MP4TOANNEXB, h264_mp4toannexb);
REGISTER_BSF (IMX_DUMP_HEADER, imx_dump_header); REGISTER_BSF(IMX_DUMP_HEADER, imx_dump_header);
REGISTER_BSF (MJPEG2JPEG, mjpeg2jpeg); REGISTER_BSF(MJPEG2JPEG, mjpeg2jpeg);
REGISTER_BSF (MJPEGA_DUMP_HEADER, mjpega_dump_header); REGISTER_BSF(MJPEGA_DUMP_HEADER, mjpega_dump_header);
REGISTER_BSF (MP3_HEADER_COMPRESS, mp3_header_compress); REGISTER_BSF(MP3_HEADER_COMPRESS, mp3_header_compress);
REGISTER_BSF (MP3_HEADER_DECOMPRESS, mp3_header_decompress); REGISTER_BSF(MP3_HEADER_DECOMPRESS, mp3_header_decompress);
REGISTER_BSF (MOV2TEXTSUB, mov2textsub); REGISTER_BSF(MOV2TEXTSUB, mov2textsub);
REGISTER_BSF (NOISE, noise); REGISTER_BSF(NOISE, noise);
REGISTER_BSF (REMOVE_EXTRADATA, remove_extradata); REGISTER_BSF(REMOVE_EXTRADATA, remove_extradata);
REGISTER_BSF (TEXT2MOVSUB, text2movsub); REGISTER_BSF(TEXT2MOVSUB, text2movsub);
} }

50
libavdevice/alldevices.c
Unescape View File

@ -22,13 +22,23 @@
#include "libavformat/avformat.h" #include "libavformat/avformat.h"
#include "avdevice.h" #include "avdevice.h"
#define REGISTER_OUTDEV(X,x) { \ #define REGISTER_OUTDEV(X, x) \
extern AVOutputFormat ff_##x##_muxer; \ { \
if(CONFIG_##X##_OUTDEV) av_register_output_format(&ff_##x##_muxer); } extern AVOutputFormat ff_##x##_muxer; \
#define REGISTER_INDEV(X,x) { \ if (CONFIG_##X##_OUTDEV) \
extern AVInputFormat ff_##x##_demuxer; \ av_register_output_format(&ff_##x##_muxer); \
if(CONFIG_##X##_INDEV) av_register_input_format(&ff_##x##_demuxer); } }
#define REGISTER_INOUTDEV(X,x) REGISTER_OUTDEV(X,x); REGISTER_INDEV(X,x)
#define REGISTER_INDEV(X, x) \
{ \
extern AVInputFormat ff_##x##_demuxer; \
if (CONFIG_##X##_INDEV) \
av_register_input_format(&ff_##x##_demuxer); \
}
#define REGISTER_INOUTDEV(X, x) \
REGISTER_OUTDEV(X, x); \
REGISTER_INDEV(X, x)
void avdevice_register_all(void) void avdevice_register_all(void)
{ {
@ -39,19 +49,19 @@ void avdevice_register_all(void)
initialized = 1; initialized = 1;
/* devices */ /* devices */
REGISTER_INOUTDEV (ALSA, alsa); REGISTER_INOUTDEV(ALSA, alsa);
REGISTER_INDEV (BKTR, bktr); REGISTER_INDEV (BKTR, bktr);
REGISTER_INDEV (DV1394, dv1394); REGISTER_INDEV (DV1394, dv1394);
REGISTER_INDEV (FBDEV, fbdev); REGISTER_INDEV (FBDEV, fbdev);
REGISTER_INDEV (JACK, jack); REGISTER_INDEV (JACK, jack);
REGISTER_INOUTDEV (OSS, oss); REGISTER_INOUTDEV(OSS, oss);
REGISTER_INDEV (PULSE, pulse); REGISTER_INDEV (PULSE, pulse);
REGISTER_INOUTDEV (SNDIO, sndio); REGISTER_INOUTDEV(SNDIO, sndio);
REGISTER_INDEV (V4L2, v4l2); REGISTER_INDEV (V4L2, v4l2);
REGISTER_INDEV (VFWCAP, vfwcap); REGISTER_INDEV (VFWCAP, vfwcap);
REGISTER_INDEV (X11GRAB, x11grab); REGISTER_INDEV (X11GRAB, x11grab);
/* external libraries */ /* external libraries */
REGISTER_INDEV (LIBCDIO, libcdio); REGISTER_INDEV (LIBCDIO, libcdio);
REGISTER_INDEV (LIBDC1394, libdc1394); REGISTER_INDEV (LIBDC1394, libdc1394);
} }

125
libavfilter/allfilters.c
Unescape View File

@ -23,9 +23,12 @@
#include "config.h" #include "config.h"
#define REGISTER_FILTER(X,x,y) { \ #define REGISTER_FILTER(X, x, y) \
extern AVFilter avfilter_##y##_##x ; \ { \
if(CONFIG_##X##_FILTER ) avfilter_register(&avfilter_##y##_##x ); } extern AVFilter avfilter_##y##_##x; \
if (CONFIG_##X##_FILTER) \
avfilter_register(&avfilter_##y##_##x); \
}
#define REGISTER_FILTER_UNCONDITIONAL(x) \ #define REGISTER_FILTER_UNCONDITIONAL(x) \
{ \ { \
@ -41,69 +44,69 @@ void avfilter_register_all(void)
return; return;
initialized = 1; initialized = 1;
REGISTER_FILTER (AFORMAT, aformat, af); REGISTER_FILTER(AFORMAT, aformat, af);
REGISTER_FILTER (AMIX, amix, af); REGISTER_FILTER(AMIX, amix, af);
REGISTER_FILTER (ANULL, anull, af); REGISTER_FILTER(ANULL, anull, af);
REGISTER_FILTER (ASHOWINFO, ashowinfo, af); REGISTER_FILTER(ASHOWINFO, ashowinfo, af);
REGISTER_FILTER (ASPLIT, asplit, af); REGISTER_FILTER(ASPLIT, asplit, af);
REGISTER_FILTER (ASYNCTS, asyncts, af); REGISTER_FILTER(ASYNCTS, asyncts, af);
REGISTER_FILTER (CHANNELMAP, channelmap, af); REGISTER_FILTER(CHANNELMAP, channelmap, af);
REGISTER_FILTER (CHANNELSPLIT,channelsplit,af); REGISTER_FILTER(CHANNELSPLIT, channelsplit, af);
REGISTER_FILTER (JOIN, join, af); REGISTER_FILTER(JOIN, join, af);
REGISTER_FILTER (RESAMPLE, resample, af); REGISTER_FILTER(RESAMPLE, resample, af);
REGISTER_FILTER (VOLUME, volume, af); REGISTER_FILTER(VOLUME, volume, af);
REGISTER_FILTER (ANULLSRC, anullsrc, asrc); REGISTER_FILTER(ANULLSRC, anullsrc, asrc);
REGISTER_FILTER (ANULLSINK, anullsink, asink); REGISTER_FILTER(ANULLSINK, anullsink, asink);
REGISTER_FILTER (BLACKFRAME, blackframe, vf); REGISTER_FILTER(BLACKFRAME, blackframe, vf);
REGISTER_FILTER (BOXBLUR, boxblur, vf); REGISTER_FILTER(BOXBLUR, boxblur, vf);
REGISTER_FILTER (COPY, copy, vf); REGISTER_FILTER(COPY, copy, vf);
REGISTER_FILTER (CROP, crop, vf); REGISTER_FILTER(CROP, crop, vf);
REGISTER_FILTER (CROPDETECT, cropdetect, vf); REGISTER_FILTER(CROPDETECT, cropdetect, vf);
REGISTER_FILTER (DELOGO, delogo, vf); REGISTER_FILTER(DELOGO, delogo, vf);
REGISTER_FILTER (DRAWBOX, drawbox, vf); REGISTER_FILTER(DRAWBOX, drawbox, vf);
REGISTER_FILTER (DRAWTEXT, drawtext, vf); REGISTER_FILTER(DRAWTEXT, drawtext, vf);
REGISTER_FILTER (FADE, fade, vf); REGISTER_FILTER(FADE, fade, vf);
REGISTER_FILTER (FIELDORDER, fieldorder, vf); REGISTER_FILTER(FIELDORDER, fieldorder, vf);
REGISTER_FILTER (FORMAT, format, vf); REGISTER_FILTER(FORMAT, format, vf);
REGISTER_FILTER (FPS, fps, vf); REGISTER_FILTER(FPS, fps, vf);
REGISTER_FILTER (FREI0R, frei0r, vf); REGISTER_FILTER(FREI0R, frei0r, vf);
REGISTER_FILTER (GRADFUN, gradfun, vf); REGISTER_FILTER(GRADFUN, gradfun, vf);
REGISTER_FILTER (HFLIP, hflip, vf); REGISTER_FILTER(HFLIP, hflip, vf);
REGISTER_FILTER (HQDN3D, hqdn3d, vf); REGISTER_FILTER(HQDN3D, hqdn3d, vf);
REGISTER_FILTER (LUT, lut, vf); REGISTER_FILTER(LUT, lut, vf);
REGISTER_FILTER (LUTRGB, lutrgb, vf); REGISTER_FILTER(LUTRGB, lutrgb, vf);
REGISTER_FILTER (LUTYUV, lutyuv, vf); REGISTER_FILTER(LUTYUV, lutyuv, vf);
REGISTER_FILTER (NEGATE, negate, vf); REGISTER_FILTER(NEGATE, negate, vf);
REGISTER_FILTER (NOFORMAT, noformat, vf); REGISTER_FILTER(NOFORMAT, noformat, vf);
REGISTER_FILTER (NULL, null, vf); REGISTER_FILTER(NULL, null, vf);
REGISTER_FILTER (OCV, ocv, vf); REGISTER_FILTER(OCV, ocv, vf);
REGISTER_FILTER (OVERLAY, overlay, vf); REGISTER_FILTER(OVERLAY, overlay, vf);
REGISTER_FILTER (PAD, pad, vf); REGISTER_FILTER(PAD, pad, vf);
REGISTER_FILTER (PIXDESCTEST, pixdesctest, vf); REGISTER_FILTER(PIXDESCTEST, pixdesctest, vf);
REGISTER_FILTER (SCALE, scale, vf); REGISTER_FILTER(SCALE, scale, vf);
REGISTER_FILTER (SELECT, select, vf); REGISTER_FILTER(SELECT, select, vf);
REGISTER_FILTER (SETDAR, setdar, vf); REGISTER_FILTER(SETDAR, setdar, vf);
REGISTER_FILTER (SETPTS, setpts, vf); REGISTER_FILTER(SETPTS, setpts, vf);
REGISTER_FILTER (SETSAR, setsar, vf); REGISTER_FILTER(SETSAR, setsar, vf);
REGISTER_FILTER (SETTB, settb, vf); REGISTER_FILTER(SETTB, settb, vf);
REGISTER_FILTER (SHOWINFO, showinfo, vf); REGISTER_FILTER(SHOWINFO, showinfo, vf);
REGISTER_FILTER (SPLIT, split, vf); REGISTER_FILTER(SPLIT, split, vf);
REGISTER_FILTER (TRANSPOSE, transpose, vf); REGISTER_FILTER(TRANSPOSE, transpose, vf);
REGISTER_FILTER (UNSHARP, unsharp, vf); REGISTER_FILTER(UNSHARP, unsharp, vf);
REGISTER_FILTER (VFLIP, vflip, vf); REGISTER_FILTER(VFLIP, vflip, vf);
REGISTER_FILTER (YADIF, yadif, vf); REGISTER_FILTER(YADIF, yadif, vf);
REGISTER_FILTER (COLOR, color, vsrc); REGISTER_FILTER(COLOR, color, vsrc);
REGISTER_FILTER (FREI0R, frei0r_src, vsrc); REGISTER_FILTER(FREI0R, frei0r_src, vsrc);
REGISTER_FILTER (MOVIE, movie, vsrc); REGISTER_FILTER(MOVIE, movie, vsrc);
REGISTER_FILTER (NULLSRC, nullsrc, vsrc); REGISTER_FILTER(NULLSRC, nullsrc, vsrc);
REGISTER_FILTER (RGBTESTSRC, rgbtestsrc, vsrc); REGISTER_FILTER(RGBTESTSRC, rgbtestsrc, vsrc);
REGISTER_FILTER (TESTSRC, testsrc, vsrc); REGISTER_FILTER(TESTSRC, testsrc, vsrc);
REGISTER_FILTER (NULLSINK, nullsink, vsink); REGISTER_FILTER(NULLSINK, nullsink, vsink);
/* those filters are part of public or internal API => registered /* those filters are part of public or internal API => registered
* unconditionally */ * unconditionally */

473
libavformat/allformats.c
Unescape View File

@ -18,25 +18,38 @@
* License along with Libav; if not, write to the Free Software * License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "avformat.h" #include "avformat.h"
#include "rtp.h" #include "rtp.h"
#include "rdt.h" #include "rdt.h"
#include "url.h" #include "url.h"
#include "version.h" #include "version.h"
#define REGISTER_MUXER(X,x) { \ #define REGISTER_MUXER(X, x) \
extern AVOutputFormat ff_##x##_muxer; \ { \
if(CONFIG_##X##_MUXER) av_register_output_format(&ff_##x##_muxer); } extern AVOutputFormat ff_##x##_muxer; \
if (CONFIG_##X##_MUXER) \
av_register_output_format(&ff_##x##_muxer); \
}
#define REGISTER_DEMUXER(X,x) { \ #define REGISTER_DEMUXER(X, x) \
extern AVInputFormat ff_##x##_demuxer; \ { \
if(CONFIG_##X##_DEMUXER) av_register_input_format(&ff_##x##_demuxer); } extern AVInputFormat ff_##x##_demuxer; \
if (CONFIG_##X##_DEMUXER) \
av_register_input_format(&ff_##x##_demuxer); \
}
#define REGISTER_MUXDEMUX(X,x) REGISTER_MUXER(X,x); REGISTER_DEMUXER(X,x) #define REGISTER_MUXDEMUX(X, x) \
REGISTER_MUXER(X, x); \
REGISTER_DEMUXER(X,x)
#define REGISTER_PROTOCOL(X,x) { \ #define REGISTER_PROTOCOL(X, x) \
extern URLProtocol ff_##x##_protocol; \ { \
if(CONFIG_##X##_PROTOCOL) ffurl_register_protocol(&ff_##x##_protocol, sizeof(ff_##x##_protocol)); } extern URLProtocol ff_##x##_protocol; \
if (CONFIG_##X##_PROTOCOL) \
ffurl_register_protocol(&ff_##x##_protocol, \
sizeof(ff_##x##_protocol)); \
}
void av_register_all(void) void av_register_all(void)
{ {
@ -49,234 +62,234 @@ void av_register_all(void)
avcodec_register_all(); avcodec_register_all();
/* (de)muxers */ /* (de)muxers */
REGISTER_MUXER (A64, a64); REGISTER_MUXER (A64, a64);
REGISTER_DEMUXER (AAC, aac); REGISTER_DEMUXER (AAC, aac);
REGISTER_MUXDEMUX (AC3, ac3); REGISTER_MUXDEMUX(AC3, ac3);
REGISTER_MUXER (ADTS, adts); REGISTER_MUXER (ADTS, adts);
REGISTER_MUXDEMUX (ADX, adx); REGISTER_MUXDEMUX(ADX, adx);
REGISTER_DEMUXER (AEA, aea); REGISTER_DEMUXER (AEA, aea);
REGISTER_MUXDEMUX (AIFF, aiff); REGISTER_MUXDEMUX(AIFF, aiff);
REGISTER_MUXDEMUX (AMR, amr); REGISTER_MUXDEMUX(AMR, amr);
REGISTER_DEMUXER (ANM, anm); REGISTER_DEMUXER (ANM, anm);
REGISTER_DEMUXER (APC, apc); REGISTER_DEMUXER (APC, apc);
REGISTER_DEMUXER (APE, ape); REGISTER_DEMUXER (APE, ape);
REGISTER_MUXDEMUX (ASF, asf); REGISTER_MUXDEMUX(ASF, asf);
REGISTER_MUXDEMUX (ASS, ass); REGISTER_MUXDEMUX(ASS, ass);
REGISTER_MUXER (ASF_STREAM, asf_stream); REGISTER_MUXER (ASF_STREAM, asf_stream);
REGISTER_MUXDEMUX (AU, au); REGISTER_MUXDEMUX(AU, au);
REGISTER_MUXDEMUX (AVI, avi); REGISTER_MUXDEMUX(AVI, avi);
REGISTER_DEMUXER (AVISYNTH, avisynth); REGISTER_DEMUXER (AVISYNTH, avisynth);
REGISTER_MUXER (AVM2, avm2); REGISTER_MUXER (AVM2, avm2);
REGISTER_DEMUXER (AVS, avs); REGISTER_DEMUXER (AVS, avs);
REGISTER_DEMUXER (BETHSOFTVID, bethsoftvid); REGISTER_DEMUXER (BETHSOFTVID, bethsoftvid);
REGISTER_DEMUXER (BFI, bfi); REGISTER_DEMUXER (BFI, bfi);
REGISTER_DEMUXER (BINK, bink); REGISTER_DEMUXER (BINK, bink);
REGISTER_DEMUXER (BMV, bmv); REGISTER_DEMUXER (BMV, bmv);
REGISTER_DEMUXER (C93, c93); REGISTER_DEMUXER (C93, c93);
REGISTER_DEMUXER (CAF, caf); REGISTER_DEMUXER (CAF, caf);
REGISTER_MUXDEMUX (CAVSVIDEO, cavsvideo); REGISTER_MUXDEMUX(CAVSVIDEO, cavsvideo);
REGISTER_DEMUXER (CDG, cdg); REGISTER_DEMUXER (CDG, cdg);
REGISTER_DEMUXER (CDXL, cdxl); REGISTER_DEMUXER (CDXL, cdxl);
REGISTER_MUXER (CRC, crc); REGISTER_MUXER (CRC, crc);
REGISTER_MUXDEMUX (DAUD, daud); REGISTER_MUXDEMUX(DAUD, daud);
REGISTER_DEMUXER (DFA, dfa); REGISTER_DEMUXER (DFA, dfa);
REGISTER_MUXDEMUX (DIRAC, dirac); REGISTER_MUXDEMUX(DIRAC, dirac);
REGISTER_MUXDEMUX (DNXHD, dnxhd); REGISTER_MUXDEMUX(DNXHD, dnxhd);
REGISTER_DEMUXER (DSICIN, dsicin); REGISTER_DEMUXER (DSICIN, dsicin);
REGISTER_MUXDEMUX (DTS, dts); REGISTER_MUXDEMUX(DTS, dts);
REGISTER_MUXDEMUX (DV, dv); REGISTER_MUXDEMUX(DV, dv);
REGISTER_DEMUXER (DXA, dxa); REGISTER_DEMUXER (DXA, dxa);
REGISTER_DEMUXER (EA, ea); REGISTER_DEMUXER (EA, ea);
REGISTER_DEMUXER (EA_CDATA, ea_cdata); REGISTER_DEMUXER (EA_CDATA, ea_cdata);
REGISTER_MUXDEMUX (EAC3, eac3); REGISTER_MUXDEMUX(EAC3, eac3);
REGISTER_MUXDEMUX (FFM, ffm); REGISTER_MUXDEMUX(FFM, ffm);
REGISTER_MUXDEMUX (FFMETADATA, ffmetadata); REGISTER_MUXDEMUX(FFMETADATA, ffmetadata);
REGISTER_MUXDEMUX (FILMSTRIP, filmstrip); REGISTER_MUXDEMUX(FILMSTRIP, filmstrip);
REGISTER_MUXDEMUX (FLAC, flac); REGISTER_MUXDEMUX(FLAC, flac);
REGISTER_DEMUXER (FLIC, flic); REGISTER_DEMUXER (FLIC, flic);
REGISTER_MUXDEMUX (FLV, flv); REGISTER_MUXDEMUX(FLV, flv);
REGISTER_DEMUXER (FOURXM, fourxm); REGISTER_DEMUXER (FOURXM, fourxm);
REGISTER_MUXER (FRAMECRC, framecrc); REGISTER_MUXER (FRAMECRC, framecrc);
REGISTER_MUXER (FRAMEMD5, framemd5); REGISTER_MUXER (FRAMEMD5, framemd5);
REGISTER_MUXDEMUX (G722, g722); REGISTER_MUXDEMUX(G722, g722);
REGISTER_DEMUXER (G723_1, g723_1); REGISTER_DEMUXER (G723_1, g723_1);
REGISTER_MUXER (GIF, gif); REGISTER_MUXER (GIF, gif);
REGISTER_DEMUXER (GSM, gsm); REGISTER_DEMUXER (GSM, gsm);
REGISTER_MUXDEMUX (GXF, gxf); REGISTER_MUXDEMUX(GXF, gxf);
REGISTER_MUXDEMUX (H261, h261); REGISTER_MUXDEMUX(H261, h261);
REGISTER_MUXDEMUX (H263, h263); REGISTER_MUXDEMUX(H263, h263);
REGISTER_MUXDEMUX (H264, h264); REGISTER_MUXDEMUX(H264, h264);
REGISTER_MUXDEMUX (HLS, hls); REGISTER_MUXDEMUX(HLS, hls);
REGISTER_DEMUXER (IDCIN, idcin); REGISTER_DEMUXER (IDCIN, idcin);
REGISTER_DEMUXER (IFF, iff); REGISTER_DEMUXER (IFF, iff);
REGISTER_MUXDEMUX (ILBC, ilbc); REGISTER_MUXDEMUX(ILBC, ilbc);
REGISTER_MUXDEMUX (IMAGE2, image2); REGISTER_MUXDEMUX(IMAGE2, image2);
REGISTER_MUXDEMUX (IMAGE2PIPE, image2pipe); REGISTER_MUXDEMUX(IMAGE2PIPE, image2pipe);
REGISTER_DEMUXER (INGENIENT, ingenient); REGISTER_DEMUXER (INGENIENT, ingenient);
REGISTER_DEMUXER (IPMOVIE, ipmovie); REGISTER_DEMUXER (IPMOVIE, ipmovie);
REGISTER_MUXER (IPOD, ipod); REGISTER_MUXER (IPOD, ipod);
REGISTER_MUXER (ISMV, ismv); REGISTER_MUXER (ISMV, ismv);
REGISTER_DEMUXER (ISS, iss); REGISTER_DEMUXER (ISS, iss);
REGISTER_DEMUXER (IV8, iv8); REGISTER_DEMUXER (IV8, iv8);
REGISTER_MUXDEMUX (IVF, ivf); REGISTER_MUXDEMUX(IVF, ivf);
REGISTER_DEMUXER (JV, jv); REGISTER_DEMUXER (JV, jv);
REGISTER_MUXDEMUX (LATM, latm); REGISTER_MUXDEMUX(LATM, latm);
REGISTER_DEMUXER (LMLM4, lmlm4); REGISTER_DEMUXER (LMLM4, lmlm4);
REGISTER_DEMUXER (LXF, lxf); REGISTER_DEMUXER (LXF, lxf);
REGISTER_MUXDEMUX (M4V, m4v); REGISTER_MUXDEMUX(M4V, m4v);
REGISTER_MUXER (MD5, md5); REGISTER_MUXER (MD5, md5);
REGISTER_MUXDEMUX (MATROSKA, matroska); REGISTER_MUXDEMUX(MATROSKA, matroska);
REGISTER_MUXER (MATROSKA_AUDIO, matroska_audio); REGISTER_MUXER (MATROSKA_AUDIO, matroska_audio);
REGISTER_MUXDEMUX (MJPEG, mjpeg); REGISTER_MUXDEMUX(MJPEG, mjpeg);
REGISTER_MUXDEMUX (MLP, mlp); REGISTER_MUXDEMUX(MLP, mlp);
REGISTER_DEMUXER (MM, mm); REGISTER_DEMUXER (MM, mm);
REGISTER_MUXDEMUX (MMF, mmf); REGISTER_MUXDEMUX(MMF, mmf);
REGISTER_MUXDEMUX (MOV, mov); REGISTER_MUXDEMUX(MOV, mov);
REGISTER_MUXER (MP2, mp2); REGISTER_MUXER (MP2, mp2);
REGISTER_MUXDEMUX (MP3, mp3); REGISTER_MUXDEMUX(MP3, mp3);
REGISTER_MUXER (MP4, mp4); REGISTER_MUXER (MP4, mp4);
REGISTER_DEMUXER (MPC, mpc); REGISTER_DEMUXER (MPC, mpc);
REGISTER_DEMUXER (MPC8, mpc8); REGISTER_DEMUXER (MPC8, mpc8);
REGISTER_MUXER (MPEG1SYSTEM, mpeg1system); REGISTER_MUXER (MPEG1SYSTEM, mpeg1system);
REGISTER_MUXER (MPEG1VCD, mpeg1vcd); REGISTER_MUXER (MPEG1VCD, mpeg1vcd);
REGISTER_MUXER (MPEG1VIDEO, mpeg1video); REGISTER_MUXER (MPEG1VIDEO, mpeg1video);
REGISTER_MUXER (MPEG2DVD, mpeg2dvd); REGISTER_MUXER (MPEG2DVD, mpeg2dvd);
REGISTER_MUXER (MPEG2SVCD, mpeg2svcd); REGISTER_MUXER (MPEG2SVCD, mpeg2svcd);
REGISTER_MUXER (MPEG2VIDEO, mpeg2video); REGISTER_MUXER (MPEG2VIDEO, mpeg2video);
REGISTER_MUXER (MPEG2VOB, mpeg2vob); REGISTER_MUXER (MPEG2VOB, mpeg2vob);
REGISTER_DEMUXER (MPEGPS, mpegps); REGISTER_DEMUXER (MPEGPS, mpegps);
REGISTER_MUXDEMUX (MPEGTS, mpegts); REGISTER_MUXDEMUX(MPEGTS, mpegts);
REGISTER_DEMUXER (MPEGTSRAW, mpegtsraw); REGISTER_DEMUXER (MPEGTSRAW, mpegtsraw);
REGISTER_DEMUXER (MPEGVIDEO, mpegvideo); REGISTER_DEMUXER (MPEGVIDEO, mpegvideo);
REGISTER_MUXER (MPJPEG, mpjpeg); REGISTER_MUXER (MPJPEG, mpjpeg);
REGISTER_DEMUXER (MSNWC_TCP, msnwc_tcp); REGISTER_DEMUXER (MSNWC_TCP, msnwc_tcp);
REGISTER_DEMUXER (MTV, mtv); REGISTER_DEMUXER (MTV, mtv);
REGISTER_DEMUXER (MVI, mvi); REGISTER_DEMUXER (MVI, mvi);
REGISTER_MUXDEMUX (MXF, mxf); REGISTER_MUXDEMUX(MXF, mxf);
REGISTER_MUXER (MXF_D10, mxf_d10); REGISTER_MUXER (MXF_D10, mxf_d10);
REGISTER_DEMUXER (MXG, mxg); REGISTER_DEMUXER (MXG, mxg);
REGISTER_DEMUXER (NC, nc); REGISTER_DEMUXER (NC, nc);
REGISTER_DEMUXER (NSV, nsv); REGISTER_DEMUXER (NSV, nsv);
REGISTER_MUXER (NULL, null); REGISTER_MUXER (NULL, null);
REGISTER_MUXDEMUX (NUT, nut); REGISTER_MUXDEMUX(NUT, nut);
REGISTER_DEMUXER (NUV, nuv); REGISTER_DEMUXER (NUV, nuv);
REGISTER_MUXDEMUX (OGG, ogg); REGISTER_MUXDEMUX(OGG, ogg);
REGISTER_MUXDEMUX (OMA, oma); REGISTER_MUXDEMUX(OMA, oma);
REGISTER_MUXDEMUX (PCM_ALAW, pcm_alaw); REGISTER_MUXDEMUX(PCM_ALAW, pcm_alaw);
REGISTER_MUXDEMUX (PCM_MULAW, pcm_mulaw); REGISTER_MUXDEMUX(PCM_MULAW, pcm_mulaw);
REGISTER_MUXDEMUX (PCM_F64BE, pcm_f64be); REGISTER_MUXDEMUX(PCM_F64BE, pcm_f64be);
REGISTER_MUXDEMUX (PCM_F64LE, pcm_f64le); REGISTER_MUXDEMUX(PCM_F64LE, pcm_f64le);
REGISTER_MUXDEMUX (PCM_F32BE, pcm_f32be); REGISTER_MUXDEMUX(PCM_F32BE, pcm_f32be);
REGISTER_MUXDEMUX (PCM_F32LE, pcm_f32le); REGISTER_MUXDEMUX(PCM_F32LE, pcm_f32le);
REGISTER_MUXDEMUX (PCM_S32BE, pcm_s32be); REGISTER_MUXDEMUX(PCM_S32BE, pcm_s32be);
REGISTER_MUXDEMUX (PCM_S32LE, pcm_s32le); REGISTER_MUXDEMUX(PCM_S32LE, pcm_s32le);
REGISTER_MUXDEMUX (PCM_S24BE, pcm_s24be); REGISTER_MUXDEMUX(PCM_S24BE, pcm_s24be);
REGISTER_MUXDEMUX (PCM_S24LE, pcm_s24le); REGISTER_MUXDEMUX(PCM_S24LE, pcm_s24le);
REGISTER_MUXDEMUX (PCM_S16BE, pcm_s16be); REGISTER_MUXDEMUX(PCM_S16BE, pcm_s16be);
REGISTER_MUXDEMUX (PCM_S16LE, pcm_s16le); REGISTER_MUXDEMUX(PCM_S16LE, pcm_s16le);
REGISTER_MUXDEMUX (PCM_S8, pcm_s8); REGISTER_MUXDEMUX(PCM_S8, pcm_s8);
REGISTER_MUXDEMUX (PCM_U32BE, pcm_u32be); REGISTER_MUXDEMUX(PCM_U32BE, pcm_u32be);
REGISTER_MUXDEMUX (PCM_U32LE, pcm_u32le); REGISTER_MUXDEMUX(PCM_U32LE, pcm_u32le);
REGISTER_MUXDEMUX (PCM_U24BE, pcm_u24be); REGISTER_MUXDEMUX(PCM_U24BE, pcm_u24be);
REGISTER_MUXDEMUX (PCM_U24LE, pcm_u24le); REGISTER_MUXDEMUX(PCM_U24LE, pcm_u24le);
REGISTER_MUXDEMUX (PCM_U16BE, pcm_u16be); REGISTER_MUXDEMUX(PCM_U16BE, pcm_u16be);
REGISTER_MUXDEMUX (PCM_U16LE, pcm_u16le); REGISTER_MUXDEMUX(PCM_U16LE, pcm_u16le);
REGISTER_MUXDEMUX (PCM_U8, pcm_u8); REGISTER_MUXDEMUX(PCM_U8, pcm_u8);
REGISTER_DEMUXER (PMP, pmp); REGISTER_DEMUXER (PMP, pmp);
REGISTER_MUXER (PSP, psp); REGISTER_MUXER (PSP, psp);
REGISTER_DEMUXER (PVA, pva); REGISTER_DEMUXER (PVA, pva);
REGISTER_DEMUXER (QCP, qcp); REGISTER_DEMUXER (QCP, qcp);
REGISTER_DEMUXER (R3D, r3d); REGISTER_DEMUXER (R3D, r3d);
REGISTER_MUXDEMUX (RAWVIDEO, rawvideo); REGISTER_MUXDEMUX(RAWVIDEO, rawvideo);
REGISTER_DEMUXER (RL2, rl2); REGISTER_DEMUXER (RL2, rl2);
REGISTER_MUXDEMUX (RM, rm); REGISTER_MUXDEMUX(RM, rm);
REGISTER_MUXDEMUX (ROQ, roq); REGISTER_MUXDEMUX(ROQ, roq);
REGISTER_DEMUXER (RPL, rpl); REGISTER_DEMUXER (RPL, rpl);
REGISTER_MUXDEMUX (RSO, rso); REGISTER_MUXDEMUX(RSO, rso);
REGISTER_MUXDEMUX (RTP, rtp); REGISTER_MUXDEMUX(RTP, rtp);
REGISTER_MUXDEMUX (RTSP, rtsp); REGISTER_MUXDEMUX(RTSP, rtsp);
REGISTER_MUXDEMUX (SAP, sap); REGISTER_MUXDEMUX(SAP, sap);
REGISTER_DEMUXER (SDP, sdp); REGISTER_DEMUXER (SDP, sdp);
#if CONFIG_RTPDEC #if CONFIG_RTPDEC
av_register_rtp_dynamic_payload_handlers(); av_register_rtp_dynamic_payload_handlers();
av_register_rdt_dynamic_payload_handlers(); av_register_rdt_dynamic_payload_handlers();
#endif #endif
REGISTER_DEMUXER (SEGAFILM, segafilm); REGISTER_DEMUXER (SEGAFILM, segafilm);
REGISTER_MUXER (SEGMENT, segment); REGISTER_MUXER (SEGMENT, segment);
REGISTER_DEMUXER (SHORTEN, shorten); REGISTER_DEMUXER (SHORTEN, shorten);
REGISTER_DEMUXER (SIFF, siff); REGISTER_DEMUXER (SIFF, siff);
REGISTER_DEMUXER (SMACKER, smacker); REGISTER_DEMUXER (SMACKER, smacker);
REGISTER_MUXDEMUX (SMJPEG, smjpeg); REGISTER_MUXDEMUX(SMJPEG, smjpeg);
REGISTER_MUXER (SMOOTHSTREAMING, smoothstreaming); REGISTER_MUXER (SMOOTHSTREAMING, smoothstreaming);
REGISTER_DEMUXER (SOL, sol); REGISTER_DEMUXER (SOL, sol);
REGISTER_MUXDEMUX (SOX, sox); REGISTER_MUXDEMUX(SOX, sox);
REGISTER_MUXDEMUX (SPDIF, spdif); REGISTER_MUXDEMUX(SPDIF, spdif);
REGISTER_MUXDEMUX (SRT, srt); REGISTER_MUXDEMUX(SRT, srt);
REGISTER_DEMUXER (STR, str); REGISTER_DEMUXER (STR, str);
REGISTER_MUXDEMUX (SWF, swf); REGISTER_MUXDEMUX(SWF, swf);
REGISTER_DEMUXER (TAK, tak); REGISTER_DEMUXER (TAK, tak);
REGISTER_MUXER (TG2, tg2); REGISTER_MUXER (TG2, tg2);
REGISTER_MUXER (TGP, tgp); REGISTER_MUXER (TGP, tgp);
REGISTER_DEMUXER (THP, thp); REGISTER_DEMUXER (THP, thp);
REGISTER_DEMUXER (TIERTEXSEQ, tiertexseq); REGISTER_DEMUXER (TIERTEXSEQ, tiertexseq);
REGISTER_DEMUXER (TMV, tmv); REGISTER_DEMUXER (TMV, tmv);
REGISTER_MUXDEMUX (TRUEHD, truehd); REGISTER_MUXDEMUX(TRUEHD, truehd);
REGISTER_DEMUXER (TTA, tta); REGISTER_DEMUXER (TTA, tta);
REGISTER_DEMUXER (TXD, txd); REGISTER_DEMUXER (TXD, txd);
REGISTER_DEMUXER (TTY, tty); REGISTER_DEMUXER (TTY, tty);
REGISTER_DEMUXER (VC1, vc1); REGISTER_DEMUXER (VC1, vc1);
REGISTER_MUXDEMUX (VC1T, vc1t); REGISTER_MUXDEMUX(VC1T, vc1t);
REGISTER_DEMUXER (VMD, vmd); REGISTER_DEMUXER (VMD, vmd);
REGISTER_MUXDEMUX (VOC, voc); REGISTER_MUXDEMUX(VOC, voc);
REGISTER_DEMUXER (VQF, vqf); REGISTER_DEMUXER (VQF, vqf);
REGISTER_DEMUXER (W64, w64); REGISTER_DEMUXER (W64, w64);
REGISTER_MUXDEMUX (WAV, wav); REGISTER_MUXDEMUX(WAV, wav);
REGISTER_DEMUXER (WC3, wc3); REGISTER_DEMUXER (WC3, wc3);
REGISTER_MUXER (WEBM, webm); REGISTER_MUXER (WEBM, webm);
REGISTER_DEMUXER (WSAUD, wsaud); REGISTER_DEMUXER (WSAUD, wsaud);
REGISTER_DEMUXER (WSVQA, wsvqa); REGISTER_DEMUXER (WSVQA, wsvqa);
REGISTER_DEMUXER (WTV, wtv); REGISTER_DEMUXER (WTV, wtv);
REGISTER_DEMUXER (WV, wv); REGISTER_DEMUXER (WV, wv);
REGISTER_DEMUXER (XA, xa); REGISTER_DEMUXER (XA, xa);
REGISTER_DEMUXER (XMV, xmv); REGISTER_DEMUXER (XMV, xmv);
REGISTER_DEMUXER (XWMA, xwma); REGISTER_DEMUXER (XWMA, xwma);
REGISTER_DEMUXER (YOP, yop); REGISTER_DEMUXER (YOP, yop);
REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe); REGISTER_MUXDEMUX(YUV4MPEGPIPE, yuv4mpegpipe);
/* protocols */ /* protocols */
#if FF_API_APPLEHTTP_PROTO #if FF_API_APPLEHTTP_PROTO
REGISTER_PROTOCOL (APPLEHTTP, applehttp); REGISTER_PROTOCOL(APPLEHTTP, applehttp);
#endif #endif
REGISTER_PROTOCOL (CONCAT, concat); REGISTER_PROTOCOL(CONCAT, concat);
REGISTER_PROTOCOL (CRYPTO, crypto); REGISTER_PROTOCOL(CRYPTO, crypto);
REGISTER_PROTOCOL (FFRTMPCRYPT, ffrtmpcrypt); REGISTER_PROTOCOL(FFRTMPCRYPT, ffrtmpcrypt);
REGISTER_PROTOCOL (FFRTMPHTTP, ffrtmphttp); REGISTER_PROTOCOL(FFRTMPHTTP, ffrtmphttp);
REGISTER_PROTOCOL (FILE, file); REGISTER_PROTOCOL(FILE, file);
REGISTER_PROTOCOL (GOPHER, gopher); REGISTER_PROTOCOL(GOPHER, gopher);
REGISTER_PROTOCOL (HLS, hls); REGISTER_PROTOCOL(HLS, hls);
REGISTER_PROTOCOL (HTTP, http); REGISTER_PROTOCOL(HTTP, http);
REGISTER_PROTOCOL (HTTPPROXY, httpproxy); REGISTER_PROTOCOL(HTTPPROXY, httpproxy);
REGISTER_PROTOCOL (HTTPS, https); REGISTER_PROTOCOL(HTTPS, https);
REGISTER_PROTOCOL (MMSH, mmsh); REGISTER_PROTOCOL(MMSH, mmsh);
REGISTER_PROTOCOL (MMST, mmst); REGISTER_PROTOCOL(MMST, mmst);
REGISTER_PROTOCOL (MD5, md5); REGISTER_PROTOCOL(MD5, md5);
REGISTER_PROTOCOL (PIPE, pipe); REGISTER_PROTOCOL(PIPE, pipe);
REGISTER_PROTOCOL (RTMP, rtmp); REGISTER_PROTOCOL(RTMP, rtmp);
REGISTER_PROTOCOL (RTMPE, rtmpe); REGISTER_PROTOCOL(RTMPE, rtmpe);
REGISTER_PROTOCOL (RTMPS, rtmps); REGISTER_PROTOCOL(RTMPS, rtmps);
REGISTER_PROTOCOL (RTMPT, rtmpt); REGISTER_PROTOCOL(RTMPT, rtmpt);
REGISTER_PROTOCOL (RTMPTE, rtmpte); REGISTER_PROTOCOL(RTMPTE, rtmpte);
REGISTER_PROTOCOL (RTMPTS, rtmpts); REGISTER_PROTOCOL(RTMPTS, rtmpts);
REGISTER_PROTOCOL (RTP, rtp); REGISTER_PROTOCOL(RTP, rtp);
REGISTER_PROTOCOL (SCTP, sctp); REGISTER_PROTOCOL(SCTP, sctp);
REGISTER_PROTOCOL (TCP, tcp); REGISTER_PROTOCOL(TCP, tcp);
REGISTER_PROTOCOL (TLS, tls); REGISTER_PROTOCOL(TLS, tls);
REGISTER_PROTOCOL (UDP, udp); REGISTER_PROTOCOL(UDP, udp);
/* external libraries */ /* external libraries */
REGISTER_PROTOCOL (LIBRTMP, librtmp); REGISTER_PROTOCOL(LIBRTMP, librtmp);
REGISTER_PROTOCOL (LIBRTMPE, librtmpe); REGISTER_PROTOCOL(LIBRTMPE, librtmpe);
REGISTER_PROTOCOL (LIBRTMPS, librtmps); REGISTER_PROTOCOL(LIBRTMPS, librtmps);
REGISTER_PROTOCOL (LIBRTMPT, librtmpt); REGISTER_PROTOCOL(LIBRTMPT, librtmpt);
REGISTER_PROTOCOL (LIBRTMPTE, librtmpte); REGISTER_PROTOCOL(LIBRTMPTE, librtmpte);
} }

Write Preview
Loading…
Cancel
Save