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