avformat.h@ 7789

Last change on this file since 7789 was 5776, checked in by vboxsync, 17 years ago
ffmpeg: exported to OSE
File size: 20.0 KB

Line
1	#ifndef AVFORMAT_H
2	#define AVFORMAT_H
3
4	#ifdef __cplusplus
5	extern "C" {
6	#endif
7
8	#define LIBAVFORMAT_VERSION_INT ((50<<16)+(4<<8)+0)
9	#define LIBAVFORMAT_VERSION 50.4.0
10	#define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT
11
12	#define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
13
14	#include <time.h>
15	#include <stdio.h> /* FILE */
16	#include "avcodec.h"
17
18	#include "avio.h"
19
20	/* packet functions */
21
22	#ifndef MAXINT64
23	#define MAXINT64 int64_t_C(0x7fffffffffffffff)
24	#endif
25
26	#ifndef MININT64
27	#define MININT64 int64_t_C(0x8000000000000000)
28	#endif
29
30	typedef struct AVPacket {
31	int64_t pts; ///< presentation time stamp in time_base units
32	int64_t dts; ///< decompression time stamp in time_base units
33	uint8_t *data;
34	int size;
35	int stream_index;
36	int flags;
37	int duration; ///< presentation duration in time_base units (0 if not available)
38	void (destruct)(struct AVPacket );
39	void *priv;
40	int64_t pos; ///< byte position in stream, -1 if unknown
41	} AVPacket;
42	#define PKT_FLAG_KEY 0x0001
43
44	void av_destruct_packet_nofree(AVPacket *pkt);
45	void av_destruct_packet(AVPacket *pkt);
46
47	/* initialize optional fields of a packet */
48	static inline void av_init_packet(AVPacket *pkt)
49	{
50	pkt->pts = AV_NOPTS_VALUE;
51	pkt->dts = AV_NOPTS_VALUE;
52	pkt->pos = -1;
53	pkt->duration = 0;
54	pkt->flags = 0;
55	pkt->stream_index = 0;
56	pkt->destruct= av_destruct_packet_nofree;
57	}
58
59	int av_new_packet(AVPacket *pkt, int size);
60	int av_get_packet(ByteIOContext s, AVPacket pkt, int size);
61	int av_dup_packet(AVPacket *pkt);
62
63	/**
64	* Free a packet
65	*
66	* @param pkt packet to free
67	*/
68	static inline void av_free_packet(AVPacket *pkt)
69	{
70	if (pkt && pkt->destruct) {
71	pkt->destruct(pkt);
72	}
73	}
74
75	/*************************************************/
76	/* fractional numbers for exact pts handling */
77
78	/* the exact value of the fractional number is: 'val + num / den'. num
79	is assumed to be such as 0 <= num < den */
80	typedef struct AVFrac {
81	int64_t val, num, den;
82	} AVFrac;
83
84	/*************************************************/
85	/* input/output formats */
86
87	struct AVFormatContext;
88
89	/* this structure contains the data a format has to probe a file */
90	typedef struct AVProbeData {
91	const char *filename;
92	unsigned char *buf;
93	int buf_size;
94	} AVProbeData;
95
96	#define AVPROBE_SCORE_MAX 100
97
98	typedef struct AVFormatParameters {
99	AVRational time_base;
100	int sample_rate;
101	int channels;
102	int width;
103	int height;
104	enum PixelFormat pix_fmt;
105	struct AVImageFormat *image_format;
106	int channel; /* used to select dv channel */
107	const char device; / video, audio or DV device */
108	const char standard; / tv standard, NTSC, PAL, SECAM */
109	int mpeg2ts_raw:1; /* force raw MPEG2 transport stream output, if possible */
110	int mpeg2ts_compute_pcr:1; /* compute exact PCR for each transport
111	stream packet (only meaningful if
112	mpeg2ts_raw is TRUE */
113	int initial_pause:1; /* do not begin to play the stream
114	immediately (RTSP only) */
115	enum CodecID video_codec_id;
116	enum CodecID audio_codec_id;
117	} AVFormatParameters;
118
119	#define AVFMT_NOFILE 0x0001 /* no file should be opened */
120	#define AVFMT_NEEDNUMBER 0x0002 /* needs '%d' in filename */
121	#define AVFMT_SHOW_IDS 0x0008 /* show format stream IDs numbers */
122	#define AVFMT_RAWPICTURE 0x0020 /* format wants AVPicture structure for
123	raw picture data */
124	#define AVFMT_GLOBALHEADER 0x0040 /* format wants global header */
125
126	typedef struct AVOutputFormat {
127	const char *name;
128	const char *long_name;
129	const char *mime_type;
130	const char extensions; / comma separated extensions */
131	/* size of private data so that it can be allocated in the wrapper */
132	int priv_data_size;
133	/* output support */
134	enum CodecID audio_codec; /* default audio codec */
135	enum CodecID video_codec; /* default video codec */
136	int (write_header)(struct AVFormatContext );
137	int (write_packet)(struct AVFormatContext , AVPacket *pkt);
138	int (write_trailer)(struct AVFormatContext );
139	/* can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER */
140	int flags;
141	/* currently only used to set pixel format if not YUV420P */
142	int (set_parameters)(struct AVFormatContext , AVFormatParameters *);
143	int (interleave_packet)(struct AVFormatContext , AVPacket out, AVPacket in, int flush);
144	/* private fields */
145	struct AVOutputFormat *next;
146	} AVOutputFormat;
147
148	typedef struct AVInputFormat {
149	const char *name;
150	const char *long_name;
151	/* size of private data so that it can be allocated in the wrapper */
152	int priv_data_size;
153	/* tell if a given file has a chance of being parsing by this format */
154	int (read_probe)(AVProbeData );
155	/* read the format header and initialize the AVFormatContext
156	structure. Return 0 if OK. 'ap' if non NULL contains
157	additionnal paramters. Only used in raw format right
158	now. 'av_new_stream' should be called to create new streams. */
159	int (read_header)(struct AVFormatContext ,
160	AVFormatParameters *ap);
161	/* read one packet and put it in 'pkt'. pts and flags are also
162	set. 'av_new_stream' can be called only if the flag
163	AVFMTCTX_NOHEADER is used. */
164	int (read_packet)(struct AVFormatContext , AVPacket *pkt);
165	/* close the stream. The AVFormatContext and AVStreams are not
166	freed by this function */
167	int (read_close)(struct AVFormatContext );
168	/**
169	* seek to a given timestamp relative to the frames in
170	* stream component stream_index
171	* @param stream_index must not be -1
172	* @param flags selects which direction should be preferred if no exact
173	* match is available
174	*/
175	int (read_seek)(struct AVFormatContext ,
176	int stream_index, int64_t timestamp, int flags);
177	/**
178	* gets the next timestamp in AV_TIME_BASE units.
179	*/
180	int64_t (read_timestamp)(struct AVFormatContext s, int stream_index,
181	int64_t *pos, int64_t pos_limit);
182	/* can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER */
183	int flags;
184	/* if extensions are defined, then no probe is done. You should
185	usually not use extension format guessing because it is not
186	reliable enough */
187	const char *extensions;
188	/* general purpose read only value that the format can use */
189	int value;
190
191	/* start/resume playing - only meaningful if using a network based format
192	(RTSP) */
193	int (read_play)(struct AVFormatContext );
194
195	/* pause playing - only meaningful if using a network based format
196	(RTSP) */
197	int (read_pause)(struct AVFormatContext );
198
199	/* private fields */
200	struct AVInputFormat *next;
201	} AVInputFormat;
202
203	typedef struct AVIndexEntry {
204	int64_t pos;
205	int64_t timestamp;
206	#define AVINDEX_KEYFRAME 0x0001
207	int flags:2;
208	int size:30; //yeah trying to keep the size of this small to reduce memory requirements (its 24 vs 32 byte due to possible 8byte align)
209	int min_distance; /* min distance between this and the previous keyframe, used to avoid unneeded searching */
210	} AVIndexEntry;
211
212	typedef struct AVStream {
213	int index; /* stream index in AVFormatContext */
214	int id; /* format specific stream id */
215	AVCodecContext codec; / codec context */
216	/**
217	* real base frame rate of the stream.
218	* for example if the timebase is 1/90000 and all frames have either
219	* approximately 3600 or 1800 timer ticks then r_frame_rate will be 50/1
220	*/
221	AVRational r_frame_rate;
222	void *priv_data;
223	/* internal data used in av_find_stream_info() */
224	int64_t codec_info_duration;
225	int codec_info_nb_frames;
226	/* encoding: PTS generation when outputing stream */
227	AVFrac pts;
228
229	/**
230	* this is the fundamental unit of time (in seconds) in terms
231	* of which frame timestamps are represented. for fixed-fps content,
232	* timebase should be 1/framerate and timestamp increments should be
233	* identically 1.
234	*/
235	AVRational time_base;
236	int pts_wrap_bits; /* number of bits in pts (used for wrapping control) */
237	/* ffmpeg.c private use */
238	int stream_copy; /* if TRUE, just copy stream */
239	enum AVDiscard discard; ///< selects which packets can be discarded at will and dont need to be demuxed
240	//FIXME move stuff to a flags field?
241	/* quality, as it has been removed from AVCodecContext and put in AVVideoFrame
242	* MN:dunno if thats the right place, for it */
243	float quality;
244	/* decoding: position of the first frame of the component, in
245	AV_TIME_BASE fractional seconds. */
246	int64_t start_time;
247	/* decoding: duration of the stream, in AV_TIME_BASE fractional
248	seconds. */
249	int64_t duration;
250
251	char language[4]; /* ISO 639 3-letter language code (empty string if undefined) */
252
253	/* av_read_frame() support */
254	int need_parsing; ///< 1->full parsing needed, 2->only parse headers dont repack
255	struct AVCodecParserContext *parser;
256
257	int64_t cur_dts;
258	int last_IP_duration;
259	int64_t last_IP_pts;
260	/* av_seek_frame() support */
261	AVIndexEntry index_entries; / only used if the format does not
262	support seeking natively */
263	int nb_index_entries;
264	int index_entries_allocated_size;
265
266	int64_t nb_frames; ///< number of frames in this stream if known or 0
267	} AVStream;
268
269	#define AVFMTCTX_NOHEADER 0x0001 /* signal that no header is present
270	(streams are added dynamically) */
271
272	#define MAX_STREAMS 20
273
274	/* format I/O context */
275	typedef struct AVFormatContext {
276	const AVClass av_class; / set by av_alloc_format_context */
277	/* can only be iformat or oformat, not both at the same time */
278	struct AVInputFormat *iformat;
279	struct AVOutputFormat *oformat;
280	void *priv_data;
281	ByteIOContext pb;
282	int nb_streams;
283	AVStream *streams[MAX_STREAMS];
284	char filename[1024]; /* input or output filename */
285	/* stream info */
286	int64_t timestamp;
287	char title[512];
288	char author[512];
289	char copyright[512];
290	char comment[512];
291	char album[512];
292	int year; /* ID3 year, 0 if none */
293	int track; /* track number, 0 if none */
294	char genre[32]; /* ID3 genre */
295
296	int ctx_flags; /* format specific flags, see AVFMTCTX_xx */
297	/* private data for pts handling (do not modify directly) */
298	/* This buffer is only needed when packets were already buffered but
299	not decoded, for example to get the codec parameters in mpeg
300	streams */
301	struct AVPacketList *packet_buffer;
302
303	/* decoding: position of the first frame of the component, in
304	AV_TIME_BASE fractional seconds. NEVER set this value directly:
305	it is deduced from the AVStream values. */
306	int64_t start_time;
307	/* decoding: duration of the stream, in AV_TIME_BASE fractional
308	seconds. NEVER set this value directly: it is deduced from the
309	AVStream values. */
310	int64_t duration;
311	/* decoding: total file size. 0 if unknown */
312	int64_t file_size;
313	/* decoding: total stream bitrate in bit/s, 0 if not
314	available. Never set it directly if the file_size and the
315	duration are known as ffmpeg can compute it automatically. */
316	int bit_rate;
317
318	/* av_read_frame() support */
319	AVStream *cur_st;
320	const uint8_t *cur_ptr;
321	int cur_len;
322	AVPacket cur_pkt;
323
324	/* av_seek_frame() support */
325	int64_t data_offset; /* offset of the first packet */
326	int index_built;
327
328	int mux_rate;
329	int packet_size;
330	int preload;
331	int max_delay;
332
333	#define AVFMT_NOOUTPUTLOOP -1
334	#define AVFMT_INFINITEOUTPUTLOOP 0
335	/* number of times to loop output in formats that support it */
336	int loop_output;
337
338	int flags;
339	#define AVFMT_FLAG_GENPTS 0x0001 ///< generate pts if missing even if it requires parsing future frames
340	} AVFormatContext;
341
342	typedef struct AVPacketList {
343	AVPacket pkt;
344	struct AVPacketList *next;
345	} AVPacketList;
346
347	extern AVInputFormat *first_iformat;
348	extern AVOutputFormat *first_oformat;
349
350	/* still image support */
351	struct AVInputImageContext;
352	typedef struct AVInputImageContext AVInputImageContext;
353
354	typedef struct AVImageInfo {
355	enum PixelFormat pix_fmt; /* requested pixel format */
356	int width; /* requested width */
357	int height; /* requested height */
358	int interleaved; /* image is interleaved (e.g. interleaved GIF) */
359	AVPicture pict; /* returned allocated image */
360	} AVImageInfo;
361
362	/* AVImageFormat.flags field constants */
363	#define AVIMAGE_INTERLEAVED 0x0001 /* image format support interleaved output */
364
365	typedef struct AVImageFormat {
366	const char *name;
367	const char *extensions;
368	/* tell if a given file has a chance of being parsing by this format */
369	int (img_probe)(AVProbeData );
370	/* read a whole image. 'alloc_cb' is called when the image size is
371	known so that the caller can allocate the image. If 'allo_cb'
372	returns non zero, then the parsing is aborted. Return '0' if
373	OK. */
374	int (img_read)(ByteIOContext ,
375	int (alloc_cb)(void , AVImageInfo info), void );
376	/* write the image */
377	int supported_pixel_formats; /* mask of supported formats for output */
378	int (img_write)(ByteIOContext , AVImageInfo *);
379	int flags;
380	struct AVImageFormat *next;
381	} AVImageFormat;
382
383	void av_register_image_format(AVImageFormat *img_fmt);
384	AVImageFormat av_probe_image_format(AVProbeData pd);
385	AVImageFormat guess_image_format(const char filename);
386	enum CodecID av_guess_image2_codec(const char *filename);
387	int av_read_image(ByteIOContext pb, const char filename,
388	AVImageFormat *fmt,
389	int (alloc_cb)(void , AVImageInfo info), void opaque);
390	int av_write_image(ByteIOContext pb, AVImageFormat fmt, AVImageInfo *img);
391
392	extern AVImageFormat *first_image_format;
393
394	/* XXX: use automatic init with either ELF sections or C file parser */
395	/* modules */
396
397	#include "rtp.h"
398
399	#include "rtsp.h"
400
401	/* yuv4mpeg.c */
402	extern AVOutputFormat yuv4mpegpipe_muxer;
403
404	/* utils.c */
405	void av_register_input_format(AVInputFormat *format);
406	void av_register_output_format(AVOutputFormat *format);
407	AVOutputFormat guess_stream_format(const char short_name,
408	const char filename, const char mime_type);
409	AVOutputFormat guess_format(const char short_name,
410	const char filename, const char mime_type);
411	enum CodecID av_guess_codec(AVOutputFormat fmt, const char short_name,
412	const char filename, const char mime_type, enum CodecType type);
413
414	void av_hex_dump(FILE f, uint8_t buf, int size);
415	void av_pkt_dump(FILE f, AVPacket pkt, int dump_payload);
416
417	void av_register_all(void);
418
419	typedef struct FifoBuffer {
420	uint8_t *buffer;
421	uint8_t rptr, wptr, *end;
422	} FifoBuffer;
423
424	int fifo_init(FifoBuffer *f, int size);
425	void fifo_free(FifoBuffer *f);
426	int fifo_size(FifoBuffer f, uint8_t rptr);
427	int fifo_read(FifoBuffer f, uint8_t buf, int buf_size, uint8_t **rptr_ptr);
428	void fifo_write(FifoBuffer f, const uint8_t buf, int size, uint8_t **wptr_ptr);
429	int put_fifo(ByteIOContext pb, FifoBuffer f, int buf_size, uint8_t **rptr_ptr);
430	void fifo_realloc(FifoBuffer *f, unsigned int size);
431
432	/* media file input */
433	AVInputFormat av_find_input_format(const char short_name);
434	AVInputFormat av_probe_input_format(AVProbeData pd, int is_opened);
435	int av_open_input_stream(AVFormatContext **ic_ptr,
436	ByteIOContext pb, const char filename,
437	AVInputFormat fmt, AVFormatParameters ap);
438	int av_open_input_file(AVFormatContext *ic_ptr, const char filename,
439	AVInputFormat *fmt,
440	int buf_size,
441	AVFormatParameters *ap);
442	/* no av_open for output, so applications will need this: */
443	AVFormatContext *av_alloc_format_context(void);
444
445	#define AVERROR_UNKNOWN (-1) /* unknown error */
446	#define AVERROR_IO (-2) /* i/o error */
447	#define AVERROR_NUMEXPECTED (-3) /* number syntax expected in filename */
448	#define AVERROR_INVALIDDATA (-4) /* invalid data found */
449	#define AVERROR_NOMEM (-5) /* not enough memory */
450	#define AVERROR_NOFMT (-6) /* unknown format */
451	#define AVERROR_NOTSUPP (-7) /* operation not supported */
452
453	int av_find_stream_info(AVFormatContext *ic);
454	int av_read_packet(AVFormatContext s, AVPacket pkt);
455	int av_read_frame(AVFormatContext s, AVPacket pkt);
456	int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags);
457	int av_read_play(AVFormatContext *s);
458	int av_read_pause(AVFormatContext *s);
459	void av_close_input_file(AVFormatContext *s);
460	AVStream av_new_stream(AVFormatContext s, int id);
461	void av_set_pts_info(AVStream *s, int pts_wrap_bits,
462	int pts_num, int pts_den);
463
464	#define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
465	#define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes
466	#define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non keyframes
467
468	int av_find_default_stream_index(AVFormatContext *s);
469	int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
470	int av_add_index_entry(AVStream *st,
471	int64_t pos, int64_t timestamp, int size, int distance, int flags);
472	int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags);
473
474	/* media file output */
475	int av_set_parameters(AVFormatContext s, AVFormatParameters ap);
476	int av_write_header(AVFormatContext *s);
477	int av_write_frame(AVFormatContext s, AVPacket pkt);
478	int av_interleaved_write_frame(AVFormatContext s, AVPacket pkt);
479
480	int av_write_trailer(AVFormatContext *s);
481
482	void dump_format(AVFormatContext *ic,
483	int index,
484	const char *url,
485	int is_output);
486	int parse_image_size(int width_ptr, int height_ptr, const char *str);
487	int parse_frame_rate(int frame_rate, int frame_rate_base, const char *arg);
488	int64_t parse_date(const char *datestr, int duration);
489
490	int64_t av_gettime(void);
491
492	/* ffm specific for ffserver */
493	#define FFM_PACKET_SIZE 4096
494	offset_t ffm_read_write_index(int fd);
495	void ffm_write_write_index(int fd, offset_t pos);
496	void ffm_set_write_index(AVFormatContext *s, offset_t pos, offset_t file_size);
497
498	int find_info_tag(char arg, int arg_size, const char tag1, const char *info);
499
500	int get_frame_filename(char *buf, int buf_size,
501	const char *path, int number);
502	int filename_number_test(const char *filename);
503
504	/* grab specific */
505	int video_grab_init(void);
506	int audio_init(void);
507
508	/* DV1394 */
509	int dv1394_init(void);
510	int dc1394_init(void);
511
512	#ifdef HAVE_AV_CONFIG_H
513
514	#include "os_support.h"
515
516	int strstart(const char str, const char val, const char **ptr);
517	int stristart(const char str, const char val, const char **ptr);
518	void pstrcpy(char buf, int buf_size, const char str);
519	char pstrcat(char buf, int buf_size, const char *s);
520
521	void __dynarray_add(unsigned long *tab_ptr, int nb_ptr, unsigned long elem);
522
523	#ifdef __GNUC__
524	#define dynarray_add(tab, nb_ptr, elem)\
525	do {\
526	typeof(tab) _tab = (tab);\
527	typeof(elem) _elem = (elem);\
528	(void)sizeof(*_tab == _elem); / check that types are compatible */\
529	__dynarray_add((unsigned long **)_tab, nb_ptr, (unsigned long)_elem);\
530	} while(0)
531	#else
532	#define dynarray_add(tab, nb_ptr, elem)\
533	do {\
534	__dynarray_add((unsigned long **)(tab), nb_ptr, (unsigned long)(elem));\
535	} while(0)
536	#endif
537
538	time_t mktimegm(struct tm *tm);
539	struct tm brktimegm(time_t secs, struct tm tm);
540	const char small_strptime(const char p, const char *fmt,
541	struct tm *dt);
542
543	struct in_addr;
544	int resolve_host(struct in_addr sin_addr, const char hostname);
545
546	void url_split(char *proto, int proto_size,
547	char *authorization, int authorization_size,
548	char *hostname, int hostname_size,
549	int *port_ptr,
550	char *path, int path_size,
551	const char *url);
552
553	int match_ext(const char filename, const char extensions);
554
555	#endif /* HAVE_AV_CONFIG_H */
556
557	#ifdef __cplusplus
558	}
559	#endif
560
561	#endif /* AVFORMAT_H */
562

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/ffmpeg-20060710/libavformat/avformat.h@ 7789

Download in other formats: