ijkplayer框架簡析 -- av_register_all

#define REGISTER_MUXER(X, x)\
{\
extern AVOutputFormat ff_##x##_muxer;\
if (CONFIG_##X##_MUXER)\
av_register_output_format(&ff_##x##_muxer);\
}

#define REGISTER_DEMUXER(X, x)\
{\
extern AVInputFormat ff_##x##_demuxer;\
if (CONFIG_##X##_DEMUXER)\
av_register_input_format(&ff_##x##_demuxer);\
}

#define REGISTER_MUXDEMUX(X, x) REGISTER_MUXER(X, x); REGISTER_DEMUXER(X, x)

static void register_all(void)
{
avcodec_register_all();

/* (de)muxers */
REGISTER_MUXER(A64,a64);
REGISTER_DEMUXER (AA,aa);
REGISTER_DEMUXER (AAC,aac);
REGISTER_MUXDEMUX(AC3,ac3);
REGISTER_DEMUXER (ACM,acm);
REGISTER_DEMUXER (ACT,act);
REGISTER_DEMUXER (ADF,adf);
REGISTER_DEMUXER (ADP,adp);
REGISTER_DEMUXER (ADS,ads);
REGISTER_MUXER(ADTS,adts);
REGISTER_MUXDEMUX(ADX,adx);
REGISTER_DEMUXER (AEA,aea);
REGISTER_DEMUXER (AFC,afc);
REGISTER_MUXDEMUX(AIFF,aiff);
REGISTER_DEMUXER (AIX,aix);
REGISTER_MUXDEMUX(AMR,amr);
REGISTER_DEMUXER (ANM,anm);
REGISTER_DEMUXER (APC,apc);
REGISTER_DEMUXER (APE,ape);
REGISTER_MUXDEMUX(APNG,apng);
REGISTER_DEMUXER (AQTITLE,aqtitle);
REGISTER_MUXDEMUX(ASF,asf);
REGISTER_DEMUXER (ASF_O,asf_o);
REGISTER_MUXDEMUX(ASS,ass);
REGISTER_MUXDEMUX(AST,ast);
REGISTER_MUXER(ASF_STREAM,asf_stream);
REGISTER_MUXDEMUX(AU,au);
REGISTER_MUXDEMUX(AVI,avi);
REGISTER_DEMUXER (AVISYNTH,avisynth);
REGISTER_MUXER(AVM2,avm2);
REGISTER_DEMUXER (AVR,avr);
REGISTER_DEMUXER (AVS,avs);
REGISTER_DEMUXER (BETHSOFTVID,bethsoftvid);
REGISTER_DEMUXER (BFI,bfi);
REGISTER_DEMUXER (BINTEXT,bintext);
REGISTER_DEMUXER (BINK,bink);
REGISTER_MUXDEMUX(BIT,bit);
REGISTER_DEMUXER (BMV,bmv);
REGISTER_DEMUXER (BFSTM,bfstm);
REGISTER_DEMUXER (BRSTM,brstm);
REGISTER_DEMUXER (BOA,boa);
REGISTER_DEMUXER (C93,c93);
REGISTER_MUXDEMUX(CAF,caf);
REGISTER_MUXDEMUX(CAVSVIDEO,cavsvideo);
REGISTER_DEMUXER (CDG,cdg);
REGISTER_DEMUXER (CDXL,cdxl);
REGISTER_DEMUXER (CINE,cine);
REGISTER_DEMUXER (CONCAT,concat);
REGISTER_MUXER(CRC,crc);
REGISTER_MUXDEMUX(DASH,dash);
REGISTER_MUXDEMUX(DATA,data);
REGISTER_MUXDEMUX(DAUD,daud);
REGISTER_DEMUXER (DCSTR,dcstr);
REGISTER_DEMUXER (DFA,dfa);
REGISTER_MUXDEMUX(DIRAC,dirac);
REGISTER_MUXDEMUX(DNXHD,dnxhd);
REGISTER_DEMUXER (DSF,dsf);
REGISTER_DEMUXER (DSICIN,dsicin);
REGISTER_DEMUXER (DSS,dss);
REGISTER_MUXDEMUX(DTS,dts);
REGISTER_DEMUXER (DTSHD,dtshd);
REGISTER_MUXDEMUX(DV,dv);
REGISTER_DEMUXER (DVBSUB,dvbsub);
REGISTER_DEMUXER (DVBTXT,dvbtxt);
REGISTER_DEMUXER (DXA,dxa);
REGISTER_DEMUXER (EA,ea);
REGISTER_DEMUXER (EA_CDATA,ea_cdata);
REGISTER_MUXDEMUX(EAC3,eac3);
REGISTER_DEMUXER (EPAF,epaf);
REGISTER_MUXER(F4V,f4v);
REGISTER_MUXDEMUX(FFM,ffm);
REGISTER_MUXDEMUX(FFMETADATA,ffmetadata);
REGISTER_MUXER(FIFO,fifo);
REGISTER_MUXDEMUX(FILMSTRIP,filmstrip);
REGISTER_MUXDEMUX(FITS,fits);
REGISTER_MUXDEMUX(FLAC,flac);
REGISTER_DEMUXER (FLIC,flic);
REGISTER_MUXDEMUX(FLV,flv);
REGISTER_DEMUXER (LIVE_FLV,live_flv);
REGISTER_DEMUXER (FOURXM,fourxm);
REGISTER_MUXER(FRAMECRC,framecrc);
REGISTER_MUXER(FRAMEHASH,framehash);
REGISTER_MUXER(FRAMEMD5,framemd5);
REGISTER_DEMUXER (FRM,frm);
REGISTER_DEMUXER (FSB,fsb);
REGISTER_MUXDEMUX(G722,g722);
REGISTER_MUXDEMUX(G723_1,g723_1);
REGISTER_MUXDEMUX(G726,g726);
REGISTER_MUXDEMUX(G726LE,g726le);
REGISTER_DEMUXER (G729,g729);
REGISTER_DEMUXER (GDV,gdv);
REGISTER_DEMUXER (GENH,genh);
REGISTER_MUXDEMUX(GIF,gif);
REGISTER_MUXDEMUX(GSM,gsm);
REGISTER_MUXDEMUX(GXF,gxf);
REGISTER_MUXDEMUX(H261,h261);
REGISTER_MUXDEMUX(H263,h263);
REGISTER_MUXDEMUX(H264,h264);
REGISTER_MUXER(HASH,hash);
REGISTER_MUXER(HDS,hds);
REGISTER_MUXDEMUX(HEVC,hevc);
REGISTER_MUXDEMUX(HLS,hls);
REGISTER_DEMUXER (HNM,hnm);
REGISTER_MUXDEMUX(ICO,ico);
REGISTER_DEMUXER (IDCIN,idcin);
REGISTER_DEMUXER (IDF,idf);
REGISTER_DEMUXER (IFF,iff);
REGISTER_MUXDEMUX(ILBC,ilbc);
REGISTER_MUXDEMUX(IMAGE2,image2);
REGISTER_MUXDEMUX(IMAGE2PIPE,image2pipe);
REGISTER_DEMUXER (IMAGE2_ALIAS_PIX, image2_alias_pix);
REGISTER_DEMUXER (IMAGE2_BRENDER_PIX, image2_brender_pix);
REGISTER_DEMUXER (INGENIENT,ingenient);
REGISTER_DEMUXER (IPMOVIE,ipmovie);
REGISTER_MUXER(IPOD,ipod);
REGISTER_MUXDEMUX(IRCAM,ircam);
REGISTER_MUXER(ISMV,ismv);
REGISTER_DEMUXER (ISS,iss);
REGISTER_DEMUXER (IV8,iv8);
REGISTER_MUXDEMUX(IVF,ivf);
REGISTER_DEMUXER (IVR,ivr);
REGISTER_MUXDEMUX(JACOSUB,jacosub);
REGISTER_DEMUXER (JV,jv);
REGISTER_MUXER(LATM,latm);
REGISTER_DEMUXER (LMLM4,lmlm4);
REGISTER_DEMUXER (LOAS,loas);
REGISTER_MUXDEMUX(LRC,lrc);
REGISTER_DEMUXER (LVF,lvf);
REGISTER_DEMUXER (LXF,lxf);
REGISTER_MUXDEMUX(M4V,m4v);
REGISTER_MUXER(MD5,md5);
REGISTER_MUXDEMUX(MATROSKA,matroska);
REGISTER_MUXER(MATROSKA_AUDIO,matroska_audio);
REGISTER_DEMUXER (MGSTS,mgsts);
REGISTER_MUXDEMUX(MICRODVD,microdvd);
REGISTER_MUXDEMUX(MJPEG,mjpeg);
REGISTER_DEMUXER (MJPEG_2000,mjpeg_2000);
REGISTER_MUXDEMUX(MLP,mlp);
REGISTER_DEMUXER (MLV,mlv);
REGISTER_DEMUXER (MM,mm);
REGISTER_MUXDEMUX(MMF,mmf);
REGISTER_MUXDEMUX(MOV,mov);
REGISTER_MUXER(MP2,mp2);
REGISTER_MUXDEMUX(MP3,mp3);
REGISTER_MUXER(MP4,mp4);
REGISTER_DEMUXER (MPC,mpc);
REGISTER_DEMUXER (MPC8,mpc8);
REGISTER_MUXER(MPEG1SYSTEM,mpeg1system);
REGISTER_MUXER(MPEG1VCD,mpeg1vcd);
REGISTER_MUXER(MPEG1VIDEO,mpeg1video);
REGISTER_MUXER(MPEG2DVD,mpeg2dvd);
REGISTER_MUXER(MPEG2SVCD,mpeg2svcd);
REGISTER_MUXER(MPEG2VIDEO,mpeg2video);
REGISTER_MUXER(MPEG2VOB,mpeg2vob);
REGISTER_DEMUXER (MPEGPS,mpegps);
REGISTER_MUXDEMUX(MPEGTS,mpegts);
REGISTER_DEMUXER (MPEGTSRAW,mpegtsraw);
REGISTER_DEMUXER (MPEGVIDEO,mpegvideo);
REGISTER_MUXDEMUX(MPJPEG,mpjpeg);
REGISTER_DEMUXER (MPL2,mpl2);
REGISTER_DEMUXER (MPSUB,mpsub);
REGISTER_DEMUXER (MSF,msf);
REGISTER_DEMUXER (MSNWC_TCP,msnwc_tcp);
REGISTER_DEMUXER (MTAF,mtaf);
REGISTER_DEMUXER (MTV,mtv);
REGISTER_DEMUXER (MUSX,musx);
REGISTER_DEMUXER (MV,mv);
REGISTER_DEMUXER (MVI,mvi);
REGISTER_MUXDEMUX(MXF,mxf);
REGISTER_MUXER(MXF_D10,mxf_d10);
REGISTER_MUXER(MXF_OPATOM,mxf_opatom);
REGISTER_DEMUXER (MXG,mxg);
REGISTER_DEMUXER (NC,nc);
REGISTER_DEMUXER (NISTSPHERE,nistsphere);
REGISTER_DEMUXER (NSV,nsv);
REGISTER_MUXER(NULL,null);
REGISTER_MUXDEMUX(NUT,nut);
REGISTER_DEMUXER (NUV,nuv);
REGISTER_MUXER(OGA,oga);
REGISTER_MUXDEMUX(OGG,ogg);
REGISTER_MUXER(OGV,ogv);
REGISTER_MUXDEMUX(OMA,oma);
REGISTER_MUXER(OPUS,opus);
REGISTER_DEMUXER (PAF,paf);
REGISTER_MUXDEMUX(PCM_ALAW,pcm_alaw);
REGISTER_MUXDEMUX(PCM_MULAW,pcm_mulaw);
REGISTER_MUXDEMUX(PCM_F64BE,pcm_f64be);
REGISTER_MUXDEMUX(PCM_F64LE,pcm_f64le);
REGISTER_MUXDEMUX(PCM_F32BE,pcm_f32be);
REGISTER_MUXDEMUX(PCM_F32LE,pcm_f32le);
REGISTER_MUXDEMUX(PCM_S32BE,pcm_s32be);
REGISTER_MUXDEMUX(PCM_S32LE,pcm_s32le);
REGISTER_MUXDEMUX(PCM_S24BE,pcm_s24be);
REGISTER_MUXDEMUX(PCM_S24LE,pcm_s24le);
REGISTER_MUXDEMUX(PCM_S16BE,pcm_s16be);
REGISTER_MUXDEMUX(PCM_S16LE,pcm_s16le);
REGISTER_MUXDEMUX(PCM_S8,pcm_s8);
REGISTER_MUXDEMUX(PCM_U32BE,pcm_u32be);
REGISTER_MUXDEMUX(PCM_U32LE,pcm_u32le);
REGISTER_MUXDEMUX(PCM_U24BE,pcm_u24be);
REGISTER_MUXDEMUX(PCM_U24LE,pcm_u24le);
REGISTER_MUXDEMUX(PCM_U16BE,pcm_u16be);
REGISTER_MUXDEMUX(PCM_U16LE,pcm_u16le);
REGISTER_MUXDEMUX(PCM_U8,pcm_u8);
REGISTER_DEMUXER (PJS,pjs);
REGISTER_DEMUXER (PMP,pmp);
REGISTER_MUXER(PSP,psp);
REGISTER_DEMUXER (PVA,pva);
REGISTER_DEMUXER (PVF,pvf);
REGISTER_DEMUXER (QCP,qcp);
REGISTER_DEMUXER (R3D,r3d);
REGISTER_MUXDEMUX(RAWVIDEO,rawvideo);
REGISTER_DEMUXER (REALTEXT,realtext);
REGISTER_DEMUXER (REDSPARK,redspark);
REGISTER_DEMUXER (RL2,rl2);
REGISTER_MUXDEMUX(RM,rm);
REGISTER_MUXDEMUX(ROQ,roq);
REGISTER_DEMUXER (RPL,rpl);
REGISTER_DEMUXER (RSD,rsd);
REGISTER_MUXDEMUX(RSO,rso);
REGISTER_MUXDEMUX(RTP,rtp);
REGISTER_MUXER(RTP_MPEGTS,rtp_mpegts);
REGISTER_MUXDEMUX(RTSP,rtsp);
REGISTER_DEMUXER (S337M,s337m);
REGISTER_DEMUXER (SAMI,sami);
REGISTER_MUXDEMUX(SAP,sap);
REGISTER_DEMUXER (SBG,sbg);
REGISTER_MUXDEMUX(SCC,scc);
REGISTER_DEMUXER (SDP,sdp);
REGISTER_DEMUXER (SDR2,sdr2);
REGISTER_DEMUXER (SDS,sds);
REGISTER_DEMUXER (SDX,sdx);
#if CONFIG_RTPDEC
ff_register_rtp_dynamic_payload_handlers();
ff_register_rdt_dynamic_payload_handlers();
#endif
REGISTER_DEMUXER (SEGAFILM,segafilm);
REGISTER_MUXER(SEGMENT,segment);
REGISTER_MUXER(SEGMENT,stream_segment);
REGISTER_DEMUXER (SHORTEN,shorten);
REGISTER_DEMUXER (SIFF,siff);
REGISTER_MUXER(SINGLEJPEG,singlejpeg);
REGISTER_DEMUXER (SLN,sln);
REGISTER_DEMUXER (SMACKER,smacker);
REGISTER_MUXDEMUX(SMJPEG,smjpeg);
REGISTER_MUXER(SMOOTHSTREAMING,smoothstreaming);
REGISTER_DEMUXER (SMUSH,smush);
REGISTER_DEMUXER (SOL,sol);
REGISTER_MUXDEMUX(SOX,sox);
REGISTER_MUXER(SPX,spx);
REGISTER_MUXDEMUX(SPDIF,spdif);
REGISTER_MUXDEMUX(SRT,srt);
REGISTER_DEMUXER (STR,str);
REGISTER_DEMUXER (STL,stl);
REGISTER_DEMUXER (SUBVIEWER1,subviewer1);
REGISTER_DEMUXER (SUBVIEWER,subviewer);
REGISTER_MUXDEMUX(SUP,sup);
REGISTER_DEMUXER (SVAG,svag);
REGISTER_MUXDEMUX(SWF,swf);
REGISTER_DEMUXER (TAK,tak);
REGISTER_MUXER(TEE,tee);
REGISTER_DEMUXER (TEDCAPTIONS,tedcaptions);
REGISTER_MUXER(TG2,tg2);
REGISTER_MUXER(TGP,tgp);
REGISTER_DEMUXER (THP,thp);
REGISTER_DEMUXER (THREEDOSTR,threedostr);
REGISTER_DEMUXER (TIERTEXSEQ,tiertexseq);
REGISTER_MUXER(MKVTIMESTAMP_V2,mkvtimestamp_v2);
REGISTER_DEMUXER (TMV,tmv);
REGISTER_MUXDEMUX(TRUEHD,truehd);
REGISTER_MUXDEMUX(TTA,tta);
REGISTER_DEMUXER (TXD,txd);
REGISTER_DEMUXER (TTY,tty);
REGISTER_MUXER(UNCODEDFRAMECRC,uncodedframecrc);
REGISTER_DEMUXER (V210,v210);
REGISTER_DEMUXER (V210X,v210x);
REGISTER_DEMUXER (VAG,vag);
REGISTER_MUXDEMUX(VC1,vc1);
REGISTER_MUXDEMUX(VC1T,vc1t);
REGISTER_DEMUXER (VIVO,vivo);
REGISTER_DEMUXER (VMD,vmd);
REGISTER_DEMUXER (VOBSUB,vobsub);
REGISTER_MUXDEMUX(VOC,voc);
REGISTER_DEMUXER (VPK,vpk);
REGISTER_DEMUXER (VPLAYER,vplayer);
REGISTER_DEMUXER (VQF,vqf);
REGISTER_MUXDEMUX(W64,w64);
REGISTER_MUXDEMUX(WAV,wav);
REGISTER_DEMUXER (WC3,wc3);
REGISTER_MUXER(WEBM,webm);
REGISTER_MUXDEMUX(WEBM_DASH_MANIFEST, webm_dash_manifest);
REGISTER_MUXER(WEBM_CHUNK,webm_chunk);
REGISTER_MUXER(WEBP,webp);
REGISTER_MUXDEMUX(WEBVTT,webvtt);
REGISTER_DEMUXER (WSAUD,wsaud);
REGISTER_DEMUXER (WSD,wsd);
REGISTER_DEMUXER (WSVQA,wsvqa);
REGISTER_MUXDEMUX(WTV,wtv);
REGISTER_DEMUXER (WVE,wve);
REGISTER_MUXDEMUX(WV,wv);
REGISTER_DEMUXER (XA,xa);
REGISTER_DEMUXER (XBIN,xbin);
REGISTER_DEMUXER (XMV,xmv);
REGISTER_DEMUXER (XVAG,xvag);
REGISTER_DEMUXER (XWMA,xwma);
REGISTER_DEMUXER (YOP,yop);
REGISTER_MUXDEMUX(YUV4MPEGPIPE,yuv4mpegpipe);

/* image demuxers */
REGISTER_DEMUXER (IMAGE_BMP_PIPE,image_bmp_pipe);
REGISTER_DEMUXER (IMAGE_DDS_PIPE,image_dds_pipe);
REGISTER_DEMUXER (IMAGE_DPX_PIPE,image_dpx_pipe);
REGISTER_DEMUXER (IMAGE_EXR_PIPE,image_exr_pipe);
REGISTER_DEMUXER (IMAGE_J2K_PIPE,image_j2k_pipe);
REGISTER_DEMUXER (IMAGE_JPEG_PIPE,image_jpeg_pipe);
REGISTER_DEMUXER (IMAGE_JPEGLS_PIPE,image_jpegls_pipe);
REGISTER_DEMUXER (IMAGE_PAM_PIPE,image_pam_pipe);
REGISTER_DEMUXER (IMAGE_PBM_PIPE,image_pbm_pipe);
REGISTER_DEMUXER (IMAGE_PCX_PIPE,image_pcx_pipe);
REGISTER_DEMUXER (IMAGE_PGMYUV_PIPE,image_pgmyuv_pipe);
REGISTER_DEMUXER (IMAGE_PGM_PIPE,image_pgm_pipe);
REGISTER_DEMUXER (IMAGE_PICTOR_PIPE,image_pictor_pipe);
REGISTER_DEMUXER (IMAGE_PNG_PIPE,image_png_pipe);
REGISTER_DEMUXER (IMAGE_PPM_PIPE,image_ppm_pipe);
REGISTER_DEMUXER (IMAGE_PSD_PIPE,image_psd_pipe);
REGISTER_DEMUXER (IMAGE_QDRAW_PIPE,image_qdraw_pipe);
REGISTER_DEMUXER (IMAGE_SGI_PIPE,image_sgi_pipe);
REGISTER_DEMUXER (IMAGE_SVG_PIPE,image_svg_pipe);
REGISTER_DEMUXER (IMAGE_SUNRAST_PIPE,image_sunrast_pipe);
REGISTER_DEMUXER (IMAGE_TIFF_PIPE,image_tiff_pipe);
REGISTER_DEMUXER (IMAGE_WEBP_PIPE,image_webp_pipe);
REGISTER_DEMUXER (IMAGE_XPM_PIPE,image_xpm_pipe);

/* external libraries */
REGISTER_MUXER(CHROMAPRINT,chromaprint);
REGISTER_DEMUXER (LIBGME,libgme);
REGISTER_DEMUXER (LIBMODPLUG,libmodplug);
REGISTER_DEMUXER (LIBOPENMPT,libopenmpt);
}

void av_register_all(void)
{
static AVOnce control = AV_ONCE_INIT;

ff_thread_once(&control, register_all);
}

#define REGISTER_DEMUXER(X, x)\
{\
extern AVInputFormat ff_##x##_demuxer;\
if (CONFIG_##X##_DEMUXER)\
av_register_input_format(&ff_##x##_demuxer);\
}

void av_register_input_format(AVInputFormat *format)
{
AVInputFormat **p = last_iformat;

// Note, format could be added after the first 2 checks but that implies that *p is no longer NULL
while(p != &format->next && !format->next && avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
p = &(*p)->next;

if (!format->next)
last_iformat = &format->next;
}

#define REGISTER_MUXER(X, x)\
{\
extern AVOutputFormat ff_##x##_muxer;\
if (CONFIG_##X##_MUXER)\
av_register_output_format(&ff_##x##_muxer);\
}

void av_register_output_format(AVOutputFormat *format)
{
AVOutputFormat **p = last_oformat;

// Note, format could be added after the first 2 checks but that implies that *p is no longer NULL
while(p != &format->next && !format->next && avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
p = &(*p)->next;

if (!format->next)
last_oformat = &format->next;
}

#define REGISTER_MUXDEMUX(X, x) REGISTER_MUXER(X, x); REGISTER_DEMUXER(X, x)

#define REGISTER_HWACCEL(X, x)\
{\
extern AVHWAccel ff_##x##_hwaccel;\
if (CONFIG_##X##_HWACCEL)\
av_register_hwaccel(&ff_##x##_hwaccel);\
}

#define REGISTER_ENCODER(X, x)\
{\
extern AVCodec ff_##x##_encoder;\
if (CONFIG_##X##_ENCODER)\
avcodec_register(&ff_##x##_encoder);\
}

#define REGISTER_DECODER(X, x)\
{\
extern AVCodec ff_##x##_decoder;\
if (CONFIG_##X##_DECODER)\
avcodec_register(&ff_##x##_decoder);\
}

#define REGISTER_ENCDEC(X, x) REGISTER_ENCODER(X, x); REGISTER_DECODER(X, x)

#define REGISTER_PARSER(X, x)\
{\
extern AVCodecParser ff_##x##_parser;\
if (CONFIG_##X##_PARSER)\
av_register_codec_parser(&ff_##x##_parser);\
}

static void register_all(void)
{
/* hardware accelerators */
REGISTER_HWACCEL(H263_VAAPI,h263_vaapi);
REGISTER_HWACCEL(H263_VIDEOTOOLBOX, h263_videotoolbox);
REGISTER_HWACCEL(H264_CUVID,h264_cuvid);
REGISTER_HWACCEL(H264_D3D11VA,h264_d3d11va);
REGISTER_HWACCEL(H264_D3D11VA2,h264_d3d11va2);
REGISTER_HWACCEL(H264_DXVA2,h264_dxva2);
REGISTER_HWACCEL(H264_MEDIACODEC,h264_mediacodec);
REGISTER_HWACCEL(H264_MMAL,h264_mmal);
REGISTER_HWACCEL(H264_QSV,h264_qsv);
REGISTER_HWACCEL(H264_VAAPI,h264_vaapi);
REGISTER_HWACCEL(H264_VDA,h264_vda);
REGISTER_HWACCEL(H264_VDA_OLD,h264_vda_old);
REGISTER_HWACCEL(H264_VDPAU,h264_vdpau);
REGISTER_HWACCEL(H264_VIDEOTOOLBOX, h264_videotoolbox);
REGISTER_HWACCEL(HEVC_CUVID,hevc_cuvid);
REGISTER_HWACCEL(HEVC_D3D11VA,hevc_d3d11va);
REGISTER_HWACCEL(HEVC_D3D11VA2,hevc_d3d11va2);
REGISTER_HWACCEL(HEVC_DXVA2,hevc_dxva2);
REGISTER_HWACCEL(HEVC_MEDIACODEC,hevc_mediacodec);
REGISTER_HWACCEL(HEVC_QSV,hevc_qsv);
REGISTER_HWACCEL(HEVC_VAAPI,hevc_vaapi);
REGISTER_HWACCEL(HEVC_VDPAU,hevc_vdpau);
REGISTER_HWACCEL(HEVC_VIDEOTOOLBOX, hevc_videotoolbox);
REGISTER_HWACCEL(MJPEG_CUVID,mjpeg_cuvid);
REGISTER_HWACCEL(MPEG1_CUVID,mpeg1_cuvid);
REGISTER_HWACCEL(MPEG1_XVMC,mpeg1_xvmc);
REGISTER_HWACCEL(MPEG1_VDPAU,mpeg1_vdpau);
REGISTER_HWACCEL(MPEG1_VIDEOTOOLBOX, mpeg1_videotoolbox);
REGISTER_HWACCEL(MPEG2_CUVID,mpeg2_cuvid);
REGISTER_HWACCEL(MPEG2_XVMC,mpeg2_xvmc);
REGISTER_HWACCEL(MPEG2_D3D11VA,mpeg2_d3d11va);
REGISTER_HWACCEL(MPEG2_D3D11VA2,mpeg2_d3d11va2);
REGISTER_HWACCEL(MPEG2_DXVA2,mpeg2_dxva2);
REGISTER_HWACCEL(MPEG2_MMAL,mpeg2_mmal);
REGISTER_HWACCEL(MPEG2_QSV,mpeg2_qsv);
REGISTER_HWACCEL(MPEG2_VAAPI,mpeg2_vaapi);
REGISTER_HWACCEL(MPEG2_VDPAU,mpeg2_vdpau);
REGISTER_HWACCEL(MPEG2_VIDEOTOOLBOX, mpeg2_videotoolbox);
REGISTER_HWACCEL(MPEG2_MEDIACODEC,mpeg2_mediacodec);
REGISTER_HWACCEL(MPEG4_CUVID,mpeg4_cuvid);
REGISTER_HWACCEL(MPEG4_MEDIACODEC,mpeg4_mediacodec);
REGISTER_HWACCEL(MPEG4_MMAL,mpeg4_mmal);
REGISTER_HWACCEL(MPEG4_VAAPI,mpeg4_vaapi);
REGISTER_HWACCEL(MPEG4_VDPAU,mpeg4_vdpau);
REGISTER_HWACCEL(MPEG4_VIDEOTOOLBOX, mpeg4_videotoolbox);
REGISTER_HWACCEL(VC1_CUVID,vc1_cuvid);
REGISTER_HWACCEL(VC1_D3D11VA,vc1_d3d11va);
REGISTER_HWACCEL(VC1_D3D11VA2,vc1_d3d11va2);
REGISTER_HWACCEL(VC1_DXVA2,vc1_dxva2);
REGISTER_HWACCEL(VC1_VAAPI,vc1_vaapi);
REGISTER_HWACCEL(VC1_VDPAU,vc1_vdpau);
REGISTER_HWACCEL(VC1_MMAL,vc1_mmal);
REGISTER_HWACCEL(VC1_QSV,vc1_qsv);
REGISTER_HWACCEL(VP8_CUVID,vp8_cuvid);
REGISTER_HWACCEL(VP8_MEDIACODEC,vp8_mediacodec);
REGISTER_HWACCEL(VP8_QSV,vp8_qsv);
REGISTER_HWACCEL(VP9_CUVID,vp9_cuvid);
REGISTER_HWACCEL(VP9_D3D11VA,vp9_d3d11va);
REGISTER_HWACCEL(VP9_D3D11VA2,vp9_d3d11va2);
REGISTER_HWACCEL(VP9_DXVA2,vp9_dxva2);
REGISTER_HWACCEL(VP9_MEDIACODEC,vp9_mediacodec);
REGISTER_HWACCEL(VP9_VAAPI,vp9_vaapi);
REGISTER_HWACCEL(WMV3_D3D11VA,wmv3_d3d11va);
REGISTER_HWACCEL(WMV3_D3D11VA2,wmv3_d3d11va2);
REGISTER_HWACCEL(WMV3_DXVA2,wmv3_dxva2);
REGISTER_HWACCEL(WMV3_VAAPI,wmv3_vaapi);
REGISTER_HWACCEL(WMV3_VDPAU,wmv3_vdpau);

/* video codecs */
REGISTER_ENCODER(A64MULTI,a64multi);
REGISTER_ENCODER(A64MULTI5,a64multi5);
REGISTER_DECODER(AASC,aasc);
REGISTER_DECODER(AIC,aic);
REGISTER_ENCDEC (ALIAS_PIX,alias_pix);
REGISTER_ENCDEC (AMV,amv);
REGISTER_DECODER(ANM,anm);
REGISTER_DECODER(ANSI,ansi);
REGISTER_ENCDEC (APNG,apng);
REGISTER_ENCDEC (ASV1,asv1);
REGISTER_ENCDEC (ASV2,asv2);
REGISTER_DECODER(AURA,aura);
REGISTER_DECODER(AURA2,aura2);
REGISTER_ENCDEC (AVRP,avrp);
REGISTER_DECODER(AVRN,avrn);
REGISTER_DECODER(AVS,avs);
REGISTER_ENCDEC (AVUI,avui);
REGISTER_ENCDEC (AYUV,ayuv);
REGISTER_DECODER(BETHSOFTVID,bethsoftvid);
REGISTER_DECODER(BFI,bfi);
REGISTER_DECODER(BINK,bink);
REGISTER_ENCDEC (BMP,bmp);
REGISTER_DECODER(BMV_VIDEO,bmv_video);
REGISTER_DECODER(BRENDER_PIX,brender_pix);
REGISTER_DECODER(C93,c93);
REGISTER_DECODER(CAVS,cavs);
REGISTER_DECODER(CDGRAPHICS,cdgraphics);
REGISTER_DECODER(CDXL,cdxl);
REGISTER_DECODER(CFHD,cfhd);
REGISTER_ENCDEC (CINEPAK,cinepak);
REGISTER_DECODER(CLEARVIDEO,clearvideo);
REGISTER_ENCDEC (CLJR,cljr);
REGISTER_DECODER(CLLC,cllc);
REGISTER_ENCDEC (COMFORTNOISE,comfortnoise);
REGISTER_DECODER(CPIA,cpia);
REGISTER_DECODER(CSCD,cscd);
REGISTER_DECODER(CYUV,cyuv);
REGISTER_DECODER(DDS,dds);
REGISTER_DECODER(DFA,dfa);
REGISTER_DECODER(DIRAC,dirac);
REGISTER_ENCDEC (DNXHD,dnxhd);
REGISTER_ENCDEC (DPX,dpx);
REGISTER_DECODER(DSICINVIDEO,dsicinvideo);
REGISTER_DECODER(DVAUDIO,dvaudio);
REGISTER_ENCDEC (DVVIDEO,dvvideo);
REGISTER_DECODER(DXA,dxa);
REGISTER_DECODER(DXTORY,dxtory);
REGISTER_DECODER(DXV,dxv);
REGISTER_DECODER(EACMV,eacmv);
REGISTER_DECODER(EAMAD,eamad);
REGISTER_DECODER(EATGQ,eatgq);
REGISTER_DECODER(EATGV,eatgv);
REGISTER_DECODER(EATQI,eatqi);
REGISTER_DECODER(EIGHTBPS,eightbps);
REGISTER_DECODER(EIGHTSVX_EXP,eightsvx_exp);
REGISTER_DECODER(EIGHTSVX_FIB,eightsvx_fib);
REGISTER_DECODER(ESCAPE124,escape124);
REGISTER_DECODER(ESCAPE130,escape130);
REGISTER_DECODER(EXR,exr);
REGISTER_ENCDEC (FFV1,ffv1);
REGISTER_ENCDEC (FFVHUFF,ffvhuff);
REGISTER_DECODER(FIC,fic);
REGISTER_ENCDEC (FITS,fits);
REGISTER_ENCDEC (FLASHSV,flashsv);
REGISTER_ENCDEC (FLASHSV2,flashsv2);
REGISTER_DECODER(FLIC,flic);
REGISTER_ENCDEC (FLV,flv);
REGISTER_DECODER(FMVC,fmvc);
REGISTER_DECODER(FOURXM,fourxm);
REGISTER_DECODER(FRAPS,fraps);
REGISTER_DECODER(FRWU,frwu);
REGISTER_DECODER(G2M,g2m);
REGISTER_DECODER(GDV,gdv);
REGISTER_ENCDEC (GIF,gif);
REGISTER_ENCDEC (H261,h261);
REGISTER_ENCDEC (H263,h263);
REGISTER_DECODER(H263I,h263i);
REGISTER_ENCDEC (H263P,h263p);
REGISTER_DECODER(H263_V4L2M2M,h263_v4l2m2m);
REGISTER_DECODER(H264,h264);
REGISTER_DECODER(H264_CRYSTALHD,h264_crystalhd);
REGISTER_DECODER(H264_V4L2M2M,h264_v4l2m2m);
REGISTER_DECODER(H264_MEDIACODEC,h264_mediacodec);
REGISTER_DECODER(H264_MMAL,h264_mmal);
REGISTER_DECODER(H264_QSV,h264_qsv);
REGISTER_DECODER(H264_RKMPP,h264_rkmpp);
REGISTER_DECODER(H264_VDA,h264_vda);
#if FF_API_VDPAU
REGISTER_DECODER(H264_VDPAU,h264_vdpau);
#endif
REGISTER_ENCDEC (HAP,hap);
REGISTER_DECODER(HEVC,hevc);
REGISTER_DECODER(HEVC_QSV,hevc_qsv);
REGISTER_DECODER(HEVC_RKMPP,hevc_rkmpp);
REGISTER_DECODER(HEVC_V4L2M2M,hevc_v4l2m2m);
REGISTER_DECODER(HNM4_VIDEO,hnm4_video);
REGISTER_DECODER(HQ_HQA,hq_hqa);
REGISTER_DECODER(HQX,hqx);
REGISTER_ENCDEC (HUFFYUV,huffyuv);
REGISTER_DECODER(IDCIN,idcin);
REGISTER_DECODER(IFF_ILBM,iff_ilbm);
REGISTER_DECODER(INDEO2,indeo2);
REGISTER_DECODER(INDEO3,indeo3);
REGISTER_DECODER(INDEO4,indeo4);
REGISTER_DECODER(INDEO5,indeo5);
REGISTER_DECODER(INTERPLAY_VIDEO,interplay_video);
REGISTER_ENCDEC (JPEG2000,jpeg2000);
REGISTER_ENCDEC (JPEGLS,jpegls);
REGISTER_DECODER(JV,jv);
REGISTER_DECODER(KGV1,kgv1);
REGISTER_DECODER(KMVC,kmvc);
REGISTER_DECODER(LAGARITH,lagarith);
REGISTER_ENCODER(LJPEG,ljpeg);
REGISTER_DECODER(LOCO,loco);
REGISTER_DECODER(M101,m101);
REGISTER_DECODER(MAGICYUV,magicyuv);
REGISTER_DECODER(MDEC,mdec);
REGISTER_DECODER(MIMIC,mimic);
REGISTER_ENCDEC (MJPEG,mjpeg);
REGISTER_DECODER(MJPEGB,mjpegb);
REGISTER_DECODER(MMVIDEO,mmvideo);
REGISTER_DECODER(MOTIONPIXELS,motionpixels);
#if FF_API_XVMC
REGISTER_DECODER(MPEG_XVMC,mpeg_xvmc);
#endif /* FF_API_XVMC */
REGISTER_ENCDEC (MPEG1VIDEO,mpeg1video);
REGISTER_ENCDEC (MPEG2VIDEO,mpeg2video);
REGISTER_ENCDEC (MPEG4,mpeg4);
REGISTER_DECODER(MPEG4_CRYSTALHD,mpeg4_crystalhd);
REGISTER_DECODER(MPEG4_V4L2M2M,mpeg4_v4l2m2m);
REGISTER_DECODER(MPEG4_MMAL,mpeg4_mmal);
#if FF_API_VDPAU
REGISTER_DECODER(MPEG4_VDPAU,mpeg4_vdpau);
#endif
REGISTER_DECODER(MPEGVIDEO,mpegvideo);
#if FF_API_VDPAU
REGISTER_DECODER(MPEG_VDPAU,mpeg_vdpau);
REGISTER_DECODER(MPEG1_VDPAU,mpeg1_vdpau);
#endif
REGISTER_DECODER(MPEG1_V4L2M2M,mpeg1_v4l2m2m);
REGISTER_DECODER(MPEG2_MMAL,mpeg2_mmal);
REGISTER_DECODER(MPEG2_CRYSTALHD,mpeg2_crystalhd);
REGISTER_DECODER(MPEG2_V4L2M2M,mpeg2_v4l2m2m);
REGISTER_DECODER(MPEG2_QSV,mpeg2_qsv);
REGISTER_DECODER(MPEG2_MEDIACODEC,mpeg2_mediacodec);
REGISTER_DECODER(MSA1,msa1);
REGISTER_DECODER(MSCC,mscc);
REGISTER_DECODER(MSMPEG4V1,msmpeg4v1);
REGISTER_ENCDEC (MSMPEG4V2,msmpeg4v2);
REGISTER_ENCDEC (MSMPEG4V3,msmpeg4v3);
REGISTER_DECODER(MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
REGISTER_DECODER(MSRLE,msrle);
REGISTER_DECODER(MSS1,mss1);
REGISTER_DECODER(MSS2,mss2);
REGISTER_ENCDEC (MSVIDEO1,msvideo1);
REGISTER_DECODER(MSZH,mszh);
REGISTER_DECODER(MTS2,mts2);
REGISTER_DECODER(MVC1,mvc1);
REGISTER_DECODER(MVC2,mvc2);
REGISTER_DECODER(MXPEG,mxpeg);
REGISTER_DECODER(NUV,nuv);
REGISTER_DECODER(PAF_VIDEO,paf_video);
REGISTER_ENCDEC (PAM,pam);
REGISTER_ENCDEC (PBM,pbm);
REGISTER_ENCDEC (PCX,pcx);
REGISTER_ENCDEC (PGM,pgm);
REGISTER_ENCDEC (PGMYUV,pgmyuv);
REGISTER_DECODER(PICTOR,pictor);
REGISTER_DECODER(PIXLET,pixlet);
REGISTER_ENCDEC (PNG,png);
REGISTER_ENCDEC (PPM,ppm);
REGISTER_ENCDEC (PRORES,prores);
REGISTER_ENCODER(PRORES_AW,prores_aw);
REGISTER_ENCODER(PRORES_KS,prores_ks);
REGISTER_DECODER(PRORES_LGPL,prores_lgpl);
REGISTER_DECODER(PSD,psd);
REGISTER_DECODER(PTX,ptx);
REGISTER_DECODER(QDRAW,qdraw);
REGISTER_DECODER(QPEG,qpeg);
REGISTER_ENCDEC (QTRLE,qtrle);
REGISTER_ENCDEC (R10K,r10k);
REGISTER_ENCDEC (R210,r210);
REGISTER_ENCDEC (RAWVIDEO,rawvideo);
REGISTER_DECODER(RL2,rl2);
REGISTER_ENCDEC (ROQ,roq);
REGISTER_DECODER(RPZA,rpza);
REGISTER_DECODER(RSCC,rscc);
REGISTER_ENCDEC (RV10,rv10);
REGISTER_ENCDEC (RV20,rv20);
REGISTER_DECODER(RV30,rv30);
REGISTER_DECODER(RV40,rv40);
REGISTER_ENCDEC (S302M,s302m);
REGISTER_DECODER(SANM,sanm);
REGISTER_DECODER(SCPR,scpr);
REGISTER_DECODER(SCREENPRESSO,screenpresso);
REGISTER_DECODER(SDX2_DPCM,sdx2_dpcm);
REGISTER_ENCDEC (SGI,sgi);
REGISTER_DECODER(SGIRLE,sgirle);
REGISTER_DECODER(SHEERVIDEO,sheervideo);
REGISTER_DECODER(SMACKER,smacker);
REGISTER_DECODER(SMC,smc);
REGISTER_DECODER(SMVJPEG,smvjpeg);
REGISTER_ENCDEC (SNOW,snow);
REGISTER_DECODER(SP5X,sp5x);
REGISTER_DECODER(SPEEDHQ,speedhq);
REGISTER_DECODER(SRGC,srgc);
REGISTER_ENCDEC (SUNRAST,sunrast);
REGISTER_ENCDEC (SVQ1,svq1);
REGISTER_DECODER(SVQ3,svq3);
REGISTER_ENCDEC (TARGA,targa);
REGISTER_DECODER(TARGA_Y216,targa_y216);
REGISTER_DECODER(TDSC,tdsc);
REGISTER_DECODER(THEORA,theora);
REGISTER_DECODER(THP,thp);
REGISTER_DECODER(TIERTEXSEQVIDEO,tiertexseqvideo);
REGISTER_ENCDEC (TIFF,tiff);
REGISTER_DECODER(TMV,tmv);
REGISTER_DECODER(TRUEMOTION1,truemotion1);
REGISTER_DECODER(TRUEMOTION2,truemotion2);
REGISTER_DECODER(TRUEMOTION2RT,truemotion2rt);
REGISTER_DECODER(TSCC,tscc);
REGISTER_DECODER(TSCC2,tscc2);
REGISTER_DECODER(TXD,txd);
REGISTER_DECODER(ULTI,ulti);
REGISTER_ENCDEC (UTVIDEO,utvideo);
REGISTER_ENCDEC (V210,v210);
REGISTER_DECODER(V210X,v210x);
REGISTER_ENCDEC (V308,v308);
REGISTER_ENCDEC (V408,v408);
REGISTER_ENCDEC (V410,v410);
REGISTER_DECODER(VB,vb);
REGISTER_DECODER(VBLE,vble);
REGISTER_DECODER(VC1,vc1);
REGISTER_DECODER(VC1_CRYSTALHD,vc1_crystalhd);
#if FF_API_VDPAU
REGISTER_DECODER(VC1_VDPAU,vc1_vdpau);
#endif
REGISTER_DECODER(VC1IMAGE,vc1image);
REGISTER_DECODER(VC1_MMAL,vc1_mmal);
REGISTER_DECODER(VC1_QSV,vc1_qsv);
REGISTER_DECODER(VC1_V4L2M2M,vc1_v4l2m2m);
REGISTER_ENCODER(VC2,vc2);
REGISTER_DECODER(VCR1,vcr1);
REGISTER_DECODER(VMDVIDEO,vmdvideo);
REGISTER_DECODER(VMNC,vmnc);
REGISTER_DECODER(VP3,vp3);
REGISTER_DECODER(VP5,vp5);
REGISTER_DECODER(VP6,vp6);
REGISTER_DECODER(VP6A,vp6a);
REGISTER_DECODER(VP6F,vp6f);
REGISTER_DECODER(VP7,vp7);
REGISTER_DECODER(VP8,vp8);
REGISTER_DECODER(VP8_RKMPP,vp8_rkmpp);
REGISTER_DECODER(VP8_V4L2M2M,vp8_v4l2m2m);
REGISTER_DECODER(VP9,vp9);
REGISTER_DECODER(VP9_RKMPP,vp9_rkmpp);
REGISTER_DECODER(VP9_V4L2M2M,vp9_v4l2m2m);
REGISTER_DECODER(VQA,vqa);
REGISTER_DECODER(BITPACKED,bitpacked);
REGISTER_DECODER(WEBP,webp);
REGISTER_ENCDEC (WRAPPED_AVFRAME,wrapped_avframe);
REGISTER_ENCDEC (WMV1,wmv1);
REGISTER_ENCDEC (WMV2,wmv2);
REGISTER_DECODER(WMV3,wmv3);
REGISTER_DECODER(WMV3_CRYSTALHD,wmv3_crystalhd);
#if FF_API_VDPAU
REGISTER_DECODER(WMV3_VDPAU,wmv3_vdpau);
#endif
REGISTER_DECODER(WMV3IMAGE,wmv3image);
REGISTER_DECODER(WNV1,wnv1);
REGISTER_DECODER(XAN_WC3,xan_wc3);
REGISTER_DECODER(XAN_WC4,xan_wc4);
REGISTER_ENCDEC (XBM,xbm);
REGISTER_ENCDEC (XFACE,xface);
REGISTER_DECODER(XL,xl);
REGISTER_DECODER(XPM,xpm);
REGISTER_ENCDEC (XWD,xwd);
REGISTER_ENCDEC (Y41P,y41p);
REGISTER_DECODER(YLC,ylc);
REGISTER_DECODER(YOP,yop);
REGISTER_ENCDEC (YUV4,yuv4);
REGISTER_DECODER(ZERO12V,zero12v);
REGISTER_DECODER(ZEROCODEC,zerocodec);
REGISTER_ENCDEC (ZLIB,zlib);
REGISTER_ENCDEC (ZMBV,zmbv);

/* audio codecs */
REGISTER_ENCDEC (AAC,aac);
REGISTER_DECODER(AAC_FIXED,aac_fixed);
REGISTER_DECODER(AAC_LATM,aac_latm);
REGISTER_ENCDEC (AC3,ac3);
REGISTER_ENCDEC (AC3_FIXED,ac3_fixed);
REGISTER_ENCDEC (ALAC,alac);
REGISTER_DECODER(ALS,als);
REGISTER_DECODER(AMRNB,amrnb);
REGISTER_DECODER(AMRWB,amrwb);
REGISTER_DECODER(APE,ape);
REGISTER_DECODER(ATRAC1,atrac1);
REGISTER_DECODER(ATRAC3,atrac3);
REGISTER_DECODER(ATRAC3AL,atrac3al);
REGISTER_DECODER(ATRAC3P,atrac3p);
REGISTER_DECODER(ATRAC3PAL,atrac3pal);
REGISTER_DECODER(BINKAUDIO_DCT,binkaudio_dct);
REGISTER_DECODER(BINKAUDIO_RDFT,binkaudio_rdft);
REGISTER_DECODER(BMV_AUDIO,bmv_audio);
REGISTER_DECODER(COOK,cook);
REGISTER_ENCDEC (DCA,dca);
REGISTER_DECODER(DOLBY_E,dolby_e);
REGISTER_DECODER(DSD_LSBF,dsd_lsbf);
REGISTER_DECODER(DSD_MSBF,dsd_msbf);
REGISTER_DECODER(DSD_LSBF_PLANAR,dsd_lsbf_planar);
REGISTER_DECODER(DSD_MSBF_PLANAR,dsd_msbf_planar);
REGISTER_DECODER(DSICINAUDIO,dsicinaudio);
REGISTER_DECODER(DSS_SP,dss_sp);
REGISTER_DECODER(DST,dst);
REGISTER_ENCDEC (EAC3,eac3);
REGISTER_DECODER(EVRC,evrc);
REGISTER_DECODER(FFWAVESYNTH,ffwavesynth);
REGISTER_ENCDEC (FLAC,flac);
REGISTER_ENCDEC (G723_1,g723_1);
REGISTER_DECODER(G729,g729);
REGISTER_DECODER(GSM,gsm);
REGISTER_DECODER(GSM_MS,gsm_ms);
REGISTER_DECODER(IAC,iac);
REGISTER_DECODER(IMC,imc);
REGISTER_DECODER(INTERPLAY_ACM,interplay_acm);
REGISTER_DECODER(MACE3,mace3);
REGISTER_DECODER(MACE6,mace6);
REGISTER_DECODER(METASOUND,metasound);
REGISTER_ENCDEC (MLP,mlp);
REGISTER_DECODER(MP1,mp1);
REGISTER_DECODER(MP1FLOAT,mp1float);
REGISTER_ENCDEC (MP2,mp2);
REGISTER_DECODER(MP2FLOAT,mp2float);
REGISTER_ENCODER(MP2FIXED,mp2fixed);
REGISTER_DECODER(MP3,mp3);
REGISTER_DECODER(MP3FLOAT,mp3float);
REGISTER_DECODER(MP3ADU,mp3adu);
REGISTER_DECODER(MP3ADUFLOAT,mp3adufloat);
REGISTER_DECODER(MP3ON4,mp3on4);
REGISTER_DECODER(MP3ON4FLOAT,mp3on4float);
REGISTER_DECODER(MPC7,mpc7);
REGISTER_DECODER(MPC8,mpc8);
REGISTER_ENCDEC (NELLYMOSER,nellymoser);
REGISTER_DECODER(ON2AVC,on2avc);
REGISTER_ENCDEC (OPUS,opus);
REGISTER_DECODER(PAF_AUDIO,paf_audio);
REGISTER_DECODER(QCELP,qcelp);
REGISTER_DECODER(QDM2,qdm2);
REGISTER_DECODER(QDMC,qdmc);
REGISTER_ENCDEC (RA_144,ra_144);
REGISTER_DECODER(RA_288,ra_288);
REGISTER_DECODER(RALF,ralf);
REGISTER_DECODER(SHORTEN,shorten);
REGISTER_DECODER(SIPR,sipr);
REGISTER_DECODER(SMACKAUD,smackaud);
REGISTER_ENCDEC (SONIC,sonic);
REGISTER_ENCODER(SONIC_LS,sonic_ls);
REGISTER_DECODER(TAK,tak);
REGISTER_ENCDEC (TRUEHD,truehd);
REGISTER_DECODER(TRUESPEECH,truespeech);
REGISTER_ENCDEC (TTA,tta);
REGISTER_DECODER(TWINVQ,twinvq);
REGISTER_DECODER(VMDAUDIO,vmdaudio);
REGISTER_ENCDEC (VORBIS,vorbis);
REGISTER_ENCDEC (WAVPACK,wavpack);
REGISTER_DECODER(WMALOSSLESS,wmalossless);
REGISTER_DECODER(WMAPRO,wmapro);
REGISTER_ENCDEC (WMAV1,wmav1);
REGISTER_ENCDEC (WMAV2,wmav2);
REGISTER_DECODER(WMAVOICE,wmavoice);
REGISTER_DECODER(WS_SND1,ws_snd1);
REGISTER_DECODER(XMA1,xma1);
REGISTER_DECODER(XMA2,xma2);

/* PCM codecs */
REGISTER_ENCDEC (PCM_ALAW,pcm_alaw);
REGISTER_DECODER(PCM_BLURAY,pcm_bluray);
REGISTER_DECODER(PCM_DVD,pcm_dvd);
REGISTER_DECODER(PCM_F16LE,pcm_f16le);
REGISTER_DECODER(PCM_F24LE,pcm_f24le);
REGISTER_ENCDEC (PCM_F32BE,pcm_f32be);
REGISTER_ENCDEC (PCM_F32LE,pcm_f32le);
REGISTER_ENCDEC (PCM_F64BE,pcm_f64be);
REGISTER_ENCDEC (PCM_F64LE,pcm_f64le);
REGISTER_DECODER(PCM_LXF,pcm_lxf);
REGISTER_ENCDEC (PCM_MULAW,pcm_mulaw);
REGISTER_ENCDEC (PCM_S8,pcm_s8);
REGISTER_ENCDEC (PCM_S8_PLANAR,pcm_s8_planar);
REGISTER_ENCDEC (PCM_S16BE,pcm_s16be);
REGISTER_ENCDEC (PCM_S16BE_PLANAR,pcm_s16be_planar);
REGISTER_ENCDEC (PCM_S16LE,pcm_s16le);
REGISTER_ENCDEC (PCM_S16LE_PLANAR,pcm_s16le_planar);
REGISTER_ENCDEC (PCM_S24BE,pcm_s24be);
REGISTER_ENCDEC (PCM_S24DAUD,pcm_s24daud);
REGISTER_ENCDEC (PCM_S24LE,pcm_s24le);
REGISTER_ENCDEC (PCM_S24LE_PLANAR,pcm_s24le_planar);
REGISTER_ENCDEC (PCM_S32BE,pcm_s32be);
REGISTER_ENCDEC (PCM_S32LE,pcm_s32le);
REGISTER_ENCDEC (PCM_S32LE_PLANAR,pcm_s32le_planar);
REGISTER_ENCDEC (PCM_S64BE,pcm_s64be);
REGISTER_ENCDEC (PCM_S64LE,pcm_s64le);
REGISTER_ENCDEC (PCM_U8,pcm_u8);
REGISTER_ENCDEC (PCM_U16BE,pcm_u16be);
REGISTER_ENCDEC (PCM_U16LE,pcm_u16le);
REGISTER_ENCDEC (PCM_U24BE,pcm_u24be);
REGISTER_ENCDEC (PCM_U24LE,pcm_u24le);
REGISTER_ENCDEC (PCM_U32BE,pcm_u32be);
REGISTER_ENCDEC (PCM_U32LE,pcm_u32le);
REGISTER_DECODER(PCM_ZORK,pcm_zork);

/* DPCM codecs */
REGISTER_DECODER(GREMLIN_DPCM,gremlin_dpcm);
REGISTER_DECODER(INTERPLAY_DPCM,interplay_dpcm);
REGISTER_ENCDEC (ROQ_DPCM,roq_dpcm);
REGISTER_DECODER(SOL_DPCM,sol_dpcm);
REGISTER_DECODER(XAN_DPCM,xan_dpcm);

/* ADPCM codecs */
REGISTER_DECODER(ADPCM_4XM,adpcm_4xm);
REGISTER_ENCDEC (ADPCM_ADX,adpcm_adx);
REGISTER_DECODER(ADPCM_AFC,adpcm_afc);
REGISTER_DECODER(ADPCM_AICA,adpcm_aica);
REGISTER_DECODER(ADPCM_CT,adpcm_ct);
REGISTER_DECODER(ADPCM_DTK,adpcm_dtk);
REGISTER_DECODER(ADPCM_EA,adpcm_ea);
REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
REGISTER_DECODER(ADPCM_EA_R1,adpcm_ea_r1);
REGISTER_DECODER(ADPCM_EA_R2,adpcm_ea_r2);
REGISTER_DECODER(ADPCM_EA_R3,adpcm_ea_r3);
REGISTER_DECODER(ADPCM_EA_XAS,adpcm_ea_xas);
REGISTER_ENCDEC (ADPCM_G722,adpcm_g722);
REGISTER_ENCDEC (ADPCM_G726,adpcm_g726);
REGISTER_ENCDEC (ADPCM_G726LE,adpcm_g726le);
REGISTER_DECODER(ADPCM_IMA_AMV,adpcm_ima_amv);
REGISTER_DECODER(ADPCM_IMA_APC,adpcm_ima_apc);
REGISTER_DECODER(ADPCM_IMA_DAT4,adpcm_ima_dat4);
REGISTER_DECODER(ADPCM_IMA_DK3,adpcm_ima_dk3);
REGISTER_DECODER(ADPCM_IMA_DK4,adpcm_ima_dk4);
REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
REGISTER_DECODER(ADPCM_IMA_ISS,adpcm_ima_iss);
REGISTER_DECODER(ADPCM_IMA_OKI,adpcm_ima_oki);
REGISTER_ENCDEC (ADPCM_IMA_QT,adpcm_ima_qt);
REGISTER_DECODER(ADPCM_IMA_RAD,adpcm_ima_rad);
REGISTER_DECODER(ADPCM_IMA_SMJPEG,adpcm_ima_smjpeg);
REGISTER_ENCDEC (ADPCM_IMA_WAV,adpcm_ima_wav);
REGISTER_DECODER(ADPCM_IMA_WS,adpcm_ima_ws);
REGISTER_ENCDEC (ADPCM_MS,adpcm_ms);
REGISTER_DECODER(ADPCM_MTAF,adpcm_mtaf);
REGISTER_DECODER(ADPCM_PSX,adpcm_psx);
REGISTER_DECODER(ADPCM_SBPRO_2,adpcm_sbpro_2);
REGISTER_DECODER(ADPCM_SBPRO_3,adpcm_sbpro_3);
REGISTER_DECODER(ADPCM_SBPRO_4,adpcm_sbpro_4);
REGISTER_ENCDEC (ADPCM_SWF,adpcm_swf);
REGISTER_DECODER(ADPCM_THP,adpcm_thp);
REGISTER_DECODER(ADPCM_THP_LE,adpcm_thp_le);
REGISTER_DECODER(ADPCM_VIMA,adpcm_vima);
REGISTER_DECODER(ADPCM_XA,adpcm_xa);
REGISTER_ENCDEC (ADPCM_YAMAHA,adpcm_yamaha);

/* subtitles */
REGISTER_ENCDEC (SSA,ssa);
REGISTER_ENCDEC (ASS,ass);
REGISTER_DECODER(CCAPTION,ccaption);
REGISTER_ENCDEC (DVBSUB,dvbsub);
REGISTER_ENCDEC (DVDSUB,dvdsub);
REGISTER_DECODER(JACOSUB,jacosub);
REGISTER_DECODER(MICRODVD,microdvd);
REGISTER_ENCDEC (MOVTEXT,movtext);
REGISTER_DECODER(MPL2,mpl2);
REGISTER_DECODER(PGSSUB,pgssub);
REGISTER_DECODER(PJS,pjs);
REGISTER_DECODER(REALTEXT,realtext);
REGISTER_DECODER(SAMI,sami);
REGISTER_ENCDEC (SRT,srt);
REGISTER_DECODER(STL,stl);
REGISTER_ENCDEC (SUBRIP,subrip);
REGISTER_DECODER(SUBVIEWER,subviewer);
REGISTER_DECODER(SUBVIEWER1,subviewer1);
REGISTER_ENCDEC (TEXT,text);
REGISTER_DECODER(VPLAYER,vplayer);
REGISTER_ENCDEC (WEBVTT,webvtt);
REGISTER_ENCDEC (XSUB,xsub);

/* external libraries */
REGISTER_ENCDEC (AAC_AT,aac_at);
REGISTER_DECODER(AC3_AT,ac3_at);
REGISTER_DECODER(ADPCM_IMA_QT_AT,adpcm_ima_qt_at);
REGISTER_ENCDEC (ALAC_AT,alac_at);
REGISTER_DECODER(AMR_NB_AT,amr_nb_at);
REGISTER_DECODER(EAC3_AT,eac3_at);
REGISTER_DECODER(GSM_MS_AT,gsm_ms_at);
REGISTER_ENCDEC (ILBC_AT,ilbc_at);
REGISTER_DECODER(MP1_AT,mp1_at);
REGISTER_DECODER(MP2_AT,mp2_at);
REGISTER_DECODER(MP3_AT,mp3_at);
REGISTER_ENCDEC (PCM_ALAW_AT,pcm_alaw_at);
REGISTER_ENCDEC (PCM_MULAW_AT,pcm_mulaw_at);
REGISTER_DECODER(QDMC_AT,qdmc_at);
REGISTER_DECODER(QDM2_AT,qdm2_at);
REGISTER_DECODER(LIBCELT,libcelt);
REGISTER_ENCDEC (LIBFDK_AAC,libfdk_aac);
REGISTER_ENCDEC (LIBGSM,libgsm);
REGISTER_ENCDEC (LIBGSM_MS,libgsm_ms);
REGISTER_ENCDEC (LIBILBC,libilbc);
REGISTER_ENCODER(LIBMP3LAME,libmp3lame);
REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
REGISTER_ENCDEC (LIBOPENJPEG,libopenjpeg);
REGISTER_ENCDEC (LIBOPUS,libopus);
REGISTER_DECODER(LIBRSVG,librsvg);
REGISTER_ENCODER(LIBSHINE,libshine);
REGISTER_ENCDEC (LIBSPEEX,libspeex);
REGISTER_ENCODER(LIBTHEORA,libtheora);
REGISTER_ENCODER(LIBTWOLAME,libtwolame);
REGISTER_ENCODER(LIBVO_AMRWBENC,libvo_amrwbenc);
REGISTER_ENCDEC (LIBVORBIS,libvorbis);
REGISTER_ENCDEC (LIBVPX_VP8,libvpx_vp8);
REGISTER_ENCDEC (LIBVPX_VP9,libvpx_vp9);
REGISTER_ENCODER(LIBWAVPACK,libwavpack);
REGISTER_ENCODER(LIBWEBP_ANIM,libwebp_anim);/* preferred over libwebp */
REGISTER_ENCODER(LIBWEBP,libwebp);
REGISTER_ENCODER(LIBX262,libx262);
REGISTER_ENCODER(LIBX264,libx264);
REGISTER_ENCODER(LIBX264RGB,libx264rgb);
REGISTER_ENCODER(LIBX265,libx265);
REGISTER_ENCODER(LIBXAVS,libxavs);
REGISTER_ENCODER(LIBXVID,libxvid);
REGISTER_DECODER(LIBZVBI_TELETEXT,libzvbi_teletext);

/* text */
REGISTER_DECODER(BINTEXT,bintext);
REGISTER_DECODER(XBIN,xbin);
REGISTER_DECODER(IDF,idf);

/* external libraries, that shouldn't be used by default if one of the
* above is available */
REGISTER_ENCODER(H263_V4L2M2M,h263_v4l2m2m);
REGISTER_ENCDEC (LIBOPENH264,libopenh264);
REGISTER_DECODER(H264_CUVID,h264_cuvid);
REGISTER_ENCODER(H264_NVENC,h264_nvenc);
REGISTER_ENCODER(H264_OMX,h264_omx);
REGISTER_ENCODER(H264_QSV,h264_qsv);
REGISTER_ENCODER(H264_V4L2M2M,h264_v4l2m2m);
REGISTER_ENCODER(H264_VAAPI,h264_vaapi);
REGISTER_ENCODER(H264_VIDEOTOOLBOX, h264_videotoolbox);
#if FF_API_NVENC_OLD_NAME
REGISTER_ENCODER(NVENC,nvenc);
REGISTER_ENCODER(NVENC_H264,nvenc_h264);
REGISTER_ENCODER(NVENC_HEVC,nvenc_hevc);
#endif
REGISTER_DECODER(HEVC_CUVID,hevc_cuvid);
REGISTER_DECODER(HEVC_MEDIACODEC,hevc_mediacodec);
REGISTER_ENCODER(HEVC_NVENC,hevc_nvenc);
REGISTER_ENCODER(HEVC_QSV,hevc_qsv);
REGISTER_ENCODER(HEVC_V4L2M2M,hevc_v4l2m2m);
REGISTER_ENCODER(HEVC_VAAPI,hevc_vaapi);
REGISTER_ENCODER(LIBKVAZAAR,libkvazaar);
REGISTER_DECODER(MJPEG_CUVID,mjpeg_cuvid);
REGISTER_ENCODER(MJPEG_VAAPI,mjpeg_vaapi);
REGISTER_DECODER(MPEG1_CUVID,mpeg1_cuvid);
REGISTER_DECODER(MPEG2_CUVID,mpeg2_cuvid);
REGISTER_ENCODER(MPEG2_QSV,mpeg2_qsv);
REGISTER_ENCODER(MPEG2_VAAPI,mpeg2_vaapi);
REGISTER_DECODER(MPEG4_CUVID,mpeg4_cuvid);
REGISTER_DECODER(MPEG4_MEDIACODEC,mpeg4_mediacodec);
REGISTER_ENCODER(MPEG4_V4L2M2M,mpeg4_v4l2m2m);
REGISTER_DECODER(VC1_CUVID,vc1_cuvid);
REGISTER_DECODER(VP8_CUVID,vp8_cuvid);
REGISTER_DECODER(VP8_MEDIACODEC,vp8_mediacodec);
REGISTER_DECODER(VP8_QSV,vp8_qsv);
REGISTER_ENCODER(VP8_V4L2M2M,vp8_v4l2m2m);
REGISTER_ENCODER(VP8_VAAPI,vp8_vaapi);
REGISTER_DECODER(VP9_CUVID,vp9_cuvid);
REGISTER_DECODER(VP9_MEDIACODEC,vp9_mediacodec);
REGISTER_ENCODER(VP9_VAAPI,vp9_vaapi);

/* parsers */
REGISTER_PARSER(AAC,aac);
REGISTER_PARSER(AAC_LATM,aac_latm);
REGISTER_PARSER(AC3,ac3);
REGISTER_PARSER(ADX,adx);
REGISTER_PARSER(BMP,bmp);
REGISTER_PARSER(CAVSVIDEO,cavsvideo);
REGISTER_PARSER(COOK,cook);
REGISTER_PARSER(DCA,dca);
REGISTER_PARSER(DIRAC,dirac);
REGISTER_PARSER(DNXHD,dnxhd);
REGISTER_PARSER(DPX,dpx);
REGISTER_PARSER(DVAUDIO,dvaudio);
REGISTER_PARSER(DVBSUB,dvbsub);
REGISTER_PARSER(DVDSUB,dvdsub);
REGISTER_PARSER(DVD_NAV,dvd_nav);
REGISTER_PARSER(FLAC,flac);
REGISTER_PARSER(G729,g729);
REGISTER_PARSER(GSM,gsm);
REGISTER_PARSER(H261,h261);
REGISTER_PARSER(H263,h263);
REGISTER_PARSER(H264,h264);
REGISTER_PARSER(HEVC,hevc);
REGISTER_PARSER(MJPEG,mjpeg);
REGISTER_PARSER(MLP,mlp);
REGISTER_PARSER(MPEG4VIDEO,mpeg4video);
REGISTER_PARSER(MPEGAUDIO,mpegaudio);
REGISTER_PARSER(MPEGVIDEO,mpegvideo);
REGISTER_PARSER(OPUS,opus);
REGISTER_PARSER(PNG,png);
REGISTER_PARSER(PNM,pnm);
REGISTER_PARSER(RV30,rv30);
REGISTER_PARSER(RV40,rv40);
REGISTER_PARSER(SIPR,sipr);
REGISTER_PARSER(TAK,tak);
REGISTER_PARSER(VC1,vc1);
REGISTER_PARSER(VORBIS,vorbis);
REGISTER_PARSER(VP3,vp3);
REGISTER_PARSER(VP8,vp8);
REGISTER_PARSER(VP9,vp9);
REGISTER_PARSER(XMA,xma);
}

void avcodec_register_all(void)
{
static AVOnce control = AV_ONCE_INIT;

ff_thread_once(&control, register_all);
}

#define REGISTER_ENCODER(X, x)\
{\
extern AVCodec ff_##x##_encoder;\
if (CONFIG_##X##_ENCODER)\
avcodec_register(&ff_##x##_encoder);\
}

av_cold void avcodec_register(AVCodec *codec)
{
AVCodec **p;
avcodec_init();
p = last_avcodec;
codec->next = NULL;

while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, codec))
p = &(*p)->next;
last_avcodec = &codec->next;

if (codec->init_static_data)
codec->init_static_data(codec);
}

/* encoder management */
static AVCodec *first_avcodec = NULL;
static AVCodec **last_avcodec = &first_avcodec;