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 | ||
5b21bdab DB |
21 | #ifndef FFMPEG_AVFORMAT_H |
22 | #define FFMPEG_AVFORMAT_H | |
de6d9b64 | 23 | |
800c289a | 24 | #define LIBAVFORMAT_VERSION_MAJOR 52 |
90c2295b | 25 | #define LIBAVFORMAT_VERSION_MINOR 8 |
800c289a | 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 | |
f71869a4 | 38 | #include <time.h> |
67070e4f | 39 | #include <stdio.h> /* FILE */ |
76a448ed | 40 | #include "libavcodec/avcodec.h" |
de6d9b64 | 41 | |
de6d9b64 FB |
42 | #include "avio.h" |
43 | ||
44 | /* packet functions */ | |
45 | ||
46 | typedef struct AVPacket { | |
2692067a MN |
47 | int64_t pts; ///< presentation time stamp in time_base units |
48 | int64_t dts; ///< decompression time stamp in time_base units | |
0c1a9eda | 49 | uint8_t *data; |
6fa5a56c FB |
50 | int size; |
51 | int stream_index; | |
52 | int flags; | |
2692067a | 53 | int duration; ///< presentation duration in time_base units (0 if not available) |
6fa5a56c FB |
54 | void (*destruct)(struct AVPacket *); |
55 | void *priv; | |
2692067a | 56 | int64_t pos; ///< byte position in stream, -1 if unknown |
115329f1 | 57 | } AVPacket; |
6fa5a56c FB |
58 | #define PKT_FLAG_KEY 0x0001 |
59 | ||
63dd1377 | 60 | void av_destruct_packet_nofree(AVPacket *pkt); |
3217cb42 PI |
61 | |
62 | /** | |
63 | * Default packet destructor. | |
64 | */ | |
90ad92b3 | 65 | void av_destruct_packet(AVPacket *pkt); |
63dd1377 | 66 | |
05abfce9 RP |
67 | /** |
68 | * Initialize optional fields of a packet to default values. | |
69 | * | |
70 | * @param pkt packet | |
71 | */ | |
659596f0 | 72 | void av_init_packet(AVPacket *pkt); |
de6d9b64 | 73 | |
3217cb42 | 74 | /** |
ac3967c1 | 75 | * Allocate the payload of a packet and initialize its fields to default values. |
3217cb42 PI |
76 | * |
77 | * @param pkt packet | |
78 | * @param size wanted payload size | |
79 | * @return 0 if OK. AVERROR_xxx otherwise. | |
80 | */ | |
de6d9b64 | 81 | int av_new_packet(AVPacket *pkt, int size); |
3217cb42 PI |
82 | |
83 | /** | |
ac3967c1 | 84 | * Allocate and read the payload of a packet and initialize its fields to default values. |
3217cb42 PI |
85 | * |
86 | * @param pkt packet | |
87 | * @param size wanted payload size | |
88 | * @return >0 (read size) if OK. AVERROR_xxx otherwise. | |
89 | */ | |
2692067a | 90 | int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size); |
3217cb42 | 91 | |
43d414ba PI |
92 | /** |
93 | * @warning This is a hack - the packet memory allocation stuff is broken. The | |
94 | * packet is allocated if it was not really allocated | |
95 | */ | |
fb2758c8 | 96 | int av_dup_packet(AVPacket *pkt); |
6fa5a56c FB |
97 | |
98 | /** | |
99 | * Free a packet | |
100 | * | |
101 | * @param pkt packet to free | |
102 | */ | |
103 | static inline void av_free_packet(AVPacket *pkt) | |
104 | { | |
342474ab | 105 | if (pkt && pkt->destruct) { |
bb270c08 | 106 | pkt->destruct(pkt); |
342474ab | 107 | } |
6fa5a56c | 108 | } |
de6d9b64 FB |
109 | |
110 | /*************************************************/ | |
916c80e9 FB |
111 | /* fractional numbers for exact pts handling */ |
112 | ||
671adb17 MC |
113 | /** |
114 | * the exact value of the fractional number is: 'val + num / den'. | |
115 | * num is assumed to be such as 0 <= num < den | |
116 | * @deprecated Use AVRational instead | |
117 | */ | |
916c80e9 | 118 | typedef struct AVFrac { |
115329f1 | 119 | int64_t val, num, den; |
955ab9a4 | 120 | } AVFrac attribute_deprecated; |
916c80e9 | 121 | |
916c80e9 | 122 | /*************************************************/ |
b9a281db | 123 | /* input/output formats */ |
de6d9b64 | 124 | |
7caf0cc6 MN |
125 | struct AVCodecTag; |
126 | ||
de6d9b64 | 127 | struct AVFormatContext; |
b9a281db | 128 | |
43d414ba | 129 | /** this structure contains the data a format has to probe a file */ |
b9a281db | 130 | typedef struct AVProbeData { |
5c91a675 | 131 | const char *filename; |
b9a281db FB |
132 | unsigned char *buf; |
133 | int buf_size; | |
134 | } AVProbeData; | |
135 | ||
0288a747 | 136 | #define AVPROBE_SCORE_MAX 100 ///< max score, half of that is used for file extension based detection |
87e87886 | 137 | #define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer |
de6d9b64 FB |
138 | |
139 | typedef struct AVFormatParameters { | |
c0df9d75 | 140 | AVRational time_base; |
de6d9b64 FB |
141 | int sample_rate; |
142 | int channels; | |
143 | int width; | |
144 | int height; | |
4606ac8d | 145 | enum PixelFormat pix_fmt; |
43d414ba | 146 | int channel; /**< used to select dv channel */ |
43d414ba PI |
147 | const char *standard; /**< tv standard, NTSC, PAL, SECAM */ |
148 | int mpeg2ts_raw:1; /**< force raw MPEG2 transport stream output, if possible */ | |
149 | int mpeg2ts_compute_pcr:1; /**< compute exact PCR for each transport | |
da24c5e3 | 150 | stream packet (only meaningful if |
864ff8c1 | 151 | mpeg2ts_raw is TRUE) */ |
43d414ba | 152 | int initial_pause:1; /**< do not begin to play the stream |
fb2758c8 | 153 | immediately (RTSP only) */ |
4eb72c6b | 154 | int prealloced_context:1; |
71957315 | 155 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
5b6d5596 MN |
156 | enum CodecID video_codec_id; |
157 | enum CodecID audio_codec_id; | |
71957315 | 158 | #endif |
de6d9b64 FB |
159 | } AVFormatParameters; |
160 | ||
40d9c544 RD |
161 | //! demuxer will use url_fopen, no opened file should be provided by the caller |
162 | #define AVFMT_NOFILE 0x0001 | |
43d414ba PI |
163 | #define AVFMT_NEEDNUMBER 0x0002 /**< needs '%d' in filename */ |
164 | #define AVFMT_SHOW_IDS 0x0008 /**< show format stream IDs numbers */ | |
165 | #define AVFMT_RAWPICTURE 0x0020 /**< format wants AVPicture structure for | |
fb025625 | 166 | raw picture data */ |
43d414ba | 167 | #define AVFMT_GLOBALHEADER 0x0040 /**< format wants global header */ |
755bfeab | 168 | #define AVFMT_NOTIMESTAMPS 0x0080 /**< format does not need / have any timestamps */ |
43d414ba | 169 | #define AVFMT_GENERIC_INDEX 0x0100 /**< use generic index building code */ |
b9a281db FB |
170 | |
171 | typedef struct AVOutputFormat { | |
de6d9b64 FB |
172 | const char *name; |
173 | const char *long_name; | |
174 | const char *mime_type; | |
cf29452b | 175 | const char *extensions; /**< comma separated filename extensions */ |
43d414ba | 176 | /** size of private data so that it can be allocated in the wrapper */ |
b9a281db | 177 | int priv_data_size; |
de6d9b64 | 178 | /* output support */ |
43d414ba PI |
179 | enum CodecID audio_codec; /**< default audio codec */ |
180 | enum CodecID video_codec; /**< default video codec */ | |
de6d9b64 | 181 | int (*write_header)(struct AVFormatContext *); |
e928649b | 182 | int (*write_packet)(struct AVFormatContext *, AVPacket *pkt); |
de6d9b64 | 183 | int (*write_trailer)(struct AVFormatContext *); |
43d414ba | 184 | /** can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER */ |
b9a281db | 185 | int flags; |
43d414ba | 186 | /** currently only used to set pixel format if not YUV420P */ |
290c5fa6 | 187 | int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *); |
fe2d6fe2 | 188 | int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush); |
7caf0cc6 MN |
189 | |
190 | /** | |
191 | * list of supported codec_id-codec_tag pairs, ordered by "better choice first" | |
192 | * the arrays are all CODEC_ID_NONE terminated | |
193 | */ | |
6c77805f | 194 | const struct AVCodecTag **codec_tag; |
7caf0cc6 | 195 | |
11bf3847 AJ |
196 | enum CodecID subtitle_codec; /**< default subtitle codec */ |
197 | ||
b9a281db FB |
198 | /* private fields */ |
199 | struct AVOutputFormat *next; | |
200 | } AVOutputFormat; | |
de6d9b64 | 201 | |
b9a281db FB |
202 | typedef struct AVInputFormat { |
203 | const char *name; | |
204 | const char *long_name; | |
43d414ba | 205 | /** size of private data so that it can be allocated in the wrapper */ |
b9a281db | 206 | int priv_data_size; |
65d7d68b | 207 | /** |
5d81d641 DB |
208 | * Tell if a given file has a chance of being parsed by this format. |
209 | * The buffer provided is guaranteed to be AVPROBE_PADDING_SIZE bytes | |
210 | * big so you do not have to check for that unless you need more. | |
65d7d68b | 211 | */ |
b9a281db | 212 | int (*read_probe)(AVProbeData *); |
43d414ba | 213 | /** read the format header and initialize the AVFormatContext |
de6d9b64 | 214 | structure. Return 0 if OK. 'ap' if non NULL contains |
e42dba48 | 215 | additional paramters. Only used in raw format right |
b9a281db | 216 | now. 'av_new_stream' should be called to create new streams. */ |
de6d9b64 FB |
217 | int (*read_header)(struct AVFormatContext *, |
218 | AVFormatParameters *ap); | |
43d414ba | 219 | /** read one packet and put it in 'pkt'. pts and flags are also |
b9a281db | 220 | set. 'av_new_stream' can be called only if the flag |
da24c5e3 | 221 | AVFMTCTX_NOHEADER is used. */ |
de6d9b64 | 222 | int (*read_packet)(struct AVFormatContext *, AVPacket *pkt); |
43d414ba | 223 | /** close the stream. The AVFormatContext and AVStreams are not |
de6d9b64 FB |
224 | freed by this function */ |
225 | int (*read_close)(struct AVFormatContext *); | |
115329f1 DB |
226 | /** |
227 | * seek to a given timestamp relative to the frames in | |
3ba1438d MN |
228 | * stream component stream_index |
229 | * @param stream_index must not be -1 | |
115329f1 | 230 | * @param flags selects which direction should be preferred if no exact |
3ba1438d | 231 | * match is available |
05ce0f11 | 232 | * @return >= 0 on success (but not necessarily the new offset) |
3ba1438d | 233 | */ |
115329f1 | 234 | int (*read_seek)(struct AVFormatContext *, |
3ba1438d | 235 | int stream_index, int64_t timestamp, int flags); |
8d14a25c | 236 | /** |
2576a9ec | 237 | * gets the next timestamp in stream[stream_index].time_base units. |
de14759e | 238 | * @return the timestamp or AV_NOPTS_VALUE if an error occured |
8d14a25c MN |
239 | */ |
240 | int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index, | |
241 | int64_t *pos, int64_t pos_limit); | |
43d414ba | 242 | /** can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER */ |
de6d9b64 | 243 | int flags; |
43d414ba | 244 | /** if extensions are defined, then no probe is done. You should |
b9a281db FB |
245 | usually not use extension format guessing because it is not |
246 | reliable enough */ | |
247 | const char *extensions; | |
43d414ba | 248 | /** general purpose read only value that the format can use */ |
b9a281db | 249 | int value; |
fb2758c8 | 250 | |
43d414ba | 251 | /** start/resume playing - only meaningful if using a network based format |
fb2758c8 FB |
252 | (RTSP) */ |
253 | int (*read_play)(struct AVFormatContext *); | |
254 | ||
43d414ba | 255 | /** pause playing - only meaningful if using a network based format |
fb2758c8 FB |
256 | (RTSP) */ |
257 | int (*read_pause)(struct AVFormatContext *); | |
258 | ||
6c77805f | 259 | const struct AVCodecTag **codec_tag; |
7caf0cc6 | 260 | |
b9a281db FB |
261 | /* private fields */ |
262 | struct AVInputFormat *next; | |
263 | } AVInputFormat; | |
de6d9b64 | 264 | |
57004ff1 AJ |
265 | enum AVStreamParseType { |
266 | AVSTREAM_PARSE_NONE, | |
267 | AVSTREAM_PARSE_FULL, /**< full parsing and repack */ | |
268 | AVSTREAM_PARSE_HEADERS, /**< only parse headers, don't repack */ | |
269 | AVSTREAM_PARSE_TIMESTAMPS, /**< full parsing and interpolation of timestamps for frames not starting on packet boundary */ | |
270 | }; | |
271 | ||
fb2758c8 FB |
272 | typedef struct AVIndexEntry { |
273 | int64_t pos; | |
274 | int64_t timestamp; | |
275 | #define AVINDEX_KEYFRAME 0x0001 | |
30a43f2d | 276 | int flags:2; |
90b5b51e | 277 | int size:30; //Yeah, trying to keep the size of this small to reduce memory requirements (it is 24 vs 32 byte due to possible 8byte align). |
43d414ba | 278 | int min_distance; /**< min distance between this and the previous keyframe, used to avoid unneeded searching */ |
fb2758c8 FB |
279 | } AVIndexEntry; |
280 | ||
90c2295b ES |
281 | #define AV_DISPOSITION_DEFAULT 0x0001 |
282 | #define AV_DISPOSITION_DUB 0x0002 | |
283 | #define AV_DISPOSITION_ORIGINAL 0x0004 | |
284 | #define AV_DISPOSITION_COMMENT 0x0008 | |
285 | #define AV_DISPOSITION_LYRICS 0x0010 | |
286 | #define AV_DISPOSITION_KARAOKE 0x0020 | |
287 | ||
ba66ae94 MN |
288 | /** |
289 | * Stream structure. | |
290 | * New fields can be added to the end with minor version bumps. | |
8bfb108b | 291 | * Removal, reordering and changes to existing fields require a major |
ba66ae94 | 292 | * version bump. |
8bfb108b | 293 | * sizeof(AVStream) must not be used outside libav*. |
ba66ae94 | 294 | */ |
de6d9b64 | 295 | typedef struct AVStream { |
43d414ba PI |
296 | int index; /**< stream index in AVFormatContext */ |
297 | int id; /**< format specific stream id */ | |
298 | AVCodecContext *codec; /**< codec context */ | |
b4b87d48 | 299 | /** |
8bfb108b DB |
300 | * Real base frame rate of the stream. |
301 | * This is the lowest frame rate with which all timestamps can be | |
864ff8c1 | 302 | * represented accurately (it is the least common multiple of all |
8bfb108b DB |
303 | * frame rates in the stream), Note, this value is just a guess! |
304 | * For example if the timebase is 1/90000 and all frames have either | |
305 | * approximately 3600 or 1800 timer ticks then r_frame_rate will be 50/1. | |
b4b87d48 MN |
306 | */ |
307 | AVRational r_frame_rate; | |
de6d9b64 | 308 | void *priv_data; |
82583548 | 309 | |
b9a281db | 310 | /* internal data used in av_find_stream_info() */ |
82583548 | 311 | int64_t first_dts; |
43d414ba | 312 | /** encoding: PTS generation when outputing stream */ |
a9fd2b19 | 313 | struct AVFrac pts; |
5b28c8c3 MN |
314 | |
315 | /** | |
8bfb108b DB |
316 | * This is the fundamental unit of time (in seconds) in terms |
317 | * of which frame timestamps are represented. For fixed-fps content, | |
318 | * timebase should be 1/frame rate and timestamp increments should be | |
5b28c8c3 MN |
319 | * identically 1. |
320 | */ | |
9ee91c2f | 321 | AVRational time_base; |
43d414ba | 322 | int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */ |
a48b7a6b | 323 | /* ffmpeg.c private use */ |
15786dc4 | 324 | int stream_copy; /**< if set, just copy stream */ |
755bfeab | 325 | enum AVDiscard discard; ///< selects which packets can be discarded at will and do not need to be demuxed |
b4aea108 | 326 | //FIXME move stuff to a flags field? |
43d414ba | 327 | /** quality, as it has been removed from AVCodecContext and put in AVVideoFrame |
755bfeab | 328 | * MN: dunno if that is the right place for it */ |
115329f1 | 329 | float quality; |
6d96a9b9 | 330 | /** |
8bfb108b DB |
331 | * Decoding: pts of the first frame of the stream, in stream time base. |
332 | * Only set this if you are absolutely 100% sure that the value you set | |
333 | * it to really is the pts of the first frame. | |
4854c253 | 334 | * This may be undefined (AV_NOPTS_VALUE). |
8bfb108b DB |
335 | * @note The ASF header does NOT contain a correct start_time the ASF |
336 | * demuxer must NOT set this. | |
6d96a9b9 | 337 | */ |
115329f1 | 338 | int64_t start_time; |
e26381b6 | 339 | /** |
8bfb108b | 340 | * Decoding: duration of the stream, in stream time base. |
e26381b6 NB |
341 | * If a source file does not specify a duration, but does specify |
342 | * a bitrate, this value will be estimates from bit rate and file size. | |
343 | */ | |
ee404803 | 344 | int64_t duration; |
fb2758c8 | 345 | |
43d414ba | 346 | char language[4]; /** ISO 639 3-letter language code (empty string if undefined) */ |
09730260 | 347 | |
fb2758c8 | 348 | /* av_read_frame() support */ |
57004ff1 | 349 | enum AVStreamParseType need_parsing; |
fb2758c8 | 350 | struct AVCodecParserContext *parser; |
6ec87caa | 351 | |
fb2758c8 | 352 | int64_t cur_dts; |
635fbcb1 MN |
353 | int last_IP_duration; |
354 | int64_t last_IP_pts; | |
fb2758c8 | 355 | /* av_seek_frame() support */ |
43d414ba | 356 | AVIndexEntry *index_entries; /**< only used if the format does not |
fb2758c8 FB |
357 | support seeking natively */ |
358 | int nb_index_entries; | |
191e8ca7 | 359 | unsigned int index_entries_allocated_size; |
115329f1 | 360 | |
b4b87d48 | 361 | int64_t nb_frames; ///< number of frames in this stream if known or 0 |
504ee036 MN |
362 | |
363 | #define MAX_REORDER_DELAY 4 | |
364 | int64_t pts_buffer[MAX_REORDER_DELAY+1]; | |
f8d7c9d3 ES |
365 | |
366 | char *filename; /**< source filename of the stream */ | |
90c2295b ES |
367 | |
368 | int disposition; /**< AV_DISPOSITION_* bitfield */ | |
de6d9b64 FB |
369 | } AVStream; |
370 | ||
15afa396 NS |
371 | #define AV_PROGRAM_RUNNING 1 |
372 | ||
ba66ae94 | 373 | /** |
ba66ae94 | 374 | * New fields can be added to the end with minor version bumps. |
8bfb108b | 375 | * Removal, reordering and changes to existing fields require a major |
ba66ae94 | 376 | * version bump. |
8bfb108b | 377 | * sizeof(AVProgram) must not be used outside libav*. |
ba66ae94 | 378 | */ |
15afa396 NS |
379 | typedef struct AVProgram { |
380 | int id; | |
381 | char *provider_name; ///< Network name for DVB streams | |
382 | char *name; ///< Service name for DVB streams | |
383 | int flags; | |
384 | enum AVDiscard discard; ///< selects which program to discard and which to feed to the caller | |
526efa10 NS |
385 | unsigned int *stream_index; |
386 | unsigned int nb_stream_indexes; | |
15afa396 NS |
387 | } AVProgram; |
388 | ||
43d414ba | 389 | #define AVFMTCTX_NOHEADER 0x0001 /**< signal that no header is present |
da24c5e3 FB |
390 | (streams are added dynamically) */ |
391 | ||
de6d9b64 FB |
392 | #define MAX_STREAMS 20 |
393 | ||
252f17e2 MN |
394 | /** |
395 | * format I/O context. | |
396 | * New fields can be added to the end with minor version bumps. | |
8bfb108b | 397 | * Removal, reordering and changes to existing fields require a major |
252f17e2 | 398 | * version bump. |
8bfb108b | 399 | * sizeof(AVFormatContext) must not be used outside libav*. |
252f17e2 | 400 | */ |
de6d9b64 | 401 | typedef struct AVFormatContext { |
43d414ba | 402 | const AVClass *av_class; /**< set by av_alloc_format_context */ |
b9a281db FB |
403 | /* can only be iformat or oformat, not both at the same time */ |
404 | struct AVInputFormat *iformat; | |
405 | struct AVOutputFormat *oformat; | |
de6d9b64 | 406 | void *priv_data; |
899681cd | 407 | ByteIOContext *pb; |
db69c2e5 | 408 | unsigned int nb_streams; |
de6d9b64 | 409 | AVStream *streams[MAX_STREAMS]; |
43d414ba | 410 | char filename[1024]; /**< input or output filename */ |
de6d9b64 | 411 | /* stream info */ |
4568325a | 412 | int64_t timestamp; |
de6d9b64 FB |
413 | char title[512]; |
414 | char author[512]; | |
415 | char copyright[512]; | |
416 | char comment[512]; | |
6a58e151 | 417 | char album[512]; |
43d414ba PI |
418 | int year; /**< ID3 year, 0 if none */ |
419 | int track; /**< track number, 0 if none */ | |
420 | char genre[32]; /**< ID3 genre */ | |
6a58e151 | 421 | |
43d414ba | 422 | int ctx_flags; /**< format specific flags, see AVFMTCTX_xx */ |
916c80e9 | 423 | /* private data for pts handling (do not modify directly) */ |
43d414ba | 424 | /** This buffer is only needed when packets were already buffered but |
de6d9b64 FB |
425 | not decoded, for example to get the codec parameters in mpeg |
426 | streams */ | |
ee404803 FB |
427 | struct AVPacketList *packet_buffer; |
428 | ||
43d414ba | 429 | /** decoding: position of the first frame of the component, in |
ee404803 FB |
430 | AV_TIME_BASE fractional seconds. NEVER set this value directly: |
431 | it is deduced from the AVStream values. */ | |
115329f1 | 432 | int64_t start_time; |
43d414ba | 433 | /** decoding: duration of the stream, in AV_TIME_BASE fractional |
ee404803 FB |
434 | seconds. NEVER set this value directly: it is deduced from the |
435 | AVStream values. */ | |
436 | int64_t duration; | |
43d414ba | 437 | /** decoding: total file size. 0 if unknown */ |
ee404803 | 438 | int64_t file_size; |
43d414ba | 439 | /** decoding: total stream bitrate in bit/s, 0 if not |
ee404803 FB |
440 | available. Never set it directly if the file_size and the |
441 | duration are known as ffmpeg can compute it automatically. */ | |
442 | int bit_rate; | |
fb2758c8 FB |
443 | |
444 | /* av_read_frame() support */ | |
445 | AVStream *cur_st; | |
446 | const uint8_t *cur_ptr; | |
447 | int cur_len; | |
448 | AVPacket cur_pkt; | |
449 | ||
fb2758c8 | 450 | /* av_seek_frame() support */ |
43d414ba | 451 | int64_t data_offset; /** offset of the first packet */ |
fb2758c8 | 452 | int index_built; |
115329f1 | 453 | |
2db3c638 MN |
454 | int mux_rate; |
455 | int packet_size; | |
17c88cb0 MN |
456 | int preload; |
457 | int max_delay; | |
8108551a | 458 | |
115329f1 DB |
459 | #define AVFMT_NOOUTPUTLOOP -1 |
460 | #define AVFMT_INFINITEOUTPUTLOOP 0 | |
43d414ba | 461 | /** number of times to loop output in formats that support it */ |
8108551a | 462 | int loop_output; |
115329f1 | 463 | |
30bc6613 MN |
464 | int flags; |
465 | #define AVFMT_FLAG_GENPTS 0x0001 ///< generate pts if missing even if it requires parsing future frames | |
2c00106c | 466 | #define AVFMT_FLAG_IGNIDX 0x0002 ///< ignore index |
bf09c2e2 | 467 | #define AVFMT_FLAG_NONBLOCK 0x0004 ///< do not block when reading packets from input |
5894e1bb VP |
468 | |
469 | int loop_input; | |
43d414ba | 470 | /** decoding: size of data to probe; encoding unused */ |
9e6c9470 | 471 | unsigned int probesize; |
a44b3c4d MN |
472 | |
473 | /** | |
474 | * maximum duration in AV_TIME_BASE units over which the input should be analyzed in av_find_stream_info() | |
475 | */ | |
476 | int max_analyze_duration; | |
c964c2c7 RD |
477 | |
478 | const uint8_t *key; | |
479 | int keylen; | |
15afa396 NS |
480 | |
481 | unsigned int nb_programs; | |
482 | AVProgram **programs; | |
62600469 MN |
483 | |
484 | /** | |
485 | * Forced video codec_id. | |
486 | * demuxing: set by user | |
487 | */ | |
488 | enum CodecID video_codec_id; | |
489 | /** | |
490 | * Forced audio codec_id. | |
491 | * demuxing: set by user | |
492 | */ | |
493 | enum CodecID audio_codec_id; | |
494 | /** | |
495 | * Forced subtitle codec_id. | |
496 | * demuxing: set by user | |
497 | */ | |
498 | enum CodecID subtitle_codec_id; | |
3dea63bd PK |
499 | |
500 | /** | |
501 | * Maximum amount of memory in bytes to use per stream for the index. | |
502 | * If the needed index exceeds this size entries will be discarded as | |
503 | * needed to maintain a smaller size. This can lead to slower or less | |
504 | * accurate seeking (depends on demuxer). | |
505 | * Demuxers for which a full in memory index is mandatory will ignore | |
506 | * this. | |
507 | * muxing : unused | |
508 | * demuxing: set by user | |
509 | */ | |
510 | unsigned int max_index_size; | |
de6d9b64 FB |
511 | } AVFormatContext; |
512 | ||
513 | typedef struct AVPacketList { | |
514 | AVPacket pkt; | |
515 | struct AVPacketList *next; | |
516 | } AVPacketList; | |
517 | ||
84be6e72 | 518 | #if LIBAVFORMAT_VERSION_INT < (53<<16) |
b9a281db FB |
519 | extern AVInputFormat *first_iformat; |
520 | extern AVOutputFormat *first_oformat; | |
84be6e72 MN |
521 | #endif |
522 | ||
523 | AVInputFormat *av_iformat_next(AVInputFormat *f); | |
524 | AVOutputFormat *av_oformat_next(AVOutputFormat *f); | |
de6d9b64 | 525 | |
5b6d5596 | 526 | enum CodecID av_guess_image2_codec(const char *filename); |
290c5fa6 | 527 | |
b9a281db FB |
528 | /* XXX: use automatic init with either ELF sections or C file parser */ |
529 | /* modules */ | |
de6d9b64 | 530 | |
b9a281db | 531 | /* utils.c */ |
b9a281db FB |
532 | void av_register_input_format(AVInputFormat *format); |
533 | void av_register_output_format(AVOutputFormat *format); | |
115329f1 | 534 | AVOutputFormat *guess_stream_format(const char *short_name, |
36ada60c | 535 | const char *filename, const char *mime_type); |
115329f1 | 536 | AVOutputFormat *guess_format(const char *short_name, |
b9a281db | 537 | const char *filename, const char *mime_type); |
3217cb42 PI |
538 | |
539 | /** | |
540 | * Guesses the codec id based upon muxer and filename. | |
541 | */ | |
115329f1 | 542 | enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, |
5b6d5596 | 543 | const char *filename, const char *mime_type, enum CodecType type); |
de6d9b64 | 544 | |
3217cb42 | 545 | /** |
750f0e1f PI |
546 | * Send a nice hexadecimal dump of a buffer to the specified file stream. |
547 | * | |
548 | * @param f The file stream pointer where the dump should be sent to. | |
3217cb42 PI |
549 | * @param buf buffer |
550 | * @param size buffer size | |
750f0e1f PI |
551 | * |
552 | * @see av_hex_dump_log, av_pkt_dump, av_pkt_dump_log | |
3217cb42 | 553 | */ |
fb2758c8 | 554 | void av_hex_dump(FILE *f, uint8_t *buf, int size); |
3217cb42 PI |
555 | |
556 | /** | |
750f0e1f PI |
557 | * Send a nice hexadecimal dump of a buffer to the log. |
558 | * | |
559 | * @param avcl A pointer to an arbitrary struct of which the first field is a | |
560 | * pointer to an AVClass struct. | |
561 | * @param level The importance level of the message, lower values signifying | |
562 | * higher importance. | |
563 | * @param buf buffer | |
564 | * @param size buffer size | |
565 | * | |
566 | * @see av_hex_dump, av_pkt_dump, av_pkt_dump_log | |
567 | */ | |
568 | void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size); | |
569 | ||
570 | /** | |
571 | * Send a nice dump of a packet to the specified file stream. | |
572 | * | |
573 | * @param f The file stream pointer where the dump should be sent to. | |
3217cb42 PI |
574 | * @param pkt packet to dump |
575 | * @param dump_payload true if the payload must be displayed too | |
576 | */ | |
fb2758c8 | 577 | void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload); |
de6d9b64 | 578 | |
750f0e1f PI |
579 | /** |
580 | * Send a nice dump of a packet to the log. | |
581 | * | |
582 | * @param avcl A pointer to an arbitrary struct of which the first field is a | |
583 | * pointer to an AVClass struct. | |
584 | * @param level The importance level of the message, lower values signifying | |
585 | * higher importance. | |
586 | * @param pkt packet to dump | |
587 | * @param dump_payload true if the payload must be displayed too | |
588 | */ | |
589 | void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload); | |
590 | ||
94988531 | 591 | void av_register_all(void); |
de6d9b64 | 592 | |
43d414ba | 593 | /** codec tag <-> codec id */ |
6c77805f MN |
594 | enum CodecID av_codec_get_id(const struct AVCodecTag **tags, unsigned int tag); |
595 | unsigned int av_codec_get_tag(const struct AVCodecTag **tags, enum CodecID id); | |
7caf0cc6 | 596 | |
b9a281db | 597 | /* media file input */ |
3217cb42 PI |
598 | |
599 | /** | |
600 | * finds AVInputFormat based on input format's short name. | |
601 | */ | |
b9a281db | 602 | AVInputFormat *av_find_input_format(const char *short_name); |
3217cb42 PI |
603 | |
604 | /** | |
605 | * Guess file format. | |
606 | * | |
607 | * @param is_opened whether the file is already opened, determines whether | |
608 | * demuxers with or without AVFMT_NOFILE are probed | |
609 | */ | |
94988531 | 610 | AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened); |
3217cb42 PI |
611 | |
612 | /** | |
613 | * Allocates all the structures needed to read an input stream. | |
614 | * This does not open the needed codecs for decoding the stream[s]. | |
615 | */ | |
115329f1 DB |
616 | int av_open_input_stream(AVFormatContext **ic_ptr, |
617 | ByteIOContext *pb, const char *filename, | |
da24c5e3 | 618 | AVInputFormat *fmt, AVFormatParameters *ap); |
3217cb42 PI |
619 | |
620 | /** | |
864ff8c1 | 621 | * Open a media file as input. The codecs are not opened. Only the file |
3217cb42 PI |
622 | * header (if present) is read. |
623 | * | |
624 | * @param ic_ptr the opened media file handle is put here | |
625 | * @param filename filename to open. | |
626 | * @param fmt if non NULL, force the file format to use | |
627 | * @param buf_size optional buffer size (zero if default is OK) | |
e42dba48 | 628 | * @param ap additional parameters needed when opening the file (NULL if default) |
3217cb42 PI |
629 | * @return 0 if OK. AVERROR_xxx otherwise. |
630 | */ | |
115329f1 | 631 | int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, |
b9a281db FB |
632 | AVInputFormat *fmt, |
633 | int buf_size, | |
634 | AVFormatParameters *ap); | |
88808c60 MN |
635 | /** |
636 | * Allocate an AVFormatContext. | |
5d81d641 | 637 | * Can be freed with av_free() but do not forget to free everything you |
88808c60 MN |
638 | * explicitly allocated as well! |
639 | */ | |
bc874dae | 640 | AVFormatContext *av_alloc_format_context(void); |
b9a281db | 641 | |
3217cb42 PI |
642 | /** |
643 | * Read packets of a media file to get stream information. This | |
644 | * is useful for file formats with no headers such as MPEG. This | |
645 | * function also computes the real frame rate in case of mpeg2 repeat | |
646 | * frame mode. | |
647 | * The logical file position is not changed by this function; | |
648 | * examined packets may be buffered for later processing. | |
649 | * | |
650 | * @param ic media file handle | |
651 | * @return >=0 if OK. AVERROR_xxx if error. | |
4e8988a3 | 652 | * @todo Let user decide somehow what information is needed so we do not waste time getting stuff the user does not need. |
3217cb42 | 653 | */ |
b9a281db | 654 | int av_find_stream_info(AVFormatContext *ic); |
3217cb42 PI |
655 | |
656 | /** | |
657 | * Read a transport packet from a media file. | |
658 | * | |
864ff8c1 | 659 | * This function is obsolete and should never be used. |
3217cb42 PI |
660 | * Use av_read_frame() instead. |
661 | * | |
662 | * @param s media file handle | |
663 | * @param pkt is filled | |
664 | * @return 0 if OK. AVERROR_xxx if error. | |
665 | */ | |
de6d9b64 | 666 | int av_read_packet(AVFormatContext *s, AVPacket *pkt); |
3217cb42 PI |
667 | |
668 | /** | |
669 | * Return the next frame of a stream. | |
670 | * | |
671 | * The returned packet is valid | |
672 | * until the next av_read_frame() or until av_close_input_file() and | |
673 | * must be freed with av_free_packet. For video, the packet contains | |
674 | * exactly one frame. For audio, it contains an integer number of | |
675 | * frames if each frame has a known fixed size (e.g. PCM or ADPCM | |
676 | * data). If the audio frames have a variable size (e.g. MPEG audio), | |
677 | * then it contains one frame. | |
678 | * | |
679 | * pkt->pts, pkt->dts and pkt->duration are always set to correct | |
a050f802 | 680 | * values in AVStream.timebase units (and guessed if the format cannot |
3217cb42 PI |
681 | * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format |
682 | * has B frames, so it is better to rely on pkt->dts if you do not | |
683 | * decompress the payload. | |
684 | * | |
685 | * @return 0 if OK, < 0 if error or end of file. | |
686 | */ | |
fb2758c8 | 687 | int av_read_frame(AVFormatContext *s, AVPacket *pkt); |
3217cb42 PI |
688 | |
689 | /** | |
690 | * Seek to the key frame at timestamp. | |
691 | * 'timestamp' in 'stream_index'. | |
692 | * @param stream_index If stream_index is (-1), a default | |
693 | * stream is selected, and timestamp is automatically converted | |
694 | * from AV_TIME_BASE units to the stream specific time_base. | |
695 | * @param timestamp timestamp in AVStream.time_base units | |
696 | * or if there is no stream specified then in AV_TIME_BASE units | |
697 | * @param flags flags which select direction and seeking mode | |
698 | * @return >= 0 on success | |
699 | */ | |
3ba1438d | 700 | int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags); |
3217cb42 PI |
701 | |
702 | /** | |
703 | * start playing a network based stream (e.g. RTSP stream) at the | |
704 | * current position | |
705 | */ | |
fb2758c8 | 706 | int av_read_play(AVFormatContext *s); |
3217cb42 PI |
707 | |
708 | /** | |
709 | * Pause a network based stream (e.g. RTSP stream). | |
710 | * | |
711 | * Use av_read_play() to resume it. | |
712 | */ | |
fb2758c8 | 713 | int av_read_pause(AVFormatContext *s); |
3217cb42 PI |
714 | |
715 | /** | |
2506fd54 RD |
716 | * Free a AVFormatContext allocated by av_open_input_stream. |
717 | * @param s context to free | |
718 | */ | |
719 | void av_close_input_stream(AVFormatContext *s); | |
720 | ||
721 | /** | |
3217cb42 PI |
722 | * Close a media file (but not its codecs). |
723 | * | |
724 | * @param s media file handle | |
725 | */ | |
de6d9b64 | 726 | void av_close_input_file(AVFormatContext *s); |
3217cb42 PI |
727 | |
728 | /** | |
729 | * Add a new stream to a media file. | |
730 | * | |
731 | * Can only be called in the read_header() function. If the flag | |
732 | * AVFMTCTX_NOHEADER is in the format context, then new streams | |
733 | * can be added in read_packet too. | |
734 | * | |
735 | * @param s media file handle | |
736 | * @param id file format dependent stream id | |
737 | */ | |
b9a281db | 738 | AVStream *av_new_stream(AVFormatContext *s, int id); |
15afa396 | 739 | AVProgram *av_new_program(AVFormatContext *s, int id); |
3217cb42 PI |
740 | |
741 | /** | |
742 | * Set the pts for a given stream. | |
743 | * | |
744 | * @param s stream | |
745 | * @param pts_wrap_bits number of bits effectively used by the pts | |
746 | * (used for wrap control, 33 is the value for MPEG) | |
747 | * @param pts_num numerator to convert to seconds (MPEG: 1) | |
748 | * @param pts_den denominator to convert to seconds (MPEG: 90000) | |
749 | */ | |
9ee91c2f | 750 | void av_set_pts_info(AVStream *s, int pts_wrap_bits, |
916c80e9 | 751 | int pts_num, int pts_den); |
de6d9b64 | 752 | |
3ba1438d MN |
753 | #define AVSEEK_FLAG_BACKWARD 1 ///< seek backward |
754 | #define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes | |
27a5fe5f | 755 | #define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non keyframes |
3ba1438d | 756 | |
b754978a | 757 | int av_find_default_stream_index(AVFormatContext *s); |
3217cb42 PI |
758 | |
759 | /** | |
760 | * Gets the index for a specific timestamp. | |
761 | * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to | |
762 | * the timestamp which is <= the requested one, if backward is 0 | |
763 | * then it will be >= | |
764 | * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise | |
765 | * @return < 0 if no such timestamp could be found | |
766 | */ | |
dc56fc38 | 767 | int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags); |
3217cb42 PI |
768 | |
769 | /** | |
3dea63bd PK |
770 | * Ensures the index uses less memory than the maximum specified in |
771 | * AVFormatContext.max_index_size, by discarding entries if it grows | |
772 | * too large. | |
773 | * This function is not part of the public API and should only be called | |
774 | * by demuxers. | |
775 | */ | |
776 | void ff_reduce_index(AVFormatContext *s, int stream_index); | |
777 | ||
778 | /** | |
3217cb42 PI |
779 | * Add a index entry into a sorted list updateing if it is already there. |
780 | * | |
781 | * @param timestamp timestamp in the timebase of the given stream | |
782 | */ | |
3e9245a9 | 783 | int av_add_index_entry(AVStream *st, |
30a43f2d | 784 | int64_t pos, int64_t timestamp, int size, int distance, int flags); |
3217cb42 PI |
785 | |
786 | /** | |
787 | * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp(). | |
755bfeab | 788 | * This is not supposed to be called directly by a user application, but by demuxers. |
3217cb42 PI |
789 | * @param target_ts target timestamp in the time base of the given stream |
790 | * @param stream_index stream number | |
791 | */ | |
3ba1438d | 792 | int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags); |
3217cb42 PI |
793 | |
794 | /** | |
795 | * Updates cur_dts of all streams based on given timestamp and AVStream. | |
796 | * | |
797 | * Stream ref_st unchanged, others set cur_dts in their native timebase | |
755bfeab | 798 | * only needed for timestamp wrapping or if (dts not set and pts!=dts). |
3217cb42 PI |
799 | * @param timestamp new dts expressed in time_base of param ref_st |
800 | * @param ref_st reference stream giving time_base of param timestamp | |
801 | */ | |
22ffac70 | 802 | void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp); |
3217cb42 PI |
803 | |
804 | /** | |
805 | * Does a binary search using read_timestamp(). | |
755bfeab | 806 | * This is not supposed to be called directly by a user application, but by demuxers. |
3217cb42 PI |
807 | * @param target_ts target timestamp in the time base of the given stream |
808 | * @param stream_index stream number | |
809 | */ | |
89ddd2a9 | 810 | int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )); |
b754978a | 811 | |
43d414ba | 812 | /** media file output */ |
290c5fa6 | 813 | int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap); |
3217cb42 PI |
814 | |
815 | /** | |
755bfeab DB |
816 | * Allocate the stream private data and write the stream header to an |
817 | * output media file. | |
3217cb42 PI |
818 | * |
819 | * @param s media file handle | |
820 | * @return 0 if OK. AVERROR_xxx if error. | |
821 | */ | |
b9a281db | 822 | int av_write_header(AVFormatContext *s); |
3217cb42 PI |
823 | |
824 | /** | |
825 | * Write a packet to an output media file. | |
826 | * | |
827 | * The packet shall contain one audio or video frame. | |
828 | * The packet must be correctly interleaved according to the container specification, | |
829 | * if not then av_interleaved_write_frame must be used | |
830 | * | |
831 | * @param s media file handle | |
832 | * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ... | |
833 | * @return < 0 if error, = 0 if OK, 1 if end of stream wanted. | |
834 | */ | |
e928649b | 835 | int av_write_frame(AVFormatContext *s, AVPacket *pkt); |
3217cb42 PI |
836 | |
837 | /** | |
838 | * Writes a packet to an output media file ensuring correct interleaving. | |
839 | * | |
840 | * The packet must contain one audio or video frame. | |
841 | * If the packets are already correctly interleaved the application should | |
90b5b51e DB |
842 | * call av_write_frame() instead as it is slightly faster. It is also important |
843 | * to keep in mind that completely non-interleaved input will need huge amounts | |
844 | * of memory to interleave with this, so it is preferable to interleave at the | |
845 | * demuxer level. | |
3217cb42 PI |
846 | * |
847 | * @param s media file handle | |
848 | * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ... | |
849 | * @return < 0 if error, = 0 if OK, 1 if end of stream wanted. | |
850 | */ | |
3c895fc0 | 851 | int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt); |
3217cb42 PI |
852 | |
853 | /** | |
854 | * Interleave a packet per DTS in an output media file. | |
855 | * | |
856 | * Packets with pkt->destruct == av_destruct_packet will be freed inside this function, | |
857 | * so they cannot be used after it, note calling av_free_packet() on them is still safe. | |
858 | * | |
859 | * @param s media file handle | |
860 | * @param out the interleaved packet will be output here | |
861 | * @param in the input packet | |
862 | * @param flush 1 if no further packets are available as input and all | |
863 | * remaining packets should be output | |
864 | * @return 1 if a packet was output, 0 if no packet could be output, | |
865 | * < 0 if an error occured | |
866 | */ | |
f21c0b4c | 867 | int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush); |
e928649b | 868 | |
3217cb42 PI |
869 | /** |
870 | * @brief Write the stream trailer to an output media file and | |
871 | * free the file private data. | |
872 | * | |
873 | * @param s media file handle | |
874 | * @return 0 if OK. AVERROR_xxx if error. | |
875 | */ | |
b9a281db | 876 | int av_write_trailer(AVFormatContext *s); |
de6d9b64 FB |
877 | |
878 | void dump_format(AVFormatContext *ic, | |
115329f1 | 879 | int index, |
de6d9b64 FB |
880 | const char *url, |
881 | int is_output); | |
3217cb42 PI |
882 | |
883 | /** | |
884 | * parses width and height out of string str. | |
26ef3220 | 885 | * @deprecated Use av_parse_video_frame_size instead. |
3217cb42 | 886 | */ |
26ef3220 | 887 | attribute_deprecated int parse_image_size(int *width_ptr, int *height_ptr, const char *str); |
3217cb42 PI |
888 | |
889 | /** | |
890 | * Converts frame rate from string to a fraction. | |
26ef3220 | 891 | * @deprecated Use av_parse_video_frame_rate instead. |
3217cb42 | 892 | */ |
26ef3220 | 893 | attribute_deprecated int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg); |
3217cb42 PI |
894 | |
895 | /** | |
f9436161 SS |
896 | * Parses \p datestr and returns a corresponding number of microseconds. |
897 | * @param datestr String representing a date or a duration. | |
898 | * - If a date the syntax is: | |
3217cb42 | 899 | * @code |
3217cb42 | 900 | * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]} |
3217cb42 | 901 | * @endcode |
f9436161 SS |
902 | * Time is localtime unless Z is appended, in which case it is |
903 | * interpreted as UTC. | |
904 | * If the year-month-day part isn't specified it takes the current | |
905 | * year-month-day. | |
906 | * Returns the number of microseconds since 1st of January, 1970 up to | |
907 | * the time of the parsed date or INT64_MIN if \p datestr cannot be | |
908 | * successfully parsed. | |
909 | * - If a duration the syntax is: | |
910 | * @code | |
911 | * [-]HH[:MM[:SS[.m...]]] | |
912 | * [-]S+[.m...] | |
913 | * @endcode | |
914 | * Returns the number of microseconds contained in a time interval | |
915 | * with the specified duration or INT64_MIN if \p datestr cannot be | |
7338d368 | 916 | * successfully parsed. |
f9436161 SS |
917 | * @param duration Flag which tells how to interpret \p datestr, if |
918 | * not zero \p datestr is interpreted as a duration, otherwise as a | |
919 | * date. | |
3217cb42 | 920 | */ |
0c1a9eda | 921 | int64_t parse_date(const char *datestr, int duration); |
de6d9b64 | 922 | |
0c1a9eda | 923 | int64_t av_gettime(void); |
94988531 | 924 | |
de6d9b64 FB |
925 | /* ffm specific for ffserver */ |
926 | #define FFM_PACKET_SIZE 4096 | |
927 | offset_t ffm_read_write_index(int fd); | |
928 | void ffm_write_write_index(int fd, offset_t pos); | |
929 | void ffm_set_write_index(AVFormatContext *s, offset_t pos, offset_t file_size); | |
930 | ||
3217cb42 PI |
931 | /** |
932 | * Attempts to find a specific tag in a URL. | |
933 | * | |
934 | * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. | |
935 | * Return 1 if found. | |
936 | */ | |
de6d9b64 FB |
937 | int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info); |
938 | ||
3217cb42 PI |
939 | /** |
940 | * Returns in 'buf' the path with '%d' replaced by number. | |
941 | ||
942 | * Also handles the '%0nd' format where 'n' is the total number | |
943 | * of digits and '%%'. | |
944 | * | |
945 | * @param buf destination buffer | |
946 | * @param buf_size destination buffer size | |
947 | * @param path numbered sequence string | |
8ea0e802 | 948 | * @param number frame number |
3217cb42 PI |
949 | * @return 0 if OK, -1 if format error. |
950 | */ | |
5c07cf53 MB |
951 | int av_get_frame_filename(char *buf, int buf_size, |
952 | const char *path, int number); | |
3217cb42 PI |
953 | |
954 | /** | |
955 | * Check whether filename actually is a numbered sequence generator. | |
956 | * | |
957 | * @param filename possible numbered sequence string | |
958 | * @return 1 if a valid numbered sequence string, 0 otherwise. | |
959 | */ | |
5c07cf53 | 960 | int av_filename_number_test(const char *filename); |
96baaa6a | 961 | |
c5388c07 LA |
962 | /** |
963 | * Generate an SDP for an RTP session. | |
964 | * | |
965 | * @param ac array of AVFormatContexts describing the RTP streams. If the | |
966 | * array is composed by only one context, such context can contain | |
967 | * multiple AVStreams (one AVStream per RTP stream). Otherwise, | |
968 | * all the contexts in the array (an AVCodecContext per RTP stream) | |
969 | * must contain only one AVStream | |
8767b80f LA |
970 | * @param n_files number of AVCodecContexts contained in ac |
971 | * @param buff buffer where the SDP will be stored (must be allocated by | |
972 | * the caller | |
973 | * @param size the size of the buffer | |
974 | * @return 0 if OK. AVERROR_xxx if error. | |
c5388c07 | 975 | */ |
8767b80f | 976 | int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size); |
c5388c07 | 977 | |
fb025625 | 978 | #ifdef HAVE_AV_CONFIG_H |
f71869a4 | 979 | |
39f472c3 FB |
980 | void __dynarray_add(unsigned long **tab_ptr, int *nb_ptr, unsigned long elem); |
981 | ||
e4e70d2e | 982 | #ifdef __GNUC__ |
39f472c3 FB |
983 | #define dynarray_add(tab, nb_ptr, elem)\ |
984 | do {\ | |
985 | typeof(tab) _tab = (tab);\ | |
986 | typeof(elem) _elem = (elem);\ | |
987 | (void)sizeof(**_tab == _elem); /* check that types are compatible */\ | |
988 | __dynarray_add((unsigned long **)_tab, nb_ptr, (unsigned long)_elem);\ | |
989 | } while(0) | |
e4e70d2e FH |
990 | #else |
991 | #define dynarray_add(tab, nb_ptr, elem)\ | |
992 | do {\ | |
993 | __dynarray_add((unsigned long **)(tab), nb_ptr, (unsigned long)(elem));\ | |
994 | } while(0) | |
995 | #endif | |
39f472c3 | 996 | |
f71869a4 | 997 | time_t mktimegm(struct tm *tm); |
0c9fc6e1 | 998 | struct tm *brktimegm(time_t secs, struct tm *tm); |
115329f1 | 999 | const char *small_strptime(const char *p, const char *fmt, |
f71869a4 FB |
1000 | struct tm *dt); |
1001 | ||
fb025625 FB |
1002 | struct in_addr; |
1003 | int resolve_host(struct in_addr *sin_addr, const char *hostname); | |
1004 | ||
1005 | void url_split(char *proto, int proto_size, | |
6ba5cbc6 | 1006 | char *authorization, int authorization_size, |
fb025625 FB |
1007 | char *hostname, int hostname_size, |
1008 | int *port_ptr, | |
1009 | char *path, int path_size, | |
1010 | const char *url); | |
1011 | ||
a941f391 FB |
1012 | int match_ext(const char *filename, const char *extensions); |
1013 | ||
fb025625 FB |
1014 | #endif /* HAVE_AV_CONFIG_H */ |
1015 | ||
5b21bdab | 1016 | #endif /* FFMPEG_AVFORMAT_H */ |