avformat.h 30.5 KB
Newer Older
1 2 3
/*
 * copyright (c) 2001 Fabrice Bellard
 *
4 5 6
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
7 8
 * modify it under the terms of the GNU Lesser General Public
 * 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 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 19 20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

Fabrice Bellard's avatar
Fabrice Bellard committed
21 22
#ifndef AVFORMAT_H
#define AVFORMAT_H
Fabrice Bellard's avatar
Fabrice Bellard committed
23

24 25
#define LIBAVFORMAT_VERSION_INT ((51<<16)+(12<<8)+1)
#define LIBAVFORMAT_VERSION     51.12.1
Michael Niedermayer's avatar
Michael Niedermayer committed
26
#define LIBAVFORMAT_BUILD       LIBAVFORMAT_VERSION_INT
27

Michael Niedermayer's avatar
Michael Niedermayer committed
28
#define LIBAVFORMAT_IDENT       "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
29

30
#include <time.h>
Zdenek Kabelac's avatar
Zdenek Kabelac committed
31
#include <stdio.h>  /* FILE */
Fabrice Bellard's avatar
Fabrice Bellard committed
32 33 34 35 36 37 38
#include "avcodec.h"

#include "avio.h"

/* packet functions */

typedef struct AVPacket {
Michael Niedermayer's avatar
Michael Niedermayer committed
39 40
    int64_t pts;                            ///< presentation time stamp in time_base units
    int64_t dts;                            ///< decompression time stamp in time_base units
41
    uint8_t *data;
42 43 44
    int   size;
    int   stream_index;
    int   flags;
Michael Niedermayer's avatar
Michael Niedermayer committed
45
    int   duration;                         ///< presentation duration in time_base units (0 if not available)
46 47
    void  (*destruct)(struct AVPacket *);
    void  *priv;
Michael Niedermayer's avatar
Michael Niedermayer committed
48
    int64_t pos;                            ///< byte position in stream, -1 if unknown
49
} AVPacket;
50 51
#define PKT_FLAG_KEY   0x0001

Michael Niedermayer's avatar
Michael Niedermayer committed
52
void av_destruct_packet_nofree(AVPacket *pkt);
53 54 55 56

/**
 * Default packet destructor.
 */
57
void av_destruct_packet(AVPacket *pkt);
Michael Niedermayer's avatar
Michael Niedermayer committed
58

Ramiro Polla's avatar
Ramiro Polla committed
59 60 61 62 63
/**
 * Initialize optional fields of a packet to default values.
 *
 * @param pkt packet
 */
Ramiro Polla's avatar
Ramiro Polla committed
64
void av_init_packet(AVPacket *pkt);
Fabrice Bellard's avatar
Fabrice Bellard committed
65

66
/**
Diego Biurrun's avatar
Diego Biurrun committed
67
 * Allocate the payload of a packet and initialize its fields to default values.
68 69 70 71 72
 *
 * @param pkt packet
 * @param size wanted payload size
 * @return 0 if OK. AVERROR_xxx otherwise.
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
73
int av_new_packet(AVPacket *pkt, int size);
74 75

/**
Diego Biurrun's avatar
Diego Biurrun committed
76
 * Allocate and read the payload of a packet and initialize its fields to default values.
77 78 79 80 81
 *
 * @param pkt packet
 * @param size wanted payload size
 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
82
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size);
83

84 85 86 87
/**
 * @warning This is a hack - the packet memory allocation stuff is broken. The
 * packet is allocated if it was not really allocated
 */
88
int av_dup_packet(AVPacket *pkt);
89 90 91 92 93 94 95 96

/**
 * Free a packet
 *
 * @param pkt packet to free
 */
static inline void av_free_packet(AVPacket *pkt)
{
97
    if (pkt && pkt->destruct) {
98
        pkt->destruct(pkt);
99
    }
100
}
Fabrice Bellard's avatar
Fabrice Bellard committed
101

Fabrice Bellard's avatar
Fabrice Bellard committed
102 103 104
/*************************************************/
/* fractional numbers for exact pts handling */

105 106 107 108 109
/**
 * the exact value of the fractional number is: 'val + num / den'.
 * num is assumed to be such as 0 <= num < den
 * @deprecated Use AVRational instead
*/
Fabrice Bellard's avatar
Fabrice Bellard committed
110
typedef struct AVFrac {
111
    int64_t val, num, den;
Michael Niedermayer's avatar
Michael Niedermayer committed
112
} AVFrac attribute_deprecated;
Fabrice Bellard's avatar
Fabrice Bellard committed
113

