LCOV - code coverage report
Current view: top level - src/libavcodec - allcodecs.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 494 494 100.0 %
Date: 2017-06-23 19:00:59 Functions: 2 2 100.0 %

          Line data    Source code
       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 "config.h"
      28             : #include "libavutil/thread.h"
      29             : #include "avcodec.h"
      30             : #include "version.h"
      31             : 
      32             : #define REGISTER_HWACCEL(X, x)                                          \
      33             :     {                                                                   \
      34             :         extern AVHWAccel ff_##x##_hwaccel;                              \
      35             :         if (CONFIG_##X##_HWACCEL)                                       \
      36             :             av_register_hwaccel(&ff_##x##_hwaccel);                     \
      37             :     }
      38             : 
      39             : #define REGISTER_ENCODER(X, x)                                          \
      40             :     {                                                                   \
      41             :         extern AVCodec ff_##x##_encoder;                                \
      42             :         if (CONFIG_##X##_ENCODER)                                       \
      43             :             avcodec_register(&ff_##x##_encoder);                        \
      44             :     }
      45             : 
      46             : #define REGISTER_DECODER(X, x)                                          \
      47             :     {                                                                   \
      48             :         extern AVCodec ff_##x##_decoder;                                \
      49             :         if (CONFIG_##X##_DECODER)                                       \
      50             :             avcodec_register(&ff_##x##_decoder);                        \
      51             :     }
      52             : 
      53             : #define REGISTER_ENCDEC(X, x) REGISTER_ENCODER(X, x); 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        5348 : static void register_all(void)
      63             : {
      64             :     /* hardware accelerators */
      65             :     REGISTER_HWACCEL(H263_VAAPI,        h263_vaapi);
      66             :     REGISTER_HWACCEL(H263_VIDEOTOOLBOX, h263_videotoolbox);
      67        5348 :     REGISTER_HWACCEL(H264_CUVID,        h264_cuvid);
      68             :     REGISTER_HWACCEL(H264_D3D11VA,      h264_d3d11va);
      69             :     REGISTER_HWACCEL(H264_DXVA2,        h264_dxva2);
      70             :     REGISTER_HWACCEL(H264_MEDIACODEC,   h264_mediacodec);
      71             :     REGISTER_HWACCEL(H264_MMAL,         h264_mmal);
      72             :     REGISTER_HWACCEL(H264_QSV,          h264_qsv);
      73             :     REGISTER_HWACCEL(H264_VAAPI,        h264_vaapi);
      74             :     REGISTER_HWACCEL(H264_VDA,          h264_vda);
      75             :     REGISTER_HWACCEL(H264_VDA_OLD,      h264_vda_old);
      76             :     REGISTER_HWACCEL(H264_VDPAU,        h264_vdpau);
      77             :     REGISTER_HWACCEL(H264_VIDEOTOOLBOX, h264_videotoolbox);
      78        5348 :     REGISTER_HWACCEL(HEVC_CUVID,        hevc_cuvid);
      79             :     REGISTER_HWACCEL(HEVC_D3D11VA,      hevc_d3d11va);
      80             :     REGISTER_HWACCEL(HEVC_DXVA2,        hevc_dxva2);
      81             :     REGISTER_HWACCEL(HEVC_MEDIACODEC,   hevc_mediacodec);
      82             :     REGISTER_HWACCEL(HEVC_QSV,          hevc_qsv);
      83             :     REGISTER_HWACCEL(HEVC_VAAPI,        hevc_vaapi);
      84             :     REGISTER_HWACCEL(HEVC_VDPAU,        hevc_vdpau);
      85        5348 :     REGISTER_HWACCEL(MJPEG_CUVID,       mjpeg_cuvid);
      86        5348 :     REGISTER_HWACCEL(MPEG1_CUVID,       mpeg1_cuvid);
      87             :     REGISTER_HWACCEL(MPEG1_XVMC,        mpeg1_xvmc);
      88             :     REGISTER_HWACCEL(MPEG1_VDPAU,       mpeg1_vdpau);
      89             :     REGISTER_HWACCEL(MPEG1_VIDEOTOOLBOX, mpeg1_videotoolbox);
      90        5348 :     REGISTER_HWACCEL(MPEG2_CUVID,       mpeg2_cuvid);
      91             :     REGISTER_HWACCEL(MPEG2_XVMC,        mpeg2_xvmc);
      92             :     REGISTER_HWACCEL(MPEG2_D3D11VA,     mpeg2_d3d11va);
      93             :     REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
      94             :     REGISTER_HWACCEL(MPEG2_MMAL,        mpeg2_mmal);
      95             :     REGISTER_HWACCEL(MPEG2_QSV,         mpeg2_qsv);
      96             :     REGISTER_HWACCEL(MPEG2_VAAPI,       mpeg2_vaapi);
      97             :     REGISTER_HWACCEL(MPEG2_VDPAU,       mpeg2_vdpau);
      98             :     REGISTER_HWACCEL(MPEG2_VIDEOTOOLBOX, mpeg2_videotoolbox);
      99             :     REGISTER_HWACCEL(MPEG2_MEDIACODEC,  mpeg2_mediacodec);
     100        5348 :     REGISTER_HWACCEL(MPEG4_CUVID,       mpeg4_cuvid);
     101             :     REGISTER_HWACCEL(MPEG4_MEDIACODEC,  mpeg4_mediacodec);
     102             :     REGISTER_HWACCEL(MPEG4_MMAL,        mpeg4_mmal);
     103             :     REGISTER_HWACCEL(MPEG4_VAAPI,       mpeg4_vaapi);
     104             :     REGISTER_HWACCEL(MPEG4_VDPAU,       mpeg4_vdpau);
     105             :     REGISTER_HWACCEL(MPEG4_VIDEOTOOLBOX, mpeg4_videotoolbox);
     106        5348 :     REGISTER_HWACCEL(VC1_CUVID,         vc1_cuvid);
     107             :     REGISTER_HWACCEL(VC1_D3D11VA,       vc1_d3d11va);
     108             :     REGISTER_HWACCEL(VC1_DXVA2,         vc1_dxva2);
     109             :     REGISTER_HWACCEL(VC1_VAAPI,         vc1_vaapi);
     110             :     REGISTER_HWACCEL(VC1_VDPAU,         vc1_vdpau);
     111             :     REGISTER_HWACCEL(VC1_MMAL,          vc1_mmal);
     112             :     REGISTER_HWACCEL(VC1_QSV,           vc1_qsv);
     113        5348 :     REGISTER_HWACCEL(VP8_CUVID,         vp8_cuvid);
     114             :     REGISTER_HWACCEL(VP8_MEDIACODEC,    vp8_mediacodec);
     115             :     REGISTER_HWACCEL(VP8_QSV,           vp8_qsv);
     116        5348 :     REGISTER_HWACCEL(VP9_CUVID,         vp9_cuvid);
     117             :     REGISTER_HWACCEL(VP9_D3D11VA,       vp9_d3d11va);
     118             :     REGISTER_HWACCEL(VP9_DXVA2,         vp9_dxva2);
     119             :     REGISTER_HWACCEL(VP9_MEDIACODEC,    vp9_mediacodec);
     120             :     REGISTER_HWACCEL(VP9_VAAPI,         vp9_vaapi);
     121             :     REGISTER_HWACCEL(WMV3_D3D11VA,      wmv3_d3d11va);
     122             :     REGISTER_HWACCEL(WMV3_DXVA2,        wmv3_dxva2);
     123             :     REGISTER_HWACCEL(WMV3_VAAPI,        wmv3_vaapi);
     124             :     REGISTER_HWACCEL(WMV3_VDPAU,        wmv3_vdpau);
     125             : 
     126             :     /* video codecs */
     127        5348 :     REGISTER_ENCODER(A64MULTI,          a64multi);
     128        5348 :     REGISTER_ENCODER(A64MULTI5,         a64multi5);
     129        5348 :     REGISTER_DECODER(AASC,              aasc);
     130        5348 :     REGISTER_DECODER(AIC,               aic);
     131        5348 :     REGISTER_ENCDEC (ALIAS_PIX,         alias_pix);
     132        5348 :     REGISTER_ENCDEC (AMV,               amv);
     133        5348 :     REGISTER_DECODER(ANM,               anm);
     134        5348 :     REGISTER_DECODER(ANSI,              ansi);
     135        5348 :     REGISTER_ENCDEC (APNG,              apng);
     136        5348 :     REGISTER_ENCDEC (ASV1,              asv1);
     137        5348 :     REGISTER_ENCDEC (ASV2,              asv2);
     138        5348 :     REGISTER_DECODER(AURA,              aura);
     139        5348 :     REGISTER_DECODER(AURA2,             aura2);
     140        5348 :     REGISTER_ENCDEC (AVRP,              avrp);
     141        5348 :     REGISTER_DECODER(AVRN,              avrn);
     142        5348 :     REGISTER_DECODER(AVS,               avs);
     143        5348 :     REGISTER_ENCDEC (AVUI,              avui);
     144        5348 :     REGISTER_ENCDEC (AYUV,              ayuv);
     145        5348 :     REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
     146        5348 :     REGISTER_DECODER(BFI,               bfi);
     147        5348 :     REGISTER_DECODER(BINK,              bink);
     148        5348 :     REGISTER_ENCDEC (BMP,               bmp);
     149        5348 :     REGISTER_DECODER(BMV_VIDEO,         bmv_video);
     150        5348 :     REGISTER_DECODER(BRENDER_PIX,       brender_pix);
     151        5348 :     REGISTER_DECODER(C93,               c93);
     152        5348 :     REGISTER_DECODER(CAVS,              cavs);
     153        5348 :     REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
     154        5348 :     REGISTER_DECODER(CDXL,              cdxl);
     155        5348 :     REGISTER_DECODER(CFHD,              cfhd);
     156        5348 :     REGISTER_ENCDEC (CINEPAK,           cinepak);
     157        5348 :     REGISTER_DECODER(CLEARVIDEO,        clearvideo);
     158        5348 :     REGISTER_ENCDEC (CLJR,              cljr);
     159        5348 :     REGISTER_DECODER(CLLC,              cllc);
     160        5348 :     REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
     161        5348 :     REGISTER_DECODER(CPIA,              cpia);
     162        5348 :     REGISTER_DECODER(CSCD,              cscd);
     163        5348 :     REGISTER_DECODER(CYUV,              cyuv);
     164        5348 :     REGISTER_DECODER(DDS,               dds);
     165        5348 :     REGISTER_DECODER(DFA,               dfa);
     166        5348 :     REGISTER_DECODER(DIRAC,             dirac);
     167        5348 :     REGISTER_ENCDEC (DNXHD,             dnxhd);
     168        5348 :     REGISTER_ENCDEC (DPX,               dpx);
     169        5348 :     REGISTER_DECODER(DSICINVIDEO,       dsicinvideo);
     170        5348 :     REGISTER_DECODER(DVAUDIO,           dvaudio);
     171        5348 :     REGISTER_ENCDEC (DVVIDEO,           dvvideo);
     172        5348 :     REGISTER_DECODER(DXA,               dxa);
     173        5348 :     REGISTER_DECODER(DXTORY,            dxtory);
     174        5348 :     REGISTER_DECODER(DXV,               dxv);
     175        5348 :     REGISTER_DECODER(EACMV,             eacmv);
     176        5348 :     REGISTER_DECODER(EAMAD,             eamad);
     177        5348 :     REGISTER_DECODER(EATGQ,             eatgq);
     178        5348 :     REGISTER_DECODER(EATGV,             eatgv);
     179        5348 :     REGISTER_DECODER(EATQI,             eatqi);
     180        5348 :     REGISTER_DECODER(EIGHTBPS,          eightbps);
     181        5348 :     REGISTER_DECODER(EIGHTSVX_EXP,      eightsvx_exp);
     182        5348 :     REGISTER_DECODER(EIGHTSVX_FIB,      eightsvx_fib);
     183        5348 :     REGISTER_DECODER(ESCAPE124,         escape124);
     184        5348 :     REGISTER_DECODER(ESCAPE130,         escape130);
     185        5348 :     REGISTER_DECODER(EXR,               exr);
     186        5348 :     REGISTER_ENCDEC (FFV1,              ffv1);
     187        5348 :     REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
     188        5348 :     REGISTER_DECODER(FIC,               fic);
     189        5348 :     REGISTER_ENCDEC (FLASHSV,           flashsv);
     190        5348 :     REGISTER_ENCDEC (FLASHSV2,          flashsv2);
     191        5348 :     REGISTER_DECODER(FLIC,              flic);
     192        5348 :     REGISTER_ENCDEC (FLV,               flv);
     193        5348 :     REGISTER_DECODER(FMVC,              fmvc);
     194        5348 :     REGISTER_DECODER(FOURXM,            fourxm);
     195        5348 :     REGISTER_DECODER(FRAPS,             fraps);
     196        5348 :     REGISTER_DECODER(FRWU,              frwu);
     197        5348 :     REGISTER_DECODER(G2M,               g2m);
     198        5348 :     REGISTER_DECODER(GDV,               gdv);
     199        5348 :     REGISTER_ENCDEC (GIF,               gif);
     200        5348 :     REGISTER_ENCDEC (H261,              h261);
     201        5348 :     REGISTER_ENCDEC (H263,              h263);
     202        5348 :     REGISTER_DECODER(H263I,             h263i);
     203        5348 :     REGISTER_ENCDEC (H263P,             h263p);
     204        5348 :     REGISTER_DECODER(H264,              h264);
     205             :     REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);
     206             :     REGISTER_DECODER(H264_MEDIACODEC,   h264_mediacodec);
     207             :     REGISTER_DECODER(H264_MMAL,         h264_mmal);
     208             :     REGISTER_DECODER(H264_QSV,          h264_qsv);
     209             :     REGISTER_DECODER(H264_VDA,          h264_vda);
     210             : #if FF_API_VDPAU
     211             :     REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
     212             : #endif
     213        5348 :     REGISTER_ENCDEC (HAP,               hap);
     214        5348 :     REGISTER_DECODER(HEVC,              hevc);
     215             :     REGISTER_DECODER(HEVC_QSV,          hevc_qsv);
     216        5348 :     REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);
     217        5348 :     REGISTER_DECODER(HQ_HQA,            hq_hqa);
     218        5348 :     REGISTER_DECODER(HQX,               hqx);
     219        5348 :     REGISTER_ENCDEC (HUFFYUV,           huffyuv);
     220        5348 :     REGISTER_DECODER(IDCIN,             idcin);
     221        5348 :     REGISTER_DECODER(IFF_ILBM,          iff_ilbm);
     222        5348 :     REGISTER_DECODER(INDEO2,            indeo2);
     223        5348 :     REGISTER_DECODER(INDEO3,            indeo3);
     224        5348 :     REGISTER_DECODER(INDEO4,            indeo4);
     225        5348 :     REGISTER_DECODER(INDEO5,            indeo5);
     226        5348 :     REGISTER_DECODER(INTERPLAY_VIDEO,   interplay_video);
     227        5348 :     REGISTER_ENCDEC (JPEG2000,          jpeg2000);
     228        5348 :     REGISTER_ENCDEC (JPEGLS,            jpegls);
     229        5348 :     REGISTER_DECODER(JV,                jv);
     230        5348 :     REGISTER_DECODER(KGV1,              kgv1);
     231        5348 :     REGISTER_DECODER(KMVC,              kmvc);
     232        5348 :     REGISTER_DECODER(LAGARITH,          lagarith);
     233        5348 :     REGISTER_ENCODER(LJPEG,             ljpeg);
     234        5348 :     REGISTER_DECODER(LOCO,              loco);
     235        5348 :     REGISTER_DECODER(M101,              m101);
     236        5348 :     REGISTER_DECODER(MAGICYUV,          magicyuv);
     237        5348 :     REGISTER_DECODER(MDEC,              mdec);
     238        5348 :     REGISTER_DECODER(MIMIC,             mimic);
     239        5348 :     REGISTER_ENCDEC (MJPEG,             mjpeg);
     240        5348 :     REGISTER_DECODER(MJPEGB,            mjpegb);
     241        5348 :     REGISTER_DECODER(MMVIDEO,           mmvideo);
     242        5348 :     REGISTER_DECODER(MOTIONPIXELS,      motionpixels);
     243             : #if FF_API_XVMC
     244             :     REGISTER_DECODER(MPEG_XVMC,         mpeg_xvmc);
     245             : #endif /* FF_API_XVMC */
     246        5348 :     REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
     247        5348 :     REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
     248        5348 :     REGISTER_ENCDEC (MPEG4,             mpeg4);
     249             :     REGISTER_DECODER(MPEG4_CRYSTALHD,   mpeg4_crystalhd);
     250             :     REGISTER_DECODER(MPEG4_MMAL,        mpeg4_mmal);
     251             : #if FF_API_VDPAU
     252             :     REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);
     253             : #endif
     254        5348 :     REGISTER_DECODER(MPEGVIDEO,         mpegvideo);
     255             : #if FF_API_VDPAU
     256             :     REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);
     257             :     REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);
     258             : #endif
     259             :     REGISTER_DECODER(MPEG2_MMAL,        mpeg2_mmal);
     260             :     REGISTER_DECODER(MPEG2_CRYSTALHD,   mpeg2_crystalhd);
     261             :     REGISTER_DECODER(MPEG2_QSV,         mpeg2_qsv);
     262             :     REGISTER_DECODER(MPEG2_MEDIACODEC,  mpeg2_mediacodec);
     263        5348 :     REGISTER_DECODER(MSA1,              msa1);
     264        5348 :     REGISTER_DECODER(MSCC,              mscc);
     265        5348 :     REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
     266        5348 :     REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
     267        5348 :     REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
     268             :     REGISTER_DECODER(MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
     269        5348 :     REGISTER_DECODER(MSRLE,             msrle);
     270        5348 :     REGISTER_DECODER(MSS1,              mss1);
     271        5348 :     REGISTER_DECODER(MSS2,              mss2);
     272        5348 :     REGISTER_ENCDEC (MSVIDEO1,          msvideo1);
     273        5348 :     REGISTER_DECODER(MSZH,              mszh);
     274        5348 :     REGISTER_DECODER(MTS2,              mts2);
     275        5348 :     REGISTER_DECODER(MVC1,              mvc1);
     276        5348 :     REGISTER_DECODER(MVC2,              mvc2);
     277        5348 :     REGISTER_DECODER(MXPEG,             mxpeg);
     278        5348 :     REGISTER_DECODER(NUV,               nuv);
     279        5348 :     REGISTER_DECODER(PAF_VIDEO,         paf_video);
     280        5348 :     REGISTER_ENCDEC (PAM,               pam);
     281        5348 :     REGISTER_ENCDEC (PBM,               pbm);
     282        5348 :     REGISTER_ENCDEC (PCX,               pcx);
     283        5348 :     REGISTER_ENCDEC (PGM,               pgm);
     284        5348 :     REGISTER_ENCDEC (PGMYUV,            pgmyuv);
     285        5348 :     REGISTER_DECODER(PICTOR,            pictor);
     286        5348 :     REGISTER_DECODER(PIXLET,            pixlet);
     287        5348 :     REGISTER_ENCDEC (PNG,               png);
     288        5348 :     REGISTER_ENCDEC (PPM,               ppm);
     289        5348 :     REGISTER_ENCDEC (PRORES,            prores);
     290        5348 :     REGISTER_ENCODER(PRORES_AW,         prores_aw);
     291        5348 :     REGISTER_ENCODER(PRORES_KS,         prores_ks);
     292        5348 :     REGISTER_DECODER(PRORES_LGPL,       prores_lgpl);
     293        5348 :     REGISTER_DECODER(PSD,               psd);
     294        5348 :     REGISTER_DECODER(PTX,               ptx);
     295        5348 :     REGISTER_DECODER(QDRAW,             qdraw);
     296        5348 :     REGISTER_DECODER(QPEG,              qpeg);
     297        5348 :     REGISTER_ENCDEC (QTRLE,             qtrle);
     298        5348 :     REGISTER_ENCDEC (R10K,              r10k);
     299        5348 :     REGISTER_ENCDEC (R210,              r210);
     300        5348 :     REGISTER_ENCDEC (RAWVIDEO,          rawvideo);
     301        5348 :     REGISTER_DECODER(RL2,               rl2);
     302        5348 :     REGISTER_ENCDEC (ROQ,               roq);
     303        5348 :     REGISTER_DECODER(RPZA,              rpza);
     304        5348 :     REGISTER_DECODER(RSCC,              rscc);
     305        5348 :     REGISTER_ENCDEC (RV10,              rv10);
     306        5348 :     REGISTER_ENCDEC (RV20,              rv20);
     307        5348 :     REGISTER_DECODER(RV30,              rv30);
     308        5348 :     REGISTER_DECODER(RV40,              rv40);
     309        5348 :     REGISTER_ENCDEC (S302M,             s302m);
     310        5348 :     REGISTER_DECODER(SANM,              sanm);
     311        5348 :     REGISTER_DECODER(SCPR,              scpr);
     312        5348 :     REGISTER_DECODER(SCREENPRESSO,      screenpresso);
     313        5348 :     REGISTER_DECODER(SDX2_DPCM,         sdx2_dpcm);
     314        5348 :     REGISTER_ENCDEC (SGI,               sgi);
     315        5348 :     REGISTER_DECODER(SGIRLE,            sgirle);
     316        5348 :     REGISTER_DECODER(SHEERVIDEO,        sheervideo);
     317        5348 :     REGISTER_DECODER(SMACKER,           smacker);
     318        5348 :     REGISTER_DECODER(SMC,               smc);
     319        5348 :     REGISTER_DECODER(SMVJPEG,           smvjpeg);
     320        5348 :     REGISTER_ENCDEC (SNOW,              snow);
     321        5348 :     REGISTER_DECODER(SP5X,              sp5x);
     322        5348 :     REGISTER_DECODER(SPEEDHQ,           speedhq);
     323        5348 :     REGISTER_DECODER(SRGC,              srgc);
     324        5348 :     REGISTER_ENCDEC (SUNRAST,           sunrast);
     325        5348 :     REGISTER_ENCDEC (SVQ1,              svq1);
     326        5348 :     REGISTER_DECODER(SVQ3,              svq3);
     327        5348 :     REGISTER_ENCDEC (TARGA,             targa);
     328        5348 :     REGISTER_DECODER(TARGA_Y216,        targa_y216);
     329        5348 :     REGISTER_DECODER(TDSC,              tdsc);
     330        5348 :     REGISTER_DECODER(THEORA,            theora);
     331        5348 :     REGISTER_DECODER(THP,               thp);
     332        5348 :     REGISTER_DECODER(TIERTEXSEQVIDEO,   tiertexseqvideo);
     333        5348 :     REGISTER_ENCDEC (TIFF,              tiff);
     334        5348 :     REGISTER_DECODER(TMV,               tmv);
     335        5348 :     REGISTER_DECODER(TRUEMOTION1,       truemotion1);
     336        5348 :     REGISTER_DECODER(TRUEMOTION2,       truemotion2);
     337        5348 :     REGISTER_DECODER(TRUEMOTION2RT,     truemotion2rt);
     338        5348 :     REGISTER_DECODER(TSCC,              tscc);
     339        5348 :     REGISTER_DECODER(TSCC2,             tscc2);
     340        5348 :     REGISTER_DECODER(TXD,               txd);
     341        5348 :     REGISTER_DECODER(ULTI,              ulti);
     342        5348 :     REGISTER_ENCDEC (UTVIDEO,           utvideo);
     343        5348 :     REGISTER_ENCDEC (V210,              v210);
     344        5348 :     REGISTER_DECODER(V210X,             v210x);
     345        5348 :     REGISTER_ENCDEC (V308,              v308);
     346        5348 :     REGISTER_ENCDEC (V408,              v408);
     347        5348 :     REGISTER_ENCDEC (V410,              v410);
     348        5348 :     REGISTER_DECODER(VB,                vb);
     349        5348 :     REGISTER_DECODER(VBLE,              vble);
     350        5348 :     REGISTER_DECODER(VC1,               vc1);
     351             :     REGISTER_DECODER(VC1_CRYSTALHD,     vc1_crystalhd);
     352             : #if FF_API_VDPAU
     353             :     REGISTER_DECODER(VC1_VDPAU,         vc1_vdpau);
     354             : #endif
     355        5348 :     REGISTER_DECODER(VC1IMAGE,          vc1image);
     356             :     REGISTER_DECODER(VC1_MMAL,          vc1_mmal);
     357             :     REGISTER_DECODER(VC1_QSV,           vc1_qsv);
     358        5348 :     REGISTER_ENCODER(VC2,               vc2);
     359        5348 :     REGISTER_DECODER(VCR1,              vcr1);
     360        5348 :     REGISTER_DECODER(VMDVIDEO,          vmdvideo);
     361        5348 :     REGISTER_DECODER(VMNC,              vmnc);
     362        5348 :     REGISTER_DECODER(VP3,               vp3);
     363        5348 :     REGISTER_DECODER(VP5,               vp5);
     364        5348 :     REGISTER_DECODER(VP6,               vp6);
     365        5348 :     REGISTER_DECODER(VP6A,              vp6a);
     366        5348 :     REGISTER_DECODER(VP6F,              vp6f);
     367        5348 :     REGISTER_DECODER(VP7,               vp7);
     368        5348 :     REGISTER_DECODER(VP8,               vp8);
     369        5348 :     REGISTER_DECODER(VP9,               vp9);
     370        5348 :     REGISTER_DECODER(VQA,               vqa);
     371        5348 :     REGISTER_DECODER(BITPACKED,         bitpacked);
     372        5348 :     REGISTER_DECODER(WEBP,              webp);
     373        5348 :     REGISTER_ENCODER(WRAPPED_AVFRAME,   wrapped_avframe);
     374        5348 :     REGISTER_ENCDEC (WMV1,              wmv1);
     375        5348 :     REGISTER_ENCDEC (WMV2,              wmv2);
     376        5348 :     REGISTER_DECODER(WMV3,              wmv3);
     377             :     REGISTER_DECODER(WMV3_CRYSTALHD,    wmv3_crystalhd);
     378             : #if FF_API_VDPAU
     379             :     REGISTER_DECODER(WMV3_VDPAU,        wmv3_vdpau);
     380             : #endif
     381        5348 :     REGISTER_DECODER(WMV3IMAGE,         wmv3image);
     382        5348 :     REGISTER_DECODER(WNV1,              wnv1);
     383        5348 :     REGISTER_DECODER(XAN_WC3,           xan_wc3);
     384        5348 :     REGISTER_DECODER(XAN_WC4,           xan_wc4);
     385        5348 :     REGISTER_ENCDEC (XBM,               xbm);
     386        5348 :     REGISTER_ENCDEC (XFACE,             xface);
     387        5348 :     REGISTER_DECODER(XL,                xl);
     388        5348 :     REGISTER_DECODER(XPM,               xpm);
     389        5348 :     REGISTER_ENCDEC (XWD,               xwd);
     390        5348 :     REGISTER_ENCDEC (Y41P,              y41p);
     391        5348 :     REGISTER_DECODER(YLC,               ylc);
     392        5348 :     REGISTER_DECODER(YOP,               yop);
     393        5348 :     REGISTER_ENCDEC (YUV4,              yuv4);
     394        5348 :     REGISTER_DECODER(ZERO12V,           zero12v);
     395        5348 :     REGISTER_DECODER(ZEROCODEC,         zerocodec);
     396        5348 :     REGISTER_ENCDEC (ZLIB,              zlib);
     397        5348 :     REGISTER_ENCDEC (ZMBV,              zmbv);
     398             : 
     399             :     /* audio codecs */
     400        5348 :     REGISTER_ENCDEC (AAC,               aac);
     401        5348 :     REGISTER_DECODER(AAC_FIXED,         aac_fixed);
     402        5348 :     REGISTER_DECODER(AAC_LATM,          aac_latm);
     403        5348 :     REGISTER_ENCDEC (AC3,               ac3);
     404        5348 :     REGISTER_ENCDEC (AC3_FIXED,         ac3_fixed);
     405        5348 :     REGISTER_ENCDEC (ALAC,              alac);
     406        5348 :     REGISTER_DECODER(ALS,               als);
     407        5348 :     REGISTER_DECODER(AMRNB,             amrnb);
     408        5348 :     REGISTER_DECODER(AMRWB,             amrwb);
     409        5348 :     REGISTER_DECODER(APE,               ape);
     410        5348 :     REGISTER_DECODER(ATRAC1,            atrac1);
     411        5348 :     REGISTER_DECODER(ATRAC3,            atrac3);
     412        5348 :     REGISTER_DECODER(ATRAC3AL,          atrac3al);
     413        5348 :     REGISTER_DECODER(ATRAC3P,           atrac3p);
     414        5348 :     REGISTER_DECODER(ATRAC3PAL,         atrac3pal);
     415        5348 :     REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
     416        5348 :     REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
     417        5348 :     REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
     418        5348 :     REGISTER_DECODER(COOK,              cook);
     419        5348 :     REGISTER_ENCDEC (DCA,               dca);
     420        5348 :     REGISTER_DECODER(DSD_LSBF,          dsd_lsbf);
     421        5348 :     REGISTER_DECODER(DSD_MSBF,          dsd_msbf);
     422        5348 :     REGISTER_DECODER(DSD_LSBF_PLANAR,   dsd_lsbf_planar);
     423        5348 :     REGISTER_DECODER(DSD_MSBF_PLANAR,   dsd_msbf_planar);
     424        5348 :     REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
     425        5348 :     REGISTER_DECODER(DSS_SP,            dss_sp);
     426        5348 :     REGISTER_DECODER(DST,               dst);
     427        5348 :     REGISTER_ENCDEC (EAC3,              eac3);
     428        5348 :     REGISTER_DECODER(EVRC,              evrc);
     429        5348 :     REGISTER_DECODER(FFWAVESYNTH,       ffwavesynth);
     430        5348 :     REGISTER_ENCDEC (FLAC,              flac);
     431        5348 :     REGISTER_ENCDEC (G723_1,            g723_1);
     432        5348 :     REGISTER_DECODER(G729,              g729);
     433        5348 :     REGISTER_DECODER(GSM,               gsm);
     434        5348 :     REGISTER_DECODER(GSM_MS,            gsm_ms);
     435        5348 :     REGISTER_DECODER(IAC,               iac);
     436        5348 :     REGISTER_DECODER(IMC,               imc);
     437        5348 :     REGISTER_DECODER(INTERPLAY_ACM,     interplay_acm);
     438        5348 :     REGISTER_DECODER(MACE3,             mace3);
     439        5348 :     REGISTER_DECODER(MACE6,             mace6);
     440        5348 :     REGISTER_DECODER(METASOUND,         metasound);
     441        5348 :     REGISTER_ENCDEC (MLP,               mlp);
     442        5348 :     REGISTER_DECODER(MP1,               mp1);
     443        5348 :     REGISTER_DECODER(MP1FLOAT,          mp1float);
     444        5348 :     REGISTER_ENCDEC (MP2,               mp2);
     445        5348 :     REGISTER_DECODER(MP2FLOAT,          mp2float);
     446        5348 :     REGISTER_ENCODER(MP2FIXED,          mp2fixed);
     447        5348 :     REGISTER_DECODER(MP3,               mp3);
     448        5348 :     REGISTER_DECODER(MP3FLOAT,          mp3float);
     449        5348 :     REGISTER_DECODER(MP3ADU,            mp3adu);
     450        5348 :     REGISTER_DECODER(MP3ADUFLOAT,       mp3adufloat);
     451        5348 :     REGISTER_DECODER(MP3ON4,            mp3on4);
     452        5348 :     REGISTER_DECODER(MP3ON4FLOAT,       mp3on4float);
     453        5348 :     REGISTER_DECODER(MPC7,              mpc7);
     454        5348 :     REGISTER_DECODER(MPC8,              mpc8);
     455        5348 :     REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
     456        5348 :     REGISTER_DECODER(ON2AVC,            on2avc);
     457        5348 :     REGISTER_ENCDEC (OPUS,              opus);
     458        5348 :     REGISTER_DECODER(PAF_AUDIO,         paf_audio);
     459        5348 :     REGISTER_DECODER(QCELP,             qcelp);
     460        5348 :     REGISTER_DECODER(QDM2,              qdm2);
     461        5348 :     REGISTER_DECODER(QDMC,              qdmc);
     462        5348 :     REGISTER_ENCDEC (RA_144,            ra_144);
     463        5348 :     REGISTER_DECODER(RA_288,            ra_288);
     464        5348 :     REGISTER_DECODER(RALF,              ralf);
     465        5348 :     REGISTER_DECODER(SHORTEN,           shorten);
     466        5348 :     REGISTER_DECODER(SIPR,              sipr);
     467        5348 :     REGISTER_DECODER(SMACKAUD,          smackaud);
     468        5348 :     REGISTER_ENCDEC (SONIC,             sonic);
     469        5348 :     REGISTER_ENCODER(SONIC_LS,          sonic_ls);
     470        5348 :     REGISTER_DECODER(TAK,               tak);
     471        5348 :     REGISTER_ENCDEC (TRUEHD,            truehd);
     472        5348 :     REGISTER_DECODER(TRUESPEECH,        truespeech);
     473        5348 :     REGISTER_ENCDEC (TTA,               tta);
     474        5348 :     REGISTER_DECODER(TWINVQ,            twinvq);
     475        5348 :     REGISTER_DECODER(VMDAUDIO,          vmdaudio);
     476        5348 :     REGISTER_ENCDEC (VORBIS,            vorbis);
     477        5348 :     REGISTER_ENCDEC (WAVPACK,           wavpack);
     478        5348 :     REGISTER_DECODER(WMALOSSLESS,       wmalossless);
     479        5348 :     REGISTER_DECODER(WMAPRO,            wmapro);
     480        5348 :     REGISTER_ENCDEC (WMAV1,             wmav1);
     481        5348 :     REGISTER_ENCDEC (WMAV2,             wmav2);
     482        5348 :     REGISTER_DECODER(WMAVOICE,          wmavoice);
     483        5348 :     REGISTER_DECODER(WS_SND1,           ws_snd1);
     484        5348 :     REGISTER_DECODER(XMA1,              xma1);
     485        5348 :     REGISTER_DECODER(XMA2,              xma2);
     486             : 
     487             :     /* PCM codecs */
     488        5348 :     REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
     489        5348 :     REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
     490        5348 :     REGISTER_DECODER(PCM_DVD,           pcm_dvd);
     491        5348 :     REGISTER_DECODER(PCM_F16LE,         pcm_f16le);
     492        5348 :     REGISTER_DECODER(PCM_F24LE,         pcm_f24le);
     493        5348 :     REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
     494        5348 :     REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
     495        5348 :     REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
     496        5348 :     REGISTER_ENCDEC (PCM_F64LE,         pcm_f64le);
     497        5348 :     REGISTER_DECODER(PCM_LXF,           pcm_lxf);
     498        5348 :     REGISTER_ENCDEC (PCM_MULAW,         pcm_mulaw);
     499        5348 :     REGISTER_ENCDEC (PCM_S8,            pcm_s8);
     500        5348 :     REGISTER_ENCDEC (PCM_S8_PLANAR,     pcm_s8_planar);
     501        5348 :     REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
     502        5348 :     REGISTER_ENCDEC (PCM_S16BE_PLANAR,  pcm_s16be_planar);
     503        5348 :     REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
     504        5348 :     REGISTER_ENCDEC (PCM_S16LE_PLANAR,  pcm_s16le_planar);
     505        5348 :     REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
     506        5348 :     REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
     507        5348 :     REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
     508        5348 :     REGISTER_ENCDEC (PCM_S24LE_PLANAR,  pcm_s24le_planar);
     509        5348 :     REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
     510        5348 :     REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
     511        5348 :     REGISTER_ENCDEC (PCM_S32LE_PLANAR,  pcm_s32le_planar);
     512        5348 :     REGISTER_ENCDEC (PCM_S64BE,         pcm_s64be);
     513        5348 :     REGISTER_ENCDEC (PCM_S64LE,         pcm_s64le);
     514        5348 :     REGISTER_ENCDEC (PCM_U8,            pcm_u8);
     515        5348 :     REGISTER_ENCDEC (PCM_U16BE,         pcm_u16be);
     516        5348 :     REGISTER_ENCDEC (PCM_U16LE,         pcm_u16le);
     517        5348 :     REGISTER_ENCDEC (PCM_U24BE,         pcm_u24be);
     518        5348 :     REGISTER_ENCDEC (PCM_U24LE,         pcm_u24le);
     519        5348 :     REGISTER_ENCDEC (PCM_U32BE,         pcm_u32be);
     520        5348 :     REGISTER_ENCDEC (PCM_U32LE,         pcm_u32le);
     521        5348 :     REGISTER_DECODER(PCM_ZORK,          pcm_zork);
     522             : 
     523             :     /* DPCM codecs */
     524        5348 :     REGISTER_DECODER(GREMLIN_DPCM,      gremlin_dpcm);
     525        5348 :     REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
     526        5348 :     REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
     527        5348 :     REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
     528        5348 :     REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
     529             : 
     530             :     /* ADPCM codecs */
     531        5348 :     REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
     532        5348 :     REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
     533        5348 :     REGISTER_DECODER(ADPCM_AFC,         adpcm_afc);
     534        5348 :     REGISTER_DECODER(ADPCM_AICA,        adpcm_aica);
     535        5348 :     REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
     536        5348 :     REGISTER_DECODER(ADPCM_DTK,         adpcm_dtk);
     537        5348 :     REGISTER_DECODER(ADPCM_EA,          adpcm_ea);
     538        5348 :     REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
     539        5348 :     REGISTER_DECODER(ADPCM_EA_R1,       adpcm_ea_r1);
     540        5348 :     REGISTER_DECODER(ADPCM_EA_R2,       adpcm_ea_r2);
     541        5348 :     REGISTER_DECODER(ADPCM_EA_R3,       adpcm_ea_r3);
     542        5348 :     REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
     543        5348 :     REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
     544        5348 :     REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
     545        5348 :     REGISTER_DECODER(ADPCM_G726LE,      adpcm_g726le);
     546        5348 :     REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
     547        5348 :     REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
     548        5348 :     REGISTER_DECODER(ADPCM_IMA_DAT4,    adpcm_ima_dat4);
     549        5348 :     REGISTER_DECODER(ADPCM_IMA_DK3,     adpcm_ima_dk3);
     550        5348 :     REGISTER_DECODER(ADPCM_IMA_DK4,     adpcm_ima_dk4);
     551        5348 :     REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
     552        5348 :     REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
     553        5348 :     REGISTER_DECODER(ADPCM_IMA_ISS,     adpcm_ima_iss);
     554        5348 :     REGISTER_DECODER(ADPCM_IMA_OKI,     adpcm_ima_oki);
     555        5348 :     REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
     556        5348 :     REGISTER_DECODER(ADPCM_IMA_RAD,     adpcm_ima_rad);
     557        5348 :     REGISTER_DECODER(ADPCM_IMA_SMJPEG,  adpcm_ima_smjpeg);
     558        5348 :     REGISTER_ENCDEC (ADPCM_IMA_WAV,     adpcm_ima_wav);
     559        5348 :     REGISTER_DECODER(ADPCM_IMA_WS,      adpcm_ima_ws);
     560        5348 :     REGISTER_ENCDEC (ADPCM_MS,          adpcm_ms);
     561        5348 :     REGISTER_DECODER(ADPCM_MTAF,        adpcm_mtaf);
     562        5348 :     REGISTER_DECODER(ADPCM_PSX,         adpcm_psx);
     563        5348 :     REGISTER_DECODER(ADPCM_SBPRO_2,     adpcm_sbpro_2);
     564        5348 :     REGISTER_DECODER(ADPCM_SBPRO_3,     adpcm_sbpro_3);
     565        5348 :     REGISTER_DECODER(ADPCM_SBPRO_4,     adpcm_sbpro_4);
     566        5348 :     REGISTER_ENCDEC (ADPCM_SWF,         adpcm_swf);
     567        5348 :     REGISTER_DECODER(ADPCM_THP,         adpcm_thp);
     568        5348 :     REGISTER_DECODER(ADPCM_THP_LE,      adpcm_thp_le);
     569        5348 :     REGISTER_DECODER(ADPCM_VIMA,        adpcm_vima);
     570        5348 :     REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
     571        5348 :     REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
     572             : 
     573             :     /* subtitles */
     574        5348 :     REGISTER_ENCDEC (SSA,               ssa);
     575        5348 :     REGISTER_ENCDEC (ASS,               ass);
     576        5348 :     REGISTER_DECODER(CCAPTION,          ccaption);
     577        5348 :     REGISTER_ENCDEC (DVBSUB,            dvbsub);
     578        5348 :     REGISTER_ENCDEC (DVDSUB,            dvdsub);
     579        5348 :     REGISTER_DECODER(JACOSUB,           jacosub);
     580        5348 :     REGISTER_DECODER(MICRODVD,          microdvd);
     581        5348 :     REGISTER_ENCDEC (MOVTEXT,           movtext);
     582        5348 :     REGISTER_DECODER(MPL2,              mpl2);
     583        5348 :     REGISTER_DECODER(PGSSUB,            pgssub);
     584        5348 :     REGISTER_DECODER(PJS,               pjs);
     585        5348 :     REGISTER_DECODER(REALTEXT,          realtext);
     586        5348 :     REGISTER_DECODER(SAMI,              sami);
     587        5348 :     REGISTER_ENCDEC (SRT,               srt);
     588        5348 :     REGISTER_DECODER(STL,               stl);
     589        5348 :     REGISTER_ENCDEC (SUBRIP,            subrip);
     590        5348 :     REGISTER_DECODER(SUBVIEWER,         subviewer);
     591        5348 :     REGISTER_DECODER(SUBVIEWER1,        subviewer1);
     592        5348 :     REGISTER_ENCDEC (TEXT,              text);
     593        5348 :     REGISTER_DECODER(VPLAYER,           vplayer);
     594        5348 :     REGISTER_ENCDEC (WEBVTT,            webvtt);
     595        5348 :     REGISTER_ENCDEC (XSUB,              xsub);
     596             : 
     597             :     /* external libraries */
     598             :     REGISTER_ENCDEC (AAC_AT,            aac_at);
     599             :     REGISTER_DECODER(AC3_AT,            ac3_at);
     600             :     REGISTER_DECODER(ADPCM_IMA_QT_AT,   adpcm_ima_qt_at);
     601             :     REGISTER_ENCDEC (ALAC_AT,           alac_at);
     602             :     REGISTER_DECODER(AMR_NB_AT,         amr_nb_at);
     603             :     REGISTER_DECODER(EAC3_AT,           eac3_at);
     604             :     REGISTER_DECODER(GSM_MS_AT,         gsm_ms_at);
     605             :     REGISTER_ENCDEC (ILBC_AT,           ilbc_at);
     606             :     REGISTER_DECODER(MP1_AT,            mp1_at);
     607             :     REGISTER_DECODER(MP2_AT,            mp2_at);
     608             :     REGISTER_DECODER(MP3_AT,            mp3_at);
     609             :     REGISTER_ENCDEC (PCM_ALAW_AT,       pcm_alaw_at);
     610             :     REGISTER_ENCDEC (PCM_MULAW_AT,      pcm_mulaw_at);
     611             :     REGISTER_DECODER(QDMC_AT,           qdmc_at);
     612             :     REGISTER_DECODER(QDM2_AT,           qdm2_at);
     613             :     REGISTER_DECODER(LIBCELT,           libcelt);
     614             :     REGISTER_ENCDEC (LIBFDK_AAC,        libfdk_aac);
     615             :     REGISTER_ENCDEC (LIBGSM,            libgsm);
     616             :     REGISTER_ENCDEC (LIBGSM_MS,         libgsm_ms);
     617             :     REGISTER_ENCDEC (LIBILBC,           libilbc);
     618             :     REGISTER_ENCODER(LIBMP3LAME,        libmp3lame);
     619             :     REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
     620             :     REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
     621             :     REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
     622             :     REGISTER_ENCDEC (LIBOPUS,           libopus);
     623             :     REGISTER_DECODER(LIBRSVG,           librsvg);
     624             :     REGISTER_ENCODER(LIBSHINE,          libshine);
     625             :     REGISTER_ENCDEC (LIBSPEEX,          libspeex);
     626             :     REGISTER_ENCODER(LIBTHEORA,         libtheora);
     627             :     REGISTER_ENCODER(LIBTWOLAME,        libtwolame);
     628             :     REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
     629             :     REGISTER_ENCDEC (LIBVORBIS,         libvorbis);
     630             :     REGISTER_ENCDEC (LIBVPX_VP8,        libvpx_vp8);
     631             :     REGISTER_ENCDEC (LIBVPX_VP9,        libvpx_vp9);
     632             :     REGISTER_ENCODER(LIBWAVPACK,        libwavpack);
     633             :     REGISTER_ENCODER(LIBWEBP_ANIM,      libwebp_anim);  /* preferred over libwebp */
     634             :     REGISTER_ENCODER(LIBWEBP,           libwebp);
     635             :     REGISTER_ENCODER(LIBX262,           libx262);
     636             :     REGISTER_ENCODER(LIBX264,           libx264);
     637             :     REGISTER_ENCODER(LIBX264RGB,        libx264rgb);
     638             :     REGISTER_ENCODER(LIBX265,           libx265);
     639             :     REGISTER_ENCODER(LIBXAVS,           libxavs);
     640             :     REGISTER_ENCODER(LIBXVID,           libxvid);
     641             :     REGISTER_DECODER(LIBZVBI_TELETEXT,  libzvbi_teletext);
     642             : 
     643             :     /* text */
     644        5348 :     REGISTER_DECODER(BINTEXT,           bintext);
     645        5348 :     REGISTER_DECODER(XBIN,              xbin);
     646        5348 :     REGISTER_DECODER(IDF,               idf);
     647             : 
     648             :     /* external libraries, that shouldn't be used by default if one of the
     649             :      * above is available */
     650             :     REGISTER_ENCDEC (LIBOPENH264,       libopenh264);
     651        5348 :     REGISTER_DECODER(H264_CUVID,        h264_cuvid);
     652        5348 :     REGISTER_ENCODER(H264_NVENC,        h264_nvenc);
     653             :     REGISTER_ENCODER(H264_OMX,          h264_omx);
     654             :     REGISTER_ENCODER(H264_QSV,          h264_qsv);
     655             :     REGISTER_ENCODER(H264_VAAPI,        h264_vaapi);
     656             :     REGISTER_ENCODER(H264_VIDEOTOOLBOX, h264_videotoolbox);
     657             : #if FF_API_NVENC_OLD_NAME
     658        5348 :     REGISTER_ENCODER(NVENC,             nvenc);
     659        5348 :     REGISTER_ENCODER(NVENC_H264,        nvenc_h264);
     660        5348 :     REGISTER_ENCODER(NVENC_HEVC,        nvenc_hevc);
     661             : #endif
     662        5348 :     REGISTER_DECODER(HEVC_CUVID,        hevc_cuvid);
     663             :     REGISTER_DECODER(HEVC_MEDIACODEC,   hevc_mediacodec);
     664        5348 :     REGISTER_ENCODER(HEVC_NVENC,        hevc_nvenc);
     665             :     REGISTER_ENCODER(HEVC_QSV,          hevc_qsv);
     666             :     REGISTER_ENCODER(HEVC_VAAPI,        hevc_vaapi);
     667             :     REGISTER_ENCODER(LIBKVAZAAR,        libkvazaar);
     668        5348 :     REGISTER_DECODER(MJPEG_CUVID,       mjpeg_cuvid);
     669             :     REGISTER_ENCODER(MJPEG_VAAPI,       mjpeg_vaapi);
     670        5348 :     REGISTER_DECODER(MPEG1_CUVID,       mpeg1_cuvid);
     671        5348 :     REGISTER_DECODER(MPEG2_CUVID,       mpeg2_cuvid);
     672             :     REGISTER_ENCODER(MPEG2_QSV,         mpeg2_qsv);
     673             :     REGISTER_ENCODER(MPEG2_VAAPI,       mpeg2_vaapi);
     674        5348 :     REGISTER_DECODER(MPEG4_CUVID,       mpeg4_cuvid);
     675             :     REGISTER_DECODER(MPEG4_MEDIACODEC,  mpeg4_mediacodec);
     676        5348 :     REGISTER_DECODER(VC1_CUVID,         vc1_cuvid);
     677        5348 :     REGISTER_DECODER(VP8_CUVID,         vp8_cuvid);
     678             :     REGISTER_DECODER(VP8_MEDIACODEC,    vp8_mediacodec);
     679             :     REGISTER_DECODER(VP8_QSV,           vp8_qsv);
     680             :     REGISTER_ENCODER(VP8_VAAPI,         vp8_vaapi);
     681        5348 :     REGISTER_DECODER(VP9_CUVID,         vp9_cuvid);
     682             :     REGISTER_DECODER(VP9_MEDIACODEC,    vp9_mediacodec);
     683             : 
     684             :     /* parsers */
     685        5348 :     REGISTER_PARSER(AAC,                aac);
     686        5348 :     REGISTER_PARSER(AAC_LATM,           aac_latm);
     687        5348 :     REGISTER_PARSER(AC3,                ac3);
     688        5348 :     REGISTER_PARSER(ADX,                adx);
     689        5348 :     REGISTER_PARSER(BMP,                bmp);
     690        5348 :     REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
     691        5348 :     REGISTER_PARSER(COOK,               cook);
     692        5348 :     REGISTER_PARSER(DCA,                dca);
     693        5348 :     REGISTER_PARSER(DIRAC,              dirac);
     694        5348 :     REGISTER_PARSER(DNXHD,              dnxhd);
     695        5348 :     REGISTER_PARSER(DPX,                dpx);
     696        5348 :     REGISTER_PARSER(DVAUDIO,            dvaudio);
     697        5348 :     REGISTER_PARSER(DVBSUB,             dvbsub);
     698        5348 :     REGISTER_PARSER(DVDSUB,             dvdsub);
     699        5348 :     REGISTER_PARSER(DVD_NAV,            dvd_nav);
     700        5348 :     REGISTER_PARSER(FLAC,               flac);
     701        5348 :     REGISTER_PARSER(G729,               g729);
     702        5348 :     REGISTER_PARSER(GSM,                gsm);
     703        5348 :     REGISTER_PARSER(H261,               h261);
     704        5348 :     REGISTER_PARSER(H263,               h263);
     705        5348 :     REGISTER_PARSER(H264,               h264);
     706        5348 :     REGISTER_PARSER(HEVC,               hevc);
     707        5348 :     REGISTER_PARSER(MJPEG,              mjpeg);
     708        5348 :     REGISTER_PARSER(MLP,                mlp);
     709        5348 :     REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
     710        5348 :     REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
     711        5348 :     REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
     712        5348 :     REGISTER_PARSER(OPUS,               opus);
     713        5348 :     REGISTER_PARSER(PNG,                png);
     714        5348 :     REGISTER_PARSER(PNM,                pnm);
     715        5348 :     REGISTER_PARSER(RV30,               rv30);
     716        5348 :     REGISTER_PARSER(RV40,               rv40);
     717        5348 :     REGISTER_PARSER(SIPR,               sipr);
     718        5348 :     REGISTER_PARSER(TAK,                tak);
     719        5348 :     REGISTER_PARSER(VC1,                vc1);
     720        5348 :     REGISTER_PARSER(VORBIS,             vorbis);
     721        5348 :     REGISTER_PARSER(VP3,                vp3);
     722        5348 :     REGISTER_PARSER(VP8,                vp8);
     723        5348 :     REGISTER_PARSER(VP9,                vp9);
     724        5348 :     REGISTER_PARSER(XMA,                xma);
     725        5348 : }
     726             : 
     727       10521 : void avcodec_register_all(void)
     728             : {
     729             :     static AVOnce control = AV_ONCE_INIT;
     730             : 
     731       10521 :     ff_thread_once(&control, register_all);
     732       10521 : }

Generated by: LCOV version 1.13