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