Fabrice Bellard's avatar
Fabrice Bellard committed
114
/*************************************************/
115
/* input/output formats */
Fabrice Bellard's avatar
Fabrice Bellard committed
116

117 118
struct AVCodecTag;

Fabrice Bellard's avatar
Fabrice Bellard committed
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 125 126 127
    unsigned char *buf;
    int buf_size;
} AVProbeData;

Michael Niedermayer's avatar
Michael Niedermayer committed
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
Fabrice Bellard's avatar
Fabrice Bellard committed
130 131

typedef struct AVFormatParameters {
132
    AVRational time_base;
Fabrice Bellard's avatar
Fabrice Bellard committed
133 134 135 136
    int sample_rate;
    int channels;
    int width;
    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 143 144
    const char *standard; /**< tv standard, NTSC, PAL, SECAM */
    int mpeg2ts_raw:1;  /**< force raw MPEG2 transport stream output, if possible */
    int mpeg2ts_compute_pcr:1; /**< compute exact PCR for each transport
145
                                  stream packet (only meaningful if
Ramiro Polla's avatar
Typos  
Ramiro Polla committed
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 151
    enum CodecID video_codec_id;
    enum CodecID audio_codec_id;
Fabrice Bellard's avatar
Fabrice Bellard committed
152 153
} AVFormatParameters;

154 155
//! demuxer will use url_fopen, no opened file should be provided by the caller
#define AVFMT_NOFILE        0x0001
156 157 158
#define AVFMT_NEEDNUMBER    0x0002 /**< needs '%d' in filename */
#define AVFMT_SHOW_IDS      0x0008 /**< show format stream IDs numbers */
#define AVFMT_RAWPICTURE    0x0020 /**< format wants AVPicture structure for
Fabrice Bellard's avatar
Fabrice Bellard committed
159
                                      raw picture data */
160
#define AVFMT_GLOBALHEADER  0x0040 /**< format wants global header */
Diego Biurrun's avatar
Diego Biurrun committed
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 {
Fabrice Bellard's avatar
Fabrice Bellard committed
165 166 167
    const char *name;
    const char *long_name;
    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;
Fabrice Bellard's avatar
Fabrice Bellard committed
171
    /* output support */
172 173
    enum CodecID audio_codec; /**< default audio codec */
    enum CodecID video_codec; /**< default video codec */
Fabrice Bellard's avatar
Fabrice Bellard committed
174
    int (*write_header)(struct AVFormatContext *);
175
    int (*write_packet)(struct AVFormatContext *, AVPacket *pkt);
Fabrice Bellard's avatar
Fabrice Bellard committed
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 185 186

    /**
     * list of supported codec_id-codec_tag pairs, ordered by "better choice first"
     * the arrays are all CODEC_ID_NONE terminated
     */
187
    const struct AVCodecTag **codec_tag;
188

189 190 191
    /* private fields */
    struct AVOutputFormat *next;
} AVOutputFormat;
Fabrice Bellard's avatar
Fabrice Bellard committed
192

193 194 195
typedef struct AVInputFormat {
    const char *name;
    const char *long_name;
196
    /** size of private data so that it can be allocated in the wrapper */
197
    int priv_data_size;
Ramiro Polla's avatar
Typos  
Ramiro Polla committed
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
Fabrice Bellard's avatar
Fabrice Bellard committed
201
       structure. Return 0 if OK. 'ap' if non NULL contains
Diego Biurrun's avatar
Diego Biurrun committed
202
       additional paramters. Only used in raw format right
203
       now. 'av_new_stream' should be called to create new streams.  */
Fabrice Bellard's avatar
Fabrice Bellard committed
204 205
    int (*read_header)(struct AVFormatContext *,
                       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. */
Fabrice Bellard's avatar
Fabrice Bellard committed
209
    int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);
210
    /** close the stream. The AVFormatContext and AVStreams are not
Fabrice Bellard's avatar
Fabrice Bellard committed
211 212
       freed by this function */
    int (*read_close)(struct AVFormatContext *);
213 214
    /**
     * seek to a given timestamp relative to the frames in
215 216
     * stream component stream_index
     * @param stream_index must not be -1
217
     * @param flags selects which direction should be preferred if no exact
218 219
     *              match is available
     */
220
    int (*read_seek)(struct AVFormatContext *,
221
                     int stream_index, int64_t timestamp, int flags);
222 223 224 225 226
    /**
     * gets the next timestamp in AV_TIME_BASE units.
     */
    int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index,
                              int64_t *pos, int64_t pos_limit);
227
    /** can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER */
Fabrice Bellard's avatar
Fabrice Bellard committed
228
    int flags;
229
    /** if extensions are defined, then no probe is done. You should
230 231 232
       usually not use extension format guessing because it is not
       reliable enough */
    const char *extensions;
233
    /** general purpose read only value that the format can use */
234
    int value;
235

236
    /** start/resume playing - only meaningful if using a network based format
237 238 239
       (RTSP) */
    int (*read_play)(struct AVFormatContext *);

240
    /** pause playing - only meaningful if using a network based format
241 242 243
       (RTSP) */
    int (*read_pause)(struct AVFormatContext *);

244
    const struct AVCodecTag **codec_tag;
245

246 247 248
    /* private fields */
    struct AVInputFormat *next;
} AVInputFormat;
Fabrice Bellard's avatar
Fabrice Bellard committed
249

