You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

262 lines
11KB

  1. /*
  2. * Register all the formats and protocols
  3. * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
  4. *
  5. * This file is part of Libav.
  6. *
  7. * Libav 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. * Libav 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 Libav; if not, write to the Free Software
  19. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20. */
  21. #include "avformat.h"
  22. #include "rtp.h"
  23. #include "rdt.h"
  24. #include "url.h"
  25. #include "version.h"
  26. #define REGISTER_MUXER(X, x) \
  27. { \
  28. extern AVOutputFormat ff_##x##_muxer; \
  29. if (CONFIG_##X##_MUXER) \
  30. av_register_output_format(&ff_##x##_muxer); \
  31. }
  32. #define REGISTER_DEMUXER(X, x) \
  33. { \
  34. extern AVInputFormat ff_##x##_demuxer; \
  35. if (CONFIG_##X##_DEMUXER) \
  36. av_register_input_format(&ff_##x##_demuxer); \
  37. }
  38. #define REGISTER_MUXDEMUX(X, x) REGISTER_MUXER(X, x); REGISTER_DEMUXER(X, x)
  39. void av_register_all(void)
  40. {
  41. static int initialized;
  42. if (initialized)
  43. return;
  44. initialized = 1;
  45. avcodec_register_all();
  46. /* (de)muxers */
  47. REGISTER_MUXER (A64, a64);
  48. REGISTER_DEMUXER (AAC, aac);
  49. REGISTER_MUXDEMUX(AC3, ac3);
  50. REGISTER_MUXER (ADTS, adts);
  51. REGISTER_MUXDEMUX(ADX, adx);
  52. REGISTER_DEMUXER (AEA, aea);
  53. REGISTER_MUXDEMUX(AIFF, aiff);
  54. REGISTER_MUXDEMUX(AMR, amr);
  55. REGISTER_DEMUXER (ANM, anm);
  56. REGISTER_DEMUXER (APC, apc);
  57. REGISTER_DEMUXER (APE, ape);
  58. REGISTER_MUXDEMUX(ASF, asf);
  59. REGISTER_MUXDEMUX(ASS, ass);
  60. REGISTER_MUXER (ASF_STREAM, asf_stream);
  61. REGISTER_MUXDEMUX(AU, au);
  62. REGISTER_MUXDEMUX(AVI, avi);
  63. REGISTER_DEMUXER (AVISYNTH, avisynth);
  64. REGISTER_MUXER (AVM2, avm2);
  65. REGISTER_DEMUXER (AVS, avs);
  66. REGISTER_DEMUXER (BETHSOFTVID, bethsoftvid);
  67. REGISTER_DEMUXER (BFI, bfi);
  68. REGISTER_DEMUXER (BINK, bink);
  69. REGISTER_DEMUXER (BMV, bmv);
  70. REGISTER_DEMUXER (C93, c93);
  71. REGISTER_DEMUXER (CAF, caf);
  72. REGISTER_MUXDEMUX(CAVSVIDEO, cavsvideo);
  73. REGISTER_DEMUXER (CDG, cdg);
  74. REGISTER_DEMUXER (CDXL, cdxl);
  75. REGISTER_MUXER (CRC, crc);
  76. REGISTER_MUXER (DASH, dash);
  77. REGISTER_MUXDEMUX(DAUD, daud);
  78. REGISTER_DEMUXER (DFA, dfa);
  79. REGISTER_MUXDEMUX(DIRAC, dirac);
  80. REGISTER_MUXDEMUX(DNXHD, dnxhd);
  81. REGISTER_DEMUXER (DSICIN, dsicin);
  82. REGISTER_DEMUXER (DSS, dss);
  83. REGISTER_MUXDEMUX(DTS, dts);
  84. REGISTER_MUXDEMUX(DV, dv);
  85. REGISTER_DEMUXER (DXA, dxa);
  86. REGISTER_DEMUXER (EA, ea);
  87. REGISTER_DEMUXER (EA_CDATA, ea_cdata);
  88. REGISTER_MUXDEMUX(EAC3, eac3);
  89. REGISTER_MUXER (F4V, f4v);
  90. REGISTER_MUXDEMUX(FFMETADATA, ffmetadata);
  91. REGISTER_MUXDEMUX(FILMSTRIP, filmstrip);
  92. REGISTER_MUXDEMUX(FLAC, flac);
  93. REGISTER_DEMUXER (FLIC, flic);
  94. REGISTER_MUXDEMUX(FLV, flv);
  95. REGISTER_DEMUXER (FOURXM, fourxm);
  96. REGISTER_MUXER (FRAMECRC, framecrc);
  97. REGISTER_MUXER (FRAMEMD5, framemd5);
  98. REGISTER_MUXDEMUX(G722, g722);
  99. REGISTER_MUXDEMUX(G723_1, g723_1);
  100. REGISTER_DEMUXER (G729, g729);
  101. REGISTER_MUXER (GIF, gif);
  102. REGISTER_DEMUXER (GSM, gsm);
  103. REGISTER_MUXDEMUX(GXF, gxf);
  104. REGISTER_MUXDEMUX(H261, h261);
  105. REGISTER_MUXDEMUX(H263, h263);
  106. REGISTER_MUXDEMUX(H264, h264);
  107. REGISTER_MUXER (HDS, hds);
  108. REGISTER_MUXDEMUX(HEVC, hevc);
  109. REGISTER_MUXDEMUX(HLS, hls);
  110. REGISTER_DEMUXER (HNM, hnm);
  111. REGISTER_DEMUXER (IDCIN, idcin);
  112. REGISTER_DEMUXER (IFF, iff);
  113. REGISTER_MUXDEMUX(ILBC, ilbc);
  114. REGISTER_MUXDEMUX(IMAGE2, image2);
  115. REGISTER_MUXDEMUX(IMAGE2PIPE, image2pipe);
  116. REGISTER_DEMUXER (INGENIENT, ingenient);
  117. REGISTER_DEMUXER (IPMOVIE, ipmovie);
  118. REGISTER_MUXER (IPOD, ipod);
  119. REGISTER_MUXER (ISMV, ismv);
  120. REGISTER_DEMUXER (ISS, iss);
  121. REGISTER_DEMUXER (IV8, iv8);
  122. REGISTER_MUXDEMUX(IVF, ivf);
  123. REGISTER_DEMUXER (JV, jv);
  124. REGISTER_MUXDEMUX(LATM, latm);
  125. REGISTER_DEMUXER (LMLM4, lmlm4);
  126. REGISTER_DEMUXER (LXF, lxf);
  127. REGISTER_MUXDEMUX(M4V, m4v);
  128. REGISTER_MUXER (MD5, md5);
  129. REGISTER_MUXDEMUX(MATROSKA, matroska);
  130. REGISTER_MUXER (MATROSKA_AUDIO, matroska_audio);
  131. REGISTER_MUXDEMUX(MJPEG, mjpeg);
  132. REGISTER_MUXDEMUX(MLP, mlp);
  133. REGISTER_DEMUXER (MM, mm);
  134. REGISTER_MUXDEMUX(MMF, mmf);
  135. REGISTER_MUXDEMUX(MOV, mov);
  136. REGISTER_MUXER (MP2, mp2);
  137. REGISTER_MUXDEMUX(MP3, mp3);
  138. REGISTER_MUXER (MP4, mp4);
  139. REGISTER_DEMUXER (MPC, mpc);
  140. REGISTER_DEMUXER (MPC8, mpc8);
  141. REGISTER_MUXER (MPEG1SYSTEM, mpeg1system);
  142. REGISTER_MUXER (MPEG1VCD, mpeg1vcd);
  143. REGISTER_MUXER (MPEG1VIDEO, mpeg1video);
  144. REGISTER_MUXER (MPEG2DVD, mpeg2dvd);
  145. REGISTER_MUXER (MPEG2SVCD, mpeg2svcd);
  146. REGISTER_MUXER (MPEG2VIDEO, mpeg2video);
  147. REGISTER_MUXER (MPEG2VOB, mpeg2vob);
  148. REGISTER_DEMUXER (MPEGPS, mpegps);
  149. REGISTER_MUXDEMUX(MPEGTS, mpegts);
  150. REGISTER_DEMUXER (MPEGTSRAW, mpegtsraw);
  151. REGISTER_DEMUXER (MPEGVIDEO, mpegvideo);
  152. REGISTER_MUXDEMUX(MPJPEG, mpjpeg);
  153. REGISTER_DEMUXER (MSNWC_TCP, msnwc_tcp);
  154. REGISTER_DEMUXER (MTV, mtv);
  155. REGISTER_DEMUXER (MV, mv);
  156. REGISTER_DEMUXER (MVI, mvi);
  157. REGISTER_MUXDEMUX(MXF, mxf);
  158. REGISTER_MUXER (MXF_D10, mxf_d10);
  159. REGISTER_DEMUXER (MXG, mxg);
  160. REGISTER_DEMUXER (NC, nc);
  161. REGISTER_DEMUXER (NSV, nsv);
  162. REGISTER_MUXER (NULL, null);
  163. REGISTER_MUXDEMUX(NUT, nut);
  164. REGISTER_DEMUXER (NUV, nuv);
  165. REGISTER_MUXER (OGA, oga);
  166. REGISTER_MUXDEMUX(OGG, ogg);
  167. REGISTER_MUXDEMUX(OMA, oma);
  168. REGISTER_MUXER (OPUS, opus);
  169. REGISTER_DEMUXER (PAF, paf);
  170. REGISTER_MUXDEMUX(PCM_ALAW, pcm_alaw);
  171. REGISTER_MUXDEMUX(PCM_MULAW, pcm_mulaw);
  172. REGISTER_MUXDEMUX(PCM_F64BE, pcm_f64be);
  173. REGISTER_MUXDEMUX(PCM_F64LE, pcm_f64le);
  174. REGISTER_MUXDEMUX(PCM_F32BE, pcm_f32be);
  175. REGISTER_MUXDEMUX(PCM_F32LE, pcm_f32le);
  176. REGISTER_MUXDEMUX(PCM_S32BE, pcm_s32be);
  177. REGISTER_MUXDEMUX(PCM_S32LE, pcm_s32le);
  178. REGISTER_MUXDEMUX(PCM_S24BE, pcm_s24be);
  179. REGISTER_MUXDEMUX(PCM_S24LE, pcm_s24le);
  180. REGISTER_MUXDEMUX(PCM_S16BE, pcm_s16be);
  181. REGISTER_MUXDEMUX(PCM_S16LE, pcm_s16le);
  182. REGISTER_MUXDEMUX(PCM_S8, pcm_s8);
  183. REGISTER_MUXDEMUX(PCM_U32BE, pcm_u32be);
  184. REGISTER_MUXDEMUX(PCM_U32LE, pcm_u32le);
  185. REGISTER_MUXDEMUX(PCM_U24BE, pcm_u24be);
  186. REGISTER_MUXDEMUX(PCM_U24LE, pcm_u24le);
  187. REGISTER_MUXDEMUX(PCM_U16BE, pcm_u16be);
  188. REGISTER_MUXDEMUX(PCM_U16LE, pcm_u16le);
  189. REGISTER_MUXDEMUX(PCM_U8, pcm_u8);
  190. REGISTER_DEMUXER (PMP, pmp);
  191. REGISTER_MUXER (PSP, psp);
  192. REGISTER_DEMUXER (PVA, pva);
  193. REGISTER_DEMUXER (QCP, qcp);
  194. REGISTER_DEMUXER (R3D, r3d);
  195. REGISTER_MUXDEMUX(RAWVIDEO, rawvideo);
  196. REGISTER_DEMUXER (RL2, rl2);
  197. REGISTER_MUXDEMUX(RM, rm);
  198. REGISTER_MUXDEMUX(ROQ, roq);
  199. REGISTER_DEMUXER (RPL, rpl);
  200. REGISTER_MUXDEMUX(RSO, rso);
  201. REGISTER_MUXDEMUX(RTP, rtp);
  202. REGISTER_MUXER (RTP_MPEGTS, rtp_mpegts);
  203. REGISTER_MUXDEMUX(RTSP, rtsp);
  204. REGISTER_MUXDEMUX(SAP, sap);
  205. REGISTER_DEMUXER (SDP, sdp);
  206. #if CONFIG_RTPDEC
  207. ff_register_rtp_dynamic_payload_handlers();
  208. ff_register_rdt_dynamic_payload_handlers();
  209. #endif
  210. REGISTER_DEMUXER (SEGAFILM, segafilm);
  211. REGISTER_MUXER (SEGMENT, segment);
  212. REGISTER_DEMUXER (SHORTEN, shorten);
  213. REGISTER_DEMUXER (SIFF, siff);
  214. REGISTER_DEMUXER (SMACKER, smacker);
  215. REGISTER_MUXDEMUX(SMJPEG, smjpeg);
  216. REGISTER_MUXER (SMOOTHSTREAMING, smoothstreaming);
  217. REGISTER_DEMUXER (SMUSH, smush);
  218. REGISTER_DEMUXER (SOL, sol);
  219. REGISTER_MUXDEMUX(SOX, sox);
  220. REGISTER_MUXER (SPX, spx);
  221. REGISTER_MUXDEMUX(SPDIF, spdif);
  222. REGISTER_MUXDEMUX(SRT, srt);
  223. REGISTER_DEMUXER (STR, str);
  224. REGISTER_MUXDEMUX(SWF, swf);
  225. REGISTER_DEMUXER (TAK, tak);
  226. REGISTER_MUXER (TG2, tg2);
  227. REGISTER_MUXER (TGP, tgp);
  228. REGISTER_DEMUXER (THP, thp);
  229. REGISTER_DEMUXER (TIERTEXSEQ, tiertexseq);
  230. REGISTER_DEMUXER (TMV, tmv);
  231. REGISTER_MUXDEMUX(TRUEHD, truehd);
  232. REGISTER_DEMUXER (TTA, tta);
  233. REGISTER_DEMUXER (TXD, txd);
  234. REGISTER_DEMUXER (TTY, tty);
  235. REGISTER_DEMUXER (VC1, vc1);
  236. REGISTER_MUXDEMUX(VC1T, vc1t);
  237. REGISTER_DEMUXER (VMD, vmd);
  238. REGISTER_MUXDEMUX(VOC, voc);
  239. REGISTER_DEMUXER (VQF, vqf);
  240. REGISTER_DEMUXER (W64, w64);
  241. REGISTER_MUXDEMUX(WAV, wav);
  242. REGISTER_DEMUXER (WC3, wc3);
  243. REGISTER_MUXER (WEBM, webm);
  244. REGISTER_DEMUXER (WSAUD, wsaud);
  245. REGISTER_DEMUXER (WSVQA, wsvqa);
  246. REGISTER_DEMUXER (WTV, wtv);
  247. REGISTER_MUXDEMUX(WV, wv);
  248. REGISTER_DEMUXER (XA, xa);
  249. REGISTER_DEMUXER (XMV, xmv);
  250. REGISTER_DEMUXER (XWMA, xwma);
  251. REGISTER_DEMUXER (YOP, yop);
  252. REGISTER_MUXDEMUX(YUV4MPEGPIPE, yuv4mpegpipe);
  253. }