Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
  3.  * Copyright (c) 2002 Fabrice Bellard
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. /**
  23.  * @file
  24.  * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
  25.  */
  26.  
  27. #include "avcodec.h"
  28. #include "config.h"
  29.  
  30. #define REGISTER_HWACCEL(X, x)                                          \
  31.     {                                                                   \
  32.         extern AVHWAccel ff_##x##_hwaccel;                              \
  33.         if (CONFIG_##X##_HWACCEL)                                       \
  34.             av_register_hwaccel(&ff_##x##_hwaccel);                     \
  35.     }
  36.  
  37. #define REGISTER_ENCODER(X, x)                                          \
  38.     {                                                                   \
  39.         extern AVCodec ff_##x##_encoder;                                \
  40.         if (CONFIG_##X##_ENCODER)                                       \
  41.             avcodec_register(&ff_##x##_encoder);                        \
  42.     }
  43.  
  44. #define REGISTER_DECODER(X, x)                                          \
  45.     {                                                                   \
  46.         extern AVCodec ff_##x##_decoder;                                \
  47.         if (CONFIG_##X##_DECODER)                                       \
  48.             avcodec_register(&ff_##x##_decoder);                        \
  49.     }
  50.  
  51. #define REGISTER_ENCDEC(X, x) REGISTER_ENCODER(X, x); REGISTER_DECODER(X, x)
  52.  
  53. #define REGISTER_PARSER(X, x)                                           \
  54.     {                                                                   \
  55.         extern AVCodecParser ff_##x##_parser;                           \
  56.         if (CONFIG_##X##_PARSER)                                        \
  57.             av_register_codec_parser(&ff_##x##_parser);                 \
  58.     }
  59.  
  60. #define REGISTER_BSF(X, x)                                              \
  61.     {                                                                   \
  62.         extern AVBitStreamFilter ff_##x##_bsf;                          \
  63.         if (CONFIG_##X##_BSF)                                           \
  64.             av_register_bitstream_filter(&ff_##x##_bsf);                \
  65.     }
  66.  
  67. void avcodec_register_all(void)
  68. {
  69.     static int initialized;
  70.  
  71.     if (initialized)
  72.         return;
  73.     initialized = 1;
  74.  
  75.     /* hardware accelerators */
  76.     REGISTER_HWACCEL(H263_VAAPI,        h263_vaapi);
  77.     REGISTER_HWACCEL(H263_VDPAU,        h263_vdpau);
  78.     REGISTER_HWACCEL(H264_DXVA2,        h264_dxva2);
  79.     REGISTER_HWACCEL(H264_VAAPI,        h264_vaapi);
  80.     REGISTER_HWACCEL(H264_VDA,          h264_vda);
  81.     REGISTER_HWACCEL(H264_VDPAU,        h264_vdpau);
  82.     REGISTER_HWACCEL(MPEG1_VDPAU,       mpeg1_vdpau);
  83.     REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
  84.     REGISTER_HWACCEL(MPEG2_VAAPI,       mpeg2_vaapi);
  85.     REGISTER_HWACCEL(MPEG2_VDPAU,       mpeg2_vdpau);
  86.     REGISTER_HWACCEL(MPEG4_VAAPI,       mpeg4_vaapi);
  87.     REGISTER_HWACCEL(MPEG4_VDPAU,       mpeg4_vdpau);
  88.     REGISTER_HWACCEL(VC1_DXVA2,         vc1_dxva2);
  89.     REGISTER_HWACCEL(VC1_VAAPI,         vc1_vaapi);
  90.     REGISTER_HWACCEL(VC1_VDPAU,         vc1_vdpau);
  91.     REGISTER_HWACCEL(WMV3_DXVA2,        wmv3_dxva2);
  92.     REGISTER_HWACCEL(WMV3_VAAPI,        wmv3_vaapi);
  93.     REGISTER_HWACCEL(WMV3_VDPAU,        wmv3_vdpau);
  94.  
  95.     /* video codecs */
  96.     REGISTER_ENCODER(A64MULTI,          a64multi);
  97.     REGISTER_ENCODER(A64MULTI5,         a64multi5);
  98.     REGISTER_DECODER(AASC,              aasc);
  99.     REGISTER_DECODER(AIC,               aic);
  100.     REGISTER_ENCDEC (AMV,               amv);
  101.     REGISTER_DECODER(ANM,               anm);
  102.     REGISTER_DECODER(ANSI,              ansi);
  103.     REGISTER_ENCDEC (ASV1,              asv1);
  104.     REGISTER_ENCDEC (ASV2,              asv2);
  105.     REGISTER_DECODER(AURA,              aura);
  106.     REGISTER_DECODER(AURA2,             aura2);
  107.     REGISTER_ENCDEC (AVRP,              avrp);
  108.     REGISTER_DECODER(AVRN,              avrn);
  109.     REGISTER_DECODER(AVS,               avs);
  110.     REGISTER_ENCDEC (AVUI,              avui);
  111.     REGISTER_ENCDEC (AYUV,              ayuv);
  112.     REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
  113.     REGISTER_DECODER(BFI,               bfi);
  114.     REGISTER_DECODER(BINK,              bink);
  115.     REGISTER_ENCDEC (BMP,               bmp);
  116.     REGISTER_DECODER(BMV_VIDEO,         bmv_video);
  117.     REGISTER_DECODER(BRENDER_PIX,       brender_pix);
  118.     REGISTER_DECODER(C93,               c93);
  119.     REGISTER_DECODER(CAVS,              cavs);
  120.     REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
  121.     REGISTER_DECODER(CDXL,              cdxl);
  122.     REGISTER_DECODER(CINEPAK,           cinepak);
  123.     REGISTER_ENCDEC (CLJR,              cljr);
  124.     REGISTER_DECODER(CLLC,              cllc);
  125.     REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
  126.     REGISTER_DECODER(CPIA,              cpia);
  127.     REGISTER_DECODER(CSCD,              cscd);
  128.     REGISTER_DECODER(CYUV,              cyuv);
  129.     REGISTER_DECODER(DFA,               dfa);
  130.     REGISTER_DECODER(DIRAC,             dirac);
  131.     REGISTER_ENCDEC (DNXHD,             dnxhd);
  132.     REGISTER_ENCDEC (DPX,               dpx);
  133.     REGISTER_DECODER(DSICINVIDEO,       dsicinvideo);
  134.     REGISTER_ENCDEC (DVVIDEO,           dvvideo);
  135.     REGISTER_DECODER(DXA,               dxa);
  136.     REGISTER_DECODER(DXTORY,            dxtory);
  137.     REGISTER_DECODER(EACMV,             eacmv);
  138.     REGISTER_DECODER(EAMAD,             eamad);
  139.     REGISTER_DECODER(EATGQ,             eatgq);
  140.     REGISTER_DECODER(EATGV,             eatgv);
  141.     REGISTER_DECODER(EATQI,             eatqi);
  142.     REGISTER_DECODER(EIGHTBPS,          eightbps);
  143.     REGISTER_DECODER(EIGHTSVX_EXP,      eightsvx_exp);
  144.     REGISTER_DECODER(EIGHTSVX_FIB,      eightsvx_fib);
  145.     REGISTER_DECODER(ESCAPE124,         escape124);
  146.     REGISTER_DECODER(ESCAPE130,         escape130);
  147.     REGISTER_DECODER(EXR,               exr);
  148.     REGISTER_ENCDEC (FFV1,              ffv1);
  149.     REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
  150.     REGISTER_ENCDEC (FLASHSV,           flashsv);
  151.     REGISTER_ENCDEC (FLASHSV2,          flashsv2);
  152.     REGISTER_DECODER(FLIC,              flic);
  153.     REGISTER_ENCDEC (FLV,               flv);
  154.     REGISTER_DECODER(FOURXM,            fourxm);
  155.     REGISTER_DECODER(FRAPS,             fraps);
  156.     REGISTER_DECODER(FRWU,              frwu);
  157.     REGISTER_DECODER(G2M,               g2m);
  158.     REGISTER_ENCDEC (GIF,               gif);
  159.     REGISTER_ENCDEC (H261,              h261);
  160.     REGISTER_ENCDEC (H263,              h263);
  161.     REGISTER_DECODER(H263I,             h263i);
  162.     REGISTER_ENCDEC (H263P,             h263p);
  163.     REGISTER_DECODER(H264,              h264);
  164.     REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);
  165.     REGISTER_DECODER(H264_VDA,          h264_vda);
  166.     REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
  167.     REGISTER_DECODER(HEVC,              hevc);
  168.     REGISTER_ENCDEC (HUFFYUV,           huffyuv);
  169.     REGISTER_DECODER(IDCIN,             idcin);
  170.     REGISTER_DECODER(IFF_BYTERUN1,      iff_byterun1);
  171.     REGISTER_DECODER(IFF_ILBM,          iff_ilbm);
  172.     REGISTER_DECODER(INDEO2,            indeo2);
  173.     REGISTER_DECODER(INDEO3,            indeo3);
  174.     REGISTER_DECODER(INDEO4,            indeo4);
  175.     REGISTER_DECODER(INDEO5,            indeo5);
  176.     REGISTER_DECODER(INTERPLAY_VIDEO,   interplay_video);
  177.     REGISTER_ENCDEC (JPEG2000,          jpeg2000);
  178.     REGISTER_ENCDEC (JPEGLS,            jpegls);
  179.     REGISTER_DECODER(JV,                jv);
  180.     REGISTER_DECODER(KGV1,              kgv1);
  181.     REGISTER_DECODER(KMVC,              kmvc);
  182.     REGISTER_DECODER(LAGARITH,          lagarith);
  183.     REGISTER_ENCODER(LJPEG,             ljpeg);
  184.     REGISTER_DECODER(LOCO,              loco);
  185.     REGISTER_DECODER(MDEC,              mdec);
  186.     REGISTER_DECODER(MIMIC,             mimic);
  187.     REGISTER_ENCDEC (MJPEG,             mjpeg);
  188.     REGISTER_DECODER(MJPEGB,            mjpegb);
  189.     REGISTER_DECODER(MMVIDEO,           mmvideo);
  190.     REGISTER_DECODER(MOTIONPIXELS,      motionpixels);
  191.     REGISTER_DECODER(MPEG_XVMC,         mpeg_xvmc);
  192.     REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
  193.     REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
  194.     REGISTER_ENCDEC (MPEG4,             mpeg4);
  195.     REGISTER_DECODER(MPEG4_CRYSTALHD,   mpeg4_crystalhd);
  196.     REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);
  197.     REGISTER_DECODER(MPEGVIDEO,         mpegvideo);
  198.     REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);
  199.     REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);
  200.     REGISTER_DECODER(MPEG2_CRYSTALHD,   mpeg2_crystalhd);
  201.     REGISTER_DECODER(MSA1,              msa1);
  202.     REGISTER_DECODER(MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
  203.     REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
  204.     REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
  205.     REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
  206.     REGISTER_DECODER(MSRLE,             msrle);
  207.     REGISTER_DECODER(MSS1,              mss1);
  208.     REGISTER_DECODER(MSS2,              mss2);
  209.     REGISTER_ENCDEC (MSVIDEO1,          msvideo1);
  210.     REGISTER_DECODER(MSZH,              mszh);
  211.     REGISTER_DECODER(MTS2,              mts2);
  212.     REGISTER_DECODER(MVC1,              mvc1);
  213.     REGISTER_DECODER(MVC2,              mvc2);
  214.     REGISTER_DECODER(MXPEG,             mxpeg);
  215.     REGISTER_DECODER(NUV,               nuv);
  216.     REGISTER_DECODER(PAF_VIDEO,         paf_video);
  217.     REGISTER_ENCDEC (PAM,               pam);
  218.     REGISTER_ENCDEC (PBM,               pbm);
  219.     REGISTER_ENCDEC (PCX,               pcx);
  220.     REGISTER_ENCDEC (PGM,               pgm);
  221.     REGISTER_ENCDEC (PGMYUV,            pgmyuv);
  222.     REGISTER_DECODER(PICTOR,            pictor);
  223.     REGISTER_ENCDEC (PNG,               png);
  224.     REGISTER_ENCDEC (PPM,               ppm);
  225.     REGISTER_ENCDEC (PRORES,            prores);
  226.     REGISTER_ENCODER(PRORES_AW,         prores_aw);
  227.     REGISTER_ENCODER(PRORES_KS,         prores_ks);
  228.     REGISTER_DECODER(PRORES_LGPL,       prores_lgpl);
  229.     REGISTER_DECODER(PTX,               ptx);
  230.     REGISTER_DECODER(QDRAW,             qdraw);
  231.     REGISTER_DECODER(QPEG,              qpeg);
  232.     REGISTER_ENCDEC (QTRLE,             qtrle);
  233.     REGISTER_ENCDEC (R10K,              r10k);
  234.     REGISTER_ENCDEC (R210,              r210);
  235.     REGISTER_ENCDEC (RAWVIDEO,          rawvideo);
  236.     REGISTER_DECODER(RL2,               rl2);
  237.     REGISTER_ENCDEC (ROQ,               roq);
  238.     REGISTER_DECODER(RPZA,              rpza);
  239.     REGISTER_ENCDEC (RV10,              rv10);
  240.     REGISTER_ENCDEC (RV20,              rv20);
  241.     REGISTER_DECODER(RV30,              rv30);
  242.     REGISTER_DECODER(RV40,              rv40);
  243.     REGISTER_ENCDEC (S302M,             s302m);
  244.     REGISTER_DECODER(SANM,              sanm);
  245.     REGISTER_ENCDEC (SGI,               sgi);
  246.     REGISTER_DECODER(SGIRLE,            sgirle);
  247.     REGISTER_DECODER(SMACKER,           smacker);
  248.     REGISTER_DECODER(SMC,               smc);
  249.     REGISTER_DECODER(SMVJPEG,           smvjpeg);
  250.     REGISTER_ENCDEC (SNOW,              snow);
  251.     REGISTER_DECODER(SP5X,              sp5x);
  252.     REGISTER_ENCDEC (SUNRAST,           sunrast);
  253.     REGISTER_ENCDEC (SVQ1,              svq1);
  254.     REGISTER_DECODER(SVQ3,              svq3);
  255.     REGISTER_ENCDEC (TARGA,             targa);
  256.     REGISTER_DECODER(TARGA_Y216,        targa_y216);
  257.     REGISTER_DECODER(THEORA,            theora);
  258.     REGISTER_DECODER(THP,               thp);
  259.     REGISTER_DECODER(TIERTEXSEQVIDEO,   tiertexseqvideo);
  260.     REGISTER_ENCDEC (TIFF,              tiff);
  261.     REGISTER_DECODER(TMV,               tmv);
  262.     REGISTER_DECODER(TRUEMOTION1,       truemotion1);
  263.     REGISTER_DECODER(TRUEMOTION2,       truemotion2);
  264.     REGISTER_DECODER(TSCC,              tscc);
  265.     REGISTER_DECODER(TSCC2,             tscc2);
  266.     REGISTER_DECODER(TXD,               txd);
  267.     REGISTER_DECODER(ULTI,              ulti);
  268.     REGISTER_ENCDEC (UTVIDEO,           utvideo);
  269.     REGISTER_ENCDEC (V210,              v210);
  270.     REGISTER_DECODER(V210X,             v210x);
  271.     REGISTER_ENCDEC (V308,              v308);
  272.     REGISTER_ENCDEC (V408,              v408);
  273.     REGISTER_ENCDEC (V410,              v410);
  274.     REGISTER_DECODER(VB,                vb);
  275.     REGISTER_DECODER(VBLE,              vble);
  276.     REGISTER_DECODER(VC1,               vc1);
  277.     REGISTER_DECODER(VC1_CRYSTALHD,     vc1_crystalhd);
  278.     REGISTER_DECODER(VC1_VDPAU,         vc1_vdpau);
  279.     REGISTER_DECODER(VC1IMAGE,          vc1image);
  280.     REGISTER_DECODER(VCR1,              vcr1);
  281.     REGISTER_DECODER(VMDVIDEO,          vmdvideo);
  282.     REGISTER_DECODER(VMNC,              vmnc);
  283.     REGISTER_DECODER(VP3,               vp3);
  284.     REGISTER_DECODER(VP5,               vp5);
  285.     REGISTER_DECODER(VP6,               vp6);
  286.     REGISTER_DECODER(VP6A,              vp6a);
  287.     REGISTER_DECODER(VP6F,              vp6f);
  288.     REGISTER_DECODER(VP8,               vp8);
  289.     REGISTER_DECODER(VP9,               vp9);
  290.     REGISTER_DECODER(VQA,               vqa);
  291.     REGISTER_DECODER(WEBP,              webp);
  292.     REGISTER_ENCDEC (WMV1,              wmv1);
  293.     REGISTER_ENCDEC (WMV2,              wmv2);
  294.     REGISTER_DECODER(WMV3,              wmv3);
  295.     REGISTER_DECODER(WMV3_CRYSTALHD,    wmv3_crystalhd);
  296.     REGISTER_DECODER(WMV3_VDPAU,        wmv3_vdpau);
  297.     REGISTER_DECODER(WMV3IMAGE,         wmv3image);
  298.     REGISTER_DECODER(WNV1,              wnv1);
  299.     REGISTER_DECODER(XAN_WC3,           xan_wc3);
  300.     REGISTER_DECODER(XAN_WC4,           xan_wc4);
  301.     REGISTER_ENCDEC (XBM,               xbm);
  302.     REGISTER_ENCDEC (XFACE,             xface);
  303.     REGISTER_DECODER(XL,                xl);
  304.     REGISTER_ENCDEC (XWD,               xwd);
  305.     REGISTER_ENCDEC (Y41P,              y41p);
  306.     REGISTER_DECODER(YOP,               yop);
  307.     REGISTER_ENCDEC (YUV4,              yuv4);
  308.     REGISTER_DECODER(ZERO12V,           zero12v);
  309.     REGISTER_DECODER(ZEROCODEC,         zerocodec);
  310.     REGISTER_ENCDEC (ZLIB,              zlib);
  311.     REGISTER_ENCDEC (ZMBV,              zmbv);
  312.  
  313.     /* audio codecs */
  314.     REGISTER_ENCDEC (AAC,               aac);
  315.     REGISTER_DECODER(AAC_LATM,          aac_latm);
  316.     REGISTER_ENCDEC (AC3,               ac3);
  317.     REGISTER_ENCODER(AC3_FIXED,         ac3_fixed);
  318.     REGISTER_ENCDEC (ALAC,              alac);
  319.     REGISTER_DECODER(ALS,               als);
  320.     REGISTER_DECODER(AMRNB,             amrnb);
  321.     REGISTER_DECODER(AMRWB,             amrwb);
  322.     REGISTER_DECODER(APE,               ape);
  323.     REGISTER_DECODER(ATRAC1,            atrac1);
  324.     REGISTER_DECODER(ATRAC3,            atrac3);
  325.     REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
  326.     REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
  327.     REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
  328.     REGISTER_DECODER(COOK,              cook);
  329.     REGISTER_ENCDEC (DCA,               dca);
  330.     REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
  331.     REGISTER_ENCDEC (EAC3,              eac3);
  332.     REGISTER_DECODER(EVRC,              evrc);
  333.     REGISTER_DECODER(FFWAVESYNTH,       ffwavesynth);
  334.     REGISTER_ENCDEC (FLAC,              flac);
  335.     REGISTER_ENCDEC (G723_1,            g723_1);
  336.     REGISTER_DECODER(G729,              g729);
  337.     REGISTER_DECODER(GSM,               gsm);
  338.     REGISTER_DECODER(GSM_MS,            gsm_ms);
  339.     REGISTER_DECODER(IAC,               iac);
  340.     REGISTER_DECODER(IMC,               imc);
  341.     REGISTER_DECODER(MACE3,             mace3);
  342.     REGISTER_DECODER(MACE6,             mace6);
  343.     REGISTER_DECODER(METASOUND,         metasound);
  344.     REGISTER_DECODER(MLP,               mlp);
  345.     REGISTER_DECODER(MP1,               mp1);
  346.     REGISTER_DECODER(MP1FLOAT,          mp1float);
  347.     REGISTER_ENCDEC (MP2,               mp2);
  348.     REGISTER_DECODER(MP2FLOAT,          mp2float);
  349.     REGISTER_DECODER(MP3,               mp3);
  350.     REGISTER_DECODER(MP3FLOAT,          mp3float);
  351.     REGISTER_DECODER(MP3ADU,            mp3adu);
  352.     REGISTER_DECODER(MP3ADUFLOAT,       mp3adufloat);
  353.     REGISTER_DECODER(MP3ON4,            mp3on4);
  354.     REGISTER_DECODER(MP3ON4FLOAT,       mp3on4float);
  355.     REGISTER_DECODER(MPC7,              mpc7);
  356.     REGISTER_DECODER(MPC8,              mpc8);
  357.     REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
  358.     REGISTER_DECODER(PAF_AUDIO,         paf_audio);
  359.     REGISTER_DECODER(QCELP,             qcelp);
  360.     REGISTER_DECODER(QDM2,              qdm2);
  361.     REGISTER_ENCDEC (RA_144,            ra_144);
  362.     REGISTER_DECODER(RA_288,            ra_288);
  363.     REGISTER_DECODER(RALF,              ralf);
  364.     REGISTER_DECODER(SHORTEN,           shorten);
  365.     REGISTER_DECODER(SIPR,              sipr);
  366.     REGISTER_DECODER(SMACKAUD,          smackaud);
  367.     REGISTER_ENCDEC (SONIC,             sonic);
  368.     REGISTER_ENCODER(SONIC_LS,          sonic_ls);
  369.     REGISTER_DECODER(TAK,               tak);
  370.     REGISTER_DECODER(TRUEHD,            truehd);
  371.     REGISTER_DECODER(TRUESPEECH,        truespeech);
  372.     REGISTER_ENCDEC (TTA,               tta);
  373.     REGISTER_DECODER(TWINVQ,            twinvq);
  374.     REGISTER_DECODER(VMDAUDIO,          vmdaudio);
  375.     REGISTER_ENCDEC (VORBIS,            vorbis);
  376.     REGISTER_ENCDEC (WAVPACK,           wavpack);
  377.     REGISTER_DECODER(WMALOSSLESS,       wmalossless);
  378.     REGISTER_DECODER(WMAPRO,            wmapro);
  379.     REGISTER_ENCDEC (WMAV1,             wmav1);
  380.     REGISTER_ENCDEC (WMAV2,             wmav2);
  381.     REGISTER_DECODER(WMAVOICE,          wmavoice);
  382.     REGISTER_DECODER(WS_SND1,           ws_snd1);
  383.  
  384.     /* PCM codecs */
  385.     REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
  386.     REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
  387.     REGISTER_DECODER(PCM_DVD,           pcm_dvd);
  388.     REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
  389.     REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
  390.     REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
  391.     REGISTER_ENCDEC (PCM_F64LE,         pcm_f64le);
  392.     REGISTER_DECODER(PCM_LXF,           pcm_lxf);
  393.     REGISTER_ENCDEC (PCM_MULAW,         pcm_mulaw);
  394.     REGISTER_ENCDEC (PCM_S8,            pcm_s8);
  395.     REGISTER_ENCDEC (PCM_S8_PLANAR,     pcm_s8_planar);
  396.     REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
  397.     REGISTER_ENCDEC (PCM_S16BE_PLANAR,  pcm_s16be_planar);
  398.     REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
  399.     REGISTER_ENCDEC (PCM_S16LE_PLANAR,  pcm_s16le_planar);
  400.     REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
  401.     REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
  402.     REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
  403.     REGISTER_ENCDEC (PCM_S24LE_PLANAR,  pcm_s24le_planar);
  404.     REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
  405.     REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
  406.     REGISTER_ENCDEC (PCM_S32LE_PLANAR,  pcm_s32le_planar);
  407.     REGISTER_ENCDEC (PCM_U8,            pcm_u8);
  408.     REGISTER_ENCDEC (PCM_U16BE,         pcm_u16be);
  409.     REGISTER_ENCDEC (PCM_U16LE,         pcm_u16le);
  410.     REGISTER_ENCDEC (PCM_U24BE,         pcm_u24be);
  411.     REGISTER_ENCDEC (PCM_U24LE,         pcm_u24le);
  412.     REGISTER_ENCDEC (PCM_U32BE,         pcm_u32be);
  413.     REGISTER_ENCDEC (PCM_U32LE,         pcm_u32le);
  414.     REGISTER_DECODER(PCM_ZORK,          pcm_zork);
  415.  
  416.     /* DPCM codecs */
  417.     REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
  418.     REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
  419.     REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
  420.     REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
  421.  
  422.     /* ADPCM codecs */
  423.     REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
  424.     REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
  425.     REGISTER_DECODER(ADPCM_AFC,         adpcm_afc);
  426.     REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
  427.     REGISTER_DECODER(ADPCM_DTK,         adpcm_dtk);
  428.     REGISTER_DECODER(ADPCM_EA,          adpcm_ea);
  429.     REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
  430.     REGISTER_DECODER(ADPCM_EA_R1,       adpcm_ea_r1);
  431.     REGISTER_DECODER(ADPCM_EA_R2,       adpcm_ea_r2);
  432.     REGISTER_DECODER(ADPCM_EA_R3,       adpcm_ea_r3);
  433.     REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
  434.     REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
  435.     REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
  436.     REGISTER_DECODER(ADPCM_G726LE,      adpcm_g726le);
  437.     REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
  438.     REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
  439.     REGISTER_DECODER(ADPCM_IMA_DK3,     adpcm_ima_dk3);
  440.     REGISTER_DECODER(ADPCM_IMA_DK4,     adpcm_ima_dk4);
  441.     REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
  442.     REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
  443.     REGISTER_DECODER(ADPCM_IMA_ISS,     adpcm_ima_iss);
  444.     REGISTER_DECODER(ADPCM_IMA_OKI,     adpcm_ima_oki);
  445.     REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
  446.     REGISTER_DECODER(ADPCM_IMA_RAD,     adpcm_ima_rad);
  447.     REGISTER_DECODER(ADPCM_IMA_SMJPEG,  adpcm_ima_smjpeg);
  448.     REGISTER_ENCDEC (ADPCM_IMA_WAV,     adpcm_ima_wav);
  449.     REGISTER_DECODER(ADPCM_IMA_WS,      adpcm_ima_ws);
  450.     REGISTER_ENCDEC (ADPCM_MS,          adpcm_ms);
  451.     REGISTER_DECODER(ADPCM_SBPRO_2,     adpcm_sbpro_2);
  452.     REGISTER_DECODER(ADPCM_SBPRO_3,     adpcm_sbpro_3);
  453.     REGISTER_DECODER(ADPCM_SBPRO_4,     adpcm_sbpro_4);
  454.     REGISTER_ENCDEC (ADPCM_SWF,         adpcm_swf);
  455.     REGISTER_DECODER(ADPCM_THP,         adpcm_thp);
  456.     REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
  457.     REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
  458.     REGISTER_DECODER(VIMA,              vima);
  459.  
  460.     /* subtitles */
  461.     REGISTER_ENCDEC (SSA,               ssa);
  462.     REGISTER_ENCDEC (ASS,               ass);
  463.     REGISTER_ENCDEC (DVBSUB,            dvbsub);
  464.     REGISTER_ENCDEC (DVDSUB,            dvdsub);
  465.     REGISTER_DECODER(JACOSUB,           jacosub);
  466.     REGISTER_DECODER(MICRODVD,          microdvd);
  467.     REGISTER_ENCDEC (MOVTEXT,           movtext);
  468.     REGISTER_DECODER(MPL2,              mpl2);
  469.     REGISTER_DECODER(PGSSUB,            pgssub);
  470.     REGISTER_DECODER(PJS,               pjs);
  471.     REGISTER_DECODER(REALTEXT,          realtext);
  472.     REGISTER_DECODER(SAMI,              sami);
  473.     REGISTER_ENCDEC (SRT,               srt);
  474.     REGISTER_ENCDEC (SUBRIP,            subrip);
  475.     REGISTER_DECODER(SUBVIEWER,         subviewer);
  476.     REGISTER_DECODER(SUBVIEWER1,        subviewer1);
  477.     REGISTER_DECODER(TEXT,              text);
  478.     REGISTER_DECODER(VPLAYER,           vplayer);
  479.     REGISTER_DECODER(WEBVTT,            webvtt);
  480.     REGISTER_ENCDEC (XSUB,              xsub);
  481.  
  482.     /* external libraries */
  483.     REGISTER_DECODER(LIBCELT,           libcelt);
  484.     REGISTER_ENCODER(LIBFAAC,           libfaac);
  485.     REGISTER_ENCDEC (LIBFDK_AAC,        libfdk_aac);
  486.     REGISTER_ENCDEC (LIBGSM,            libgsm);
  487.     REGISTER_ENCDEC (LIBGSM_MS,         libgsm_ms);
  488.     REGISTER_ENCDEC (LIBILBC,           libilbc);
  489.     REGISTER_ENCODER(LIBMP3LAME,        libmp3lame);
  490.     REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
  491.     REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
  492.     REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
  493.     REGISTER_ENCDEC (LIBOPUS,           libopus);
  494.     REGISTER_ENCDEC (LIBSCHROEDINGER,   libschroedinger);
  495.     REGISTER_ENCODER(LIBSHINE,          libshine);
  496.     REGISTER_ENCDEC (LIBSPEEX,          libspeex);
  497.     REGISTER_DECODER(LIBSTAGEFRIGHT_H264, libstagefright_h264);
  498.     REGISTER_ENCODER(LIBTHEORA,         libtheora);
  499.     REGISTER_ENCODER(LIBTWOLAME,        libtwolame);
  500.     REGISTER_ENCDEC (LIBUTVIDEO,        libutvideo);
  501.     REGISTER_ENCODER(LIBVO_AACENC,      libvo_aacenc);
  502.     REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
  503.     REGISTER_ENCDEC (LIBVORBIS,         libvorbis);
  504.     REGISTER_ENCDEC (LIBVPX_VP8,        libvpx_vp8);
  505.     REGISTER_ENCDEC (LIBVPX_VP9,        libvpx_vp9);
  506.     REGISTER_ENCODER(LIBWAVPACK,        libwavpack);
  507.     REGISTER_ENCODER(LIBX264,           libx264);
  508.     REGISTER_ENCODER(LIBX264RGB,        libx264rgb);
  509.     REGISTER_ENCODER(LIBXAVS,           libxavs);
  510.     REGISTER_ENCODER(LIBXVID,           libxvid);
  511.     REGISTER_DECODER(LIBZVBI_TELETEXT,  libzvbi_teletext);
  512.     REGISTER_ENCODER(LIBAACPLUS,        libaacplus);
  513.  
  514.     /* text */
  515.     REGISTER_DECODER(BINTEXT,           bintext);
  516.     REGISTER_DECODER(XBIN,              xbin);
  517.     REGISTER_DECODER(IDF,               idf);
  518.  
  519.     /* parsers */
  520.     REGISTER_PARSER(AAC,                aac);
  521.     REGISTER_PARSER(AAC_LATM,           aac_latm);
  522.     REGISTER_PARSER(AC3,                ac3);
  523.     REGISTER_PARSER(ADX,                adx);
  524.     REGISTER_PARSER(BMP,                bmp);
  525.     REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
  526.     REGISTER_PARSER(COOK,               cook);
  527.     REGISTER_PARSER(DCA,                dca);
  528.     REGISTER_PARSER(DIRAC,              dirac);
  529.     REGISTER_PARSER(DNXHD,              dnxhd);
  530.     REGISTER_PARSER(DPX,                dpx);
  531.     REGISTER_PARSER(DVBSUB,             dvbsub);
  532.     REGISTER_PARSER(DVDSUB,             dvdsub);
  533.     REGISTER_PARSER(DVD_NAV,            dvd_nav);
  534.     REGISTER_PARSER(FLAC,               flac);
  535.     REGISTER_PARSER(GSM,                gsm);
  536.     REGISTER_PARSER(H261,               h261);
  537.     REGISTER_PARSER(H263,               h263);
  538.     REGISTER_PARSER(H264,               h264);
  539.     REGISTER_PARSER(HEVC,               hevc);
  540.     REGISTER_PARSER(MJPEG,              mjpeg);
  541.     REGISTER_PARSER(MLP,                mlp);
  542.     REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
  543.     REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
  544.     REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
  545.     REGISTER_PARSER(PNG,                png);
  546.     REGISTER_PARSER(PNM,                pnm);
  547.     REGISTER_PARSER(RV30,               rv30);
  548.     REGISTER_PARSER(RV40,               rv40);
  549.     REGISTER_PARSER(TAK,                tak);
  550.     REGISTER_PARSER(VC1,                vc1);
  551.     REGISTER_PARSER(VORBIS,             vorbis);
  552.     REGISTER_PARSER(VP3,                vp3);
  553.     REGISTER_PARSER(VP8,                vp8);
  554.  
  555.     /* bitstream filters */
  556.     REGISTER_BSF(AAC_ADTSTOASC,         aac_adtstoasc);
  557.     REGISTER_BSF(CHOMP,                 chomp);
  558.     REGISTER_BSF(DUMP_EXTRADATA,        dump_extradata);
  559.     REGISTER_BSF(H264_MP4TOANNEXB,      h264_mp4toannexb);
  560.     REGISTER_BSF(IMX_DUMP_HEADER,       imx_dump_header);
  561.     REGISTER_BSF(MJPEG2JPEG,            mjpeg2jpeg);
  562.     REGISTER_BSF(MJPEGA_DUMP_HEADER,    mjpega_dump_header);
  563.     REGISTER_BSF(MP3_HEADER_COMPRESS,   mp3_header_compress);
  564.     REGISTER_BSF(MP3_HEADER_DECOMPRESS, mp3_header_decompress);
  565.     REGISTER_BSF(MOV2TEXTSUB,           mov2textsub);
  566.     REGISTER_BSF(NOISE,                 noise);
  567.     REGISTER_BSF(REMOVE_EXTRADATA,      remove_extradata);
  568.     REGISTER_BSF(TEXT2MOVSUB,           text2movsub);
  569. }
  570.