Aurelien Jacobs's avatar
Aurelien Jacobs committed
250 251 252 253 254 255 256
enum AVStreamParseType {
    AVSTREAM_PARSE_NONE,
    AVSTREAM_PARSE_FULL,       /**< full parsing and repack */
    AVSTREAM_PARSE_HEADERS,    /**< only parse headers, don't repack */
    AVSTREAM_PARSE_TIMESTAMPS, /**< full parsing and interpolation of timestamps for frames not starting on packet boundary */
};

257 258 259 260
typedef struct AVIndexEntry {
    int64_t pos;
    int64_t timestamp;
#define AVINDEX_KEYFRAME 0x0001
Michael Niedermayer's avatar
Michael Niedermayer committed
261
    int flags:2;
Diego Biurrun's avatar
Diego Biurrun committed
262
    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).
263
    int min_distance;         /**< min distance between this and the previous keyframe, used to avoid unneeded searching */
264 265
} AVIndexEntry;

Fabrice Bellard's avatar
Fabrice Bellard committed
266
typedef struct AVStream {
267 268 269
    int index;    /**< stream index in AVFormatContext */
    int id;       /**< format specific stream id */
    AVCodecContext *codec; /**< codec context */
270 271
    /**
     * real base frame rate of the stream.
272
     * this is the lowest framerate with which all timestamps can be
Ramiro Polla's avatar
Typos  
Ramiro Polla committed
273
     * represented accurately (it is the least common multiple of all
274
     * framerates in the stream), Note, this value is just a guess!
275
     * for example if the timebase is 1/90000 and all frames have either
276 277 278
     * approximately 3600 or 1800 timer ticks then r_frame_rate will be 50/1
     */
    AVRational r_frame_rate;
Fabrice Bellard's avatar
Fabrice Bellard committed
279
    void *priv_data;
280
#if LIBAVFORMAT_VERSION_INT < (52<<16)
281
    /* internal data used in av_find_stream_info() */
282
    int64_t codec_info_duration;
283
    int codec_info_nb_frames;
284
#endif
285
    /** encoding: PTS generation when outputing stream */
286
    AVFrac pts;
287 288 289 290 291 292 293

    /**
     * this is the fundamental unit of time (in seconds) in terms
     * of which frame timestamps are represented. for fixed-fps content,
     * timebase should be 1/framerate and timestamp increments should be
     * identically 1.
     */
294
    AVRational time_base;
295
    int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
Fabrice Bellard's avatar
Fabrice Bellard committed
296
    /* ffmpeg.c private use */
Panagiotis Issaris's avatar
Panagiotis Issaris committed
297
    int stream_copy; /**< if set, just copy stream */
Diego Biurrun's avatar
Diego Biurrun committed
298
    enum AVDiscard discard; ///< selects which packets can be discarded at will and do not need to be demuxed
299
    //FIXME move stuff to a flags field?
300
    /** quality, as it has been removed from AVCodecContext and put in AVVideoFrame
Diego Biurrun's avatar
Diego Biurrun committed
301
     * MN: dunno if that is the right place for it */
302
    float quality;
303
    /** decoding: pts of the first frame of the stream, in stream time base. */
304
    int64_t start_time;
305
    /** decoding: duration of the stream, in stream time base. */
306
    int64_t duration;
307

308
    char language[4]; /** ISO 639 3-letter language code (empty string if undefined) */
309

310
    /* av_read_frame() support */
Aurelien Jacobs's avatar
Aurelien Jacobs committed
311
    enum AVStreamParseType need_parsing;
312
    struct AVCodecParserContext *parser;
313

314 315
    int64_t cur_dts;
    int last_IP_duration;
316
    int64_t last_IP_pts;
317
    /* av_seek_frame() support */
318
    AVIndexEntry *index_entries; /**< only used if the format does not
319 320
                                    support seeking natively */
    int nb_index_entries;
Måns Rullgård's avatar
Måns Rullgård committed
321
    unsigned int index_entries_allocated_size;
322

323
    int64_t nb_frames;                 ///< number of frames in this stream if known or 0
324 325 326

#define MAX_REORDER_DELAY 4
    int64_t pts_buffer[MAX_REORDER_DELAY+1];
Fabrice Bellard's avatar
Fabrice Bellard committed
327 328
} AVStream;

