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.

1913 lines
68KB

  1. /*
  2. * copyright (c) 2001 Fabrice Bellard
  3. *
  4. * This file is part of FFmpeg.
  5. *
  6. * FFmpeg is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU Lesser General Public
  8. * License as published by the Free Software Foundation; either
  9. * version 2.1 of the License, or (at your option) any later version.
  10. *
  11. * FFmpeg is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * Lesser General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU Lesser General Public
  17. * License along with FFmpeg; if not, write to the Free Software
  18. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19. */
  20. #ifndef AVFORMAT_AVFORMAT_H
  21. #define AVFORMAT_AVFORMAT_H
  22. /**
  23. * Return the LIBAVFORMAT_VERSION_INT constant.
  24. */
  25. unsigned avformat_version(void);
  26. /**
  27. * Return the libavformat build-time configuration.
  28. */
  29. const char *avformat_configuration(void);
  30. /**
  31. * Return the libavformat license.
  32. */
  33. const char *avformat_license(void);
  34. #include <time.h>
  35. #include <stdio.h> /* FILE */
  36. #include "libavcodec/avcodec.h"
  37. #include "libavutil/dict.h"
  38. #include "libavutil/log.h"
  39. #include "avio.h"
  40. #include "libavformat/version.h"
  41. struct AVFormatContext;
  42. /**
  43. * @defgroup metadata_api Public Metadata API
  44. * @{
  45. * The metadata API allows libavformat to export metadata tags to a client
  46. * application using a sequence of key/value pairs. Like all strings in FFmpeg,
  47. * metadata must be stored as UTF-8 encoded Unicode. Note that metadata
  48. * exported by demuxers isn't checked to be valid UTF-8 in most cases.
  49. * Important concepts to keep in mind:
  50. * - Keys are unique; there can never be 2 tags with the same key. This is
  51. * also meant semantically, i.e., a demuxer should not knowingly produce
  52. * several keys that are literally different but semantically identical.
  53. * E.g., key=Author5, key=Author6. In this example, all authors must be
  54. * placed in the same tag.
  55. * - Metadata is flat, not hierarchical; there are no subtags. If you
  56. * want to store, e.g., the email address of the child of producer Alice
  57. * and actor Bob, that could have key=alice_and_bobs_childs_email_address.
  58. * - Several modifiers can be applied to the tag name. This is done by
  59. * appending a dash character ('-') and the modifier name in the order
  60. * they appear in the list below -- e.g. foo-eng-sort, not foo-sort-eng.
  61. * - language -- a tag whose value is localized for a particular language
  62. * is appended with the ISO 639-2/B 3-letter language code.
  63. * For example: Author-ger=Michael, Author-eng=Mike
  64. * The original/default language is in the unqualified "Author" tag.
  65. * A demuxer should set a default if it sets any translated tag.
  66. * - sorting -- a modified version of a tag that should be used for
  67. * sorting will have '-sort' appended. E.g. artist="The Beatles",
  68. * artist-sort="Beatles, The".
  69. *
  70. * - Demuxers attempt to export metadata in a generic format, however tags
  71. * with no generic equivalents are left as they are stored in the container.
  72. * Follows a list of generic tag names:
  73. *
  74. @verbatim
  75. album -- name of the set this work belongs to
  76. album_artist -- main creator of the set/album, if different from artist.
  77. e.g. "Various Artists" for compilation albums.
  78. artist -- main creator of the work
  79. comment -- any additional description of the file.
  80. composer -- who composed the work, if different from artist.
  81. copyright -- name of copyright holder.
  82. creation_time-- date when the file was created, preferably in ISO 8601.
  83. date -- date when the work was created, preferably in ISO 8601.
  84. disc -- number of a subset, e.g. disc in a multi-disc collection.
  85. encoder -- name/settings of the software/hardware that produced the file.
  86. encoded_by -- person/group who created the file.
  87. filename -- original name of the file.
  88. genre -- <self-evident>.
  89. language -- main language in which the work is performed, preferably
  90. in ISO 639-2 format. Multiple languages can be specified by
  91. separating them with commas.
  92. performer -- artist who performed the work, if different from artist.
  93. E.g for "Also sprach Zarathustra", artist would be "Richard
  94. Strauss" and performer "London Philharmonic Orchestra".
  95. publisher -- name of the label/publisher.
  96. service_name -- name of the service in broadcasting (channel name).
  97. service_provider -- name of the service provider in broadcasting.
  98. title -- name of the work.
  99. track -- number of this work in the set, can be in form current/total.
  100. variant_bitrate -- the total bitrate of the bitrate variant that the current stream is part of
  101. @endverbatim
  102. *
  103. * Look in the examples section for an application example how to use the Metadata API.
  104. *
  105. * @}
  106. */
  107. #if FF_API_OLD_METADATA2
  108. /**
  109. * @defgroup old_metadata Old metadata API
  110. * The following functions are deprecated, use
  111. * their equivalents from libavutil/dict.h instead.
  112. * @{
  113. */
  114. #define AV_METADATA_MATCH_CASE AV_DICT_MATCH_CASE
  115. #define AV_METADATA_IGNORE_SUFFIX AV_DICT_IGNORE_SUFFIX
  116. #define AV_METADATA_DONT_STRDUP_KEY AV_DICT_DONT_STRDUP_KEY
  117. #define AV_METADATA_DONT_STRDUP_VAL AV_DICT_DONT_STRDUP_VAL
  118. #define AV_METADATA_DONT_OVERWRITE AV_DICT_DONT_OVERWRITE
  119. typedef attribute_deprecated AVDictionary AVMetadata;
  120. typedef attribute_deprecated AVDictionaryEntry AVMetadataTag;
  121. typedef struct AVMetadataConv AVMetadataConv;
  122. /**
  123. * Get a metadata element with matching key.
  124. *
  125. * @param prev Set to the previous matching element to find the next.
  126. * If set to NULL the first matching element is returned.
  127. * @param flags Allows case as well as suffix-insensitive comparisons.
  128. * @return Found tag or NULL, changing key or value leads to undefined behavior.
  129. */
  130. attribute_deprecated AVDictionaryEntry *
  131. av_metadata_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags);
  132. /**
  133. * Set the given tag in *pm, overwriting an existing tag.
  134. *
  135. * @param pm pointer to a pointer to a metadata struct. If *pm is NULL
  136. * a metadata struct is allocated and put in *pm.
  137. * @param key tag key to add to *pm (will be av_strduped depending on flags)
  138. * @param value tag value to add to *pm (will be av_strduped depending on flags).
  139. * Passing a NULL value will cause an existing tag to be deleted.
  140. * @return >= 0 on success otherwise an error code <0
  141. */
  142. attribute_deprecated int av_metadata_set2(AVDictionary **pm, const char *key, const char *value, int flags);
  143. /**
  144. * This function is provided for compatibility reason and currently does nothing.
  145. */
  146. attribute_deprecated void av_metadata_conv(struct AVFormatContext *ctx, const AVMetadataConv *d_conv,
  147. const AVMetadataConv *s_conv);
  148. /**
  149. * Copy metadata from one AVDictionary struct into another.
  150. * @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL,
  151. * this function will allocate a struct for you and put it in *dst
  152. * @param src pointer to source AVDictionary struct
  153. * @param flags flags to use when setting metadata in *dst
  154. * @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag
  155. */
  156. attribute_deprecated void av_metadata_copy(AVDictionary **dst, AVDictionary *src, int flags);
  157. /**
  158. * Free all the memory allocated for an AVDictionary struct.
  159. */
  160. attribute_deprecated void av_metadata_free(AVDictionary **m);
  161. /**
  162. * @}
  163. */
  164. #endif
  165. /* packet functions */
  166. /**
  167. * Allocate and read the payload of a packet and initialize its
  168. * fields with default values.
  169. *
  170. * @param pkt packet
  171. * @param size desired payload size
  172. * @return >0 (read size) if OK, AVERROR_xxx otherwise
  173. */
  174. int av_get_packet(AVIOContext *s, AVPacket *pkt, int size);
  175. /**
  176. * Read data and append it to the current content of the AVPacket.
  177. * If pkt->size is 0 this is identical to av_get_packet.
  178. * Note that this uses av_grow_packet and thus involves a realloc
  179. * which is inefficient. Thus this function should only be used
  180. * when there is no reasonable way to know (an upper bound of)
  181. * the final size.
  182. *
  183. * @param pkt packet
  184. * @param size amount of data to read
  185. * @return >0 (read size) if OK, AVERROR_xxx otherwise, previous data
  186. * will not be lost even if an error occurs.
  187. */
  188. int av_append_packet(AVIOContext *s, AVPacket *pkt, int size);
  189. /*************************************************/
  190. /* fractional numbers for exact pts handling */
  191. /**
  192. * The exact value of the fractional number is: 'val + num / den'.
  193. * num is assumed to be 0 <= num < den.
  194. */
  195. typedef struct AVFrac {
  196. int64_t val, num, den;
  197. } AVFrac;
  198. /*************************************************/
  199. /* input/output formats */
  200. struct AVCodecTag;
  201. /**
  202. * This structure contains the data a format has to probe a file.
  203. */
  204. typedef struct AVProbeData {
  205. const char *filename;
  206. unsigned char *buf; /**< Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero. */
  207. int buf_size; /**< Size of buf except extra allocated bytes */
  208. } AVProbeData;
  209. #define AVPROBE_SCORE_MAX 100 ///< maximum score, half of that is used for file-extension-based detection
  210. #define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer
  211. typedef struct AVFormatParameters {
  212. #if FF_API_FORMAT_PARAMETERS
  213. attribute_deprecated AVRational time_base;
  214. attribute_deprecated int sample_rate;
  215. attribute_deprecated int channels;
  216. attribute_deprecated int width;
  217. attribute_deprecated int height;
  218. attribute_deprecated enum PixelFormat pix_fmt;
  219. attribute_deprecated int channel; /**< Used to select DV channel. */
  220. attribute_deprecated const char *standard; /**< deprecated, use demuxer-specific options instead. */
  221. attribute_deprecated unsigned int mpeg2ts_raw:1; /**< deprecated, use mpegtsraw demuxer */
  222. /**< deprecated, use mpegtsraw demuxer-specific options instead */
  223. attribute_deprecated unsigned int mpeg2ts_compute_pcr:1;
  224. attribute_deprecated unsigned int initial_pause:1; /**< Do not begin to play the stream
  225. immediately (RTSP only). */
  226. attribute_deprecated unsigned int prealloced_context:1;
  227. #endif
  228. } AVFormatParameters;
  229. //! Demuxer will use avio_open, no opened file should be provided by the caller.
  230. #define AVFMT_NOFILE 0x0001
  231. #define AVFMT_NEEDNUMBER 0x0002 /**< Needs '%d' in filename. */
  232. #define AVFMT_SHOW_IDS 0x0008 /**< Show format stream IDs numbers. */
  233. #define AVFMT_RAWPICTURE 0x0020 /**< Format wants AVPicture structure for
  234. raw picture data. */
  235. #define AVFMT_GLOBALHEADER 0x0040 /**< Format wants global header. */
  236. #define AVFMT_NOTIMESTAMPS 0x0080 /**< Format does not need / have any timestamps. */
  237. #define AVFMT_GENERIC_INDEX 0x0100 /**< Use generic index building code. */
  238. #define AVFMT_TS_DISCONT 0x0200 /**< Format allows timestamp discontinuities. Note, muxers always require valid (monotone) timestamps */
  239. #define AVFMT_VARIABLE_FPS 0x0400 /**< Format allows variable fps. */
  240. #define AVFMT_NODIMENSIONS 0x0800 /**< Format does not need width/height */
  241. #define AVFMT_NOSTREAMS 0x1000 /**< Format does not require any streams */
  242. #define AVFMT_NOBINSEARCH 0x2000 /**< Format does not allow to fallback to binary search via read_timestamp */
  243. #define AVFMT_NOGENSEARCH 0x4000 /**< Format does not allow to fallback to generic search */
  244. #define AVFMT_NO_BYTE_SEEK 0x8000 /**< Format does not allow seeking by bytes */
  245. #define AVFMT_TS_NONSTRICT 0x8000000 /**< Format does not require strictly
  246. increasing timestamps, but they must
  247. still be monotonic */
  248. typedef struct AVOutputFormat {
  249. const char *name;
  250. /**
  251. * Descriptive name for the format, meant to be more human-readable
  252. * than name. You should use the NULL_IF_CONFIG_SMALL() macro
  253. * to define it.
  254. */
  255. const char *long_name;
  256. const char *mime_type;
  257. const char *extensions; /**< comma-separated filename extensions */
  258. /**
  259. * size of private data so that it can be allocated in the wrapper
  260. */
  261. int priv_data_size;
  262. /* output support */
  263. enum CodecID audio_codec; /**< default audio codec */
  264. enum CodecID video_codec; /**< default video codec */
  265. int (*write_header)(struct AVFormatContext *);
  266. int (*write_packet)(struct AVFormatContext *, AVPacket *pkt);
  267. int (*write_trailer)(struct AVFormatContext *);
  268. /**
  269. * can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_RAWPICTURE,
  270. * AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS,
  271. * AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS
  272. */
  273. int flags;
  274. void *dummy;
  275. int (*interleave_packet)(struct AVFormatContext *, AVPacket *out,
  276. AVPacket *in, int flush);
  277. /**
  278. * List of supported codec_id-codec_tag pairs, ordered by "better
  279. * choice first". The arrays are all terminated by CODEC_ID_NONE.
  280. */
  281. const struct AVCodecTag * const *codec_tag;
  282. enum CodecID subtitle_codec; /**< default subtitle codec */
  283. #if FF_API_OLD_METADATA2
  284. const AVMetadataConv *metadata_conv;
  285. #endif
  286. const AVClass *priv_class; ///< AVClass for the private context
  287. /**
  288. * Test if the given codec can be stored in this container.
  289. *
  290. * @return 1 if the codec is supported, 0 if it is not.
  291. * A negative number if unknown.
  292. */
  293. int (*query_codec)(enum CodecID id, int std_compliance);
  294. void (*get_output_timestamp)(struct AVFormatContext *s, int stream,
  295. int64_t *dts, int64_t *wall);
  296. /* private fields */
  297. struct AVOutputFormat *next;
  298. } AVOutputFormat;
  299. typedef struct AVInputFormat {
  300. /**
  301. * A comma separated list of short names for the format. New names
  302. * may be appended with a minor bump.
  303. */
  304. const char *name;
  305. /**
  306. * Descriptive name for the format, meant to be more human-readable
  307. * than name. You should use the NULL_IF_CONFIG_SMALL() macro
  308. * to define it.
  309. */
  310. const char *long_name;
  311. /**
  312. * Size of private data so that it can be allocated in the wrapper.
  313. */
  314. int priv_data_size;
  315. /**
  316. * Tell if a given file has a chance of being parsed as this format.
  317. * The buffer provided is guaranteed to be AVPROBE_PADDING_SIZE bytes
  318. * big so you do not have to check for that unless you need more.
  319. */
  320. int (*read_probe)(AVProbeData *);
  321. /**
  322. * Read the format header and initialize the AVFormatContext
  323. * structure. Return 0 if OK. 'ap' if non-NULL contains
  324. * additional parameters. Only used in raw format right
  325. * now. 'av_new_stream' should be called to create new streams.
  326. */
  327. int (*read_header)(struct AVFormatContext *,
  328. AVFormatParameters *ap);
  329. /**
  330. * Read one packet and put it in 'pkt'. pts and flags are also
  331. * set. 'av_new_stream' can be called only if the flag
  332. * AVFMTCTX_NOHEADER is used and only in the calling thread (not in a
  333. * background thread).
  334. * @return 0 on success, < 0 on error.
  335. * When returning an error, pkt must not have been allocated
  336. * or must be freed before returning
  337. */
  338. int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);
  339. /**
  340. * Close the stream. The AVFormatContext and AVStreams are not
  341. * freed by this function
  342. */
  343. int (*read_close)(struct AVFormatContext *);
  344. #if FF_API_READ_SEEK
  345. /**
  346. * Seek to a given timestamp relative to the frames in
  347. * stream component stream_index.
  348. * @param stream_index Must not be -1.
  349. * @param flags Selects which direction should be preferred if no exact
  350. * match is available.
  351. * @return >= 0 on success (but not necessarily the new offset)
  352. */
  353. attribute_deprecated int (*read_seek)(struct AVFormatContext *,
  354. int stream_index, int64_t timestamp, int flags);
  355. #endif
  356. /**
  357. * Gets the next timestamp in stream[stream_index].time_base units.
  358. * @return the timestamp or AV_NOPTS_VALUE if an error occurred
  359. */
  360. int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index,
  361. int64_t *pos, int64_t pos_limit);
  362. /**
  363. * Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS,
  364. * AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH,
  365. * AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK.
  366. */
  367. int flags;
  368. /**
  369. * If extensions are defined, then no probe is done. You should
  370. * usually not use extension format guessing because it is not
  371. * reliable enough
  372. */
  373. const char *extensions;
  374. /**
  375. * General purpose read-only value that the format can use.
  376. */
  377. int value;
  378. /**
  379. * Start/resume playing - only meaningful if using a network-based format
  380. * (RTSP).
  381. */
  382. int (*read_play)(struct AVFormatContext *);
  383. /**
  384. * Pause playing - only meaningful if using a network-based format
  385. * (RTSP).
  386. */
  387. int (*read_pause)(struct AVFormatContext *);
  388. const struct AVCodecTag * const *codec_tag;
  389. /**
  390. * Seek to timestamp ts.
  391. * Seeking will be done so that the point from which all active streams
  392. * can be presented successfully will be closest to ts and within min/max_ts.
  393. * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.
  394. */
  395. int (*read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
  396. #if FF_API_OLD_METADATA2
  397. const AVMetadataConv *metadata_conv;
  398. #endif
  399. const AVClass *priv_class; ///< AVClass for the private context
  400. /* private fields */
  401. struct AVInputFormat *next;
  402. } AVInputFormat;
  403. enum AVStreamParseType {
  404. AVSTREAM_PARSE_NONE,
  405. AVSTREAM_PARSE_FULL, /**< full parsing and repack */
  406. AVSTREAM_PARSE_HEADERS, /**< Only parse headers, do not repack. */
  407. AVSTREAM_PARSE_TIMESTAMPS, /**< full parsing and interpolation of timestamps for frames not starting on a packet boundary */
  408. AVSTREAM_PARSE_FULL_ONCE, /**< full parsing and repack of the first frame only, only implemented for H.264 currently */
  409. };
  410. typedef struct AVIndexEntry {
  411. int64_t pos;
  412. int64_t timestamp; /**<
  413. * Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are available
  414. * when seeking to this entry. That means preferable PTS on keyframe based formats.
  415. * But demuxers can choose to store a different timestamp, if it is more convenient for the implementation or nothing better
  416. * is known
  417. */
  418. #define AVINDEX_KEYFRAME 0x0001
  419. int flags:2;
  420. int size:30; //Yeah, trying to keep the size of this small to reduce memory requirements (it is 24 vs. 32 bytes due to possible 8-byte alignment).
  421. int min_distance; /**< Minimum distance between this and the previous keyframe, used to avoid unneeded searching. */
  422. } AVIndexEntry;
  423. #define AV_DISPOSITION_DEFAULT 0x0001
  424. #define AV_DISPOSITION_DUB 0x0002
  425. #define AV_DISPOSITION_ORIGINAL 0x0004
  426. #define AV_DISPOSITION_COMMENT 0x0008
  427. #define AV_DISPOSITION_LYRICS 0x0010
  428. #define AV_DISPOSITION_KARAOKE 0x0020
  429. /**
  430. * Track should be used during playback by default.
  431. * Useful for subtitle track that should be displayed
  432. * even when user did not explicitly ask for subtitles.
  433. */
  434. #define AV_DISPOSITION_FORCED 0x0040
  435. #define AV_DISPOSITION_HEARING_IMPAIRED 0x0080 /**< stream for hearing impaired audiences */
  436. #define AV_DISPOSITION_VISUAL_IMPAIRED 0x0100 /**< stream for visual impaired audiences */
  437. #define AV_DISPOSITION_CLEAN_EFFECTS 0x0200 /**< stream without voice */
  438. /**
  439. * Stream structure.
  440. * New fields can be added to the end with minor version bumps.
  441. * Removal, reordering and changes to existing fields require a major
  442. * version bump.
  443. * sizeof(AVStream) must not be used outside libav*.
  444. */
  445. typedef struct AVStream {
  446. int index; /**< stream index in AVFormatContext */
  447. int id; /**< format-specific stream ID */
  448. AVCodecContext *codec; /**< codec context */
  449. /**
  450. * Real base framerate of the stream.
  451. * This is the lowest framerate with which all timestamps can be
  452. * represented accurately (it is the least common multiple of all
  453. * framerates in the stream). Note, this value is just a guess!
  454. * For example, if the time base is 1/90000 and all frames have either
  455. * approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1.
  456. */
  457. AVRational r_frame_rate;
  458. void *priv_data;
  459. #if FF_API_REORDER_PRIVATE
  460. /* internal data used in av_find_stream_info() */
  461. int64_t first_dts;
  462. #endif
  463. /**
  464. * encoding: pts generation when outputting stream
  465. */
  466. struct AVFrac pts;
  467. /**
  468. * This is the fundamental unit of time (in seconds) in terms
  469. * of which frame timestamps are represented. For fixed-fps content,
  470. * time base should be 1/framerate and timestamp increments should be 1.
  471. * decoding: set by libavformat
  472. * encoding: set by libavformat in av_write_header
  473. */
  474. AVRational time_base;
  475. #if FF_API_REORDER_PRIVATE
  476. int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
  477. #endif
  478. #if FF_API_STREAM_COPY
  479. /* ffmpeg.c private use */
  480. attribute_deprecated int stream_copy; /**< If set, just copy stream. */
  481. #endif
  482. enum AVDiscard discard; ///< Selects which packets can be discarded at will and do not need to be demuxed.
  483. #if FF_API_AVSTREAM_QUALITY
  484. //FIXME move stuff to a flags field?
  485. /**
  486. * Quality, as it has been removed from AVCodecContext and put in AVVideoFrame.
  487. * MN: dunno if that is the right place for it
  488. */
  489. attribute_deprecated float quality;
  490. #endif
  491. /**
  492. * Decoding: pts of the first frame of the stream in presentation order, in stream time base.
  493. * Only set this if you are absolutely 100% sure that the value you set
  494. * it to really is the pts of the first frame.
  495. * This may be undefined (AV_NOPTS_VALUE).
  496. * @note The ASF header does NOT contain a correct start_time the ASF
  497. * demuxer must NOT set this.
  498. */
  499. int64_t start_time;
  500. /**
  501. * Decoding: duration of the stream, in stream time base.
  502. * If a source file does not specify a duration, but does specify
  503. * a bitrate, this value will be estimated from bitrate and file size.
  504. */
  505. int64_t duration;
  506. #if FF_API_REORDER_PRIVATE
  507. /* av_read_frame() support */
  508. enum AVStreamParseType need_parsing;
  509. struct AVCodecParserContext *parser;
  510. int64_t cur_dts;
  511. int last_IP_duration;
  512. int64_t last_IP_pts;
  513. /* av_seek_frame() support */
  514. AVIndexEntry *index_entries; /**< Only used if the format does not
  515. support seeking natively. */
  516. int nb_index_entries;
  517. unsigned int index_entries_allocated_size;
  518. #endif
  519. int64_t nb_frames; ///< number of frames in this stream if known or 0
  520. int disposition; /**< AV_DISPOSITION_* bit field */
  521. #if FF_API_REORDER_PRIVATE
  522. AVProbeData probe_data;
  523. #define MAX_REORDER_DELAY 16
  524. int64_t pts_buffer[MAX_REORDER_DELAY+1];
  525. #endif
  526. /**
  527. * sample aspect ratio (0 if unknown)
  528. * - encoding: Set by user.
  529. * - decoding: Set by libavformat.
  530. */
  531. AVRational sample_aspect_ratio;
  532. AVDictionary *metadata;
  533. #if FF_API_REORDER_PRIVATE
  534. /* Intended mostly for av_read_frame() support. Not supposed to be used by */
  535. /* external applications; try to use something else if at all possible. */
  536. const uint8_t *cur_ptr;
  537. int cur_len;
  538. AVPacket cur_pkt;
  539. // Timestamp generation support:
  540. /**
  541. * Timestamp corresponding to the last dts sync point.
  542. *
  543. * Initialized when AVCodecParserContext.dts_sync_point >= 0 and
  544. * a DTS is received from the underlying container. Otherwise set to
  545. * AV_NOPTS_VALUE by default.
  546. */
  547. int64_t reference_dts;
  548. /**
  549. * Number of packets to buffer for codec probing
  550. * NOT PART OF PUBLIC API
  551. */
  552. #define MAX_PROBE_PACKETS 2500
  553. int probe_packets;
  554. /**
  555. * last packet in packet_buffer for this stream when muxing.
  556. * used internally, NOT PART OF PUBLIC API, dont read or write from outside of libav*
  557. */
  558. struct AVPacketList *last_in_packet_buffer;
  559. #endif
  560. /**
  561. * Average framerate
  562. */
  563. AVRational avg_frame_rate;
  564. /*****************************************************************
  565. * All fields below this line are not part of the public API. They
  566. * may not be used outside of libavformat and can be changed and
  567. * removed at will.
  568. * New public fields should be added right above.
  569. *****************************************************************
  570. */
  571. /**
  572. * Number of frames that have been demuxed during av_find_stream_info()
  573. */
  574. int codec_info_nb_frames;
  575. /**
  576. * Stream Identifier
  577. * This is the MPEG-TS stream identifier +1
  578. * 0 means unknown
  579. */
  580. int stream_identifier;
  581. /**
  582. * Stream informations used internally by av_find_stream_info()
  583. */
  584. #define MAX_STD_TIMEBASES (60*12+5)
  585. struct {
  586. int64_t last_dts;
  587. int64_t duration_gcd;
  588. int duration_count;
  589. double duration_error[2][2][MAX_STD_TIMEBASES];
  590. int64_t codec_info_duration;
  591. int nb_decoded_frames;
  592. } *info;
  593. /**
  594. * flag to indicate that probing is requested
  595. * NOT PART OF PUBLIC API
  596. */
  597. int request_probe;
  598. #if !FF_API_REORDER_PRIVATE
  599. const uint8_t *cur_ptr;
  600. int cur_len;
  601. AVPacket cur_pkt;
  602. // Timestamp generation support:
  603. /**
  604. * Timestamp corresponding to the last dts sync point.
  605. *
  606. * Initialized when AVCodecParserContext.dts_sync_point >= 0 and
  607. * a DTS is received from the underlying container. Otherwise set to
  608. * AV_NOPTS_VALUE by default.
  609. */
  610. int64_t reference_dts;
  611. int64_t first_dts;
  612. int64_t cur_dts;
  613. int last_IP_duration;
  614. int64_t last_IP_pts;
  615. /**
  616. * Number of packets to buffer for codec probing
  617. */
  618. #define MAX_PROBE_PACKETS 2500
  619. int probe_packets;
  620. /**
  621. * last packet in packet_buffer for this stream when muxing.
  622. */
  623. struct AVPacketList *last_in_packet_buffer;
  624. AVProbeData probe_data;
  625. #define MAX_REORDER_DELAY 16
  626. int64_t pts_buffer[MAX_REORDER_DELAY+1];
  627. /* av_read_frame() support */
  628. enum AVStreamParseType need_parsing;
  629. struct AVCodecParserContext *parser;
  630. AVIndexEntry *index_entries; /**< Only used if the format does not
  631. support seeking natively. */
  632. int nb_index_entries;
  633. unsigned int index_entries_allocated_size;
  634. int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
  635. #endif
  636. } AVStream;
  637. #define AV_PROGRAM_RUNNING 1
  638. /**
  639. * New fields can be added to the end with minor version bumps.
  640. * Removal, reordering and changes to existing fields require a major
  641. * version bump.
  642. * sizeof(AVProgram) must not be used outside libav*.
  643. */
  644. typedef struct AVProgram {
  645. int id;
  646. int flags;
  647. enum AVDiscard discard; ///< selects which program to discard and which to feed to the caller
  648. unsigned int *stream_index;
  649. unsigned int nb_stream_indexes;
  650. AVDictionary *metadata;
  651. int program_num;
  652. int pmt_pid;
  653. int pcr_pid;
  654. } AVProgram;
  655. #define AVFMTCTX_NOHEADER 0x0001 /**< signal that no header is present
  656. (streams are added dynamically) */
  657. typedef struct AVChapter {
  658. int id; ///< unique ID to identify the chapter
  659. AVRational time_base; ///< time base in which the start/end timestamps are specified
  660. int64_t start, end; ///< chapter start/end time in time_base units
  661. AVDictionary *metadata;
  662. } AVChapter;
  663. /**
  664. * Format I/O context.
  665. * New fields can be added to the end with minor version bumps.
  666. * Removal, reordering and changes to existing fields require a major
  667. * version bump.
  668. * sizeof(AVFormatContext) must not be used outside libav*, use
  669. * avformat_alloc_context() to create an AVFormatContext.
  670. */
  671. typedef struct AVFormatContext {
  672. /**
  673. * A class for logging and AVOptions. Set by avformat_alloc_context().
  674. * Exports (de)muxer private options if they exist.
  675. */
  676. const AVClass *av_class;
  677. /**
  678. * Can only be iformat or oformat, not both at the same time.
  679. *
  680. * decoding: set by avformat_open_input().
  681. * encoding: set by the user.
  682. */
  683. struct AVInputFormat *iformat;
  684. struct AVOutputFormat *oformat;
  685. /**
  686. * Format private data. This is an AVOptions-enabled struct
  687. * if and only if iformat/oformat.priv_class is not NULL.
  688. */
  689. void *priv_data;
  690. /*
  691. * I/O context.
  692. *
  693. * decoding: either set by the user before avformat_open_input() (then
  694. * the user must close it manually) or set by avformat_open_input().
  695. * encoding: set by the user.
  696. *
  697. * Do NOT set this field if AVFMT_NOFILE flag is set in
  698. * iformat/oformat.flags. In such a case, the (de)muxer will handle
  699. * I/O in some other way and this field will be NULL.
  700. */
  701. AVIOContext *pb;
  702. /**
  703. * A list of all streams in the file. New streams are created with
  704. * avformat_new_stream().
  705. *
  706. * decoding: streams are created by libavformat in avformat_open_input().
  707. * If AVFMTCTX_NOHEADER is set in ctx_flags, then new streams may also
  708. * appear in av_read_frame().
  709. * encoding: streams are created by the user before avformat_write_header().
  710. */
  711. unsigned int nb_streams;
  712. AVStream **streams;
  713. char filename[1024]; /**< input or output filename */
  714. /* stream info */
  715. #if FF_API_TIMESTAMP
  716. /**
  717. * @deprecated use 'creation_time' metadata tag instead
  718. */
  719. attribute_deprecated int64_t timestamp;
  720. #endif
  721. int ctx_flags; /**< Format-specific flags, see AVFMTCTX_xx */
  722. #if FF_API_REORDER_PRIVATE
  723. /* private data for pts handling (do not modify directly). */
  724. /**
  725. * This buffer is only needed when packets were already buffered but
  726. * not decoded, for example to get the codec parameters in MPEG
  727. * streams.
  728. */
  729. struct AVPacketList *packet_buffer;
  730. #endif
  731. /**
  732. * Decoding: position of the first frame of the component, in
  733. * AV_TIME_BASE fractional seconds. NEVER set this value directly:
  734. * It is deduced from the AVStream values.
  735. */
  736. int64_t start_time;
  737. /**
  738. * Decoding: duration of the stream, in AV_TIME_BASE fractional
  739. * seconds. Only set this value if you know none of the individual stream
  740. * durations and also dont set any of them. This is deduced from the
  741. * AVStream values if not set.
  742. */
  743. int64_t duration;
  744. #if FF_API_FILESIZE
  745. /**
  746. * decoding: total file size, 0 if unknown
  747. */
  748. attribute_deprecated int64_t file_size;
  749. #endif
  750. /**
  751. * Decoding: total stream bitrate in bit/s, 0 if not
  752. * available. Never set it directly if the file_size and the
  753. * duration are known as FFmpeg can compute it automatically.
  754. */
  755. int bit_rate;
  756. #if FF_API_REORDER_PRIVATE
  757. /* av_read_frame() support */
  758. AVStream *cur_st;
  759. /* av_seek_frame() support */
  760. int64_t data_offset; /**< offset of the first packet */
  761. #endif
  762. #if FF_API_MUXRATE
  763. /**
  764. * use mpeg muxer private options instead
  765. */
  766. attribute_deprecated int mux_rate;
  767. #endif
  768. unsigned int packet_size;
  769. #if FF_API_PRELOAD
  770. attribute_deprecated int preload;
  771. #endif
  772. int max_delay;
  773. #if FF_API_LOOP_OUTPUT
  774. #define AVFMT_NOOUTPUTLOOP -1
  775. #define AVFMT_INFINITEOUTPUTLOOP 0
  776. /**
  777. * number of times to loop output in formats that support it
  778. *
  779. * @deprecated use the 'loop' private option in the gif muxer.
  780. */
  781. attribute_deprecated int loop_output;
  782. #endif
  783. int flags;
  784. #define AVFMT_FLAG_GENPTS 0x0001 ///< Generate missing pts even if it requires parsing future frames.
  785. #define AVFMT_FLAG_IGNIDX 0x0002 ///< Ignore index.
  786. #define AVFMT_FLAG_NONBLOCK 0x0004 ///< Do not block when reading packets from input.
  787. #define AVFMT_FLAG_IGNDTS 0x0008 ///< Ignore DTS on frames that contain both DTS & PTS
  788. #define AVFMT_FLAG_NOFILLIN 0x0010 ///< Do not infer any values from other values, just return what is stored in the container
  789. #define AVFMT_FLAG_NOPARSE 0x0020 ///< Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled
  790. #if FF_API_FLAG_RTP_HINT
  791. #define AVFMT_FLAG_RTP_HINT 0x0040 ///< Deprecated, use the -movflags rtphint muxer specific AVOption instead
  792. #endif
  793. #define AVFMT_FLAG_CUSTOM_IO 0x0080 ///< The caller has supplied a custom AVIOContext, don't avio_close() it.
  794. #define AVFMT_FLAG_DISCARD_CORRUPT 0x0100 ///< Discard frames marked corrupted
  795. #define AVFMT_FLAG_MP4A_LATM 0x8000 ///< Enable RTP MP4A-LATM payload
  796. #define AVFMT_FLAG_SORT_DTS 0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
  797. #define AVFMT_FLAG_PRIV_OPT 0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted)
  798. #define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Dont merge side data but keep it seperate.
  799. #if FF_API_LOOP_INPUT
  800. /**
  801. * @deprecated, use the 'loop' img2 demuxer private option.
  802. */
  803. attribute_deprecated int loop_input;
  804. #endif
  805. /**
  806. * decoding: size of data to probe; encoding: unused.
  807. */
  808. unsigned int probesize;
  809. /**
  810. * decoding: maximum time (in AV_TIME_BASE units) during which the input should
  811. * be analyzed in avformat_find_stream_info().
  812. */
  813. int max_analyze_duration;
  814. const uint8_t *key;
  815. int keylen;
  816. unsigned int nb_programs;
  817. AVProgram **programs;
  818. /**
  819. * Forced video codec_id.
  820. * Demuxing: Set by user.
  821. */
  822. enum CodecID video_codec_id;
  823. /**
  824. * Forced audio codec_id.
  825. * Demuxing: Set by user.
  826. */
  827. enum CodecID audio_codec_id;
  828. /**
  829. * Forced subtitle codec_id.
  830. * Demuxing: Set by user.
  831. */
  832. enum CodecID subtitle_codec_id;
  833. /**
  834. * Maximum amount of memory in bytes to use for the index of each stream.
  835. * If the index exceeds this size, entries will be discarded as
  836. * needed to maintain a smaller size. This can lead to slower or less
  837. * accurate seeking (depends on demuxer).
  838. * Demuxers for which a full in-memory index is mandatory will ignore
  839. * this.
  840. * muxing : unused
  841. * demuxing: set by user
  842. */
  843. unsigned int max_index_size;
  844. /**
  845. * Maximum amount of memory in bytes to use for buffering frames
  846. * obtained from realtime capture devices.
  847. */
  848. unsigned int max_picture_buffer;
  849. unsigned int nb_chapters;
  850. AVChapter **chapters;
  851. /**
  852. * Flags to enable debugging.
  853. */
  854. int debug;
  855. #define FF_FDEBUG_TS 0x0001
  856. #if FF_API_REORDER_PRIVATE
  857. /**
  858. * Raw packets from the demuxer, prior to parsing and decoding.
  859. * This buffer is used for buffering packets until the codec can
  860. * be identified, as parsing cannot be done without knowing the
  861. * codec.
  862. */
  863. struct AVPacketList *raw_packet_buffer;
  864. struct AVPacketList *raw_packet_buffer_end;
  865. struct AVPacketList *packet_buffer_end;
  866. #endif
  867. AVDictionary *metadata;
  868. #if FF_API_REORDER_PRIVATE
  869. /**
  870. * Remaining size available for raw_packet_buffer, in bytes.
  871. * NOT PART OF PUBLIC API
  872. */
  873. #define RAW_PACKET_BUFFER_SIZE 2500000
  874. int raw_packet_buffer_remaining_size;
  875. #endif
  876. /**
  877. * Start time of the stream in real world time, in microseconds
  878. * since the unix epoch (00:00 1st January 1970). That is, pts=0
  879. * in the stream was captured at this real world time.
  880. * - encoding: Set by user.
  881. * - decoding: Unused.
  882. */
  883. int64_t start_time_realtime;
  884. /**
  885. * decoding: number of frames used to probe fps
  886. */
  887. int fps_probe_size;
  888. /**
  889. * Error recognition; higher values will detect more errors but may
  890. * misdetect some more or less valid parts as errors.
  891. * - encoding: unused
  892. * - decoding: Set by user.
  893. */
  894. int error_recognition;
  895. /**
  896. * Transport stream id.
  897. * This will be moved into demuxer private options. Thus no API/ABI compatibility
  898. */
  899. int ts_id;
  900. /*****************************************************************
  901. * All fields below this line are not part of the public API. They
  902. * may not be used outside of libavformat and can be changed and
  903. * removed at will.
  904. * New public fields should be added right above.
  905. *****************************************************************
  906. */
  907. #if !FF_API_REORDER_PRIVATE
  908. /**
  909. * Raw packets from the demuxer, prior to parsing and decoding.
  910. * This buffer is used for buffering packets until the codec can
  911. * be identified, as parsing cannot be done without knowing the
  912. * codec.
  913. */
  914. struct AVPacketList *raw_packet_buffer;
  915. struct AVPacketList *raw_packet_buffer_end;
  916. /**
  917. * Remaining size available for raw_packet_buffer, in bytes.
  918. */
  919. #define RAW_PACKET_BUFFER_SIZE 2500000
  920. int raw_packet_buffer_remaining_size;
  921. /**
  922. * This buffer is only needed when packets were already buffered but
  923. * not decoded, for example to get the codec parameters in MPEG
  924. * streams.
  925. */
  926. struct AVPacketList *packet_buffer;
  927. struct AVPacketList *packet_buffer_end;
  928. /* av_read_frame() support */
  929. AVStream *cur_st;
  930. /* av_seek_frame() support */
  931. int64_t data_offset; /**< offset of the first packet */
  932. #endif
  933. } AVFormatContext;
  934. typedef struct AVPacketList {
  935. AVPacket pkt;
  936. struct AVPacketList *next;
  937. } AVPacketList;
  938. /**
  939. * If f is NULL, returns the first registered input format,
  940. * if f is non-NULL, returns the next registered input format after f
  941. * or NULL if f is the last one.
  942. */
  943. AVInputFormat *av_iformat_next(AVInputFormat *f);
  944. /**
  945. * If f is NULL, returns the first registered output format,
  946. * if f is non-NULL, returns the next registered output format after f
  947. * or NULL if f is the last one.
  948. */
  949. AVOutputFormat *av_oformat_next(AVOutputFormat *f);
  950. #if FF_API_GUESS_IMG2_CODEC
  951. attribute_deprecated enum CodecID av_guess_image2_codec(const char *filename);
  952. #endif
  953. /* XXX: Use automatic init with either ELF sections or C file parser */
  954. /* modules. */
  955. /* utils.c */
  956. void av_register_input_format(AVInputFormat *format);
  957. void av_register_output_format(AVOutputFormat *format);
  958. /**
  959. * Return the output format in the list of registered output formats
  960. * which best matches the provided parameters, or return NULL if
  961. * there is no match.
  962. *
  963. * @param short_name if non-NULL checks if short_name matches with the
  964. * names of the registered formats
  965. * @param filename if non-NULL checks if filename terminates with the
  966. * extensions of the registered formats
  967. * @param mime_type if non-NULL checks if mime_type matches with the
  968. * MIME type of the registered formats
  969. */
  970. AVOutputFormat *av_guess_format(const char *short_name,
  971. const char *filename,
  972. const char *mime_type);
  973. /**
  974. * Guess the codec ID based upon muxer and filename.
  975. */
  976. enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
  977. const char *filename, const char *mime_type,
  978. enum AVMediaType type);
  979. /**
  980. * Send a nice hexadecimal dump of a buffer to the specified file stream.
  981. *
  982. * @param f The file stream pointer where the dump should be sent to.
  983. * @param buf buffer
  984. * @param size buffer size
  985. *
  986. * @see av_hex_dump_log, av_pkt_dump2, av_pkt_dump_log2
  987. */
  988. void av_hex_dump(FILE *f, uint8_t *buf, int size);
  989. /**
  990. * Send a nice hexadecimal dump of a buffer to the log.
  991. *
  992. * @param avcl A pointer to an arbitrary struct of which the first field is a
  993. * pointer to an AVClass struct.
  994. * @param level The importance level of the message, lower values signifying
  995. * higher importance.
  996. * @param buf buffer
  997. * @param size buffer size
  998. *
  999. * @see av_hex_dump, av_pkt_dump2, av_pkt_dump_log2
  1000. */
  1001. void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size);
  1002. /**
  1003. * Send a nice dump of a packet to the specified file stream.
  1004. *
  1005. * @param f The file stream pointer where the dump should be sent to.
  1006. * @param pkt packet to dump
  1007. * @param dump_payload True if the payload must be displayed, too.
  1008. * @param st AVStream that the packet belongs to
  1009. */
  1010. void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st);
  1011. /**
  1012. * Send a nice dump of a packet to the log.
  1013. *
  1014. * @param avcl A pointer to an arbitrary struct of which the first field is a
  1015. * pointer to an AVClass struct.
  1016. * @param level The importance level of the message, lower values signifying
  1017. * higher importance.
  1018. * @param pkt packet to dump
  1019. * @param dump_payload True if the payload must be displayed, too.
  1020. * @param st AVStream that the packet belongs to
  1021. */
  1022. void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
  1023. AVStream *st);
  1024. #if FF_API_PKT_DUMP
  1025. attribute_deprecated void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload);
  1026. attribute_deprecated void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt,
  1027. int dump_payload);
  1028. #endif
  1029. /**
  1030. * Initialize libavformat and register all the muxers, demuxers and
  1031. * protocols. If you do not call this function, then you can select
  1032. * exactly which formats you want to support.
  1033. *
  1034. * @see av_register_input_format()
  1035. * @see av_register_output_format()
  1036. * @see av_register_protocol()
  1037. */
  1038. void av_register_all(void);
  1039. /**
  1040. * Get the CodecID for the given codec tag tag.
  1041. * If no codec id is found returns CODEC_ID_NONE.
  1042. *
  1043. * @param tags list of supported codec_id-codec_tag pairs, as stored
  1044. * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
  1045. */
  1046. enum CodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);
  1047. /**
  1048. * Get the codec tag for the given codec id id.
  1049. * If no codec tag is found returns 0.
  1050. *
  1051. * @param tags list of supported codec_id-codec_tag pairs, as stored
  1052. * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
  1053. */
  1054. unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum CodecID id);
  1055. /* media file input */
  1056. /**
  1057. * Find AVInputFormat based on the short name of the input format.
  1058. */
  1059. AVInputFormat *av_find_input_format(const char *short_name);
  1060. /**
  1061. * Guess the file format.
  1062. *
  1063. * @param is_opened Whether the file is already opened; determines whether
  1064. * demuxers with or without AVFMT_NOFILE are probed.
  1065. */
  1066. AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened);
  1067. /**
  1068. * Guess the file format.
  1069. *
  1070. * @param is_opened Whether the file is already opened; determines whether
  1071. * demuxers with or without AVFMT_NOFILE are probed.
  1072. * @param score_max A probe score larger that this is required to accept a
  1073. * detection, the variable is set to the actual detection
  1074. * score afterwards.
  1075. * If the score is <= AVPROBE_SCORE_MAX / 4 it is recommended
  1076. * to retry with a larger probe buffer.
  1077. */
  1078. AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max);
  1079. /**
  1080. * Guess the file format.
  1081. *
  1082. * @param is_opened Whether the file is already opened; determines whether
  1083. * demuxers with or without AVFMT_NOFILE are probed.
  1084. * @param score_ret The score of the best detection.
  1085. */
  1086. AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret);
  1087. /**
  1088. * Probe a bytestream to determine the input format. Each time a probe returns
  1089. * with a score that is too low, the probe buffer size is increased and another
  1090. * attempt is made. When the maximum probe size is reached, the input format
  1091. * with the highest score is returned.
  1092. *
  1093. * @param pb the bytestream to probe
  1094. * @param fmt the input format is put here
  1095. * @param filename the filename of the stream
  1096. * @param logctx the log context
  1097. * @param offset the offset within the bytestream to probe from
  1098. * @param max_probe_size the maximum probe buffer size (zero for default)
  1099. * @return 0 in case of success, a negative value corresponding to an
  1100. * AVERROR code otherwise
  1101. */
  1102. int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
  1103. const char *filename, void *logctx,
  1104. unsigned int offset, unsigned int max_probe_size);
  1105. #if FF_API_FORMAT_PARAMETERS
  1106. /**
  1107. * Allocate all the structures needed to read an input stream.
  1108. * This does not open the needed codecs for decoding the stream[s].
  1109. * @deprecated use avformat_open_input instead.
  1110. */
  1111. attribute_deprecated int av_open_input_stream(AVFormatContext **ic_ptr,
  1112. AVIOContext *pb, const char *filename,
  1113. AVInputFormat *fmt, AVFormatParameters *ap);
  1114. /**
  1115. * Open a media file as input. The codecs are not opened. Only the file
  1116. * header (if present) is read.
  1117. *
  1118. * @param ic_ptr The opened media file handle is put here.
  1119. * @param filename filename to open
  1120. * @param fmt If non-NULL, force the file format to use.
  1121. * @param buf_size optional buffer size (zero if default is OK)
  1122. * @param ap Additional parameters needed when opening the file
  1123. * (NULL if default).
  1124. * @return 0 if OK, AVERROR_xxx otherwise
  1125. *
  1126. * @deprecated use avformat_open_input instead.
  1127. */
  1128. attribute_deprecated int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
  1129. AVInputFormat *fmt,
  1130. int buf_size,
  1131. AVFormatParameters *ap);
  1132. #endif
  1133. /**
  1134. * Open an input stream and read the header. The codecs are not opened.
  1135. * The stream must be closed with av_close_input_file().
  1136. *
  1137. * @param ps Pointer to user-supplied AVFormatContext (allocated by avformat_alloc_context).
  1138. * May be a pointer to NULL, in which case an AVFormatContext is allocated by this
  1139. * function and written into ps.
  1140. * Note that a user-supplied AVFormatContext will be freed on failure.
  1141. * @param filename Name of the stream to open.
  1142. * @param fmt If non-NULL, this parameter forces a specific input format.
  1143. * Otherwise the format is autodetected.
  1144. * @param options A dictionary filled with AVFormatContext and demuxer-private options.
  1145. * On return this parameter will be destroyed and replaced with a dict containing
  1146. * options that were not found. May be NULL.
  1147. *
  1148. * @return 0 on success, a negative AVERROR on failure.
  1149. *
  1150. * @note If you want to use custom IO, preallocate the format context and set its pb field.
  1151. */
  1152. int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options);
  1153. int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap);
  1154. /**
  1155. * Allocate an AVFormatContext.
  1156. * avformat_free_context() can be used to free the context and everything
  1157. * allocated by the framework within it.
  1158. */
  1159. AVFormatContext *avformat_alloc_context(void);
  1160. #if FF_API_ALLOC_OUTPUT_CONTEXT
  1161. /**
  1162. * @deprecated deprecated in favor of avformat_alloc_output_context2()
  1163. */
  1164. attribute_deprecated
  1165. AVFormatContext *avformat_alloc_output_context(const char *format,
  1166. AVOutputFormat *oformat,
  1167. const char *filename);
  1168. #endif
  1169. /**
  1170. * Allocate an AVFormatContext for an output format.
  1171. * avformat_free_context() can be used to free the context and
  1172. * everything allocated by the framework within it.
  1173. *
  1174. * @param *ctx is set to the created format context, or to NULL in
  1175. * case of failure
  1176. * @param oformat format to use for allocating the context, if NULL
  1177. * format_name and filename are used instead
  1178. * @param format_name the name of output format to use for allocating the
  1179. * context, if NULL filename is used instead
  1180. * @param filename the name of the filename to use for allocating the
  1181. * context, may be NULL
  1182. * @return >= 0 in case of success, a negative AVERROR code in case of
  1183. * failure
  1184. */
  1185. int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat,
  1186. const char *format_name, const char *filename);
  1187. #if FF_API_FORMAT_PARAMETERS
  1188. /**
  1189. * Read packets of a media file to get stream information. This
  1190. * is useful for file formats with no headers such as MPEG. This
  1191. * function also computes the real framerate in case of MPEG-2 repeat
  1192. * frame mode.
  1193. * The logical file position is not changed by this function;
  1194. * examined packets may be buffered for later processing.
  1195. *
  1196. * @param ic media file handle
  1197. * @return >=0 if OK, AVERROR_xxx on error
  1198. * @todo Let the user decide somehow what information is needed so that
  1199. * we do not waste time getting stuff the user does not need.
  1200. *
  1201. * @deprecated use avformat_find_stream_info.
  1202. */
  1203. attribute_deprecated
  1204. int av_find_stream_info(AVFormatContext *ic);
  1205. #endif
  1206. /**
  1207. * Read packets of a media file to get stream information. This
  1208. * is useful for file formats with no headers such as MPEG. This
  1209. * function also computes the real framerate in case of MPEG-2 repeat
  1210. * frame mode.
  1211. * The logical file position is not changed by this function;
  1212. * examined packets may be buffered for later processing.
  1213. *
  1214. * @param ic media file handle
  1215. * @param options If non-NULL, an ic.nb_streams long array of pointers to
  1216. * dictionaries, where i-th member contains options for
  1217. * codec corresponding to i-th stream.
  1218. * On return each dictionary will be filled with options that were not found.
  1219. * @return >=0 if OK, AVERROR_xxx on error
  1220. *
  1221. * @note this function isn't guaranteed to open all the codecs, so
  1222. * options being non-empty at return is a perfectly normal behavior.
  1223. *
  1224. * @todo Let the user decide somehow what information is needed so that
  1225. * we do not waste time getting stuff the user does not need.
  1226. */
  1227. int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
  1228. /**
  1229. * Find the programs which belong to a given stream.
  1230. *
  1231. * @param ic media file handle
  1232. * @param last the last found program, the search will start after this
  1233. * program, or from the beginning if it is NULL
  1234. * @param s stream index
  1235. * @return the next program which belongs to s, NULL if no program is found or
  1236. * the last program is not among the programs of ic.
  1237. */
  1238. AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s);
  1239. /**
  1240. * Find the "best" stream in the file.
  1241. * The best stream is determined according to various heuristics as the most
  1242. * likely to be what the user expects.
  1243. * If the decoder parameter is non-NULL, av_find_best_stream will find the
  1244. * default decoder for the stream's codec; streams for which no decoder can
  1245. * be found are ignored.
  1246. *
  1247. * @param ic media file handle
  1248. * @param type stream type: video, audio, subtitles, etc.
  1249. * @param wanted_stream_nb user-requested stream number,
  1250. * or -1 for automatic selection
  1251. * @param related_stream try to find a stream related (eg. in the same
  1252. * program) to this one, or -1 if none
  1253. * @param decoder_ret if non-NULL, returns the decoder for the
  1254. * selected stream
  1255. * @param flags flags; none are currently defined
  1256. * @return the non-negative stream number in case of success,
  1257. * AVERROR_STREAM_NOT_FOUND if no stream with the requested type
  1258. * could be found,
  1259. * AVERROR_DECODER_NOT_FOUND if streams were found but no decoder
  1260. * @note If av_find_best_stream returns successfully and decoder_ret is not
  1261. * NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec.
  1262. */
  1263. int av_find_best_stream(AVFormatContext *ic,
  1264. enum AVMediaType type,
  1265. int wanted_stream_nb,
  1266. int related_stream,
  1267. AVCodec **decoder_ret,
  1268. int flags);
  1269. /**
  1270. * Read a transport packet from a media file.
  1271. *
  1272. * This function is obsolete and should never be used.
  1273. * Use av_read_frame() instead.
  1274. *
  1275. * @param s media file handle
  1276. * @param pkt is filled
  1277. * @return 0 if OK, AVERROR_xxx on error
  1278. */
  1279. int av_read_packet(AVFormatContext *s, AVPacket *pkt);
  1280. /**
  1281. * Return the next frame of a stream.
  1282. * This function returns what is stored in the file, and does not validate
  1283. * that what is there are valid frames for the decoder. It will split what is
  1284. * stored in the file into frames and return one for each call. It will not
  1285. * omit invalid data between valid frames so as to give the decoder the maximum
  1286. * information possible for decoding.
  1287. *
  1288. * The returned packet is valid
  1289. * until the next av_read_frame() or until av_close_input_file() and
  1290. * must be freed with av_free_packet. For video, the packet contains
  1291. * exactly one frame. For audio, it contains an integer number of
  1292. * frames if each frame has a known fixed size (e.g. PCM or ADPCM
  1293. * data). If the audio frames have a variable size (e.g. MPEG audio),
  1294. * then it contains one frame.
  1295. *
  1296. * pkt->pts, pkt->dts and pkt->duration are always set to correct
  1297. * values in AVStream.time_base units (and guessed if the format cannot
  1298. * provide them). pkt->pts can be AV_NOPTS_VALUE if the video format
  1299. * has B-frames, so it is better to rely on pkt->dts if you do not
  1300. * decompress the payload.
  1301. *
  1302. * @return 0 if OK, < 0 on error or end of file
  1303. */
  1304. int av_read_frame(AVFormatContext *s, AVPacket *pkt);
  1305. /**
  1306. * Seek to the keyframe at timestamp.
  1307. * 'timestamp' in 'stream_index'.
  1308. * @param stream_index If stream_index is (-1), a default
  1309. * stream is selected, and timestamp is automatically converted
  1310. * from AV_TIME_BASE units to the stream specific time_base.
  1311. * @param timestamp Timestamp in AVStream.time_base units
  1312. * or, if no stream is specified, in AV_TIME_BASE units.
  1313. * @param flags flags which select direction and seeking mode
  1314. * @return >= 0 on success
  1315. */
  1316. int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp,
  1317. int flags);
  1318. /**
  1319. * Seek to timestamp ts.
  1320. * Seeking will be done so that the point from which all active streams
  1321. * can be presented successfully will be closest to ts and within min/max_ts.
  1322. * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.
  1323. *
  1324. * If flags contain AVSEEK_FLAG_BYTE, then all timestamps are in bytes and
  1325. * are the file position (this may not be supported by all demuxers).
  1326. * If flags contain AVSEEK_FLAG_FRAME, then all timestamps are in frames
  1327. * in the stream with stream_index (this may not be supported by all demuxers).
  1328. * Otherwise all timestamps are in units of the stream selected by stream_index
  1329. * or if stream_index is -1, in AV_TIME_BASE units.
  1330. * If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as
  1331. * keyframes (this may not be supported by all demuxers).
  1332. *
  1333. * @param stream_index index of the stream which is used as time base reference
  1334. * @param min_ts smallest acceptable timestamp
  1335. * @param ts target timestamp
  1336. * @param max_ts largest acceptable timestamp
  1337. * @param flags flags
  1338. * @return >=0 on success, error code otherwise
  1339. *
  1340. * @note This is part of the new seek API which is still under construction.
  1341. * Thus do not use this yet. It may change at any time, do not expect
  1342. * ABI compatibility yet!
  1343. */
  1344. int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
  1345. /**
  1346. * Start playing a network-based stream (e.g. RTSP stream) at the
  1347. * current position.
  1348. */
  1349. int av_read_play(AVFormatContext *s);
  1350. /**
  1351. * Pause a network-based stream (e.g. RTSP stream).
  1352. *
  1353. * Use av_read_play() to resume it.
  1354. */
  1355. int av_read_pause(AVFormatContext *s);
  1356. /**
  1357. * Free a AVFormatContext allocated by av_open_input_stream.
  1358. * @param s context to free
  1359. */
  1360. void av_close_input_stream(AVFormatContext *s);
  1361. /**
  1362. * Close a media file (but not its codecs).
  1363. *
  1364. * @param s media file handle
  1365. */
  1366. void av_close_input_file(AVFormatContext *s);
  1367. /**
  1368. * Free an AVFormatContext and all its streams.
  1369. * @param s context to free
  1370. */
  1371. void avformat_free_context(AVFormatContext *s);
  1372. #if FF_API_NEW_STREAM
  1373. /**
  1374. * Add a new stream to a media file.
  1375. *
  1376. * Can only be called in the read_header() function. If the flag
  1377. * AVFMTCTX_NOHEADER is in the format context, then new streams
  1378. * can be added in read_packet too.
  1379. *
  1380. * @param s media file handle
  1381. * @param id file-format-dependent stream ID
  1382. */
  1383. attribute_deprecated
  1384. AVStream *av_new_stream(AVFormatContext *s, int id);
  1385. #endif
  1386. /**
  1387. * Add a new stream to a media file.
  1388. *
  1389. * When demuxing, it is called by the demuxer in read_header(). If the
  1390. * flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also
  1391. * be called in read_packet().
  1392. *
  1393. * When muxing, should be called by the user before avformat_write_header().
  1394. *
  1395. * @param c If non-NULL, the AVCodecContext corresponding to the new stream
  1396. * will be initialized to use this codec. This is needed for e.g. codec-specific
  1397. * defaults to be set, so codec should be provided if it is known.
  1398. *
  1399. * @return newly created stream or NULL on error.
  1400. */
  1401. AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c);
  1402. AVProgram *av_new_program(AVFormatContext *s, int id);
  1403. /**
  1404. * Set the pts for a given stream. If the new values would be invalid
  1405. * (<= 0), it leaves the AVStream unchanged.
  1406. *
  1407. * @param s stream
  1408. * @param pts_wrap_bits number of bits effectively used by the pts
  1409. * (used for wrap control, 33 is the value for MPEG)
  1410. * @param pts_num numerator to convert to seconds (MPEG: 1)
  1411. * @param pts_den denominator to convert to seconds (MPEG: 90000)
  1412. */
  1413. void av_set_pts_info(AVStream *s, int pts_wrap_bits,
  1414. unsigned int pts_num, unsigned int pts_den);
  1415. #define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
  1416. #define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes
  1417. #define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non-keyframes
  1418. #define AVSEEK_FLAG_FRAME 8 ///< seeking based on frame number
  1419. int av_find_default_stream_index(AVFormatContext *s);
  1420. /**
  1421. * Get the index for a specific timestamp.
  1422. * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond
  1423. * to the timestamp which is <= the requested one, if backward
  1424. * is 0, then it will be >=
  1425. * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
  1426. * @return < 0 if no such timestamp could be found
  1427. */
  1428. int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
  1429. /**
  1430. * Add an index entry into a sorted list. Update the entry if the list
  1431. * already contains it.
  1432. *
  1433. * @param timestamp timestamp in the time base of the given stream
  1434. */
  1435. int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
  1436. int size, int distance, int flags);
  1437. #if FF_API_SEEK_PUBLIC
  1438. attribute_deprecated
  1439. int av_seek_frame_binary(AVFormatContext *s, int stream_index,
  1440. int64_t target_ts, int flags);
  1441. attribute_deprecated
  1442. void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
  1443. attribute_deprecated
  1444. int64_t av_gen_search(AVFormatContext *s, int stream_index,
  1445. int64_t target_ts, int64_t pos_min,
  1446. int64_t pos_max, int64_t pos_limit,
  1447. int64_t ts_min, int64_t ts_max,
  1448. int flags, int64_t *ts_ret,
  1449. int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
  1450. #endif
  1451. /**
  1452. * media file output
  1453. */
  1454. #if FF_API_FORMAT_PARAMETERS
  1455. /**
  1456. * @deprecated pass the options to avformat_write_header directly.
  1457. */
  1458. attribute_deprecated int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap);
  1459. #endif
  1460. /**
  1461. * Split a URL string into components.
  1462. *
  1463. * The pointers to buffers for storing individual components may be null,
  1464. * in order to ignore that component. Buffers for components not found are
  1465. * set to empty strings. If the port is not found, it is set to a negative
  1466. * value.
  1467. *
  1468. * @param proto the buffer for the protocol
  1469. * @param proto_size the size of the proto buffer
  1470. * @param authorization the buffer for the authorization
  1471. * @param authorization_size the size of the authorization buffer
  1472. * @param hostname the buffer for the host name
  1473. * @param hostname_size the size of the hostname buffer
  1474. * @param port_ptr a pointer to store the port number in
  1475. * @param path the buffer for the path
  1476. * @param path_size the size of the path buffer
  1477. * @param url the URL to split
  1478. */
  1479. void av_url_split(char *proto, int proto_size,
  1480. char *authorization, int authorization_size,
  1481. char *hostname, int hostname_size,
  1482. int *port_ptr,
  1483. char *path, int path_size,
  1484. const char *url);
  1485. /**
  1486. * Allocate the stream private data and write the stream header to
  1487. * an output media file.
  1488. *
  1489. * @param s Media file handle, must be allocated with avformat_alloc_context().
  1490. * Its oformat field must be set to the desired output format;
  1491. * Its pb field must be set to an already openened AVIOContext.
  1492. * @param options An AVDictionary filled with AVFormatContext and muxer-private options.
  1493. * On return this parameter will be destroyed and replaced with a dict containing
  1494. * options that were not found. May be NULL.
  1495. *
  1496. * @return 0 on success, negative AVERROR on failure.
  1497. *
  1498. * @see av_opt_find, av_dict_set, avio_open, av_oformat_next.
  1499. */
  1500. int avformat_write_header(AVFormatContext *s, AVDictionary **options);
  1501. #if FF_API_FORMAT_PARAMETERS
  1502. /**
  1503. * Allocate the stream private data and write the stream header to an
  1504. * output media file.
  1505. * @note: this sets stream time-bases, if possible to stream->codec->time_base
  1506. * but for some formats it might also be some other time base
  1507. *
  1508. * @param s media file handle
  1509. * @return 0 if OK, AVERROR_xxx on error
  1510. *
  1511. * @deprecated use avformat_write_header.
  1512. */
  1513. attribute_deprecated int av_write_header(AVFormatContext *s);
  1514. #endif
  1515. /**
  1516. * Write a packet to an output media file.
  1517. *
  1518. * The packet shall contain one audio or video frame.
  1519. * The packet must be correctly interleaved according to the container
  1520. * specification, if not then av_interleaved_write_frame must be used.
  1521. *
  1522. * @param s media file handle
  1523. * @param pkt The packet, which contains the stream_index, buf/buf_size,
  1524. dts/pts, ...
  1525. * @return < 0 on error, = 0 if OK, 1 if end of stream wanted
  1526. */
  1527. int av_write_frame(AVFormatContext *s, AVPacket *pkt);
  1528. /**
  1529. * Write a packet to an output media file ensuring correct interleaving.
  1530. *
  1531. * The packet must contain one audio or video frame.
  1532. * If the packets are already correctly interleaved, the application should
  1533. * call av_write_frame() instead as it is slightly faster. It is also important
  1534. * to keep in mind that completely non-interleaved input will need huge amounts
  1535. * of memory to interleave with this, so it is preferable to interleave at the
  1536. * demuxer level.
  1537. *
  1538. * @param s media file handle
  1539. * @param pkt The packet, which contains the stream_index, buf/buf_size,
  1540. dts/pts, ...
  1541. * @return < 0 on error, = 0 if OK, 1 if end of stream wanted
  1542. */
  1543. int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);
  1544. /**
  1545. * Interleave a packet per dts in an output media file.
  1546. *
  1547. * Packets with pkt->destruct == av_destruct_packet will be freed inside this
  1548. * function, so they cannot be used after it. Note that calling av_free_packet()
  1549. * on them is still safe.
  1550. *
  1551. * @param s media file handle
  1552. * @param out the interleaved packet will be output here
  1553. * @param pkt the input packet
  1554. * @param flush 1 if no further packets are available as input and all
  1555. * remaining packets should be output
  1556. * @return 1 if a packet was output, 0 if no packet could be output,
  1557. * < 0 if an error occurred
  1558. */
  1559. int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
  1560. AVPacket *pkt, int flush);
  1561. /**
  1562. * Write the stream trailer to an output media file and free the
  1563. * file private data.
  1564. *
  1565. * May only be called after a successful call to av_write_header.
  1566. *
  1567. * @param s media file handle
  1568. * @return 0 if OK, AVERROR_xxx on error
  1569. */
  1570. int av_write_trailer(AVFormatContext *s);
  1571. /**
  1572. * Get timing information for the data currently output.
  1573. * The exact meaning of "currently output" depends on the format.
  1574. * It is mostly relevant for devices that have an internal buffer and/or
  1575. * work in real time.
  1576. * @param s media file handle
  1577. * @param stream stream in the media file
  1578. * @param dts[out] DTS of the last packet output for the stream, in stream
  1579. * time_base units
  1580. * @param wall[out] absolute time when that packet whas output,
  1581. * in microsecond
  1582. * @return 0 if OK, AVERROR(ENOSYS) if the format does not support it
  1583. * Note: some formats or devices may not allow to measure dts and wall
  1584. * atomically.
  1585. */
  1586. int av_get_output_timestamp(struct AVFormatContext *s, int stream,
  1587. int64_t *dts, int64_t *wall);
  1588. #if FF_API_DUMP_FORMAT
  1589. /**
  1590. * @deprecated Deprecated in favor of av_dump_format().
  1591. */
  1592. attribute_deprecated void dump_format(AVFormatContext *ic,
  1593. int index,
  1594. const char *url,
  1595. int is_output);
  1596. #endif
  1597. void av_dump_format(AVFormatContext *ic,
  1598. int index,
  1599. const char *url,
  1600. int is_output);
  1601. #if FF_API_PARSE_DATE
  1602. /**
  1603. * Parse datestr and return a corresponding number of microseconds.
  1604. *
  1605. * @param datestr String representing a date or a duration.
  1606. * See av_parse_time() for the syntax of the provided string.
  1607. * @deprecated in favor of av_parse_time()
  1608. */
  1609. attribute_deprecated
  1610. int64_t parse_date(const char *datestr, int duration);
  1611. #endif
  1612. /**
  1613. * Get the current time in microseconds.
  1614. */
  1615. int64_t av_gettime(void);
  1616. #if FF_API_FIND_INFO_TAG
  1617. /**
  1618. * @deprecated use av_find_info_tag in libavutil instead.
  1619. */
  1620. attribute_deprecated int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info);
  1621. #endif
  1622. /**
  1623. * Return in 'buf' the path with '%d' replaced by a number.
  1624. *
  1625. * Also handles the '%0nd' format where 'n' is the total number
  1626. * of digits and '%%'.
  1627. *
  1628. * @param buf destination buffer
  1629. * @param buf_size destination buffer size
  1630. * @param path numbered sequence string
  1631. * @param number frame number
  1632. * @return 0 if OK, -1 on format error
  1633. */
  1634. int av_get_frame_filename(char *buf, int buf_size,
  1635. const char *path, int number);
  1636. /**
  1637. * Check whether filename actually is a numbered sequence generator.
  1638. *
  1639. * @param filename possible numbered sequence string
  1640. * @return 1 if a valid numbered sequence string, 0 otherwise
  1641. */
  1642. int av_filename_number_test(const char *filename);
  1643. /**
  1644. * Generate an SDP for an RTP session.
  1645. *
  1646. * @param ac array of AVFormatContexts describing the RTP streams. If the
  1647. * array is composed by only one context, such context can contain
  1648. * multiple AVStreams (one AVStream per RTP stream). Otherwise,
  1649. * all the contexts in the array (an AVCodecContext per RTP stream)
  1650. * must contain only one AVStream.
  1651. * @param n_files number of AVCodecContexts contained in ac
  1652. * @param buf buffer where the SDP will be stored (must be allocated by
  1653. * the caller)
  1654. * @param size the size of the buffer
  1655. * @return 0 if OK, AVERROR_xxx on error
  1656. */
  1657. int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size);
  1658. #if FF_API_SDP_CREATE
  1659. attribute_deprecated int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size);
  1660. #endif
  1661. /**
  1662. * Return a positive value if the given filename has one of the given
  1663. * extensions, 0 otherwise.
  1664. *
  1665. * @param extensions a comma-separated list of filename extensions
  1666. */
  1667. int av_match_ext(const char *filename, const char *extensions);
  1668. /**
  1669. * Test if the given container can store a codec.
  1670. *
  1671. * @param std_compliance standards compliance level, one of FF_COMPLIANCE_*
  1672. *
  1673. * @return 1 if codec with ID codec_id can be stored in ofmt, 0 if it cannot.
  1674. * A negative number if this information is not available.
  1675. */
  1676. int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance);
  1677. /**
  1678. * Get the AVClass for AVFormatContext. It can be used in combination with
  1679. * AV_OPT_SEARCH_FAKE_OBJ for examining options.
  1680. *
  1681. * @see av_opt_find().
  1682. */
  1683. const AVClass *avformat_get_class(void);
  1684. /**
  1685. * Do global initialization of network components. This is optional,
  1686. * but recommended, since it avoids the overhead of implicitly
  1687. * doing the setup for each session.
  1688. *
  1689. * Calling this function will become mandatory if using network
  1690. * protocols at some major version bump.
  1691. */
  1692. int avformat_network_init(void);
  1693. /**
  1694. * Undo the initialization done by avformat_network_init.
  1695. */
  1696. int avformat_network_deinit(void);
  1697. #endif /* AVFORMAT_AVFORMAT_H */