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_H
|
---|
22 | #define AVFORMAT_H
|
---|
23 |
|
---|
24 | #define LIBAVFORMAT_VERSION_INT ((51<<16)+(12<<8)+1)
|
---|
25 | #define LIBAVFORMAT_VERSION 51.12.1
|
---|
26 | #define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT
|
---|
27 |
|
---|
28 | #define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
|
---|
29 |
|
---|
30 | #include <time.h>
|
---|
31 | #include <stdio.h> /* FILE */
|
---|
32 | #include "avcodec.h"
|
---|
33 |
|
---|
34 | #include "avio.h"
|
---|
35 |
|
---|
36 | /* packet functions */
|
---|
37 |
|
---|
38 | typedef struct AVPacket {
|
---|
39 | int64_t pts; ///< presentation time stamp in time_base units
|
---|
40 | int64_t dts; ///< decompression time stamp in time_base units
|
---|
41 | uint8_t *data;
|
---|
42 | int size;
|
---|
43 | int stream_index;
|
---|
44 | int flags;
|
---|
45 | int duration; ///< presentation duration in time_base units (0 if not available)
|
---|
46 | void (*destruct)(struct AVPacket *);
|
---|
47 | void *priv;
|
---|
48 | int64_t pos; ///< byte position in stream, -1 if unknown
|
---|
49 | } AVPacket;
|
---|
50 | #define PKT_FLAG_KEY 0x0001
|
---|
51 |
|
---|
52 | void av_destruct_packet_nofree(AVPacket *pkt);
|
---|
53 |
|
---|
54 | /**
|
---|
55 | * Default packet destructor.
|
---|
56 | */
|
---|
57 | void av_destruct_packet(AVPacket *pkt);
|
---|
58 |
|
---|
59 | /**
|
---|
60 | * Initialize optional fields of a packet to default values.
|
---|
61 | *
|
---|
62 | * @param pkt packet
|
---|
63 | */
|
---|
64 | void av_init_packet(AVPacket *pkt);
|
---|
65 |
|
---|
66 | /**
|
---|
67 | * Allocate the payload of a packet and initialize its fields to default values.
|
---|
68 | *
|
---|
69 | * @param pkt packet
|
---|
70 | * @param size wanted payload size
|
---|
71 | * @return 0 if OK. AVERROR_xxx otherwise.
|
---|
72 | */
|
---|
73 | int av_new_packet(AVPacket *pkt, int size);
|
---|
74 |
|
---|
75 | /**
|
---|
76 | * Allocate and read the payload of a packet and initialize its fields to default values.
|
---|
77 | *
|
---|
78 | * @param pkt packet
|
---|
79 | * @param size wanted payload size
|
---|
80 | * @return >0 (read size) if OK. AVERROR_xxx otherwise.
|
---|
81 | */
|
---|
82 | int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size);
|
---|
83 |
|
---|
84 | /**
|
---|
85 | * @warning This is a hack - the packet memory allocation stuff is broken. The
|
---|
86 | * packet is allocated if it was not really allocated
|
---|
87 | */
|
---|
88 | int av_dup_packet(AVPacket *pkt);
|
---|
89 |
|
---|
90 | /**
|
---|
91 | * Free a packet
|
---|
92 | *
|
---|
93 | * @param pkt packet to free
|
---|
94 | */
|
---|
95 | static inline void av_free_packet(AVPacket *pkt)
|
---|
96 | {
|
---|
97 | if (pkt && pkt->destruct) {
|
---|
98 | pkt->destruct(pkt);
|
---|
99 | }
|
---|
100 | }
|
---|
101 |
|
---|
102 | /*************************************************/
|
---|
103 | /* fractional numbers for exact pts handling */
|
---|
104 |
|
---|
105 | /**
|
---|
106 | * the exact value of the fractional number is: 'val + num / den'.
|
---|
107 | * num is assumed to be such as 0 <= num < den
|
---|
108 | * @deprecated Use AVRational instead
|
---|
109 | */
|
---|
110 | typedef struct AVFrac {
|
---|
111 | int64_t val, num, den;
|
---|
112 | } AVFrac attribute_deprecated;
|
---|
113 |
|
---|
114 | /*************************************************/
|
---|
115 | /* input/output formats */
|
---|
116 |
|
---|
117 | struct AVCodecTag;
|
---|
118 |
|
---|
119 | struct AVFormatContext;
|
---|
120 |
|
---|
121 | /** this structure contains the data a format has to probe a file */
|
---|
122 | typedef struct AVProbeData {
|
---|
123 | const char *filename;
|
---|
124 | unsigned char *buf;
|
---|
125 | int buf_size;
|
---|
126 | } AVProbeData;
|
---|
127 |
|
---|
128 | #define AVPROBE_SCORE_MAX 100 ///< max score, half of that is used for file extension based detection
|
---|
129 | #define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer
|
---|
130 |
|
---|
131 | typedef struct AVFormatParameters {
|
---|
132 | AVRational time_base;
|
---|
133 | int sample_rate;
|
---|
134 | int channels;
|
---|
135 | int width;
|
---|
136 | int height;
|
---|
137 | enum PixelFormat pix_fmt;
|
---|
138 | int channel; /**< used to select dv channel */
|
---|
139 | #if LIBAVFORMAT_VERSION_INT < (52<<16)
|
---|
140 | const char *device; /**< video, audio or DV device */
|
---|
141 | #endif
|
---|
142 | const char *standard; /**< tv standard, NTSC, PAL, SECAM */
|
---|
143 | int mpeg2ts_raw:1; /**< force raw MPEG2 transport stream output, if possible */
|
---|
144 | int mpeg2ts_compute_pcr:1; /**< compute exact PCR for each transport
|
---|
145 | stream packet (only meaningful if
|
---|
146 | mpeg2ts_raw is TRUE) */
|
---|
147 | int initial_pause:1; /**< do not begin to play the stream
|
---|
148 | immediately (RTSP only) */
|
---|
149 | int prealloced_context:1;
|
---|
150 | enum CodecID video_codec_id;
|
---|
151 | enum CodecID audio_codec_id;
|
---|
152 | } AVFormatParameters;
|
---|
153 |
|
---|
154 | //! demuxer will use url_fopen, no opened file should be provided by the caller
|
---|
155 | #define AVFMT_NOFILE 0x0001
|
---|
156 | #define AVFMT_NEEDNUMBER 0x0002 /**< needs '%d' in filename */
|
---|
157 | #define AVFMT_SHOW_IDS 0x0008 /**< show format stream IDs numbers */
|
---|
158 | #define AVFMT_RAWPICTURE 0x0020 /**< format wants AVPicture structure for
|
---|
159 | raw picture data */
|
---|
160 | #define AVFMT_GLOBALHEADER 0x0040 /**< format wants global header */
|
---|
161 | #define AVFMT_NOTIMESTAMPS 0x0080 /**< format does not need / have any timestamps */
|
---|
162 | #define AVFMT_GENERIC_INDEX 0x0100 /**< use generic index building code */
|
---|
163 |
|
---|
164 | typedef struct AVOutputFormat {
|
---|
165 | const char *name;
|
---|
166 | const char *long_name;
|
---|
167 | const char *mime_type;
|
---|
168 | const char *extensions; /**< comma separated filename extensions */
|
---|
169 | /** size of private data so that it can be allocated in the wrapper */
|
---|
170 | int priv_data_size;
|
---|
171 | /* output support */
|
---|
172 | enum CodecID audio_codec; /**< default audio codec */
|
---|
173 | enum CodecID video_codec; /**< default video codec */
|
---|
174 | int (*write_header)(struct AVFormatContext *);
|
---|
175 | int (*write_packet)(struct AVFormatContext *, AVPacket *pkt);
|
---|
176 | int (*write_trailer)(struct AVFormatContext *);
|
---|
177 | /** can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER */
|
---|
178 | int flags;
|
---|
179 | /** currently only used to set pixel format if not YUV420P */
|
---|
180 | int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *);
|
---|
181 | int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush);
|
---|
182 |
|
---|
183 | /**
|
---|
184 | * list of supported codec_id-codec_tag pairs, ordered by "better choice first"
|
---|
185 | * the arrays are all CODEC_ID_NONE terminated
|
---|
186 | */
|
---|
187 | const struct AVCodecTag **codec_tag;
|
---|
188 |
|
---|
189 | /* private fields */
|
---|
190 | struct AVOutputFormat *next;
|
---|
191 | } AVOutputFormat;
|
---|
192 |
|
---|
193 | typedef struct AVInputFormat {
|
---|
194 | const char *name;
|
---|
195 | const char *long_name;
|
---|
196 | /** size of private data so that it can be allocated in the wrapper */
|
---|
197 | int priv_data_size;
|
---|
198 | /** tell if a given file has a chance of being parsed by this format */
|
---|
199 | int (*read_probe)(AVProbeData *);
|
---|
200 | /** read the format header and initialize the AVFormatContext
|
---|
201 | structure. Return 0 if OK. 'ap' if non NULL contains
|
---|
202 | additional paramters. Only used in raw format right
|
---|
203 | now. 'av_new_stream' should be called to create new streams. */
|
---|
204 | int (*read_header)(struct AVFormatContext *,
|
---|
205 | AVFormatParameters *ap);
|
---|
206 | /** read one packet and put it in 'pkt'. pts and flags are also
|
---|
207 | set. 'av_new_stream' can be called only if the flag
|
---|
208 | AVFMTCTX_NOHEADER is used. */
|
---|
209 | int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);
|
---|
210 | /** close the stream. The AVFormatContext and AVStreams are not
|
---|
211 | freed by this function */
|
---|
212 | int (*read_close)(struct AVFormatContext *);
|
---|
213 | /**
|
---|
214 | * seek to a given timestamp relative to the frames in
|
---|
215 | * stream component stream_index
|
---|
216 | * @param stream_index must not be -1
|
---|
217 | * @param flags selects which direction should be preferred if no exact
|
---|
218 | * match is available
|
---|
219 | * @return >= 0 on success (but not necessarily the new offset)
|
---|
220 | */
|
---|
221 | int (*read_seek)(struct AVFormatContext *,
|
---|
222 | int stream_index, int64_t timestamp, int flags);
|
---|
223 | /**
|
---|
224 | * gets the next timestamp in AV_TIME_BASE units.
|
---|
225 | */
|
---|
226 | int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index,
|
---|
227 | int64_t *pos, int64_t pos_limit);
|
---|
228 | /** can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER */
|
---|
229 | int flags;
|
---|
230 | /** if extensions are defined, then no probe is done. You should
|
---|
231 | usually not use extension format guessing because it is not
|
---|
232 | reliable enough */
|
---|
233 | const char *extensions;
|
---|
234 | /** general purpose read only value that the format can use */
|
---|
235 | int value;
|
---|
236 |
|
---|
237 | /** start/resume playing - only meaningful if using a network based format
|
---|
238 | (RTSP) */
|
---|
239 | int (*read_play)(struct AVFormatContext *);
|
---|
240 |
|
---|
241 | /** pause playing - only meaningful if using a network based format
|
---|
242 | (RTSP) */
|
---|
243 | int (*read_pause)(struct AVFormatContext *);
|
---|
244 |
|
---|
245 | const struct AVCodecTag **codec_tag;
|
---|
246 |
|
---|
247 | /* private fields */
|
---|
248 | struct AVInputFormat *next;
|
---|
249 | } AVInputFormat;
|
---|
250 |
|
---|
251 | enum AVStreamParseType {
|
---|
252 | AVSTREAM_PARSE_NONE,
|
---|
253 | AVSTREAM_PARSE_FULL, /**< full parsing and repack */
|
---|
254 | AVSTREAM_PARSE_HEADERS, /**< only parse headers, don't repack */
|
---|
255 | AVSTREAM_PARSE_TIMESTAMPS, /**< full parsing and interpolation of timestamps for frames not starting on packet boundary */
|
---|
256 | };
|
---|
257 |
|
---|
258 | typedef struct AVIndexEntry {
|
---|
259 | int64_t pos;
|
---|
260 | int64_t timestamp;
|
---|
261 | #define AVINDEX_KEYFRAME 0x0001
|
---|
262 | int flags:2;
|
---|
263 | int size:30; //Yeah, trying to keep the size of this small to reduce memory requirements (it is 24 vs 32 byte due to possible 8byte align).
|
---|
264 | int min_distance; /**< min distance between this and the previous keyframe, used to avoid unneeded searching */
|
---|
265 | } AVIndexEntry;
|
---|
266 |
|
---|
267 | typedef struct AVStream {
|
---|
268 | int index; /**< stream index in AVFormatContext */
|
---|
269 | int id; /**< format specific stream id */
|
---|
270 | AVCodecContext *codec; /**< codec context */
|
---|
271 | /**
|
---|
272 | * real base frame rate of the stream.
|
---|
273 | * this is the lowest framerate with which all timestamps can be
|
---|
274 | * represented accurately (it is the least common multiple of all
|
---|
275 | * framerates in the stream), Note, this value is just a guess!
|
---|
276 | * for example if the timebase is 1/90000 and all frames have either
|
---|
277 | * approximately 3600 or 1800 timer ticks then r_frame_rate will be 50/1
|
---|
278 | */
|
---|
279 | AVRational r_frame_rate;
|
---|
280 | void *priv_data;
|
---|
281 | #if LIBAVFORMAT_VERSION_INT < (52<<16)
|
---|
282 | /* internal data used in av_find_stream_info() */
|
---|
283 | int64_t codec_info_duration;
|
---|
284 | int codec_info_nb_frames;
|
---|
285 | #endif
|
---|
286 | /** encoding: PTS generation when outputing stream */
|
---|
287 | struct AVFrac pts;
|
---|
288 |
|
---|
289 | /**
|
---|
290 | * this is the fundamental unit of time (in seconds) in terms
|
---|
291 | * of which frame timestamps are represented. for fixed-fps content,
|
---|
292 | * timebase should be 1/framerate and timestamp increments should be
|
---|
293 | * identically 1.
|
---|
294 | */
|
---|
295 | AVRational time_base;
|
---|
296 | int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
|
---|
297 | /* ffmpeg.c private use */
|
---|
298 | int stream_copy; /**< if set, just copy stream */
|
---|
299 | enum AVDiscard discard; ///< selects which packets can be discarded at will and do not need to be demuxed
|
---|
300 | //FIXME move stuff to a flags field?
|
---|
301 | /** quality, as it has been removed from AVCodecContext and put in AVVideoFrame
|
---|
302 | * MN: dunno if that is the right place for it */
|
---|
303 | float quality;
|
---|
304 | /** decoding: pts of the first frame of the stream, in stream time base. */
|
---|
305 | int64_t start_time;
|
---|
306 | /** decoding: duration of the stream, in stream time base. */
|
---|
307 | int64_t duration;
|
---|
308 |
|
---|
309 | char language[4]; /** ISO 639 3-letter language code (empty string if undefined) */
|
---|
310 |
|
---|
311 | /* av_read_frame() support */
|
---|
312 | enum AVStreamParseType need_parsing;
|
---|
313 | struct AVCodecParserContext *parser;
|
---|
314 |
|
---|
315 | int64_t cur_dts;
|
---|
316 | int last_IP_duration;
|
---|
317 | int64_t last_IP_pts;
|
---|
318 | /* av_seek_frame() support */
|
---|
319 | AVIndexEntry *index_entries; /**< only used if the format does not
|
---|
320 | support seeking natively */
|
---|
321 | int nb_index_entries;
|
---|
322 | unsigned int index_entries_allocated_size;
|
---|
323 |
|
---|
324 | int64_t nb_frames; ///< number of frames in this stream if known or 0
|
---|
325 |
|
---|
326 | #define MAX_REORDER_DELAY 4
|
---|
327 | int64_t pts_buffer[MAX_REORDER_DELAY+1];
|
---|
328 | } AVStream;
|
---|
329 |
|
---|
330 | #define AVFMTCTX_NOHEADER 0x0001 /**< signal that no header is present
|
---|
331 | (streams are added dynamically) */
|
---|
332 |
|
---|
333 | #define MAX_STREAMS 20
|
---|
334 |
|
---|
335 | /* format I/O context */
|
---|
336 | typedef struct AVFormatContext {
|
---|
337 | const AVClass *av_class; /**< set by av_alloc_format_context */
|
---|
338 | /* can only be iformat or oformat, not both at the same time */
|
---|
339 | struct AVInputFormat *iformat;
|
---|
340 | struct AVOutputFormat *oformat;
|
---|
341 | void *priv_data;
|
---|
342 | ByteIOContext pb;
|
---|
343 | unsigned int nb_streams;
|
---|
344 | AVStream *streams[MAX_STREAMS];
|
---|
345 | char filename[1024]; /**< input or output filename */
|
---|
346 | /* stream info */
|
---|
347 | int64_t timestamp;
|
---|
348 | char title[512];
|
---|
349 | char author[512];
|
---|
350 | char copyright[512];
|
---|
351 | char comment[512];
|
---|
352 | char album[512];
|
---|
353 | int year; /**< ID3 year, 0 if none */
|
---|
354 | int track; /**< track number, 0 if none */
|
---|
355 | char genre[32]; /**< ID3 genre */
|
---|
356 |
|
---|
357 | int ctx_flags; /**< format specific flags, see AVFMTCTX_xx */
|
---|
358 | /* private data for pts handling (do not modify directly) */
|
---|
359 | /** This buffer is only needed when packets were already buffered but
|
---|
360 | not decoded, for example to get the codec parameters in mpeg
|
---|
361 | streams */
|
---|
362 | struct AVPacketList *packet_buffer;
|
---|
363 |
|
---|
364 | /** decoding: position of the first frame of the component, in
|
---|
365 | AV_TIME_BASE fractional seconds. NEVER set this value directly:
|
---|
366 | it is deduced from the AVStream values. */
|
---|
367 | int64_t start_time;
|
---|
368 | /** decoding: duration of the stream, in AV_TIME_BASE fractional
|
---|
369 | seconds. NEVER set this value directly: it is deduced from the
|
---|
370 | AVStream values. */
|
---|
371 | int64_t duration;
|
---|
372 | /** decoding: total file size. 0 if unknown */
|
---|
373 | int64_t file_size;
|
---|
374 | /** decoding: total stream bitrate in bit/s, 0 if not
|
---|
375 | available. Never set it directly if the file_size and the
|
---|
376 | duration are known as ffmpeg can compute it automatically. */
|
---|
377 | int bit_rate;
|
---|
378 |
|
---|
379 | /* av_read_frame() support */
|
---|
380 | AVStream *cur_st;
|
---|
381 | const uint8_t *cur_ptr;
|
---|
382 | int cur_len;
|
---|
383 | AVPacket cur_pkt;
|
---|
384 |
|
---|
385 | /* av_seek_frame() support */
|
---|
386 | int64_t data_offset; /** offset of the first packet */
|
---|
387 | int index_built;
|
---|
388 |
|
---|
389 | int mux_rate;
|
---|
390 | int packet_size;
|
---|
391 | int preload;
|
---|
392 | int max_delay;
|
---|
393 |
|
---|
394 | #define AVFMT_NOOUTPUTLOOP -1
|
---|
395 | #define AVFMT_INFINITEOUTPUTLOOP 0
|
---|
396 | /** number of times to loop output in formats that support it */
|
---|
397 | int loop_output;
|
---|
398 |
|
---|
399 | int flags;
|
---|
400 | #define AVFMT_FLAG_GENPTS 0x0001 ///< generate pts if missing even if it requires parsing future frames
|
---|
401 | #define AVFMT_FLAG_IGNIDX 0x0002 ///< ignore index
|
---|
402 | #define AVFMT_FLAG_NONBLOCK 0x0004 ///< do not block when reading packets from input
|
---|
403 |
|
---|
404 | int loop_input;
|
---|
405 | /** decoding: size of data to probe; encoding unused */
|
---|
406 | unsigned int probesize;
|
---|
407 |
|
---|
408 | /**
|
---|
409 | * maximum duration in AV_TIME_BASE units over which the input should be analyzed in av_find_stream_info()
|
---|
410 | */
|
---|
411 | int max_analyze_duration;
|
---|
412 |
|
---|
413 | const uint8_t *key;
|
---|
414 | int keylen;
|
---|
415 | } AVFormatContext;
|
---|
416 |
|
---|
417 | typedef struct AVPacketList {
|
---|
418 | AVPacket pkt;
|
---|
419 | struct AVPacketList *next;
|
---|
420 | } AVPacketList;
|
---|
421 |
|
---|
422 | extern AVInputFormat *first_iformat;
|
---|
423 | extern AVOutputFormat *first_oformat;
|
---|
424 |
|
---|
425 | enum CodecID av_guess_image2_codec(const char *filename);
|
---|
426 |
|
---|
427 | /* XXX: use automatic init with either ELF sections or C file parser */
|
---|
428 | /* modules */
|
---|
429 |
|
---|
430 | #include "rtp.h"
|
---|
431 |
|
---|
432 | #include "rtsp.h"
|
---|
433 |
|
---|
434 | /* utils.c */
|
---|
435 | void av_register_input_format(AVInputFormat *format);
|
---|
436 | void av_register_output_format(AVOutputFormat *format);
|
---|
437 | AVOutputFormat *guess_stream_format(const char *short_name,
|
---|
438 | const char *filename, const char *mime_type);
|
---|
439 | AVOutputFormat *guess_format(const char *short_name,
|
---|
440 | const char *filename, const char *mime_type);
|
---|
441 |
|
---|
442 | /**
|
---|
443 | * Guesses the codec id based upon muxer and filename.
|
---|
444 | */
|
---|
445 | enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
|
---|
446 | const char *filename, const char *mime_type, enum CodecType type);
|
---|
447 |
|
---|
448 | /**
|
---|
449 | * Send a nice hexadecimal dump of a buffer to the specified file stream.
|
---|
450 | *
|
---|
451 | * @param f The file stream pointer where the dump should be sent to.
|
---|
452 | * @param buf buffer
|
---|
453 | * @param size buffer size
|
---|
454 | *
|
---|
455 | * @see av_hex_dump_log, av_pkt_dump, av_pkt_dump_log
|
---|
456 | */
|
---|
457 | void av_hex_dump(FILE *f, uint8_t *buf, int size);
|
---|
458 |
|
---|
459 | /**
|
---|
460 | * Send a nice hexadecimal dump of a buffer to the log.
|
---|
461 | *
|
---|
462 | * @param avcl A pointer to an arbitrary struct of which the first field is a
|
---|
463 | * pointer to an AVClass struct.
|
---|
464 | * @param level The importance level of the message, lower values signifying
|
---|
465 | * higher importance.
|
---|
466 | * @param buf buffer
|
---|
467 | * @param size buffer size
|
---|
468 | *
|
---|
469 | * @see av_hex_dump, av_pkt_dump, av_pkt_dump_log
|
---|
470 | */
|
---|
471 | void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size);
|
---|
472 |
|
---|
473 | /**
|
---|
474 | * Send a nice dump of a packet to the specified file stream.
|
---|
475 | *
|
---|
476 | * @param f The file stream pointer where the dump should be sent to.
|
---|
477 | * @param pkt packet to dump
|
---|
478 | * @param dump_payload true if the payload must be displayed too
|
---|
479 | */
|
---|
480 | void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload);
|
---|
481 |
|
---|
482 | /**
|
---|
483 | * Send a nice dump of a packet to the log.
|
---|
484 | *
|
---|
485 | * @param avcl A pointer to an arbitrary struct of which the first field is a
|
---|
486 | * pointer to an AVClass struct.
|
---|
487 | * @param level The importance level of the message, lower values signifying
|
---|
488 | * higher importance.
|
---|
489 | * @param pkt packet to dump
|
---|
490 | * @param dump_payload true if the payload must be displayed too
|
---|
491 | */
|
---|
492 | void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload);
|
---|
493 |
|
---|
494 | void av_register_all(void);
|
---|
495 |
|
---|
496 | /** codec tag <-> codec id */
|
---|
497 | enum CodecID av_codec_get_id(const struct AVCodecTag **tags, unsigned int tag);
|
---|
498 | unsigned int av_codec_get_tag(const struct AVCodecTag **tags, enum CodecID id);
|
---|
499 |
|
---|
500 | /* media file input */
|
---|
501 |
|
---|
502 | /**
|
---|
503 | * finds AVInputFormat based on input format's short name.
|
---|
504 | */
|
---|
505 | AVInputFormat *av_find_input_format(const char *short_name);
|
---|
506 |
|
---|
507 | /**
|
---|
508 | * Guess file format.
|
---|
509 | *
|
---|
510 | * @param is_opened whether the file is already opened, determines whether
|
---|
511 | * demuxers with or without AVFMT_NOFILE are probed
|
---|
512 | */
|
---|
513 | AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened);
|
---|
514 |
|
---|
515 | /**
|
---|
516 | * Allocates all the structures needed to read an input stream.
|
---|
517 | * This does not open the needed codecs for decoding the stream[s].
|
---|
518 | */
|
---|
519 | int av_open_input_stream(AVFormatContext **ic_ptr,
|
---|
520 | ByteIOContext *pb, const char *filename,
|
---|
521 | AVInputFormat *fmt, AVFormatParameters *ap);
|
---|
522 |
|
---|
523 | /**
|
---|
524 | * Open a media file as input. The codecs are not opened. Only the file
|
---|
525 | * header (if present) is read.
|
---|
526 | *
|
---|
527 | * @param ic_ptr the opened media file handle is put here
|
---|
528 | * @param filename filename to open.
|
---|
529 | * @param fmt if non NULL, force the file format to use
|
---|
530 | * @param buf_size optional buffer size (zero if default is OK)
|
---|
531 | * @param ap additional parameters needed when opening the file (NULL if default)
|
---|
532 | * @return 0 if OK. AVERROR_xxx otherwise.
|
---|
533 | */
|
---|
534 | int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
|
---|
535 | AVInputFormat *fmt,
|
---|
536 | int buf_size,
|
---|
537 | AVFormatParameters *ap);
|
---|
538 | /** no av_open for output, so applications will need this: */
|
---|
539 | AVFormatContext *av_alloc_format_context(void);
|
---|
540 |
|
---|
541 | /**
|
---|
542 | * Read packets of a media file to get stream information. This
|
---|
543 | * is useful for file formats with no headers such as MPEG. This
|
---|
544 | * function also computes the real frame rate in case of mpeg2 repeat
|
---|
545 | * frame mode.
|
---|
546 | * The logical file position is not changed by this function;
|
---|
547 | * examined packets may be buffered for later processing.
|
---|
548 | *
|
---|
549 | * @param ic media file handle
|
---|
550 | * @return >=0 if OK. AVERROR_xxx if error.
|
---|
551 | * @todo Let user decide somehow what information is needed so we do not waste time geting stuff the user does not need.
|
---|
552 | */
|
---|
553 | int av_find_stream_info(AVFormatContext *ic);
|
---|
554 |
|
---|
555 | /**
|
---|
556 | * Read a transport packet from a media file.
|
---|
557 | *
|
---|
558 | * This function is obsolete and should never be used.
|
---|
559 | * Use av_read_frame() instead.
|
---|
560 | *
|
---|
561 | * @param s media file handle
|
---|
562 | * @param pkt is filled
|
---|
563 | * @return 0 if OK. AVERROR_xxx if error.
|
---|
564 | */
|
---|
565 | int av_read_packet(AVFormatContext *s, AVPacket *pkt);
|
---|
566 |
|
---|
567 | /**
|
---|
568 | * Return the next frame of a stream.
|
---|
569 | *
|
---|
570 | * The returned packet is valid
|
---|
571 | * until the next av_read_frame() or until av_close_input_file() and
|
---|
572 | * must be freed with av_free_packet. For video, the packet contains
|
---|
573 | * exactly one frame. For audio, it contains an integer number of
|
---|
574 | * frames if each frame has a known fixed size (e.g. PCM or ADPCM
|
---|
575 | * data). If the audio frames have a variable size (e.g. MPEG audio),
|
---|
576 | * then it contains one frame.
|
---|
577 | *
|
---|
578 | * pkt->pts, pkt->dts and pkt->duration are always set to correct
|
---|
579 | * values in AVStream.timebase units (and guessed if the format cannot
|
---|
580 | * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
|
---|
581 | * has B frames, so it is better to rely on pkt->dts if you do not
|
---|
582 | * decompress the payload.
|
---|
583 | *
|
---|
584 | * @return 0 if OK, < 0 if error or end of file.
|
---|
585 | */
|
---|
586 | int av_read_frame(AVFormatContext *s, AVPacket *pkt);
|
---|
587 |
|
---|
588 | /**
|
---|
589 | * Seek to the key frame at timestamp.
|
---|
590 | * 'timestamp' in 'stream_index'.
|
---|
591 | * @param stream_index If stream_index is (-1), a default
|
---|
592 | * stream is selected, and timestamp is automatically converted
|
---|
593 | * from AV_TIME_BASE units to the stream specific time_base.
|
---|
594 | * @param timestamp timestamp in AVStream.time_base units
|
---|
595 | * or if there is no stream specified then in AV_TIME_BASE units
|
---|
596 | * @param flags flags which select direction and seeking mode
|
---|
597 | * @return >= 0 on success
|
---|
598 | */
|
---|
599 | int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags);
|
---|
600 |
|
---|
601 | /**
|
---|
602 | * start playing a network based stream (e.g. RTSP stream) at the
|
---|
603 | * current position
|
---|
604 | */
|
---|
605 | int av_read_play(AVFormatContext *s);
|
---|
606 |
|
---|
607 | /**
|
---|
608 | * Pause a network based stream (e.g. RTSP stream).
|
---|
609 | *
|
---|
610 | * Use av_read_play() to resume it.
|
---|
611 | */
|
---|
612 | int av_read_pause(AVFormatContext *s);
|
---|
613 |
|
---|
614 | /**
|
---|
615 | * Close a media file (but not its codecs).
|
---|
616 | *
|
---|
617 | * @param s media file handle
|
---|
618 | */
|
---|
619 | void av_close_input_file(AVFormatContext *s);
|
---|
620 |
|
---|
621 | /**
|
---|
622 | * Add a new stream to a media file.
|
---|
623 | *
|
---|
624 | * Can only be called in the read_header() function. If the flag
|
---|
625 | * AVFMTCTX_NOHEADER is in the format context, then new streams
|
---|
626 | * can be added in read_packet too.
|
---|
627 | *
|
---|
628 | * @param s media file handle
|
---|
629 | * @param id file format dependent stream id
|
---|
630 | */
|
---|
631 | AVStream *av_new_stream(AVFormatContext *s, int id);
|
---|
632 |
|
---|
633 | /**
|
---|
634 | * Set the pts for a given stream.
|
---|
635 | *
|
---|
636 | * @param s stream
|
---|
637 | * @param pts_wrap_bits number of bits effectively used by the pts
|
---|
638 | * (used for wrap control, 33 is the value for MPEG)
|
---|
639 | * @param pts_num numerator to convert to seconds (MPEG: 1)
|
---|
640 | * @param pts_den denominator to convert to seconds (MPEG: 90000)
|
---|
641 | */
|
---|
642 | void av_set_pts_info(AVStream *s, int pts_wrap_bits,
|
---|
643 | int pts_num, int pts_den);
|
---|
644 |
|
---|
645 | #define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
|
---|
646 | #define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes
|
---|
647 | #define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non keyframes
|
---|
648 |
|
---|
649 | int av_find_default_stream_index(AVFormatContext *s);
|
---|
650 |
|
---|
651 | /**
|
---|
652 | * Gets the index for a specific timestamp.
|
---|
653 | * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
|
---|
654 | * the timestamp which is <= the requested one, if backward is 0
|
---|
655 | * then it will be >=
|
---|
656 | * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
|
---|
657 | * @return < 0 if no such timestamp could be found
|
---|
658 | */
|
---|
659 | int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
|
---|
660 |
|
---|
661 | /**
|
---|
662 | * Add a index entry into a sorted list updateing if it is already there.
|
---|
663 | *
|
---|
664 | * @param timestamp timestamp in the timebase of the given stream
|
---|
665 | */
|
---|
666 | int av_add_index_entry(AVStream *st,
|
---|
667 | int64_t pos, int64_t timestamp, int size, int distance, int flags);
|
---|
668 |
|
---|
669 | /**
|
---|
670 | * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
|
---|
671 | * This is not supposed to be called directly by a user application, but by demuxers.
|
---|
672 | * @param target_ts target timestamp in the time base of the given stream
|
---|
673 | * @param stream_index stream number
|
---|
674 | */
|
---|
675 | int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags);
|
---|
676 |
|
---|
677 | /**
|
---|
678 | * Updates cur_dts of all streams based on given timestamp and AVStream.
|
---|
679 | *
|
---|
680 | * Stream ref_st unchanged, others set cur_dts in their native timebase
|
---|
681 | * only needed for timestamp wrapping or if (dts not set and pts!=dts).
|
---|
682 | * @param timestamp new dts expressed in time_base of param ref_st
|
---|
683 | * @param ref_st reference stream giving time_base of param timestamp
|
---|
684 | */
|
---|
685 | void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
|
---|
686 |
|
---|
687 | /**
|
---|
688 | * Does a binary search using read_timestamp().
|
---|
689 | * This is not supposed to be called directly by a user application, but by demuxers.
|
---|
690 | * @param target_ts target timestamp in the time base of the given stream
|
---|
691 | * @param stream_index stream number
|
---|
692 | */
|
---|
693 | int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
|
---|
694 |
|
---|
695 | /** media file output */
|
---|
696 | int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap);
|
---|
697 |
|
---|
698 | /**
|
---|
699 | * Allocate the stream private data and write the stream header to an
|
---|
700 | * output media file.
|
---|
701 | *
|
---|
702 | * @param s media file handle
|
---|
703 | * @return 0 if OK. AVERROR_xxx if error.
|
---|
704 | */
|
---|
705 | int av_write_header(AVFormatContext *s);
|
---|
706 |
|
---|
707 | /**
|
---|
708 | * Write a packet to an output media file.
|
---|
709 | *
|
---|
710 | * The packet shall contain one audio or video frame.
|
---|
711 | * The packet must be correctly interleaved according to the container specification,
|
---|
712 | * if not then av_interleaved_write_frame must be used
|
---|
713 | *
|
---|
714 | * @param s media file handle
|
---|
715 | * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
|
---|
716 | * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
|
---|
717 | */
|
---|
718 | int av_write_frame(AVFormatContext *s, AVPacket *pkt);
|
---|
719 |
|
---|
720 | /**
|
---|
721 | * Writes a packet to an output media file ensuring correct interleaving.
|
---|
722 | *
|
---|
723 | * The packet must contain one audio or video frame.
|
---|
724 | * If the packets are already correctly interleaved the application should
|
---|
725 | * call av_write_frame() instead as it is slightly faster. It is also important
|
---|
726 | * to keep in mind that completely non-interleaved input will need huge amounts
|
---|
727 | * of memory to interleave with this, so it is preferable to interleave at the
|
---|
728 | * demuxer level.
|
---|
729 | *
|
---|
730 | * @param s media file handle
|
---|
731 | * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
|
---|
732 | * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
|
---|
733 | */
|
---|
734 | int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);
|
---|
735 |
|
---|
736 | /**
|
---|
737 | * Interleave a packet per DTS in an output media file.
|
---|
738 | *
|
---|
739 | * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
|
---|
740 | * so they cannot be used after it, note calling av_free_packet() on them is still safe.
|
---|
741 | *
|
---|
742 | * @param s media file handle
|
---|
743 | * @param out the interleaved packet will be output here
|
---|
744 | * @param in the input packet
|
---|
745 | * @param flush 1 if no further packets are available as input and all
|
---|
746 | * remaining packets should be output
|
---|
747 | * @return 1 if a packet was output, 0 if no packet could be output,
|
---|
748 | * < 0 if an error occured
|
---|
749 | */
|
---|
750 | int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush);
|
---|
751 |
|
---|
752 | /**
|
---|
753 | * @brief Write the stream trailer to an output media file and
|
---|
754 | * free the file private data.
|
---|
755 | *
|
---|
756 | * @param s media file handle
|
---|
757 | * @return 0 if OK. AVERROR_xxx if error.
|
---|
758 | */
|
---|
759 | int av_write_trailer(AVFormatContext *s);
|
---|
760 |
|
---|
761 | void dump_format(AVFormatContext *ic,
|
---|
762 | int index,
|
---|
763 | const char *url,
|
---|
764 | int is_output);
|
---|
765 |
|
---|
766 | /**
|
---|
767 | * parses width and height out of string str.
|
---|
768 | * @deprecated Use av_parse_video_frame_size instead.
|
---|
769 | */
|
---|
770 | attribute_deprecated int parse_image_size(int *width_ptr, int *height_ptr, const char *str);
|
---|
771 |
|
---|
772 | /**
|
---|
773 | * Converts frame rate from string to a fraction.
|
---|
774 | * @deprecated Use av_parse_video_frame_rate instead.
|
---|
775 | */
|
---|
776 | attribute_deprecated int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg);
|
---|
777 |
|
---|
778 | /**
|
---|
779 | * Converts date string to number of seconds since Jan 1st, 1970.
|
---|
780 | *
|
---|
781 | * @code
|
---|
782 | * Syntax:
|
---|
783 | * - If not a duration:
|
---|
784 | * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
|
---|
785 | * Time is localtime unless Z is suffixed to the end. In this case GMT
|
---|
786 | * Return the date in micro seconds since 1970
|
---|
787 | *
|
---|
788 | * - If a duration:
|
---|
789 | * HH[:MM[:SS[.m...]]]
|
---|
790 | * S+[.m...]
|
---|
791 | * @endcode
|
---|
792 | */
|
---|
793 | int64_t parse_date(const char *datestr, int duration);
|
---|
794 |
|
---|
795 | int64_t av_gettime(void);
|
---|
796 |
|
---|
797 | /* ffm specific for ffserver */
|
---|
798 | #define FFM_PACKET_SIZE 4096
|
---|
799 | offset_t ffm_read_write_index(int fd);
|
---|
800 | void ffm_write_write_index(int fd, offset_t pos);
|
---|
801 | void ffm_set_write_index(AVFormatContext *s, offset_t pos, offset_t file_size);
|
---|
802 |
|
---|
803 | /**
|
---|
804 | * Attempts to find a specific tag in a URL.
|
---|
805 | *
|
---|
806 | * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
|
---|
807 | * Return 1 if found.
|
---|
808 | */
|
---|
809 | int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info);
|
---|
810 |
|
---|
811 | /**
|
---|
812 | * Returns in 'buf' the path with '%d' replaced by number.
|
---|
813 |
|
---|
814 | * Also handles the '%0nd' format where 'n' is the total number
|
---|
815 | * of digits and '%%'.
|
---|
816 | *
|
---|
817 | * @param buf destination buffer
|
---|
818 | * @param buf_size destination buffer size
|
---|
819 | * @param path numbered sequence string
|
---|
820 | * @number frame number
|
---|
821 | * @return 0 if OK, -1 if format error.
|
---|
822 | */
|
---|
823 | int av_get_frame_filename(char *buf, int buf_size,
|
---|
824 | const char *path, int number);
|
---|
825 |
|
---|
826 | /**
|
---|
827 | * Check whether filename actually is a numbered sequence generator.
|
---|
828 | *
|
---|
829 | * @param filename possible numbered sequence string
|
---|
830 | * @return 1 if a valid numbered sequence string, 0 otherwise.
|
---|
831 | */
|
---|
832 | int av_filename_number_test(const char *filename);
|
---|
833 |
|
---|
834 | #ifdef HAVE_AV_CONFIG_H
|
---|
835 |
|
---|
836 | #include "os_support.h"
|
---|
837 |
|
---|
838 | void __dynarray_add(unsigned long **tab_ptr, int *nb_ptr, unsigned long elem);
|
---|
839 |
|
---|
840 | #ifdef __GNUC__
|
---|
841 | #define dynarray_add(tab, nb_ptr, elem)\
|
---|
842 | do {\
|
---|
843 | typeof(tab) _tab = (tab);\
|
---|
844 | typeof(elem) _elem = (elem);\
|
---|
845 | (void)sizeof(**_tab == _elem); /* check that types are compatible */\
|
---|
846 | __dynarray_add((unsigned long **)_tab, nb_ptr, (unsigned long)_elem);\
|
---|
847 | } while(0)
|
---|
848 | #else
|
---|
849 | #define dynarray_add(tab, nb_ptr, elem)\
|
---|
850 | do {\
|
---|
851 | __dynarray_add((unsigned long **)(tab), nb_ptr, (unsigned long)(elem));\
|
---|
852 | } while(0)
|
---|
853 | #endif
|
---|
854 |
|
---|
855 | time_t mktimegm(struct tm *tm);
|
---|
856 | struct tm *brktimegm(time_t secs, struct tm *tm);
|
---|
857 | const char *small_strptime(const char *p, const char *fmt,
|
---|
858 | struct tm *dt);
|
---|
859 |
|
---|
860 | struct in_addr;
|
---|
861 | int resolve_host(struct in_addr *sin_addr, const char *hostname);
|
---|
862 |
|
---|
863 | void url_split(char *proto, int proto_size,
|
---|
864 | char *authorization, int authorization_size,
|
---|
865 | char *hostname, int hostname_size,
|
---|
866 | int *port_ptr,
|
---|
867 | char *path, int path_size,
|
---|
868 | const char *url);
|
---|
869 |
|
---|
870 | int match_ext(const char *filename, const char *extensions);
|
---|
871 |
|
---|
872 | #endif /* HAVE_AV_CONFIG_H */
|
---|
873 |
|
---|
874 | #endif /* AVFORMAT_H */
|
---|
875 |
|
---|