329
#define AVFMTCTX_NOHEADER      0x0001 /**< signal that no header is present
330 331
                                         (streams are added dynamically) */

Fabrice Bellard's avatar
Fabrice Bellard committed
332 333 334 335
#define MAX_STREAMS 20

/* format I/O context */
typedef struct AVFormatContext {
336
    const AVClass *av_class; /**< set by av_alloc_format_context */
337 338 339
    /* can only be iformat or oformat, not both at the same time */
    struct AVInputFormat *iformat;
    struct AVOutputFormat *oformat;
Fabrice Bellard's avatar
Fabrice Bellard committed
340 341
    void *priv_data;
    ByteIOContext pb;
342
    unsigned int nb_streams;
Fabrice Bellard's avatar
Fabrice Bellard committed
343
    AVStream *streams[MAX_STREAMS];
344
    char filename[1024]; /**< input or output filename */
Fabrice Bellard's avatar
Fabrice Bellard committed
345
    /* stream info */
346
    int64_t timestamp;
Fabrice Bellard's avatar
Fabrice Bellard committed
347 348 349 350
    char title[512];
    char author[512];
    char copyright[512];
    char comment[512];
351
    char album[512];
352 353 354
    int year;  /**< ID3 year, 0 if none */
    int track; /**< track number, 0 if none */
    char genre[32]; /**< ID3 genre */
355

356
    int ctx_flags; /**< format specific flags, see AVFMTCTX_xx */
Fabrice Bellard's avatar
Fabrice Bellard committed
357
    /* private data for pts handling (do not modify directly) */
358
    /** This buffer is only needed when packets were already buffered but
Fabrice Bellard's avatar
Fabrice Bellard committed
359 360
       not decoded, for example to get the codec parameters in mpeg
       streams */
361 362
    struct AVPacketList *packet_buffer;

363
    /** decoding: position of the first frame of the component, in
364 365
       AV_TIME_BASE fractional seconds. NEVER set this value directly:
       it is deduced from the AVStream values.  */
366
    int64_t start_time;
367
    /** decoding: duration of the stream, in AV_TIME_BASE fractional
368 369 370
       seconds. NEVER set this value directly: it is deduced from the
       AVStream values.  */
    int64_t duration;
371
    /** decoding: total file size. 0 if unknown */
372
    int64_t file_size;
373
    /** decoding: total stream bitrate in bit/s, 0 if not
374 375 376
       available. Never set it directly if the file_size and the
       duration are known as ffmpeg can compute it automatically. */
    int bit_rate;
377 378 379 380 381 382 383 384

    /* av_read_frame() support */
    AVStream *cur_st;
    const uint8_t *cur_ptr;
    int cur_len;
    AVPacket cur_pkt;

    /* av_seek_frame() support */
385
    int64_t data_offset; /** offset of the first packet */
386
    int index_built;
387

388 389
    int mux_rate;
    int packet_size;
390 391
    int preload;
    int max_delay;
392

393 394
#define AVFMT_NOOUTPUTLOOP -1
#define AVFMT_INFINITEOUTPUTLOOP 0
395
    /** number of times to loop output in formats that support it */
396
    int loop_output;
397

398 399
    int flags;
#define AVFMT_FLAG_GENPTS       0x0001 ///< generate pts if missing even if it requires parsing future frames
400
#define AVFMT_FLAG_IGNIDX       0x0002 ///< ignore index
401 402

    int loop_input;
403
    /** decoding: size of data to probe; encoding unused */
404
    unsigned int probesize;
405 406 407 408 409

    /**
     * maximum duration in AV_TIME_BASE units over which the input should be analyzed in av_find_stream_info()
     */
    int max_analyze_duration;
410 411 412

    const uint8_t *key;
    int keylen;
Fabrice Bellard's avatar
Fabrice Bellard committed
413 414 415 416 417 418 419
} AVFormatContext;

