Commit | Line | Data |
---|---|---|
04d7f601 DB |
1 | /* |
2 | * copyright (c) 2001 Fabrice Bellard | |
3 | * | |
b78e7197 DB |
4 | * This file is part of FFmpeg. |
5 | * | |
6 | * FFmpeg is free software; you can redistribute it and/or | |
04d7f601 DB |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either | |
b78e7197 | 9 | * version 2.1 of the License, or (at your option) any later version. |
04d7f601 | 10 | * |
b78e7197 | 11 | * FFmpeg is distributed in the hope that it will be useful, |
04d7f601 DB |
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 | |
b78e7197 | 17 | * License along with FFmpeg; if not, write to the Free Software |
04d7f601 DB |
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 | */ | |
20 | ||
98790382 SS |
21 | #ifndef AVFORMAT_AVFORMAT_H |
22 | #define AVFORMAT_AVFORMAT_H | |
de6d9b64 | 23 | |
800c289a | 24 | #define LIBAVFORMAT_VERSION_MAJOR 52 |
57011a13 | 25 | #define LIBAVFORMAT_VERSION_MINOR 36 |
af122d6a | 26 | #define LIBAVFORMAT_VERSION_MICRO 0 |
e97ac1e6 | 27 | |
800c289a MR |
28 | #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ |
29 | LIBAVFORMAT_VERSION_MINOR, \ | |
30 | LIBAVFORMAT_VERSION_MICRO) | |
31 | #define LIBAVFORMAT_VERSION AV_VERSION(LIBAVFORMAT_VERSION_MAJOR, \ | |
32 | LIBAVFORMAT_VERSION_MINOR, \ | |
33 | LIBAVFORMAT_VERSION_MICRO) | |
5aa083ee | 34 | #define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT |
8026c3b5 | 35 | |
5aa083ee | 36 | #define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION) |
4b1f4f23 | 37 | |
c97429e2 SS |
38 | /** |
39 | * Returns the LIBAVFORMAT_VERSION_INT constant. | |
40 | */ | |
41 | unsigned avformat_version(void); | |
42 | ||
f71869a4 | 43 | #include <time.h> |
67070e4f | 44 | #include <stdio.h> /* FILE */ |
76a448ed | 45 | #include "libavcodec/avcodec.h" |
de6d9b64 | 46 | |
de6d9b64 FB |
47 | #include "avio.h" |
48 | ||
f610a9f2 AJ |
49 | struct AVFormatContext; |
50 | ||
a6d18a0e MN |
51 | |
52 | /* | |
ea29242c MM |
53 | * Public Metadata API. |
54 | * The metadata API allows libavformat to export metadata tags to a client | |
55 | * application using a sequence of key/value pairs. | |
56 | * Important concepts to keep in mind: | |
57 | * 1. Keys are unique; there can never be 2 tags with the same key. This is | |
58 | * also meant semantically, i.e., a demuxer should not knowingly produce | |
59 | * several keys that are literally different but semantically identical. | |
60 | * E.g., key=Author5, key=Author6. In this example, all authors must be | |
61 | * placed in the same tag. | |
62 | * 2. Metadata is flat, not hierarchical; there are no subtags. If you | |
63 | * want to store, e.g., the email address of the child of producer Alice | |
64 | * and actor Bob, that could have key=alice_and_bobs_childs_email_address. | |
65 | * 3. A tag whose value is localized for a particular language is appended | |
7e030c47 | 66 | * with a dash character ('-') and the ISO 639-2/B 3-letter language code. |
ea29242c MM |
67 | * For example: Author-ger=Michael, Author-eng=Mike |
68 | * The original/default language is in the unqualified "Author" tag. | |
a6d18a0e MN |
69 | * A demuxer should set a default if it sets any translated tag. |
70 | */ | |
71 | ||
48a81c0f | 72 | #define AV_METADATA_MATCH_CASE 1 |
a6d18a0e MN |
73 | #define AV_METADATA_IGNORE_SUFFIX 2 |
74 | ||
75 | typedef struct { | |
76 | char *key; | |
77 | char *value; | |
bc1d2afb | 78 | }AVMetadataTag; |
a6d18a0e | 79 | |
e232c252 | 80 | typedef struct AVMetadata AVMetadata; |
f610a9f2 | 81 | typedef struct AVMetadataConv AVMetadataConv; |
a6d18a0e MN |
82 | |
83 | /** | |
22e77e44 DB |
84 | * Gets a metadata element with matching key. |
85 | * @param prev Set to the previous matching element to find the next. | |
86 | * @param flags Allows case as well as suffix-insensitive comparisons. | |
87 | * @return Found tag or NULL, changing key or value leads to undefined behavior. | |
a6d18a0e | 88 | */ |
bc1d2afb | 89 | AVMetadataTag * |
e232c252 | 90 | av_metadata_get(AVMetadata *m, const char *key, const AVMetadataTag *prev, int flags); |
a6d18a0e MN |
91 | |
92 | /** | |
22e77e44 DB |
93 | * Sets the given tag in m, overwriting an existing tag. |
94 | * @param key tag key to add to m (will be av_strduped) | |
95 | * @param value tag value to add to m (will be av_strduped) | |
96 | * @return >= 0 on success otherwise an error code <0 | |
a6d18a0e | 97 | */ |
5ea7ce88 | 98 | int av_metadata_set(AVMetadata **pm, const char *key, const char *value); |
a6d18a0e | 99 | |
094d9df7 | 100 | /** |
f610a9f2 AJ |
101 | * Convert all the metadata sets from ctx according to the source and |
102 | * destination conversion tables. | |
103 | * @param d_conv destination tags format conversion table | |
104 | * @param s_conv source tags format conversion table | |
105 | */ | |
106 | void av_metadata_conv(struct AVFormatContext *ctx,const AVMetadataConv *d_conv, | |
107 | const AVMetadataConv *s_conv); | |
108 | ||
109 | /** | |
22e77e44 | 110 | * Frees all the memory allocated for an AVMetadata struct. |
094d9df7 AJ |
111 | */ |
112 | void av_metadata_free(AVMetadata **m); | |
113 | ||
a6d18a0e | 114 | |
de6d9b64 FB |
115 | /* packet functions */ |
116 | ||
3217cb42 PI |
117 | |
118 | /** | |
4f57fa8c DB |
119 | * Allocate and read the payload of a packet and initialize its fields with |
120 | * default values. | |
3217cb42 PI |
121 | * |
122 | * @param pkt packet | |
4f57fa8c DB |
123 | * @param size desired payload size |
124 | * @return >0 (read size) if OK, AVERROR_xxx otherwise | |
3217cb42 | 125 | */ |
2692067a | 126 | int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size); |
3217cb42 | 127 | |
de6d9b64 FB |
128 | |
129 | /*************************************************/ | |
916c80e9 FB |
130 | /* fractional numbers for exact pts handling */ |
131 | ||
671adb17 | 132 | /** |
4f57fa8c DB |
133 | * The exact value of the fractional number is: 'val + num / den'. |
134 | * num is assumed to be 0 <= num < den. | |
4c08b2bd | 135 | */ |
916c80e9 | 136 | typedef struct AVFrac { |
115329f1 | 137 | int64_t val, num, den; |
52e57500 | 138 | } AVFrac; |
916c80e9 | 139 | |
916c80e9 | 140 | /*************************************************/ |
b9a281db | 141 | /* input/output formats */ |
de6d9b64 | 142 | |
7caf0cc6 MN |
143 | struct AVCodecTag; |
144 | ||
4f57fa8c | 145 | /** This structure contains the data a format has to probe a file. */ |
b9a281db | 146 | typedef struct AVProbeData { |
5c91a675 | 147 | const char *filename; |
b9a281db FB |
148 | unsigned char *buf; |
149 | int buf_size; | |
150 | } AVProbeData; | |
151 | ||
22e77e44 | 152 | #define AVPROBE_SCORE_MAX 100 ///< maximum score, half of that is used for file-extension-based detection |
87e87886 | 153 | #define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer |
de6d9b64 FB |
154 | |
155 | typedef struct AVFormatParameters { | |
c0df9d75 | 156 | AVRational time_base; |
de6d9b64 FB |
157 | int sample_rate; |
158 | int channels; | |
159 | int width; | |
160 | int height; | |
4606ac8d | 161 | enum PixelFormat pix_fmt; |
4f57fa8c DB |
162 | int channel; /**< Used to select DV channel. */ |
163 | const char *standard; /**< TV standard, NTSC, PAL, SECAM */ | |
164 | unsigned int mpeg2ts_raw:1; /**< Force raw MPEG-2 transport stream output, if possible. */ | |
165 | unsigned int mpeg2ts_compute_pcr:1; /**< Compute exact PCR for each transport | |
72e043dd | 166 | stream packet (only meaningful if |
4f57fa8c DB |
167 | mpeg2ts_raw is TRUE). */ |
168 | unsigned int initial_pause:1; /**< Do not begin to play the stream | |
169 | immediately (RTSP only). */ | |
72e043dd | 170 | unsigned int prealloced_context:1; |
71957315 | 171 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
5b6d5596 MN |
172 | enum CodecID video_codec_id; |
173 | enum CodecID audio_codec_id; | |
71957315 | 174 | #endif |
de6d9b64 FB |
175 | } AVFormatParameters; |
176 | ||
4f57fa8c | 177 | //! Demuxer will use url_fopen, no opened file should be provided by the caller. |
40d9c544 | 178 | #define AVFMT_NOFILE 0x0001 |
4f57fa8c DB |
179 | #define AVFMT_NEEDNUMBER 0x0002 /**< Needs '%d' in filename. */ |
180 | #define AVFMT_SHOW_IDS 0x0008 /**< Show format stream IDs numbers. */ | |
181 | #define AVFMT_RAWPICTURE 0x0020 /**< Format wants AVPicture structure for | |
182 | raw picture data. */ | |
183 | #define AVFMT_GLOBALHEADER 0x0040 /**< Format wants global header. */ | |
184 | #define AVFMT_NOTIMESTAMPS 0x0080 /**< Format does not need / have any timestamps. */ | |
185 | #define AVFMT_GENERIC_INDEX 0x0100 /**< Use generic index building code. */ | |
186 | #define AVFMT_TS_DISCONT 0x0200 /**< Format allows timestamp discontinuities. */ | |
25918212 | 187 | #define AVFMT_VARIABLE_FPS 0x0400 /**< Format allows variable fps. */ |
b9a281db FB |
188 | |
189 | typedef struct AVOutputFormat { | |
de6d9b64 | 190 | const char *name; |
bde15e74 SS |
191 | /** |
192 | * Descriptive name for the format, meant to be more human-readable | |
819174fa | 193 | * than name. You should use the NULL_IF_CONFIG_SMALL() macro |
bde15e74 SS |
194 | * to define it. |
195 | */ | |
de6d9b64 FB |
196 | const char *long_name; |
197 | const char *mime_type; | |
4f57fa8c | 198 | const char *extensions; /**< comma-separated filename extensions */ |
22e77e44 | 199 | /** size of private data so that it can be allocated in the wrapper */ |
b9a281db | 200 | int priv_data_size; |
de6d9b64 | 201 | /* output support */ |
43d414ba PI |
202 | enum CodecID audio_codec; /**< default audio codec */ |
203 | enum CodecID video_codec; /**< default video codec */ | |
de6d9b64 | 204 | int (*write_header)(struct AVFormatContext *); |
e928649b | 205 | int (*write_packet)(struct AVFormatContext *, AVPacket *pkt); |
de6d9b64 | 206 | int (*write_trailer)(struct AVFormatContext *); |
43d414ba | 207 | /** can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER */ |
b9a281db | 208 | int flags; |
4f57fa8c | 209 | /** Currently only used to set pixel format if not YUV420P. */ |
290c5fa6 | 210 | int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *); |
78cb7273 DB |
211 | int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, |
212 | AVPacket *in, int flush); | |
7caf0cc6 MN |
213 | |
214 | /** | |
78cb7273 | 215 | * List of supported codec_id-codec_tag pairs, ordered by "better |
22e77e44 | 216 | * choice first". The arrays are all terminated by CODEC_ID_NONE. |
7caf0cc6 | 217 | */ |
c1854592 | 218 | const struct AVCodecTag * const *codec_tag; |
7caf0cc6 | 219 | |
11bf3847 AJ |
220 | enum CodecID subtitle_codec; /**< default subtitle codec */ |
221 | ||
719e721a | 222 | const AVMetadataConv *metadata_conv; |
f610a9f2 | 223 | |
b9a281db FB |
224 | /* private fields */ |
225 | struct AVOutputFormat *next; | |
226 | } AVOutputFormat; | |
de6d9b64 | 227 | |
b9a281db FB |
228 | typedef struct AVInputFormat { |
229 | const char *name; | |
bde15e74 SS |
230 | /** |
231 | * Descriptive name for the format, meant to be more human-readable | |
819174fa | 232 | * than name. You should use the NULL_IF_CONFIG_SMALL() macro |
bde15e74 SS |
233 | * to define it. |
234 | */ | |
b9a281db | 235 | const char *long_name; |
4f57fa8c | 236 | /** Size of private data so that it can be allocated in the wrapper. */ |
b9a281db | 237 | int priv_data_size; |
65d7d68b | 238 | /** |
22e77e44 | 239 | * Tell if a given file has a chance of being parsed as this format. |
5d81d641 DB |
240 | * The buffer provided is guaranteed to be AVPROBE_PADDING_SIZE bytes |
241 | * big so you do not have to check for that unless you need more. | |
65d7d68b | 242 | */ |
b9a281db | 243 | int (*read_probe)(AVProbeData *); |
4f57fa8c DB |
244 | /** Read the format header and initialize the AVFormatContext |
245 | structure. Return 0 if OK. 'ap' if non-NULL contains | |
246 | additional parameters. Only used in raw format right | |
b9a281db | 247 | now. 'av_new_stream' should be called to create new streams. */ |
de6d9b64 FB |
248 | int (*read_header)(struct AVFormatContext *, |
249 | AVFormatParameters *ap); | |
4f57fa8c | 250 | /** Read one packet and put it in 'pkt'. pts and flags are also |
b9a281db | 251 | set. 'av_new_stream' can be called only if the flag |
6883ebe4 RD |
252 | AVFMTCTX_NOHEADER is used. |
253 | @return 0 on success, < 0 on error. | |
254 | When returning an error, pkt must not have been allocated | |
255 | or must be freed before returning */ | |
de6d9b64 | 256 | int (*read_packet)(struct AVFormatContext *, AVPacket *pkt); |
4f57fa8c | 257 | /** Close the stream. The AVFormatContext and AVStreams are not |
de6d9b64 FB |
258 | freed by this function */ |
259 | int (*read_close)(struct AVFormatContext *); | |
1de2db8f MN |
260 | |
261 | #if LIBAVFORMAT_VERSION_MAJOR < 53 | |
115329f1 | 262 | /** |
4f57fa8c DB |
263 | * Seek to a given timestamp relative to the frames in |
264 | * stream component stream_index. | |
22e77e44 DB |
265 | * @param stream_index Must not be -1. |
266 | * @param flags Selects which direction should be preferred if no exact | |
267 | * match is available. | |
05ce0f11 | 268 | * @return >= 0 on success (but not necessarily the new offset) |
3ba1438d | 269 | */ |
115329f1 | 270 | int (*read_seek)(struct AVFormatContext *, |
3ba1438d | 271 | int stream_index, int64_t timestamp, int flags); |
1de2db8f | 272 | #endif |
8d14a25c | 273 | /** |
4f57fa8c | 274 | * Gets the next timestamp in stream[stream_index].time_base units. |
d9526386 | 275 | * @return the timestamp or AV_NOPTS_VALUE if an error occurred |
8d14a25c MN |
276 | */ |
277 | int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index, | |
278 | int64_t *pos, int64_t pos_limit); | |
4f57fa8c | 279 | /** Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER. */ |
de6d9b64 | 280 | int flags; |
4f57fa8c | 281 | /** If extensions are defined, then no probe is done. You should |
b9a281db FB |
282 | usually not use extension format guessing because it is not |
283 | reliable enough */ | |
284 | const char *extensions; | |
4f57fa8c | 285 | /** General purpose read-only value that the format can use. */ |
b9a281db | 286 | int value; |
fb2758c8 | 287 | |
4f57fa8c DB |
288 | /** Start/resume playing - only meaningful if using a network-based format |
289 | (RTSP). */ | |
fb2758c8 FB |
290 | int (*read_play)(struct AVFormatContext *); |
291 | ||
4f57fa8c DB |
292 | /** Pause playing - only meaningful if using a network-based format |
293 | (RTSP). */ | |
fb2758c8 FB |
294 | int (*read_pause)(struct AVFormatContext *); |
295 | ||
c1854592 | 296 | const struct AVCodecTag * const *codec_tag; |
7caf0cc6 | 297 | |
1de2db8f MN |
298 | /** |
299 | * Seek to timestamp ts. | |
300 | * Seeking will be done so that the point from which all active streams | |
301 | * can be presented successfully will be closest to ts and within min/max_ts. | |
302 | * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL. | |
303 | */ | |
882fb0a3 | 304 | int (*read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags); |
1de2db8f | 305 | |
719e721a | 306 | const AVMetadataConv *metadata_conv; |
f610a9f2 | 307 | |
b9a281db FB |
308 | /* private fields */ |
309 | struct AVInputFormat *next; | |
310 | } AVInputFormat; | |
de6d9b64 | 311 | |
57004ff1 AJ |
312 | enum AVStreamParseType { |
313 | AVSTREAM_PARSE_NONE, | |
314 | AVSTREAM_PARSE_FULL, /**< full parsing and repack */ | |
4f57fa8c | 315 | AVSTREAM_PARSE_HEADERS, /**< Only parse headers, do not repack. */ |
78cb7273 | 316 | AVSTREAM_PARSE_TIMESTAMPS, /**< full parsing and interpolation of timestamps for frames not starting on a packet boundary */ |
57004ff1 AJ |
317 | }; |
318 | ||
fb2758c8 FB |
319 | typedef struct AVIndexEntry { |
320 | int64_t pos; | |
321 | int64_t timestamp; | |
322 | #define AVINDEX_KEYFRAME 0x0001 | |
30a43f2d | 323 | int flags:2; |
4f57fa8c DB |
324 | 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). |
325 | int min_distance; /**< Minimum distance between this and the previous keyframe, used to avoid unneeded searching. */ | |
fb2758c8 FB |
326 | } AVIndexEntry; |
327 | ||
90c2295b ES |
328 | #define AV_DISPOSITION_DEFAULT 0x0001 |
329 | #define AV_DISPOSITION_DUB 0x0002 | |
330 | #define AV_DISPOSITION_ORIGINAL 0x0004 | |
331 | #define AV_DISPOSITION_COMMENT 0x0008 | |
332 | #define AV_DISPOSITION_LYRICS 0x0010 | |
333 | #define AV_DISPOSITION_KARAOKE 0x0020 | |
334 | ||
ba66ae94 MN |
335 | /** |
336 | * Stream structure. | |
337 | * New fields can be added to the end with minor version bumps. | |
8bfb108b | 338 | * Removal, reordering and changes to existing fields require a major |
ba66ae94 | 339 | * version bump. |
8bfb108b | 340 | * sizeof(AVStream) must not be used outside libav*. |
ba66ae94 | 341 | */ |
de6d9b64 | 342 | typedef struct AVStream { |
43d414ba | 343 | int index; /**< stream index in AVFormatContext */ |
4f57fa8c | 344 | int id; /**< format-specific stream ID */ |
43d414ba | 345 | AVCodecContext *codec; /**< codec context */ |
b4b87d48 | 346 | /** |
22e77e44 DB |
347 | * Real base framerate of the stream. |
348 | * This is the lowest framerate with which all timestamps can be | |
864ff8c1 | 349 | * represented accurately (it is the least common multiple of all |
22e77e44 DB |
350 | * framerates in the stream). Note, this value is just a guess! |
351 | * For example, if the time base is 1/90000 and all frames have either | |
4f57fa8c | 352 | * approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1. |
b4b87d48 MN |
353 | */ |
354 | AVRational r_frame_rate; | |
de6d9b64 | 355 | void *priv_data; |
82583548 | 356 | |
b9a281db | 357 | /* internal data used in av_find_stream_info() */ |
82583548 | 358 | int64_t first_dts; |
4f57fa8c | 359 | /** encoding: pts generation when outputting stream */ |
a9fd2b19 | 360 | struct AVFrac pts; |
5b28c8c3 MN |
361 | |
362 | /** | |
8bfb108b DB |
363 | * This is the fundamental unit of time (in seconds) in terms |
364 | * of which frame timestamps are represented. For fixed-fps content, | |
22e77e44 | 365 | * time base should be 1/framerate and timestamp increments should be 1. |
5b28c8c3 | 366 | */ |
9ee91c2f | 367 | AVRational time_base; |
43d414ba | 368 | int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */ |
a48b7a6b | 369 | /* ffmpeg.c private use */ |
4f57fa8c DB |
370 | int stream_copy; /**< If set, just copy stream. */ |
371 | enum AVDiscard discard; ///< Selects which packets can be discarded at will and do not need to be demuxed. | |
b4aea108 | 372 | //FIXME move stuff to a flags field? |
4f57fa8c | 373 | /** Quality, as it has been removed from AVCodecContext and put in AVVideoFrame. |
755bfeab | 374 | * MN: dunno if that is the right place for it */ |
115329f1 | 375 | float quality; |
6d96a9b9 | 376 | /** |
8bfb108b DB |
377 | * Decoding: pts of the first frame of the stream, in stream time base. |
378 | * Only set this if you are absolutely 100% sure that the value you set | |
379 | * it to really is the pts of the first frame. | |
4854c253 | 380 | * This may be undefined (AV_NOPTS_VALUE). |
8bfb108b DB |
381 | * @note The ASF header does NOT contain a correct start_time the ASF |
382 | * demuxer must NOT set this. | |
6d96a9b9 | 383 | */ |
115329f1 | 384 | int64_t start_time; |
e26381b6 | 385 | /** |
8bfb108b | 386 | * Decoding: duration of the stream, in stream time base. |
e26381b6 | 387 | * If a source file does not specify a duration, but does specify |
4f57fa8c | 388 | * a bitrate, this value will be estimated from bitrate and file size. |
e26381b6 | 389 | */ |
ee404803 | 390 | int64_t duration; |
fb2758c8 | 391 | |
827f7e28 | 392 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
7e030c47 | 393 | char language[4]; /** ISO 639-2/B 3-letter language code (empty string if undefined) */ |
827f7e28 | 394 | #endif |
09730260 | 395 | |
fb2758c8 | 396 | /* av_read_frame() support */ |
57004ff1 | 397 | enum AVStreamParseType need_parsing; |
fb2758c8 | 398 | struct AVCodecParserContext *parser; |
6ec87caa | 399 | |
fb2758c8 | 400 | int64_t cur_dts; |
635fbcb1 MN |
401 | int last_IP_duration; |
402 | int64_t last_IP_pts; | |
fb2758c8 | 403 | /* av_seek_frame() support */ |
4f57fa8c DB |
404 | AVIndexEntry *index_entries; /**< Only used if the format does not |
405 | support seeking natively. */ | |
fb2758c8 | 406 | int nb_index_entries; |
191e8ca7 | 407 | unsigned int index_entries_allocated_size; |
115329f1 | 408 | |
b4b87d48 | 409 | int64_t nb_frames; ///< number of frames in this stream if known or 0 |
504ee036 | 410 | |
0d84a8f6 BC |
411 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
412 | int64_t unused[4+1]; | |
f8d7c9d3 ES |
413 | |
414 | char *filename; /**< source filename of the stream */ | |
827f7e28 | 415 | #endif |
90c2295b | 416 | |
4f57fa8c | 417 | int disposition; /**< AV_DISPOSITION_* bit field */ |
0bef08e5 MN |
418 | |
419 | AVProbeData probe_data; | |
0d84a8f6 BC |
420 | #define MAX_REORDER_DELAY 16 |
421 | int64_t pts_buffer[MAX_REORDER_DELAY+1]; | |
c30a4489 AJ |
422 | |
423 | /** | |
424 | * sample aspect ratio (0 if unknown) | |
425 | * - encoding: Set by user. | |
426 | * - decoding: Set by libavformat. | |
427 | */ | |
428 | AVRational sample_aspect_ratio; | |
f526adaf | 429 | |
e232c252 | 430 | AVMetadata *metadata; |
3a41c2f7 MN |
431 | |
432 | /* av_read_frame() support */ | |
433 | const uint8_t *cur_ptr; | |
434 | int cur_len; | |
435 | AVPacket cur_pkt; | |
27ca0a79 IS |
436 | |
437 | // Timestamp generation support: | |
438 | /** | |
439 | * Timestamp corresponding to the last dts sync point. | |
440 | * | |
441 | * Initialized when AVCodecParserContext.dts_sync_point >= 0 and | |
442 | * a DTS is received from the underlying container. Otherwise set to | |
443 | * AV_NOPTS_VALUE by default. | |
444 | */ | |
445 | int64_t reference_dts; | |
86cb7e33 BC |
446 | |
447 | /** | |
448 | * Number of packets to buffer for codec probing | |
449 | * NOT PART OF PUBLIC API | |
450 | */ | |
451 | #define MAX_PROBE_PACKETS 100 | |
452 | int probe_packets; | |
de6d9b64 FB |
453 | } AVStream; |
454 | ||
15afa396 NS |
455 | #define AV_PROGRAM_RUNNING 1 |
456 | ||
ba66ae94 | 457 | /** |
ba66ae94 | 458 | * New fields can be added to the end with minor version bumps. |
8bfb108b | 459 | * Removal, reordering and changes to existing fields require a major |
ba66ae94 | 460 | * version bump. |
8bfb108b | 461 | * sizeof(AVProgram) must not be used outside libav*. |
ba66ae94 | 462 | */ |
15afa396 NS |
463 | typedef struct AVProgram { |
464 | int id; | |
827f7e28 | 465 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
4f57fa8c DB |
466 | char *provider_name; ///< network name for DVB streams |
467 | char *name; ///< service name for DVB streams | |
827f7e28 | 468 | #endif |
15afa396 NS |
469 | int flags; |
470 | enum AVDiscard discard; ///< selects which program to discard and which to feed to the caller | |
526efa10 NS |
471 | unsigned int *stream_index; |
472 | unsigned int nb_stream_indexes; | |
e232c252 | 473 | AVMetadata *metadata; |
15afa396 NS |
474 | } AVProgram; |
475 | ||
43d414ba | 476 | #define AVFMTCTX_NOHEADER 0x0001 /**< signal that no header is present |
da24c5e3 FB |
477 | (streams are added dynamically) */ |
478 | ||
79d7836a | 479 | typedef struct AVChapter { |
4f57fa8c DB |
480 | int id; ///< unique ID to identify the chapter |
481 | AVRational time_base; ///< time base in which the start/end timestamps are specified | |
8931e7b4 | 482 | int64_t start, end; ///< chapter start/end time in time_base units |
827f7e28 | 483 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
c2fb6be4 | 484 | char *title; ///< chapter title |
827f7e28 | 485 | #endif |
e232c252 | 486 | AVMetadata *metadata; |
79d7836a AK |
487 | } AVChapter; |
488 | ||
de6d9b64 FB |
489 | #define MAX_STREAMS 20 |
490 | ||
252f17e2 | 491 | /** |
4f57fa8c | 492 | * Format I/O context. |
252f17e2 | 493 | * New fields can be added to the end with minor version bumps. |
8bfb108b | 494 | * Removal, reordering and changes to existing fields require a major |
252f17e2 | 495 | * version bump. |
8bfb108b | 496 | * sizeof(AVFormatContext) must not be used outside libav*. |
252f17e2 | 497 | */ |
de6d9b64 | 498 | typedef struct AVFormatContext { |
1447aac4 | 499 | const AVClass *av_class; /**< Set by avformat_alloc_context. */ |
4f57fa8c | 500 | /* Can only be iformat or oformat, not both at the same time. */ |
b9a281db FB |
501 | struct AVInputFormat *iformat; |
502 | struct AVOutputFormat *oformat; | |
de6d9b64 | 503 | void *priv_data; |
899681cd | 504 | ByteIOContext *pb; |
db69c2e5 | 505 | unsigned int nb_streams; |
de6d9b64 | 506 | AVStream *streams[MAX_STREAMS]; |
43d414ba | 507 | char filename[1024]; /**< input or output filename */ |
de6d9b64 | 508 | /* stream info */ |
4568325a | 509 | int64_t timestamp; |
827f7e28 | 510 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
de6d9b64 FB |
511 | char title[512]; |
512 | char author[512]; | |
513 | char copyright[512]; | |
514 | char comment[512]; | |
6a58e151 | 515 | char album[512]; |
43d414ba PI |
516 | int year; /**< ID3 year, 0 if none */ |
517 | int track; /**< track number, 0 if none */ | |
518 | char genre[32]; /**< ID3 genre */ | |
827f7e28 | 519 | #endif |
6a58e151 | 520 | |
4f57fa8c DB |
521 | int ctx_flags; /**< Format-specific flags, see AVFMTCTX_xx */ |
522 | /* private data for pts handling (do not modify directly). */ | |
43d414ba | 523 | /** This buffer is only needed when packets were already buffered but |
4f57fa8c DB |
524 | not decoded, for example to get the codec parameters in MPEG |
525 | streams. */ | |
ee404803 FB |
526 | struct AVPacketList *packet_buffer; |
527 | ||
4f57fa8c | 528 | /** Decoding: position of the first frame of the component, in |
ee404803 | 529 | AV_TIME_BASE fractional seconds. NEVER set this value directly: |
4f57fa8c | 530 | It is deduced from the AVStream values. */ |
115329f1 | 531 | int64_t start_time; |
4f57fa8c | 532 | /** Decoding: duration of the stream, in AV_TIME_BASE fractional |
ee404803 FB |
533 | seconds. NEVER set this value directly: it is deduced from the |
534 | AVStream values. */ | |
535 | int64_t duration; | |
4f57fa8c | 536 | /** decoding: total file size, 0 if unknown */ |
ee404803 | 537 | int64_t file_size; |
4f57fa8c | 538 | /** Decoding: total stream bitrate in bit/s, 0 if not |
ee404803 | 539 | available. Never set it directly if the file_size and the |
22e77e44 | 540 | duration are known as FFmpeg can compute it automatically. */ |
ee404803 | 541 | int bit_rate; |
fb2758c8 FB |
542 | |
543 | /* av_read_frame() support */ | |
544 | AVStream *cur_st; | |
3a41c2f7 MN |
545 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
546 | const uint8_t *cur_ptr_deprecated; | |
547 | int cur_len_deprecated; | |
548 | AVPacket cur_pkt_deprecated; | |
549 | #endif | |
fb2758c8 | 550 | |
fb2758c8 | 551 | /* av_seek_frame() support */ |
43d414ba | 552 | int64_t data_offset; /** offset of the first packet */ |
fb2758c8 | 553 | int index_built; |
115329f1 | 554 | |
2db3c638 | 555 | int mux_rate; |
92400be2 | 556 | unsigned int packet_size; |
17c88cb0 MN |
557 | int preload; |
558 | int max_delay; | |
8108551a | 559 | |
115329f1 DB |
560 | #define AVFMT_NOOUTPUTLOOP -1 |
561 | #define AVFMT_INFINITEOUTPUTLOOP 0 | |
43d414ba | 562 | /** number of times to loop output in formats that support it */ |
8108551a | 563 | int loop_output; |
115329f1 | 564 | |
30bc6613 | 565 | int flags; |
22e77e44 | 566 | #define AVFMT_FLAG_GENPTS 0x0001 ///< Generate missing pts even if it requires parsing future frames. |
4f57fa8c DB |
567 | #define AVFMT_FLAG_IGNIDX 0x0002 ///< Ignore index. |
568 | #define AVFMT_FLAG_NONBLOCK 0x0004 ///< Do not block when reading packets from input. | |
5894e1bb VP |
569 | |
570 | int loop_input; | |
22e77e44 | 571 | /** decoding: size of data to probe; encoding: unused. */ |
9e6c9470 | 572 | unsigned int probesize; |
a44b3c4d MN |
573 | |
574 | /** | |
4f57fa8c DB |
575 | * Maximum time (in AV_TIME_BASE units) during which the input should |
576 | * be analyzed in av_find_stream_info(). | |
a44b3c4d MN |
577 | */ |
578 | int max_analyze_duration; | |
c964c2c7 RD |
579 | |
580 | const uint8_t *key; | |
581 | int keylen; | |
15afa396 NS |
582 | |
583 | unsigned int nb_programs; | |
584 | AVProgram **programs; | |
62600469 MN |
585 | |
586 | /** | |
587 | * Forced video codec_id. | |
4f57fa8c | 588 | * Demuxing: Set by user. |
62600469 MN |
589 | */ |
590 | enum CodecID video_codec_id; | |
591 | /** | |
592 | * Forced audio codec_id. | |
4f57fa8c | 593 | * Demuxing: Set by user. |
62600469 MN |
594 | */ |
595 | enum CodecID audio_codec_id; | |
596 | /** | |
597 | * Forced subtitle codec_id. | |
4f57fa8c | 598 | * Demuxing: Set by user. |
62600469 MN |
599 | */ |
600 | enum CodecID subtitle_codec_id; | |
3dea63bd PK |
601 | |
602 | /** | |
22e77e44 DB |
603 | * Maximum amount of memory in bytes to use for the index of each stream. |
604 | * If the index exceeds this size, entries will be discarded as | |
3dea63bd PK |
605 | * needed to maintain a smaller size. This can lead to slower or less |
606 | * accurate seeking (depends on demuxer). | |
4f57fa8c | 607 | * Demuxers for which a full in-memory index is mandatory will ignore |
3dea63bd PK |
608 | * this. |
609 | * muxing : unused | |
610 | * demuxing: set by user | |
611 | */ | |
612 | unsigned int max_index_size; | |
ab8ab30c RP |
613 | |
614 | /** | |
ffa71b2b | 615 | * Maximum amount of memory in bytes to use for buffering frames |
4f57fa8c | 616 | * obtained from realtime capture devices. |
ab8ab30c RP |
617 | */ |
618 | unsigned int max_picture_buffer; | |
79d7836a | 619 | |
fbabf1e9 | 620 | unsigned int nb_chapters; |
79d7836a | 621 | AVChapter **chapters; |
45b2b05f MN |
622 | |
623 | /** | |
4f57fa8c | 624 | * Flags to enable debugging. |
45b2b05f MN |
625 | */ |
626 | int debug; | |
627 | #define FF_FDEBUG_TS 0x0001 | |
0bef08e5 MN |
628 | |
629 | /** | |
4f57fa8c | 630 | * Raw packets from the demuxer, prior to parsing and decoding. |
0bef08e5 MN |
631 | * This buffer is used for buffering packets until the codec can |
632 | * be identified, as parsing cannot be done without knowing the | |
633 | * codec. | |
634 | */ | |
635 | struct AVPacketList *raw_packet_buffer; | |
5c5b1731 MR |
636 | struct AVPacketList *raw_packet_buffer_end; |
637 | ||
638 | struct AVPacketList *packet_buffer_end; | |
47146dfb | 639 | |
e232c252 | 640 | AVMetadata *metadata; |
af122d6a BC |
641 | |
642 | /** | |
643 | * Remaining size available for raw_packet_buffer, in bytes. | |
644 | * NOT PART OF PUBLIC API | |
645 | */ | |
646 | #define RAW_PACKET_BUFFER_SIZE 32000 | |
647 | int raw_packet_buffer_remaining_size; | |
de6d9b64 FB |
648 | } AVFormatContext; |
649 | ||
650 | typedef struct AVPacketList { | |
651 | AVPacket pkt; | |
652 | struct AVPacketList *next; | |
653 | } AVPacketList; | |
654 | ||
84be6e72 | 655 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
b9a281db FB |
656 | extern AVInputFormat *first_iformat; |
657 | extern AVOutputFormat *first_oformat; | |
84be6e72 MN |
658 | #endif |
659 | ||
aeedac95 SS |
660 | /** |
661 | * If f is NULL, returns the first registered input format, | |
22e77e44 | 662 | * if f is non-NULL, returns the next registered input format after f |
aeedac95 SS |
663 | * or NULL if f is the last one. |
664 | */ | |
84be6e72 | 665 | AVInputFormat *av_iformat_next(AVInputFormat *f); |
aeedac95 SS |
666 | |
667 | /** | |
668 | * If f is NULL, returns the first registered output format, | |
22e77e44 | 669 | * if f is non-NULL, returns the next registered output format after f |
aeedac95 SS |
670 | * or NULL if f is the last one. |
671 | */ | |
84be6e72 | 672 | AVOutputFormat *av_oformat_next(AVOutputFormat *f); |
de6d9b64 | 673 | |
5b6d5596 | 674 | enum CodecID av_guess_image2_codec(const char *filename); |
290c5fa6 | 675 | |
22e77e44 DB |
676 | /* XXX: Use automatic init with either ELF sections or C file parser */ |
677 | /* modules. */ | |
de6d9b64 | 678 | |
b9a281db | 679 | /* utils.c */ |
b9a281db FB |
680 | void av_register_input_format(AVInputFormat *format); |
681 | void av_register_output_format(AVOutputFormat *format); | |
115329f1 | 682 | AVOutputFormat *guess_stream_format(const char *short_name, |
78cb7273 DB |
683 | const char *filename, |
684 | const char *mime_type); | |
115329f1 | 685 | AVOutputFormat *guess_format(const char *short_name, |
78cb7273 DB |
686 | const char *filename, |
687 | const char *mime_type); | |
3217cb42 PI |
688 | |
689 | /** | |
4f57fa8c | 690 | * Guesses the codec ID based upon muxer and filename. |
3217cb42 | 691 | */ |
115329f1 | 692 | enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, |
78cb7273 DB |
693 | const char *filename, const char *mime_type, |
694 | enum CodecType type); | |
de6d9b64 | 695 | |
3217cb42 | 696 | /** |
750f0e1f PI |
697 | * Send a nice hexadecimal dump of a buffer to the specified file stream. |
698 | * | |
699 | * @param f The file stream pointer where the dump should be sent to. | |
3217cb42 PI |
700 | * @param buf buffer |
701 | * @param size buffer size | |
750f0e1f PI |
702 | * |
703 | * @see av_hex_dump_log, av_pkt_dump, av_pkt_dump_log | |
3217cb42 | 704 | */ |
fb2758c8 | 705 | void av_hex_dump(FILE *f, uint8_t *buf, int size); |
3217cb42 PI |
706 | |
707 | /** | |
750f0e1f PI |
708 | * Send a nice hexadecimal dump of a buffer to the log. |
709 | * | |
710 | * @param avcl A pointer to an arbitrary struct of which the first field is a | |
711 | * pointer to an AVClass struct. | |
712 | * @param level The importance level of the message, lower values signifying | |
713 | * higher importance. | |
714 | * @param buf buffer | |
715 | * @param size buffer size | |
716 | * | |
717 | * @see av_hex_dump, av_pkt_dump, av_pkt_dump_log | |
718 | */ | |
719 | void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size); | |
720 | ||
721 | /** | |
722 | * Send a nice dump of a packet to the specified file stream. | |
723 | * | |
724 | * @param f The file stream pointer where the dump should be sent to. | |
3217cb42 | 725 | * @param pkt packet to dump |
4f57fa8c | 726 | * @param dump_payload True if the payload must be displayed, too. |
3217cb42 | 727 | */ |
fb2758c8 | 728 | void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload); |
de6d9b64 | 729 | |
750f0e1f PI |
730 | /** |
731 | * Send a nice dump of a packet to the log. | |
732 | * | |
733 | * @param avcl A pointer to an arbitrary struct of which the first field is a | |
734 | * pointer to an AVClass struct. | |
735 | * @param level The importance level of the message, lower values signifying | |
736 | * higher importance. | |
737 | * @param pkt packet to dump | |
4f57fa8c | 738 | * @param dump_payload True if the payload must be displayed, too. |
750f0e1f PI |
739 | */ |
740 | void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload); | |
741 | ||
4815e246 SS |
742 | /** |
743 | * Initialize libavformat and register all the muxers, demuxers and | |
744 | * protocols. If you do not call this function, then you can select | |
745 | * exactly which formats you want to support. | |
746 | * | |
747 | * @see av_register_input_format() | |
748 | * @see av_register_output_format() | |
5d377501 | 749 | * @see av_register_protocol() |
4815e246 | 750 | */ |
94988531 | 751 | void av_register_all(void); |
de6d9b64 | 752 | |
43d414ba | 753 | /** codec tag <-> codec id */ |
15545a09 SS |
754 | enum CodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag); |
755 | unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum CodecID id); | |
7caf0cc6 | 756 | |
b9a281db | 757 | /* media file input */ |
3217cb42 PI |
758 | |
759 | /** | |
4f57fa8c | 760 | * Finds AVInputFormat based on the short name of the input format. |
3217cb42 | 761 | */ |
b9a281db | 762 | AVInputFormat *av_find_input_format(const char *short_name); |
3217cb42 PI |
763 | |
764 | /** | |
765 | * Guess file format. | |
766 | * | |
4f57fa8c DB |
767 | * @param is_opened Whether the file is already opened; determines whether |
768 | * demuxers with or without AVFMT_NOFILE are probed. | |
3217cb42 | 769 | */ |
94988531 | 770 | AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened); |
3217cb42 PI |
771 | |
772 | /** | |
773 | * Allocates all the structures needed to read an input stream. | |
774 | * This does not open the needed codecs for decoding the stream[s]. | |
775 | */ | |
115329f1 DB |
776 | int av_open_input_stream(AVFormatContext **ic_ptr, |
777 | ByteIOContext *pb, const char *filename, | |
da24c5e3 | 778 | AVInputFormat *fmt, AVFormatParameters *ap); |
3217cb42 PI |
779 | |
780 | /** | |
864ff8c1 | 781 | * Open a media file as input. The codecs are not opened. Only the file |
3217cb42 PI |
782 | * header (if present) is read. |
783 | * | |
4f57fa8c DB |
784 | * @param ic_ptr The opened media file handle is put here. |
785 | * @param filename filename to open | |
786 | * @param fmt If non-NULL, force the file format to use. | |
3217cb42 | 787 | * @param buf_size optional buffer size (zero if default is OK) |
78cb7273 DB |
788 | * @param ap Additional parameters needed when opening the file |
789 | * (NULL if default). | |
4f57fa8c | 790 | * @return 0 if OK, AVERROR_xxx otherwise |
3217cb42 | 791 | */ |
115329f1 | 792 | int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, |
b9a281db FB |
793 | AVInputFormat *fmt, |
794 | int buf_size, | |
795 | AVFormatParameters *ap); | |
88a28965 SS |
796 | |
797 | #if LIBAVFORMAT_VERSION_MAJOR < 53 | |
798 | /** | |
799 | * @deprecated Use avformat_alloc_context() instead. | |
800 | */ | |
801 | attribute_deprecated AVFormatContext *av_alloc_format_context(void); | |
802 | #endif | |
803 | ||
88808c60 MN |
804 | /** |
805 | * Allocate an AVFormatContext. | |
5d81d641 | 806 | * Can be freed with av_free() but do not forget to free everything you |
88808c60 MN |
807 | * explicitly allocated as well! |
808 | */ | |
88a28965 | 809 | AVFormatContext *avformat_alloc_context(void); |
b9a281db | 810 | |
3217cb42 PI |
811 | /** |
812 | * Read packets of a media file to get stream information. This | |
813 | * is useful for file formats with no headers such as MPEG. This | |
22e77e44 | 814 | * function also computes the real framerate in case of MPEG-2 repeat |
3217cb42 PI |
815 | * frame mode. |
816 | * The logical file position is not changed by this function; | |
817 | * examined packets may be buffered for later processing. | |
818 | * | |
819 | * @param ic media file handle | |
4f57fa8c DB |
820 | * @return >=0 if OK, AVERROR_xxx on error |
821 | * @todo Let the user decide somehow what information is needed so that | |
822 | * we do not waste time getting stuff the user does not need. | |
3217cb42 | 823 | */ |
b9a281db | 824 | int av_find_stream_info(AVFormatContext *ic); |
3217cb42 PI |
825 | |
826 | /** | |
827 | * Read a transport packet from a media file. | |
828 | * | |
864ff8c1 | 829 | * This function is obsolete and should never be used. |
3217cb42 PI |
830 | * Use av_read_frame() instead. |
831 | * | |
832 | * @param s media file handle | |
833 | * @param pkt is filled | |
4f57fa8c | 834 | * @return 0 if OK, AVERROR_xxx on error |
3217cb42 | 835 | */ |
de6d9b64 | 836 | int av_read_packet(AVFormatContext *s, AVPacket *pkt); |
3217cb42 PI |
837 | |
838 | /** | |
839 | * Return the next frame of a stream. | |
840 | * | |
841 | * The returned packet is valid | |
842 | * until the next av_read_frame() or until av_close_input_file() and | |
843 | * must be freed with av_free_packet. For video, the packet contains | |
844 | * exactly one frame. For audio, it contains an integer number of | |
845 | * frames if each frame has a known fixed size (e.g. PCM or ADPCM | |
846 | * data). If the audio frames have a variable size (e.g. MPEG audio), | |
847 | * then it contains one frame. | |
848 | * | |
849 | * pkt->pts, pkt->dts and pkt->duration are always set to correct | |
22e77e44 | 850 | * values in AVStream.time_base units (and guessed if the format cannot |
4f57fa8c DB |
851 | * provide them). pkt->pts can be AV_NOPTS_VALUE if the video format |
852 | * has B-frames, so it is better to rely on pkt->dts if you do not | |
3217cb42 PI |
853 | * decompress the payload. |
854 | * | |
4f57fa8c | 855 | * @return 0 if OK, < 0 on error or end of file |
3217cb42 | 856 | */ |
fb2758c8 | 857 | int av_read_frame(AVFormatContext *s, AVPacket *pkt); |
3217cb42 PI |
858 | |
859 | /** | |
22e77e44 | 860 | * Seek to the keyframe at timestamp. |
3217cb42 PI |
861 | * 'timestamp' in 'stream_index'. |
862 | * @param stream_index If stream_index is (-1), a default | |
863 | * stream is selected, and timestamp is automatically converted | |
864 | * from AV_TIME_BASE units to the stream specific time_base. | |
4f57fa8c DB |
865 | * @param timestamp Timestamp in AVStream.time_base units |
866 | * or, if no stream is specified, in AV_TIME_BASE units. | |
3217cb42 PI |
867 | * @param flags flags which select direction and seeking mode |
868 | * @return >= 0 on success | |
869 | */ | |
78cb7273 DB |
870 | int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, |
871 | int flags); | |
3217cb42 PI |
872 | |
873 | /** | |
d04768fa MN |
874 | * Seek to timestamp ts. |
875 | * Seeking will be done so that the point from which all active streams | |
876 | * can be presented successfully will be closest to ts and within min/max_ts. | |
877 | * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL. | |
878 | * | |
22e77e44 | 879 | * If flags contain AVSEEK_FLAG_BYTE, then all timestamps are in bytes and |
d04768fa | 880 | * are the file position (this may not be supported by all demuxers). |
22e77e44 | 881 | * If flags contain AVSEEK_FLAG_FRAME, then all timestamps are in frames |
d04768fa | 882 | * in the stream with stream_index (this may not be supported by all demuxers). |
22e77e44 DB |
883 | * Otherwise all timestamps are in units of the stream selected by stream_index |
884 | * or if stream_index is -1, in AV_TIME_BASE units. | |
885 | * If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as | |
d04768fa MN |
886 | * keyframes (this may not be supported by all demuxers). |
887 | * | |
22e77e44 | 888 | * @param stream_index index of the stream which is used as time base reference |
d04768fa MN |
889 | * @param min_ts smallest acceptable timestamp |
890 | * @param ts target timestamp | |
891 | * @param max_ts largest acceptable timestamp | |
892 | * @param flags flags | |
893 | * @returns >=0 on success, error code otherwise | |
998b6f7c | 894 | * |
22e77e44 DB |
895 | * @NOTE This is part of the new seek API which is still under construction. |
896 | * Thus do not use this yet. It may change at any time, do not expect | |
897 | * ABI compatibility yet! | |
d04768fa MN |
898 | */ |
899 | int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags); | |
900 | ||
901 | /** | |
22e77e44 | 902 | * Start playing a network-based stream (e.g. RTSP stream) at the |
4f57fa8c | 903 | * current position. |
3217cb42 | 904 | */ |
fb2758c8 | 905 | int av_read_play(AVFormatContext *s); |
3217cb42 PI |
906 | |
907 | /** | |
22e77e44 | 908 | * Pause a network-based stream (e.g. RTSP stream). |
3217cb42 PI |
909 | * |
910 | * Use av_read_play() to resume it. | |
911 | */ | |
fb2758c8 | 912 | int av_read_pause(AVFormatContext *s); |
3217cb42 PI |
913 | |
914 | /** | |
2506fd54 RD |
915 | * Free a AVFormatContext allocated by av_open_input_stream. |
916 | * @param s context to free | |
917 | */ | |
918 | void av_close_input_stream(AVFormatContext *s); | |
919 | ||
920 | /** | |
3217cb42 PI |
921 | * Close a media file (but not its codecs). |
922 | * | |
923 | * @param s media file handle | |
924 | */ | |
de6d9b64 | 925 | void av_close_input_file(AVFormatContext *s); |
3217cb42 PI |
926 | |
927 | /** | |
928 | * Add a new stream to a media file. | |
929 | * | |
930 | * Can only be called in the read_header() function. If the flag | |
931 | * AVFMTCTX_NOHEADER is in the format context, then new streams | |
932 | * can be added in read_packet too. | |
933 | * | |
934 | * @param s media file handle | |
4f57fa8c | 935 | * @param id file-format-dependent stream ID |
3217cb42 | 936 | */ |
b9a281db | 937 | AVStream *av_new_stream(AVFormatContext *s, int id); |
15afa396 | 938 | AVProgram *av_new_program(AVFormatContext *s, int id); |
3217cb42 PI |
939 | |
940 | /** | |
79d7836a AK |
941 | * Add a new chapter. |
942 | * This function is NOT part of the public API | |
4f57fa8c | 943 | * and should ONLY be used by demuxers. |
79d7836a AK |
944 | * |
945 | * @param s media file handle | |
4f57fa8c | 946 | * @param id unique ID for this chapter |
abd2256d MN |
947 | * @param start chapter start time in time_base units |
948 | * @param end chapter end time in time_base units | |
79d7836a | 949 | * @param title chapter title |
5c37f43a | 950 | * |
4f57fa8c | 951 | * @return AVChapter or NULL on error |
79d7836a | 952 | */ |
78cb7273 DB |
953 | AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, |
954 | int64_t start, int64_t end, const char *title); | |
79d7836a AK |
955 | |
956 | /** | |
3217cb42 PI |
957 | * Set the pts for a given stream. |
958 | * | |
959 | * @param s stream | |
960 | * @param pts_wrap_bits number of bits effectively used by the pts | |
961 | * (used for wrap control, 33 is the value for MPEG) | |
962 | * @param pts_num numerator to convert to seconds (MPEG: 1) | |
963 | * @param pts_den denominator to convert to seconds (MPEG: 90000) | |
964 | */ | |
9ee91c2f | 965 | void av_set_pts_info(AVStream *s, int pts_wrap_bits, |
916c80e9 | 966 | int pts_num, int pts_den); |
de6d9b64 | 967 | |
3ba1438d MN |
968 | #define AVSEEK_FLAG_BACKWARD 1 ///< seek backward |
969 | #define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes | |
4f57fa8c | 970 | #define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non-keyframes |
3ba1438d | 971 | |
b754978a | 972 | int av_find_default_stream_index(AVFormatContext *s); |
3217cb42 PI |
973 | |
974 | /** | |
975 | * Gets the index for a specific timestamp. | |
4f57fa8c DB |
976 | * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond |
977 | * to the timestamp which is <= the requested one, if backward | |
978 | * is 0, then it will be >= | |
3217cb42 PI |
979 | * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise |
980 | * @return < 0 if no such timestamp could be found | |
981 | */ | |
dc56fc38 | 982 | int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags); |
3217cb42 PI |
983 | |
984 | /** | |
3dea63bd | 985 | * Ensures the index uses less memory than the maximum specified in |
22e77e44 | 986 | * AVFormatContext.max_index_size by discarding entries if it grows |
3dea63bd PK |
987 | * too large. |
988 | * This function is not part of the public API and should only be called | |
989 | * by demuxers. | |
990 | */ | |
991 | void ff_reduce_index(AVFormatContext *s, int stream_index); | |
992 | ||
993 | /** | |
4f57fa8c DB |
994 | * Add an index entry into a sorted list. Update the entry if the list |
995 | * already contains it. | |
3217cb42 | 996 | * |
4f57fa8c | 997 | * @param timestamp timestamp in the time base of the given stream |
3217cb42 | 998 | */ |
78cb7273 DB |
999 | int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, |
1000 | int size, int distance, int flags); | |
3217cb42 PI |
1001 | |
1002 | /** | |
78cb7273 DB |
1003 | * Does a binary search using av_index_search_timestamp() and |
1004 | * AVCodec.read_timestamp(). | |
1005 | * This is not supposed to be called directly by a user application, | |
1006 | * but by demuxers. | |
3217cb42 PI |
1007 | * @param target_ts target timestamp in the time base of the given stream |
1008 | * @param stream_index stream number | |
1009 | */ | |
78cb7273 DB |
1010 | int av_seek_frame_binary(AVFormatContext *s, int stream_index, |
1011 | int64_t target_ts, int flags); | |
3217cb42 PI |
1012 | |
1013 | /** | |
4f57fa8c | 1014 | * Updates cur_dts of all streams based on the given timestamp and AVStream. |
3217cb42 | 1015 | * |
4f57fa8c DB |
1016 | * Stream ref_st unchanged, others set cur_dts in their native time base. |
1017 | * Only needed for timestamp wrapping or if (dts not set and pts!=dts). | |
3217cb42 PI |
1018 | * @param timestamp new dts expressed in time_base of param ref_st |
1019 | * @param ref_st reference stream giving time_base of param timestamp | |
1020 | */ | |
22ffac70 | 1021 | void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp); |
3217cb42 PI |
1022 | |
1023 | /** | |
1024 | * Does a binary search using read_timestamp(). | |
78cb7273 DB |
1025 | * This is not supposed to be called directly by a user application, |
1026 | * but by demuxers. | |
3217cb42 PI |
1027 | * @param target_ts target timestamp in the time base of the given stream |
1028 | * @param stream_index stream number | |
1029 | */ | |
78cb7273 DB |
1030 | int64_t av_gen_search(AVFormatContext *s, int stream_index, |
1031 | int64_t target_ts, int64_t pos_min, | |
1032 | int64_t pos_max, int64_t pos_limit, | |
1033 | int64_t ts_min, int64_t ts_max, | |
1034 | int flags, int64_t *ts_ret, | |
1035 | int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )); | |
b754978a | 1036 | |
43d414ba | 1037 | /** media file output */ |
290c5fa6 | 1038 | int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap); |
3217cb42 PI |
1039 | |
1040 | /** | |
755bfeab DB |
1041 | * Allocate the stream private data and write the stream header to an |
1042 | * output media file. | |
3217cb42 PI |
1043 | * |
1044 | * @param s media file handle | |
4f57fa8c | 1045 | * @return 0 if OK, AVERROR_xxx on error |
3217cb42 | 1046 | */ |
b9a281db | 1047 | int av_write_header(AVFormatContext *s); |
3217cb42 PI |
1048 | |
1049 | /** | |
1050 | * Write a packet to an output media file. | |
1051 | * | |
1052 | * The packet shall contain one audio or video frame. | |
78cb7273 DB |
1053 | * The packet must be correctly interleaved according to the container |
1054 | * specification, if not then av_interleaved_write_frame must be used. | |
3217cb42 PI |
1055 | * |
1056 | * @param s media file handle | |
78cb7273 DB |
1057 | * @param pkt The packet, which contains the stream_index, buf/buf_size, |
1058 | dts/pts, ... | |
4f57fa8c | 1059 | * @return < 0 on error, = 0 if OK, 1 if end of stream wanted |
3217cb42 | 1060 | */ |
e928649b | 1061 | int av_write_frame(AVFormatContext *s, AVPacket *pkt); |
3217cb42 PI |
1062 | |
1063 | /** | |
1064 | * Writes a packet to an output media file ensuring correct interleaving. | |
1065 | * | |
1066 | * The packet must contain one audio or video frame. | |
22e77e44 | 1067 | * If the packets are already correctly interleaved, the application should |
90b5b51e DB |
1068 | * call av_write_frame() instead as it is slightly faster. It is also important |
1069 | * to keep in mind that completely non-interleaved input will need huge amounts | |
1070 | * of memory to interleave with this, so it is preferable to interleave at the | |
1071 | * demuxer level. | |
3217cb42 PI |
1072 | * |
1073 | * @param s media file handle | |
78cb7273 DB |
1074 | * @param pkt The packet, which contains the stream_index, buf/buf_size, |
1075 | dts/pts, ... | |
4f57fa8c | 1076 | * @return < 0 on error, = 0 if OK, 1 if end of stream wanted |
3217cb42 | 1077 | */ |
3c895fc0 | 1078 | int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt); |
3217cb42 PI |
1079 | |
1080 | /** | |
4f57fa8c | 1081 | * Interleave a packet per dts in an output media file. |
3217cb42 | 1082 | * |
78cb7273 | 1083 | * Packets with pkt->destruct == av_destruct_packet will be freed inside this |
22e77e44 | 1084 | * function, so they cannot be used after it. Note that calling av_free_packet() |
78cb7273 | 1085 | * on them is still safe. |
3217cb42 PI |
1086 | * |
1087 | * @param s media file handle | |
1088 | * @param out the interleaved packet will be output here | |
1089 | * @param in the input packet | |
1090 | * @param flush 1 if no further packets are available as input and all | |
1091 | * remaining packets should be output | |
1092 | * @return 1 if a packet was output, 0 if no packet could be output, | |
d9526386 | 1093 | * < 0 if an error occurred |
3217cb42 | 1094 | */ |
78cb7273 DB |
1095 | int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, |
1096 | AVPacket *pkt, int flush); | |
e928649b | 1097 | |
3217cb42 PI |
1098 | /** |
1099 | * @brief Write the stream trailer to an output media file and | |
1100 | * free the file private data. | |
1101 | * | |
dc76fe13 RD |
1102 | * May only be called after a successful call to av_write_header. |
1103 | * | |
3217cb42 | 1104 | * @param s media file handle |
4f57fa8c | 1105 | * @return 0 if OK, AVERROR_xxx on error |
3217cb42 | 1106 | */ |
b9a281db | 1107 | int av_write_trailer(AVFormatContext *s); |
de6d9b64 FB |
1108 | |
1109 | void dump_format(AVFormatContext *ic, | |
115329f1 | 1110 | int index, |
de6d9b64 FB |
1111 | const char *url, |
1112 | int is_output); | |
3217cb42 | 1113 | |
1ca9133f | 1114 | #if LIBAVFORMAT_VERSION_MAJOR < 53 |
3217cb42 | 1115 | /** |
4f57fa8c | 1116 | * Parses width and height out of string str. |
26ef3220 | 1117 | * @deprecated Use av_parse_video_frame_size instead. |
3217cb42 | 1118 | */ |
78cb7273 DB |
1119 | attribute_deprecated int parse_image_size(int *width_ptr, int *height_ptr, |
1120 | const char *str); | |
3217cb42 PI |
1121 | |
1122 | /** | |
22e77e44 | 1123 | * Converts framerate from a string to a fraction. |
26ef3220 | 1124 | * @deprecated Use av_parse_video_frame_rate instead. |
3217cb42 | 1125 | */ |
78cb7273 DB |
1126 | attribute_deprecated int parse_frame_rate(int *frame_rate, int *frame_rate_base, |
1127 | const char *arg); | |
1ca9133f | 1128 | #endif |
3217cb42 PI |
1129 | |
1130 | /** | |
819174fa | 1131 | * Parses datestr and returns a corresponding number of microseconds. |
f9436161 SS |
1132 | * @param datestr String representing a date or a duration. |
1133 | * - If a date the syntax is: | |
3217cb42 | 1134 | * @code |
3217cb42 | 1135 | * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]} |
3217cb42 | 1136 | * @endcode |
4f57fa8c | 1137 | * Time is local time unless Z is appended, in which case it is |
f9436161 | 1138 | * interpreted as UTC. |
4f57fa8c | 1139 | * If the year-month-day part is not specified it takes the current |
f9436161 SS |
1140 | * year-month-day. |
1141 | * Returns the number of microseconds since 1st of January, 1970 up to | |
819174fa | 1142 | * the time of the parsed date or INT64_MIN if datestr cannot be |
f9436161 SS |
1143 | * successfully parsed. |
1144 | * - If a duration the syntax is: | |
1145 | * @code | |
1146 | * [-]HH[:MM[:SS[.m...]]] | |
1147 | * [-]S+[.m...] | |
1148 | * @endcode | |
1149 | * Returns the number of microseconds contained in a time interval | |
819174fa | 1150 | * with the specified duration or INT64_MIN if datestr cannot be |
7338d368 | 1151 | * successfully parsed. |
819174fa SS |
1152 | * @param duration Flag which tells how to interpret datestr, if |
1153 | * not zero datestr is interpreted as a duration, otherwise as a | |
f9436161 | 1154 | * date. |
3217cb42 | 1155 | */ |
0c1a9eda | 1156 | int64_t parse_date(const char *datestr, int duration); |
de6d9b64 | 1157 | |
fff5e687 | 1158 | /** Gets the current time in microseconds. */ |
0c1a9eda | 1159 | int64_t av_gettime(void); |
94988531 | 1160 | |
4f57fa8c | 1161 | /* ffm-specific for ffserver */ |
de6d9b64 | 1162 | #define FFM_PACKET_SIZE 4096 |
bc5c918e | 1163 | int64_t ffm_read_write_index(int fd); |
6fcce4f9 | 1164 | int ffm_write_write_index(int fd, int64_t pos); |
bc5c918e | 1165 | void ffm_set_write_index(AVFormatContext *s, int64_t pos, int64_t file_size); |
de6d9b64 | 1166 | |
3217cb42 PI |
1167 | /** |
1168 | * Attempts to find a specific tag in a URL. | |
1169 | * | |
1170 | * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. | |
1171 | * Return 1 if found. | |
1172 | */ | |
de6d9b64 FB |
1173 | int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info); |
1174 | ||
3217cb42 | 1175 | /** |
22e77e44 | 1176 | * Returns in 'buf' the path with '%d' replaced by a number. |
4f57fa8c | 1177 | * |
3217cb42 PI |
1178 | * Also handles the '%0nd' format where 'n' is the total number |
1179 | * of digits and '%%'. | |
1180 | * | |
1181 | * @param buf destination buffer | |
1182 | * @param buf_size destination buffer size | |
1183 | * @param path numbered sequence string | |
8ea0e802 | 1184 | * @param number frame number |
4f57fa8c | 1185 | * @return 0 if OK, -1 on format error |
3217cb42 | 1186 | */ |
5c07cf53 MB |
1187 | int av_get_frame_filename(char *buf, int buf_size, |
1188 | const char *path, int number); | |
3217cb42 PI |
1189 | |
1190 | /** | |
1191 | * Check whether filename actually is a numbered sequence generator. | |
1192 | * | |
1193 | * @param filename possible numbered sequence string | |
4f57fa8c | 1194 | * @return 1 if a valid numbered sequence string, 0 otherwise |
3217cb42 | 1195 | */ |
5c07cf53 | 1196 | int av_filename_number_test(const char *filename); |
96baaa6a | 1197 | |
c5388c07 LA |
1198 | /** |
1199 | * Generate an SDP for an RTP session. | |
1200 | * | |
1201 | * @param ac array of AVFormatContexts describing the RTP streams. If the | |
1202 | * array is composed by only one context, such context can contain | |
1203 | * multiple AVStreams (one AVStream per RTP stream). Otherwise, | |
1204 | * all the contexts in the array (an AVCodecContext per RTP stream) | |
4f57fa8c | 1205 | * must contain only one AVStream. |
8767b80f LA |
1206 | * @param n_files number of AVCodecContexts contained in ac |
1207 | * @param buff buffer where the SDP will be stored (must be allocated by | |
4f57fa8c | 1208 | * the caller) |
8767b80f | 1209 | * @param size the size of the buffer |
4f57fa8c | 1210 | * @return 0 if OK, AVERROR_xxx on error |
c5388c07 | 1211 | */ |
8767b80f | 1212 | int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size); |
c5388c07 | 1213 | |
fb025625 | 1214 | #ifdef HAVE_AV_CONFIG_H |
f71869a4 | 1215 | |
2db5da97 | 1216 | void ff_dynarray_add(intptr_t **tab_ptr, int *nb_ptr, intptr_t elem); |
39f472c3 | 1217 | |
e4e70d2e | 1218 | #ifdef __GNUC__ |
39f472c3 FB |
1219 | #define dynarray_add(tab, nb_ptr, elem)\ |
1220 | do {\ | |
72ab9d7f DP |
1221 | __typeof__(tab) _tab = (tab);\ |
1222 | __typeof__(elem) _elem = (elem);\ | |
39f472c3 | 1223 | (void)sizeof(**_tab == _elem); /* check that types are compatible */\ |
2db5da97 | 1224 | ff_dynarray_add((intptr_t **)_tab, nb_ptr, (intptr_t)_elem);\ |
39f472c3 | 1225 | } while(0) |
e4e70d2e FH |
1226 | #else |
1227 | #define dynarray_add(tab, nb_ptr, elem)\ | |
1228 | do {\ | |
2db5da97 | 1229 | ff_dynarray_add((intptr_t **)(tab), nb_ptr, (intptr_t)(elem));\ |
e4e70d2e FH |
1230 | } while(0) |
1231 | #endif | |
39f472c3 | 1232 | |
f71869a4 | 1233 | time_t mktimegm(struct tm *tm); |
0c9fc6e1 | 1234 | struct tm *brktimegm(time_t secs, struct tm *tm); |
115329f1 | 1235 | const char *small_strptime(const char *p, const char *fmt, |
f71869a4 FB |
1236 | struct tm *dt); |
1237 | ||
fb025625 FB |
1238 | struct in_addr; |
1239 | int resolve_host(struct in_addr *sin_addr, const char *hostname); | |
1240 | ||
1241 | void url_split(char *proto, int proto_size, | |
6ba5cbc6 | 1242 | char *authorization, int authorization_size, |
fb025625 FB |
1243 | char *hostname, int hostname_size, |
1244 | int *port_ptr, | |
1245 | char *path, int path_size, | |
1246 | const char *url); | |
1247 | ||
a3303178 SS |
1248 | /** |
1249 | * Returns a positive value if the given filename has one of the given | |
1250 | * extensions, 0 otherwise. | |
1251 | * | |
1252 | * @param extensions a comma-separated list of filename extensions | |
1253 | */ | |
a941f391 FB |
1254 | int match_ext(const char *filename, const char *extensions); |
1255 | ||
fb025625 FB |
1256 | #endif /* HAVE_AV_CONFIG_H */ |
1257 | ||
98790382 | 1258 | #endif /* AVFORMAT_AVFORMAT_H */ |