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