typedef struct AVPacketList {
    AVPacket pkt;
    struct AVPacketList *next;
} AVPacketList;

420 421
extern AVInputFormat *first_iformat;
extern AVOutputFormat *first_oformat;
Fabrice Bellard's avatar
Fabrice Bellard committed
422

423
enum CodecID av_guess_image2_codec(const char *filename);
424

425 426
/* XXX: use automatic init with either ELF sections or C file parser */
/* modules */
Fabrice Bellard's avatar
Fabrice Bellard committed
427

Fabrice Bellard's avatar
Fabrice Bellard committed
428 429 430 431
#include "rtp.h"

#include "rtsp.h"

432 433 434
/* utils.c */
void av_register_input_format(AVInputFormat *format);
void av_register_output_format(AVOutputFormat *format);
435
AVOutputFormat *guess_stream_format(const char *short_name,
436
                                    const char *filename, const char *mime_type);
437
AVOutputFormat *guess_format(const char *short_name,
438
                             const char *filename, const char *mime_type);
439 440 441 442

/**
 * Guesses the codec id based upon muxer and filename.
 */
443
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
444
                            const char *filename, const char *mime_type, enum CodecType type);
Fabrice Bellard's avatar
Fabrice Bellard committed
445

446
/**
447 448 449
 * Send a nice hexadecimal dump of a buffer to the specified file stream.
 *
 * @param f The file stream pointer where the dump should be sent to.
450 451
 * @param buf buffer
 * @param size buffer size
452 453
 *
 * @see av_hex_dump_log, av_pkt_dump, av_pkt_dump_log
454
 */
455
void av_hex_dump(FILE *f, uint8_t *buf, int size);
456 457

/**
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
 * Send a nice hexadecimal dump of a buffer to the log.
 *
 * @param avcl A pointer to an arbitrary struct of which the first field is a
 * pointer to an AVClass struct.
 * @param level The importance level of the message, lower values signifying
 * higher importance.
 * @param buf buffer
 * @param size buffer size
 *
 * @see av_hex_dump, av_pkt_dump, av_pkt_dump_log
 */
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size);

/**
 * Send a nice dump of a packet to the specified file stream.
 *
 * @param f The file stream pointer where the dump should be sent to.
475 476 477
 * @param pkt packet to dump
 * @param dump_payload true if the payload must be displayed too
 */
478
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload);
Fabrice Bellard's avatar
Fabrice Bellard committed
479

480 481 482 483 484 485 486 487 488 489 490 491
/**
 * Send a nice dump of a packet to the log.
 *
 * @param avcl A pointer to an arbitrary struct of which the first field is a
 * pointer to an AVClass struct.
 * @param level The importance level of the message, lower values signifying
 * higher importance.
 * @param pkt packet to dump
 * @param dump_payload true if the payload must be displayed too
 */
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload);

Fabrice Bellard's avatar
Fabrice Bellard committed
492
void av_register_all(void);
Fabrice Bellard's avatar
Fabrice Bellard committed
493

494
/** codec tag <-> codec id */
495 496
enum CodecID av_codec_get_id(const struct AVCodecTag **tags, unsigned int tag);
unsigned int av_codec_get_tag(const struct AVCodecTag **tags, enum CodecID id);
497

498
/* media file input */
499 500 501 502

/**
 * finds AVInputFormat based on input format's short name.
 */
503
AVInputFormat *av_find_input_format(const char *short_name);
504 505 506 507 508 509 510

/**
 * Guess file format.
 *
 * @param is_opened whether the file is already opened, determines whether
 *                  demuxers with or without AVFMT_NOFILE are probed
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
511
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened);
512 513 514 515 516

/**
 * Allocates all the structures needed to read an input stream.
 *        This does not open the needed codecs for decoding the stream[s].
 */
517 518
int av_open_input_stream(AVFormatContext **ic_ptr,
                         ByteIOContext *pb, const char *filename,
519
                         AVInputFormat *fmt, AVFormatParameters *ap);
520 521

/**
Ramiro Polla's avatar
Typos  
Ramiro Polla committed
522
 * Open a media file as input. The codecs are not opened. Only the file
523 524 525 526 527 528
 * header (if present) is read.
 *
 * @param ic_ptr the opened media file handle is put here
 * @param filename filename to open.
 * @param fmt if non NULL, force the file format to use
 * @param buf_size optional buffer size (zero if default is OK)
Diego Biurrun's avatar
Diego Biurrun committed
529
 * @param ap additional parameters needed when opening the file (NULL if default)
530 531
 * @return 0 if OK. AVERROR_xxx otherwise.
 */
532
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
533 534 535
                       AVInputFormat *fmt,
                       int buf_size,
                       AVFormatParameters *ap);
536
/** no av_open for output, so applications will need this: */
537
AVFormatContext *av_alloc_format_context(void);
538

539 540 541 542 543 544 545 546 547 548
/**
 * Read packets of a media file to get stream information. This
 * is useful for file formats with no headers such as MPEG. This
 * function also computes the real frame rate in case of mpeg2 repeat
 * frame mode.
 * The logical file position is not changed by this function;
 * examined packets may be buffered for later processing.
 *
 * @param ic media file handle
 * @return >=0 if OK. AVERROR_xxx if error.
Diego Biurrun's avatar
Diego Biurrun committed
549
 * @todo Let user decide somehow what information is needed so we do not waste time geting stuff the user does not need.
550
 */
551
int av_find_stream_info(AVFormatContext *ic);
552 553 554 555

/**
 * Read a transport packet from a media file.
 *
Ramiro Polla's avatar
Typos  
Ramiro Polla committed
556
 * This function is obsolete and should never be used.
557 558 559 560 561 562
 * Use av_read_frame() instead.
 *
 * @param s media file handle
 * @param pkt is filled
 * @return 0 if OK. AVERROR_xxx if error.
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
563
int av_read_packet(AVFormatContext *s, AVPacket *pkt);
564 565 566 567 568 569 570 571 572 573 574 575 576

/**
 * Return the next frame of a stream.
 *
 * The returned packet is valid
 * until the next av_read_frame() or until av_close_input_file() and
 * must be freed with av_free_packet. For video, the packet contains
 * exactly one frame. For audio, it contains an integer number of
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
 * data). If the audio frames have a variable size (e.g. MPEG audio),
 * then it contains one frame.
 *
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
577
 * values in AVStream.timebase units (and guessed if the format cannot
578 579 580 581 582 583
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
 * has B frames, so it is better to rely on pkt->dts if you do not
 * decompress the payload.
 *
 * @return 0 if OK, < 0 if error or end of file.
 */
584
int av_read_frame(AVFormatContext *s, AVPacket *pkt);
585 586 587 588 589 590 591 592 593 594 595 596

/**
 * Seek to the key frame at timestamp.
 * 'timestamp' in 'stream_index'.
 * @param stream_index If stream_index is (-1), a default
 * stream is selected, and timestamp is automatically converted
 * from AV_TIME_BASE units to the stream specific time_base.
 * @param timestamp timestamp in AVStream.time_base units
 *        or if there is no stream specified then in AV_TIME_BASE units
 * @param flags flags which select direction and seeking mode
 * @return >= 0 on success
 */
597
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags);
598 599 600 601 602

/**
 * start playing a network based stream (e.g. RTSP stream) at the
 * current position
 */
603
int av_read_play(AVFormatContext *s);
604 605 606 607 608 609

/**
 * Pause a network based stream (e.g. RTSP stream).
 *
 * Use av_read_play() to resume it.
 */
610
int av_read_pause(AVFormatContext *s);
611 612 613 614 615 616

/**
 * Close a media file (but not its codecs).
 *
 * @param s media file handle
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
617
void av_close_input_file(AVFormatContext *s);
618 619 620 621 622 623 624 625 626 627 628

/**
 * Add a new stream to a media file.
 *
 * Can only be called in the read_header() function. If the flag
 * AVFMTCTX_NOHEADER is in the format context, then new streams
 * can be added in read_packet too.
 *
 * @param s media file handle
 * @param id file format dependent stream id
 */
629
AVStream *av_new_stream(AVFormatContext *s, int id);
630 631 632 633 634 635 636 637 638 639

/**
 * Set the pts for a given stream.
 *
 * @param s stream
 * @param pts_wrap_bits number of bits effectively used by the pts
 *        (used for wrap control, 33 is the value for MPEG)
 * @param pts_num numerator to convert to seconds (MPEG: 1)
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
 */
640
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
Fabrice Bellard's avatar
Fabrice Bellard committed
641
                     int pts_num, int pts_den);
Fabrice Bellard's avatar
Fabrice Bellard committed
642

643 644
#define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
#define AVSEEK_FLAG_BYTE     2 ///< seeking based on position in bytes
645
#define AVSEEK_FLAG_ANY      4 ///< seek to any frame, even non keyframes
646

647
int av_find_default_stream_index(AVFormatContext *s);
648 649 650 651 652 653 654 655 656

/**
 * Gets the index for a specific timestamp.
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
 *                 the timestamp which is <= the requested one, if backward is 0
 *                 then it will be >=
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
 * @return < 0 if no such timestamp could be found
 */
657
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
658 659 660 661 662 663

/**
 * Add a index entry into a sorted list updateing if it is already there.
 *
 * @param timestamp timestamp in the timebase of the given stream
 */
664
int av_add_index_entry(AVStream *st,
Michael Niedermayer's avatar
Michael Niedermayer committed
665
                       int64_t pos, int64_t timestamp, int size, int distance, int flags);
666 667 668

/**
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
Diego Biurrun's avatar
Diego Biurrun committed
669
 * This is not supposed to be called directly by a user application, but by demuxers.
670 671 672
 * @param target_ts target timestamp in the time base of the given stream
 * @param stream_index stream number
 */
673
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags);
674 675 676 677 678

/**
 * Updates cur_dts of all streams based on given timestamp and AVStream.
 *
 * Stream ref_st unchanged, others set cur_dts in their native timebase
Diego Biurrun's avatar
Diego Biurrun committed
679
 * only needed for timestamp wrapping or if (dts not set and pts!=dts).
680 681 682
 * @param timestamp new dts expressed in time_base of param ref_st
 * @param ref_st reference stream giving time_base of param timestamp
 */
683
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
684 685 686

/**
 * Does a binary search using read_timestamp().
Diego Biurrun's avatar
Diego Biurrun committed
687
 * This is not supposed to be called directly by a user application, but by demuxers.
688 689 690
 * @param target_ts target timestamp in the time base of the given stream
 * @param stream_index stream number
 */
691
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 ));
692

693
/** media file output */
694
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap);
695 696

/**
Diego Biurrun's avatar
Diego Biurrun committed
697 698
 * Allocate the stream private data and write the stream header to an
 * output media file.
699 700 701 702
 *
 * @param s media file handle
 * @return 0 if OK. AVERROR_xxx if error.
 */
703
int av_write_header(AVFormatContext *s);
704 705 706 707 708 709 710 711 712 713 714 715

/**
 * Write a packet to an output media file.
 *
 * The packet shall contain one audio or video frame.
 * The packet must be correctly interleaved according to the container specification,
 * if not then av_interleaved_write_frame must be used
 *
 * @param s media file handle
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
 */
716
int av_write_frame(AVFormatContext *s, AVPacket *pkt);
717 718 719 720 721 722

/**
 * Writes a packet to an output media file ensuring correct interleaving.
 *
 * The packet must contain one audio or video frame.
 * If the packets are already correctly interleaved the application should
Diego Biurrun's avatar
Diego Biurrun committed
723 724 725 726
 * call av_write_frame() instead as it is slightly faster. It is also important
 * to keep in mind that completely non-interleaved input will need huge amounts
 * of memory to interleave with this, so it is preferable to interleave at the
 * demuxer level.
727 728 729 730 731
 *
 * @param s media file handle
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
 */
732
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747

/**
 * Interleave a packet per DTS in an output media file.
 *
 * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
 * so they cannot be used after it, note calling av_free_packet() on them is still safe.
 *
 * @param s media file handle
 * @param out the interleaved packet will be output here
 * @param in the input packet
 * @param flush 1 if no further packets are available as input and all
 *              remaining packets should be output
 * @return 1 if a packet was output, 0 if no packet could be output,
 *         < 0 if an error occured
 */
748
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush);
749

750 751 752 753 754 755 756
/**
 * @brief Write the stream trailer to an output media file and
 *        free the file private data.
 *
 * @param s media file handle
 * @return 0 if OK. AVERROR_xxx if error.
 */
757
int av_write_trailer(AVFormatContext *s);
Fabrice Bellard's avatar
Fabrice Bellard committed
758 759

void dump_format(AVFormatContext *ic,
760
                 int index,
Fabrice Bellard's avatar
Fabrice Bellard committed
761 762
                 const char *url,
                 int is_output);
763 764 765

/**
 * parses width and height out of string str.
766
 * @deprecated Use av_parse_video_frame_size instead.
767
 */
768
attribute_deprecated int parse_image_size(int *width_ptr, int *height_ptr, const char *str);
769 770 771

/**
 * Converts frame rate from string to a fraction.
772
 * @deprecated Use av_parse_video_frame_rate instead.
773
 */
774
attribute_deprecated int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg);
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790

/**
 * Converts date string to number of seconds since Jan 1st, 1970.
 *
 * @code
 * Syntax:
 * - If not a duration:
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
 * Time is localtime unless Z is suffixed to the end. In this case GMT
 * Return the date in micro seconds since 1970
 *
 * - If a duration:
 *  HH[:MM[:SS[.m...]]]
 *  S+[.m...]
 * @endcode
 */
791
int64_t parse_date(const char *datestr, int duration);
Fabrice Bellard's avatar
Fabrice Bellard committed
792

793
int64_t av_gettime(void);
Fabrice Bellard's avatar
Fabrice Bellard committed
794

Fabrice Bellard's avatar
Fabrice Bellard committed
795 796 797 798 799 800
/* ffm specific for ffserver */
#define FFM_PACKET_SIZE 4096
offset_t ffm_read_write_index(int fd);
void ffm_write_write_index(int fd, offset_t pos);
void ffm_set_write_index(AVFormatContext *s, offset_t pos, offset_t file_size);

801 802 803 804 805 806
/**
 * Attempts to find a specific tag in a URL.
 *
 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
 * Return 1 if found.
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
807 808
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info);

809 810 811 812 813 814 815 816 817 818 819 820
/**
 * Returns in 'buf' the path with '%d' replaced by number.

 * Also handles the '%0nd' format where 'n' is the total number
 * of digits and '%%'.
 *
 * @param buf destination buffer
 * @param buf_size destination buffer size
 * @param path numbered sequence string
 * @number frame number
 * @return 0 if OK, -1 if format error.
 */
821 822
int av_get_frame_filename(char *buf, int buf_size,
                          const char *path, int number);
823 824 825 826 827 828 829

/**
 * Check whether filename actually is a numbered sequence generator.
 *
 * @param filename possible numbered sequence string
 * @return 1 if a valid numbered sequence string, 0 otherwise.
 */
830
int av_filename_number_test(const char *filename);
831

832 833 834
/* grab specific */
int video_grab_init(void);
int audio_init(void);
835

Fabrice Bellard's avatar
Fabrice Bellard committed
836 837
/* DV1394 */
int dv1394_init(void);
838
int dc1394_init(void);
Fabrice Bellard's avatar
Fabrice Bellard committed
839 840

#ifdef HAVE_AV_CONFIG_H
841 842 843

#include "os_support.h"

Fabrice Bellard's avatar
Fabrice Bellard committed
844 845 846 847 848
int strstart(const char *str, const char *val, const char **ptr);
int stristart(const char *str, const char *val, const char **ptr);
void pstrcpy(char *buf, int buf_size, const char *str);
char *pstrcat(char *buf, int buf_size, const char *s);

Fabrice Bellard's avatar
Fabrice Bellard committed
849 850
void __dynarray_add(unsigned long **tab_ptr, int *nb_ptr, unsigned long elem);

Falk Hüffner's avatar
Falk Hüffner committed
851
#ifdef __GNUC__