2006-09-10 17:02:42 +03:00
/*
* copyright ( c ) 2001 Fabrice Bellard
*
2006-10-07 18:30:46 +03:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2006-09-10 17:02:42 +03:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 18:30:46 +03:00
* version 2.1 of the License , or ( at your option ) any later version .
2006-09-10 17:02:42 +03:00
*
2006-10-07 18:30:46 +03:00
* FFmpeg is distributed in the hope that it will be useful ,
2006-09-10 17:02:42 +03:00
* 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
2006-10-07 18:30:46 +03:00
* License along with FFmpeg ; if not , write to the Free Software
2006-09-10 17:02:42 +03:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
2008-08-31 10:39:47 +03:00
# ifndef AVFORMAT_AVFORMAT_H
# define AVFORMAT_AVFORMAT_H
2001-07-22 17:18:56 +03:00
2011-12-10 22:16:57 +03:00
/**
* @ file
* @ ingroup libavf
* Main libavformat public API header
*/
2011-11-22 19:11:28 +03:00
/**
* @ defgroup libavf I / O and Muxing / Demuxing Library
* @ {
*
2011-12-11 11:05:11 +03:00
* Libavformat ( lavf ) is a library for dealing with various media container
* formats . Its main two purposes are demuxing - i . e . splitting a media file
* into component streams , and the reverse process of muxing - writing supplied
* data in a specified container format . It also has an @ ref lavf_io
* " I/O module " which supports a number of protocols for accessing the data ( e . g .
* file , tcp , http and others ) . Before using lavf , you need to call
* av_register_all ( ) to register all compiled muxers , demuxers and protocols .
* Unless you are absolutely sure you won ' t use libavformat ' s network
* capabilities , you should also call avformat_network_init ( ) .
*
* A supported input format is described by an AVInputFormat struct , conversely
* an output format is described by AVOutputFormat . You can iterate over all
* registered input / output formats using the av_iformat_next ( ) /
* av_oformat_next ( ) functions . The protocols layer is not part of the public
* API , so you can only get the names of supported protocols with the
* avio_enum_protocols ( ) function .
*
* Main lavf structure used for both muxing and demuxing is AVFormatContext ,
* which exports all information about the file being read or written . As with
2012-02-01 06:41:07 +03:00
* most Libavformat structures , its size is not part of public ABI , so it cannot be
2011-12-11 11:05:11 +03:00
* allocated on stack or directly with av_malloc ( ) . To create an
* AVFormatContext , use avformat_alloc_context ( ) ( some functions , like
* avformat_open_input ( ) might do that for you ) .
*
* Most importantly an AVFormatContext contains :
* @ li the @ ref AVFormatContext . iformat " input " or @ ref AVFormatContext . oformat
* " output " format . It is either autodetected or set by user for input ;
* always set by user for output .
* @ li an @ ref AVFormatContext . streams " array " of AVStreams , which describe all
* elementary streams stored in the file . AVStreams are typically referred to
* using their index in this array .
* @ li an @ ref AVFormatContext . pb " I/O context " . It is either opened by lavf or
* set by user for input , always set by user for output ( unless you are dealing
* with an AVFMT_NOFILE format ) .
*
2012-01-03 10:34:55 +03:00
* @ section lavf_options Passing options to ( de ) muxers
* Lavf allows to configure muxers and demuxers using the @ ref avoptions
* mechanism . Generic ( format - independent ) libavformat options are provided by
* AVFormatContext , they can be examined from a user program by calling
* av_opt_next ( ) / av_opt_find ( ) on an allocated AVFormatContext ( or its AVClass
* from avformat_get_class ( ) ) . Private ( format - specific ) options are provided by
* AVFormatContext . priv_data if and only if AVInputFormat . priv_class /
* AVOutputFormat . priv_class of the corresponding format struct is non - NULL .
* Further options may be provided by the @ ref AVFormatContext . pb " I/O context " ,
* if its AVClass is non - NULL , and the protocols layer . See the discussion on
* nesting in @ ref avoptions documentation to learn how to access those .
*
2011-11-22 19:11:28 +03:00
* @ defgroup lavf_decoding Demuxing
* @ {
2011-12-11 11:51:19 +03:00
* Demuxers read a media file and split it into chunks of data ( @ em packets ) . A
2012-01-03 09:41:14 +03:00
* @ ref AVPacket " packet " contains one or more encoded frames which belongs to a
* single elementary stream . In the lavf API this process is represented by the
2011-12-11 11:51:19 +03:00
* avformat_open_input ( ) function for opening a file , av_read_frame ( ) for
* reading a single packet and finally avformat_close_input ( ) , which does the
* cleanup .
*
* @ section lavf_decoding_open Opening a media file
* The minimum information required to open a file is its URL or filename , which
* is passed to avformat_open_input ( ) , as in the following code :
* @ code
* const char * url = " in.mp3 " ;
* AVFormatContext * s = NULL ;
* int ret = avformat_open_input ( & s , url , NULL , NULL ) ;
* if ( ret < 0 )
* abort ( ) ;
* @ endcode
* The above code attempts to allocate an AVFormatContext , open the
* specified file ( autodetecting the format ) and read the header , exporting the
* information stored there into s . Some formats do not have a header or do not
* store enough information there , so it is recommended that you call the
* avformat_find_stream_info ( ) function which tries to read and decode a few
* frames to find missing information .
*
* In some cases you might want to preallocate an AVFormatContext yourself with
* avformat_alloc_context ( ) and do some tweaking on it before passing it to
* avformat_open_input ( ) . One such case is when you want to use custom functions
* for reading input data instead of lavf internal I / O layer .
* To do that , create your own AVIOContext with avio_alloc_context ( ) , passing
* your reading callbacks to it . Then set the @ em pb field of your
* AVFormatContext to newly created AVIOContext .
*
2012-01-03 10:34:55 +03:00
* Since the format of the opened file is in general not known until after
* avformat_open_input ( ) has returned , it is not possible to set demuxer private
* options on a preallocated context . Instead , the options should be passed to
* avformat_open_input ( ) wrapped in an AVDictionary :
* @ code
* AVDictionary * options = NULL ;
* av_dict_set ( & options , " video_size " , " 640x480 " , 0 ) ;
* av_dict_set ( & options , " pixel_format " , " rgb24 " , 0 ) ;
*
* if ( avformat_open_input ( & s , url , NULL , & options ) < 0 )
* abort ( ) ;
* av_dict_free ( & options ) ;
* @ endcode
* This code passes the private options ' video_size ' and ' pixel_format ' to the
* demuxer . They would be necessary for e . g . the rawvideo demuxer , since it
* cannot know how to interpret raw video data otherwise . If the format turns
* out to be something different than raw video , those options will not be
* recognized by the demuxer and therefore will not be applied . Such unrecognized
* options are then returned in the options dictionary ( recognized options are
* consumed ) . The calling program can handle such unrecognized options as it
* wishes , e . g .
* @ code
* AVDictionaryEntry * e ;
* if ( e = av_dict_get ( options , " " , NULL , AV_DICT_IGNORE_SUFFIX ) ) {
* fprintf ( stderr , " Option %s not recognized by the demuxer. \n " , e - > key ) ;
* abort ( ) ;
* }
* @ endcode
*
2011-12-11 11:51:19 +03:00
* After you have finished reading the file , you must close it with
* avformat_close_input ( ) . It will free everything associated with the file .
*
* @ section lavf_decoding_read Reading from an opened file
2012-02-27 11:35:17 +03:00
* Reading data from an opened AVFormatContext is done by repeatedly calling
* av_read_frame ( ) on it . Each call , if successful , will return an AVPacket
* containing encoded data for one AVStream , identified by
* AVPacket . stream_index . This packet may be passed straight into the libavcodec
* decoding functions avcodec_decode_video2 ( ) , avcodec_decode_audio4 ( ) or
* avcodec_decode_subtitle2 ( ) if the caller wishes to decode the data .
*
* AVPacket . pts , AVPacket . dts and AVPacket . duration timing information will be
* set if known . They may also be unset ( i . e . AV_NOPTS_VALUE for
* pts / dts , 0 for duration ) if the stream does not provide them . The timing
* information will be in AVStream . time_base units , i . e . it has to be
* multiplied by the timebase to convert them to seconds .
*
2012-10-31 10:53:18 +03:00
* If AVPacket . buf is set on the returned packet , then the packet is
2012-10-31 21:59:53 +03:00
* allocated dynamically and the user may keep it indefinitely .
2012-10-31 10:53:18 +03:00
* Otherwise , if AVPacket . buf is NULL , the packet data is backed by a
2012-10-31 21:59:53 +03:00
* static storage somewhere inside the demuxer and the packet is only valid
* until the next av_read_frame ( ) call or closing the file . If the caller
* requires a longer lifetime , av_dup_packet ( ) will make an av_malloc ( ) ed copy
* of it .
* In both cases , the packet must be freed with av_free_packet ( ) when it is no
* longer needed .
2011-12-11 11:51:19 +03:00
*
* @ section lavf_decoding_seek Seeking
2011-11-22 19:11:28 +03:00
* @ }
*
* @ defgroup lavf_encoding Muxing
* @ {
* @ }
*
2011-12-10 22:09:04 +03:00
* @ defgroup lavf_io I / O Read / Write
2011-11-22 19:11:28 +03:00
* @ {
* @ }
*
* @ defgroup lavf_codec Demuxers
* @ {
* @ defgroup lavf_codec_native Native Demuxers
* @ {
* @ }
* @ defgroup lavf_codec_wrappers External library wrappers
* @ {
* @ }
* @ }
* @ defgroup lavf_protos I / O Protocols
* @ {
* @ }
* @ defgroup lavf_internal Internal
* @ {
* @ }
* @ }
*
*/
2010-08-17 22:30:21 +03:00
2003-09-09 00:20:55 +03:00
# include <time.h>
2003-11-14 00:15:11 +02:00
# include <stdio.h> /* FILE */
2008-02-25 11:22:11 +02:00
# include "libavcodec/avcodec.h"
2011-05-22 13:45:00 +03:00
# include "libavutil/dict.h"
2011-06-04 15:34:27 +03:00
# include "libavutil/log.h"
2001-07-22 17:18:56 +03:00
# include "avio.h"
2011-01-21 21:18:06 +02:00
# include "libavformat/version.h"
2001-07-22 17:18:56 +03:00
2009-03-01 01:34:16 +02:00
struct AVFormatContext ;
2009-01-04 20:58:49 +02:00
2011-07-01 21:49:14 +03:00
/**
* @ defgroup metadata_api Public Metadata API
* @ {
2011-12-10 22:06:49 +03:00
* @ ingroup libavf
2009-01-04 22:47:09 +02:00
* The metadata API allows libavformat to export metadata tags to a client
2011-12-10 22:39:39 +03:00
* application when demuxing . Conversely it allows a client application to
* set metadata when muxing .
*
* Metadata is exported or set as pairs of key / value strings in the ' metadata '
* fields of the AVFormatContext , AVStream , AVChapter and AVProgram structs
2011-12-11 02:40:09 +03:00
* using the @ ref lavu_dict " AVDictionary " API . Like all strings in FFmpeg ,
2011-12-10 22:39:39 +03:00
* metadata is assumed to be UTF - 8 encoded Unicode . Note that metadata
2010-02-24 20:01:44 +02:00
* exported by demuxers isn ' t checked to be valid UTF - 8 in most cases .
2011-12-10 22:39:39 +03:00
*
2009-01-04 22:47:09 +02:00
* Important concepts to keep in mind :
2011-07-01 21:49:14 +03:00
* - Keys are unique ; there can never be 2 tags with the same key . This is
2009-01-04 22:47:09 +02:00
* also meant semantically , i . e . , a demuxer should not knowingly produce
* several keys that are literally different but semantically identical .
* E . g . , key = Author5 , key = Author6 . In this example , all authors must be
* placed in the same tag .
2011-07-01 21:49:14 +03:00
* - Metadata is flat , not hierarchical ; there are no subtags . If you
2009-01-04 22:47:09 +02:00
* want to store , e . g . , the email address of the child of producer Alice
* and actor Bob , that could have key = alice_and_bobs_childs_email_address .
2011-07-01 21:49:14 +03:00
* - Several modifiers can be applied to the tag name . This is done by
2010-02-01 13:39:10 +02:00
* appending a dash character ( ' - ' ) and the modifier name in the order
* they appear in the list below - - e . g . foo - eng - sort , not foo - sort - eng .
2011-07-01 21:49:14 +03:00
* - language - - a tag whose value is localized for a particular language
2010-02-01 13:39:10 +02:00
* is appended with the ISO 639 - 2 / B 3 - letter language code .
* For example : Author - ger = Michael , Author - eng = Mike
* The original / default language is in the unqualified " Author " tag .
* A demuxer should set a default if it sets any translated tag .
2011-07-01 21:49:14 +03:00
* - sorting - - a modified version of a tag that should be used for
2010-02-01 13:39:10 +02:00
* sorting will have ' - sort ' appended . E . g . artist = " The Beatles " ,
* artist - sort = " Beatles, The " .
*
2011-07-01 21:49:14 +03:00
* - Demuxers attempt to export metadata in a generic format , however tags
2010-10-15 22:04:25 +03:00
* with no generic equivalents are left as they are stored in the container .
* Follows a list of generic tag names :
2010-02-01 13:39:10 +02:00
*
2011-07-01 21:49:14 +03:00
@ verbatim
album - - name of the set this work belongs to
album_artist - - main creator of the set / album , if different from artist .
e . g . " Various Artists " for compilation albums .
artist - - main creator of the work
comment - - any additional description of the file .
composer - - who composed the work , if different from artist .
copyright - - name of copyright holder .
creation_time - - date when the file was created , preferably in ISO 8601.
date - - date when the work was created , preferably in ISO 8601.
disc - - number of a subset , e . g . disc in a multi - disc collection .
encoder - - name / settings of the software / hardware that produced the file .
encoded_by - - person / group who created the file .
filename - - original name of the file .
genre - - < self - evident > .
language - - main language in which the work is performed , preferably
in ISO 639 - 2 format . Multiple languages can be specified by
separating them with commas .
performer - - artist who performed the work , if different from artist .
E . g for " Also sprach Zarathustra " , artist would be " Richard
Strauss " and performer " London Philharmonic Orchestra " .
publisher - - name of the label / publisher .
service_name - - name of the service in broadcasting ( channel name ) .
service_provider - - name of the service provider in broadcasting .
title - - name of the work .
track - - number of this work in the set , can be in form current / total .
variant_bitrate - - the total bitrate of the bitrate variant that the current stream is part of
@ endverbatim
*
2011-07-01 21:50:33 +03:00
* Look in the examples section for an application example how to use the Metadata API .
*
2011-07-01 21:49:14 +03:00
* @ }
2009-01-04 20:58:49 +02:00
*/
2001-07-22 17:18:56 +03:00
/* packet functions */
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Allocate and read the payload of a packet and initialize its
2009-06-29 00:01:51 +03:00
* fields with default values .
2007-03-03 14:23:20 +02:00
*
* @ param pkt packet
2008-09-27 22:51:53 +03:00
* @ param size desired payload size
* @ return > 0 ( read size ) if OK , AVERROR_xxx otherwise
2007-03-03 14:23:20 +02:00
*/
2011-02-20 12:04:12 +02:00
int av_get_packet ( AVIOContext * s , AVPacket * pkt , int size ) ;
2007-03-03 14:23:20 +02:00
2001-07-22 17:18:56 +03:00
2010-11-21 12:24:48 +02:00
/**
2010-11-21 13:33:26 +02:00
* Read data and append it to the current content of the AVPacket .
* If pkt - > size is 0 this is identical to av_get_packet .
2010-11-21 12:24:48 +02:00
* Note that this uses av_grow_packet and thus involves a realloc
* which is inefficient . Thus this function should only be used
* when there is no reasonable way to know ( an upper bound of )
* the final size .
*
* @ param pkt packet
* @ param size amount of data to read
* @ return > 0 ( read size ) if OK , AVERROR_xxx otherwise , previous data
* will not be lost even if an error occurs .
*/
2011-02-20 12:04:12 +02:00
int av_append_packet ( AVIOContext * s , AVPacket * pkt , int size ) ;
2010-11-21 12:24:48 +02:00
2002-10-21 18:54:49 +03:00
/*************************************************/
/* fractional numbers for exact pts handling */
2007-05-02 12:13:47 +03:00
/**
2008-09-27 22:51:53 +03:00
* The exact value of the fractional number is : ' val + num / den ' .
* num is assumed to be 0 < = num < den .
2009-02-11 02:25:30 +02:00
*/
2002-10-21 18:54:49 +03:00
typedef struct AVFrac {
2005-12-17 20:14:38 +02:00
int64_t val , num , den ;
2009-01-06 00:10:16 +02:00
} AVFrac ;
2002-10-21 18:54:49 +03:00
2001-07-22 17:18:56 +03:00
/*************************************************/
2002-05-20 19:28:47 +03:00
/* input/output formats */
2001-07-22 17:18:56 +03:00
2007-01-21 03:39:17 +02:00
struct AVCodecTag ;
2010-07-27 18:20:02 +03:00
/**
* This structure contains the data a format has to probe a file .
*/
2002-05-20 19:28:47 +03:00
typedef struct AVProbeData {
2003-02-10 11:35:32 +02:00
const char * filename ;
2009-09-10 01:55:10 +03:00
unsigned char * buf ; /**< Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero. */
int buf_size ; /**< Size of buf except extra allocated bytes */
2002-05-20 19:28:47 +03:00
} AVProbeData ;
2012-10-10 22:39:19 +03:00
# define AVPROBE_SCORE_RETRY (AVPROBE_SCORE_MAX / 4)
2013-03-25 18:12:51 +03:00
# define AVPROBE_SCORE_EXTENSION 50 ///< score for file extension
# define AVPROBE_SCORE_MAX 100 ///< maximum score
2007-04-08 14:34:15 +03:00
# define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer
2001-07-22 17:18:56 +03:00
2011-10-30 20:27:33 +03:00
/// Demuxer will use avio_open, no opened file should be provided by the caller.
2007-01-20 00:54:50 +02:00
# define AVFMT_NOFILE 0x0001
2008-09-27 22:51:53 +03:00
# 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
raw picture data . */
# define AVFMT_GLOBALHEADER 0x0040 /**< Format wants global header. */
# define AVFMT_NOTIMESTAMPS 0x0080 /**< Format does not need / have any timestamps. */
# define AVFMT_GENERIC_INDEX 0x0100 /**< Use generic index building code. */
2010-12-25 21:49:15 +02:00
# define AVFMT_TS_DISCONT 0x0200 /**< Format allows timestamp discontinuities. Note, muxers always require valid (monotone) timestamps */
2009-02-24 17:04:18 +02:00
# define AVFMT_VARIABLE_FPS 0x0400 /**< Format allows variable fps. */
2010-02-12 22:35:29 +02:00
# define AVFMT_NODIMENSIONS 0x0800 /**< Format does not need width/height */
2010-12-27 09:46:44 +02:00
# define AVFMT_NOSTREAMS 0x1000 /**< Format does not require any streams */
2012-08-21 02:02:13 +03:00
# define AVFMT_NOBINSEARCH 0x2000 /**< Format does not allow to fall back on binary search via read_timestamp */
# define AVFMT_NOGENSEARCH 0x4000 /**< Format does not allow to fall back on generic search */
2011-10-02 18:57:53 +03:00
# define AVFMT_NO_BYTE_SEEK 0x8000 /**< Format does not allow seeking by bytes */
2012-01-20 20:27:33 +03:00
# define AVFMT_ALLOW_FLUSH 0x10000 /**< Format allows flushing. If not set, the muxer will not receive a NULL packet in the write_packet function. */
2012-05-22 00:53:39 +03:00
# if LIBAVFORMAT_VERSION_MAJOR <= 54
# define AVFMT_TS_NONSTRICT 0x8020000 //we try to be compatible to the ABIs of ffmpeg and major forks
# else
# define AVFMT_TS_NONSTRICT 0x20000
# endif
/**< Format does not require strictly
2011-05-26 21:19:04 +03:00
increasing timestamps , but they must
still be monotonic */
2013-04-03 15:11:10 +03:00
# define AVFMT_TS_NEGATIVE 0x40000 / **< Format allows muxing negative
timestamps . If not set the timestamp
will be shifted in av_write_frame and
av_interleaved_write_frame so they
2013-04-26 12:52:51 +03:00
start from 0.
The user or muxer can override this through
AVFormatContext . avoid_negative_ts
*/
2002-05-20 19:28:47 +03:00
2012-04-30 16:47:58 +03:00
# define AVFMT_SEEK_TO_PTS 0x4000000 /**< Seeking is based on PTS */
2002-05-20 19:28:47 +03:00
2011-12-10 23:04:30 +03:00
/**
* @ addtogroup lavf_encoding
* @ {
*/
2002-05-20 19:28:47 +03:00
typedef struct AVOutputFormat {
2001-07-22 17:18:56 +03:00
const char * name ;
2008-06-03 19:20:54 +03:00
/**
* Descriptive name for the format , meant to be more human - readable
2009-05-26 01:05:43 +03:00
* than name . You should use the NULL_IF_CONFIG_SMALL ( ) macro
2008-06-03 19:20:54 +03:00
* to define it .
*/
2001-07-22 17:18:56 +03:00
const char * long_name ;
const char * mime_type ;
2008-09-27 22:51:53 +03:00
const char * extensions ; /**< comma-separated filename extensions */
2012-01-27 14:29:37 +03:00
/* output support */
2012-08-05 12:11:04 +03:00
enum AVCodecID audio_codec ; /**< default audio codec */
enum AVCodecID video_codec ; /**< default video codec */
enum AVCodecID subtitle_codec ; /**< default subtitle codec */
2012-01-27 14:29:37 +03:00
/**
* can use flags : AVFMT_NOFILE , AVFMT_NEEDNUMBER , AVFMT_RAWPICTURE ,
* AVFMT_GLOBALHEADER , AVFMT_NOTIMESTAMPS , AVFMT_VARIABLE_FPS ,
2011-05-26 21:19:04 +03:00
* AVFMT_NODIMENSIONS , AVFMT_NOSTREAMS , AVFMT_ALLOW_FLUSH ,
* AVFMT_TS_NONSTRICT
2012-01-27 14:29:37 +03:00
*/
int flags ;
/**
* List of supported codec_id - codec_tag pairs , ordered by " better
2012-08-05 12:11:04 +03:00
* choice first " . The arrays are all terminated by AV_CODEC_ID_NONE.
2012-01-27 14:29:37 +03:00
*/
const struct AVCodecTag * const * codec_tag ;
const AVClass * priv_class ; ///< AVClass for the private context
/*****************************************************************
* No fields below this line are part of the public API . They
* may not be used outside of libavformat and can be changed and
* removed at will .
* New public fields should be added right above .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
struct AVOutputFormat * next ;
2010-07-27 18:20:02 +03:00
/**
* size of private data so that it can be allocated in the wrapper
*/
2002-05-20 19:28:47 +03:00
int priv_data_size ;
2012-01-27 14:29:37 +03:00
2001-07-22 17:18:56 +03:00
int ( * write_header ) ( struct AVFormatContext * ) ;
2012-01-20 20:27:33 +03:00
/**
* Write a packet . If AVFMT_ALLOW_FLUSH is set in flags ,
* pkt can be NULL in order to flush data buffered in the muxer .
* When flushing , return 0 if there still is more data to flush ,
* or 1 if everything was flushed and there is no more buffered
* data .
*/
2004-05-29 05:06:32 +03:00
int ( * write_packet ) ( struct AVFormatContext * , AVPacket * pkt ) ;
2001-07-22 17:18:56 +03:00
int ( * write_trailer ) ( struct AVFormatContext * ) ;
2010-07-27 18:20:02 +03:00
/**
* Currently only used to set pixel format if not YUV420P .
*/
2008-09-27 23:05:12 +03:00
int ( * interleave_packet ) ( struct AVFormatContext * , AVPacket * out ,
AVPacket * in , int flush ) ;
2011-08-11 21:34:45 +03:00
/**
* Test if the given codec can be stored in this container .
*
* @ return 1 if the codec is supported , 0 if it is not .
* A negative number if unknown .
2012-08-04 19:59:03 +03:00
* MKTAG ( ' A ' , ' P ' , ' I ' , ' C ' ) if the codec is only supported as AV_DISPOSITION_ATTACHED_PIC
2011-08-11 21:34:45 +03:00
*/
2012-08-05 12:11:04 +03:00
int ( * query_codec ) ( enum AVCodecID id , int std_compliance ) ;
2011-08-11 21:34:45 +03:00
2011-06-30 20:45:22 +03:00
void ( * get_output_timestamp ) ( struct AVFormatContext * s , int stream ,
int64_t * dts , int64_t * wall ) ;
2002-05-20 19:28:47 +03:00
} AVOutputFormat ;
2011-12-10 23:04:30 +03:00
/**
* @ }
*/
2001-07-22 17:18:56 +03:00
2011-12-10 23:04:30 +03:00
/**
* @ addtogroup lavf_decoding
* @ {
*/
2002-05-20 19:28:47 +03:00
typedef struct AVInputFormat {
2010-07-27 18:20:02 +03:00
/**
* A comma separated list of short names for the format . New names
2010-07-27 17:13:24 +03:00
* may be appended with a minor bump .
*/
2002-05-20 19:28:47 +03:00
const char * name ;
2010-07-27 18:20:02 +03:00
2008-06-03 19:20:54 +03:00
/**
* Descriptive name for the format , meant to be more human - readable
2009-05-26 01:05:43 +03:00
* than name . You should use the NULL_IF_CONFIG_SMALL ( ) macro
2008-06-03 19:20:54 +03:00
* to define it .
*/
2002-05-20 19:28:47 +03:00
const char * long_name ;
2010-07-27 18:20:02 +03:00
2012-01-27 14:29:37 +03:00
/**
* Can use flags : AVFMT_NOFILE , AVFMT_NEEDNUMBER , AVFMT_SHOW_IDS ,
* AVFMT_GENERIC_INDEX , AVFMT_TS_DISCONT , AVFMT_NOBINSEARCH ,
2012-05-16 02:26:36 +03:00
* AVFMT_NOGENSEARCH , AVFMT_NO_BYTE_SEEK , AVFMT_SEEK_TO_PTS .
2012-01-27 14:29:37 +03:00
*/
int flags ;
/**
* If extensions are defined , then no probe is done . You should
* usually not use extension format guessing because it is not
* reliable enough
*/
const char * extensions ;
const struct AVCodecTag * const * codec_tag ;
const AVClass * priv_class ; ///< AVClass for the private context
/*****************************************************************
* No fields below this line are part of the public API . They
* may not be used outside of libavformat and can be changed and
* removed at will .
* New public fields should be added right above .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
struct AVInputFormat * next ;
/**
2012-01-31 09:50:31 +03:00
* Raw demuxers store their codec ID here .
2012-01-27 14:29:37 +03:00
*/
2012-01-31 09:50:31 +03:00
int raw_codec_id ;
2012-01-27 14:29:37 +03:00
2010-07-27 18:20:02 +03:00
/**
* Size of private data so that it can be allocated in the wrapper .
*/
2002-05-20 19:28:47 +03:00
int priv_data_size ;
2010-07-27 18:20:02 +03:00
2007-08-10 19:15:23 +03:00
/**
2009-02-25 21:10:39 +02:00
* Tell if a given file has a chance of being parsed as this format .
2007-12-16 19:22:09 +02:00
* The buffer provided is guaranteed to be AVPROBE_PADDING_SIZE bytes
* big so you do not have to check for that unless you need more .
2007-08-10 19:15:23 +03:00
*/
2002-05-20 19:28:47 +03:00
int ( * read_probe ) ( AVProbeData * ) ;
2010-07-27 18:20:02 +03:00
/**
* Read the format header and initialize the AVFormatContext
2012-02-19 12:35:45 +03:00
* structure . Return 0 if OK . Only used in raw format right
* now . ' avformat_new_stream ' should be called to create new streams .
2010-07-27 18:20:02 +03:00
*/
2012-01-12 15:20:36 +03:00
int ( * read_header ) ( struct AVFormatContext * ) ;
2010-07-27 18:20:02 +03:00
/**
* Read one packet and put it in ' pkt ' . pts and flags are also
2012-02-19 12:35:45 +03:00
* set . ' avformat_new_stream ' can be called only if the flag
2010-10-06 23:49:25 +03:00
* AVFMTCTX_NOHEADER is used and only in the calling thread ( not in a
* background thread ) .
2010-07-27 18:20:02 +03:00
* @ return 0 on success , < 0 on error .
* When returning an error , pkt must not have been allocated
* or must be freed before returning
*/
2001-07-22 17:18:56 +03:00
int ( * read_packet ) ( struct AVFormatContext * , AVPacket * pkt ) ;
2010-07-27 18:20:02 +03:00
/**
* Close the stream . The AVFormatContext and AVStreams are not
* freed by this function
*/
2001-07-22 17:18:56 +03:00
int ( * read_close ) ( struct AVFormatContext * ) ;
2009-02-25 05:18:11 +02:00
2005-12-17 20:14:38 +02:00
/**
2008-09-27 22:51:53 +03:00
* Seek to a given timestamp relative to the frames in
* stream component stream_index .
2009-02-25 21:10:39 +02:00
* @ param stream_index Must not be - 1.
* @ param flags Selects which direction should be preferred if no exact
* match is available .
2007-06-25 05:08:04 +03:00
* @ return > = 0 on success ( but not necessarily the new offset )
2004-10-11 01:05:43 +03:00
*/
2012-01-12 11:36:11 +03:00
int ( * read_seek ) ( struct AVFormatContext * ,
int stream_index , int64_t timestamp , int flags ) ;
2004-04-12 19:50:03 +03:00
/**
2011-12-07 15:03:53 +03:00
* Get the next timestamp in stream [ stream_index ] . time_base units .
2008-03-22 03:06:57 +02:00
* @ return the timestamp or AV_NOPTS_VALUE if an error occurred
2004-04-12 19:50:03 +03:00
*/
int64_t ( * read_timestamp ) ( struct AVFormatContext * s , int stream_index ,
int64_t * pos , int64_t pos_limit ) ;
2010-07-27 18:20:02 +03:00
/**
* Start / resume playing - only meaningful if using a network - based format
* ( RTSP ) .
*/
2003-11-10 20:37:55 +02:00
int ( * read_play ) ( struct AVFormatContext * ) ;
2010-07-27 18:20:02 +03:00
/**
* Pause playing - only meaningful if using a network - based format
* ( RTSP ) .
*/
2003-11-10 20:37:55 +02:00
int ( * read_pause ) ( struct AVFormatContext * ) ;
2009-02-25 05:18:11 +02:00
/**
2010-06-30 18:38:06 +03:00
* Seek to timestamp ts .
2009-02-25 05:18:11 +02:00
* Seeking will be done so that the point from which all active streams
* can be presented successfully will be closest to ts and within min / max_ts .
* Active streams are all streams that have AVStream . discard < AVDISCARD_ALL .
*/
2009-02-25 12:45:08 +02:00
int ( * read_seek2 ) ( struct AVFormatContext * s , int stream_index , int64_t min_ts , int64_t ts , int64_t max_ts , int flags ) ;
2002-05-20 19:28:47 +03:00
} AVInputFormat ;
2011-12-10 23:04:30 +03:00
/**
* @ }
*/
2001-07-22 17:18:56 +03:00
2007-04-15 16:51:57 +03:00
enum AVStreamParseType {
AVSTREAM_PARSE_NONE ,
AVSTREAM_PARSE_FULL , /**< full parsing and repack */
2008-09-27 22:51:53 +03:00
AVSTREAM_PARSE_HEADERS , /**< Only parse headers, do not repack. */
2008-09-27 23:05:12 +03:00
AVSTREAM_PARSE_TIMESTAMPS , /**< full parsing and interpolation of timestamps for frames not starting on a packet boundary */
2010-05-26 07:20:32 +03:00
AVSTREAM_PARSE_FULL_ONCE , /**< full parsing and repack of the first frame only, only implemented for H.264 currently */
2012-07-24 18:34:13 +03:00
AVSTREAM_PARSE_FULL_RAW = MKTAG ( 0 , ' R ' , ' A ' , ' W ' ) , /**< full parsing and repack with timestamp and position generation by parser for raw
this assumes that each packet in the file contains no demuxer level headers and
2012-10-07 20:57:13 +03:00
just codec level data , otherwise position generation would fail */
2007-04-15 16:51:57 +03:00
} ;
2003-11-10 20:37:55 +02:00
typedef struct AVIndexEntry {
int64_t pos ;
2011-10-06 21:20:43 +03:00
int64_t timestamp ; /**<
* Timestamp in AVStream . time_base units , preferably the time from which on correctly decoded frames are available
* when seeking to this entry . That means preferable PTS on keyframe based formats .
* But demuxers can choose to store a different timestamp , if it is more convenient for the implementation or nothing better
* is known
*/
2003-11-10 20:37:55 +02:00
# define AVINDEX_KEYFRAME 0x0001
2006-03-01 13:29:55 +02:00
int flags : 2 ;
2008-09-27 22:51:53 +03:00
int size : 30 ; //Yeah, trying to keep the size of this small to reduce memory requirements (it is 24 vs. 32 bytes due to possible 8-byte alignment).
int min_distance ; /**< Minimum distance between this and the previous keyframe, used to avoid unneeded searching. */
2003-11-10 20:37:55 +02:00
} AVIndexEntry ;
2008-03-07 21:25:09 +02:00
# define AV_DISPOSITION_DEFAULT 0x0001
# define AV_DISPOSITION_DUB 0x0002
# define AV_DISPOSITION_ORIGINAL 0x0004
# define AV_DISPOSITION_COMMENT 0x0008
# define AV_DISPOSITION_LYRICS 0x0010
# define AV_DISPOSITION_KARAOKE 0x0020
2010-07-27 18:20:02 +03:00
/**
* Track should be used during playback by default .
* Useful for subtitle track that should be displayed
* even when user did not explicitly ask for subtitles .
*/
2010-07-02 19:38:44 +03:00
# define AV_DISPOSITION_FORCED 0x0040
2011-02-10 08:25:13 +02:00
# define AV_DISPOSITION_HEARING_IMPAIRED 0x0080 /**< stream for hearing impaired audiences */
# define AV_DISPOSITION_VISUAL_IMPAIRED 0x0100 /**< stream for visual impaired audiences */
2011-02-14 20:43:38 +02:00
# define AV_DISPOSITION_CLEAN_EFFECTS 0x0200 /**< stream without voice */
2012-02-25 20:05:55 +03:00
/**
* The stream is stored in the file as an attached picture / " cover art " ( e . g .
* APIC frame in ID3v2 ) . The single packet associated with it will be returned
* among the first few packets read from the file unless seeking takes place .
* It can also be accessed at any time in AVStream . attached_pic .
*/
# define AV_DISPOSITION_ATTACHED_PIC 0x0400
2008-03-07 21:25:09 +02:00
2013-06-24 21:18:05 +03:00
/**
* To specify text track kind ( different from subtitles default ) .
*/
# define AV_DISPOSITION_CAPTIONS 0x10000
# define AV_DISPOSITION_DESCRIPTIONS 0x20000
# define AV_DISPOSITION_METADATA 0x40000
2012-12-02 21:27:21 +03:00
/**
* Options for behavior on timestamp wrap detection .
*/
# define AV_PTS_WRAP_IGNORE 0 ///< ignore the wrap
# define AV_PTS_WRAP_ADD_OFFSET 1 ///< add the format specific offset on wrap detection
# define AV_PTS_WRAP_SUB_OFFSET -1 ///< subtract the format specific offset on wrap detection
2007-12-20 11:59:07 +02:00
/**
* Stream structure .
* New fields can be added to the end with minor version bumps .
2007-12-21 13:50:18 +02:00
* Removal , reordering and changes to existing fields require a major
2007-12-20 11:59:07 +02:00
* version bump .
2007-12-21 13:50:18 +02:00
* sizeof ( AVStream ) must not be used outside libav * .
2007-12-20 11:59:07 +02:00
*/
2001-07-22 17:18:56 +03:00
typedef struct AVStream {
2007-03-05 02:23:23 +02:00
int index ; /**< stream index in AVFormatContext */
2012-03-22 18:05:08 +03:00
/**
* Format - specific stream ID .
* decoding : set by libavformat
2012-11-10 18:20:30 +03:00
* encoding : set by the user , replaced by libavformat if left unset
2012-03-22 18:05:08 +03:00
*/
int id ;
2012-03-15 13:27:47 +03:00
/**
* Codec context associated with this stream . Allocated and freed by
* libavformat .
*
* - decoding : The demuxer exports codec information stored in the headers
* here .
* - encoding : The user sets codec information , the muxer writes it to the
* output . Mandatory fields as specified in AVCodecContext
* documentation must be set even if this AVCodecContext is
* not actually used for encoding .
*/
AVCodecContext * codec ;
2001-07-22 17:18:56 +03:00
void * priv_data ;
2007-08-05 01:46:13 +03:00
2010-07-27 18:20:02 +03:00
/**
* encoding : pts generation when outputting stream
*/
2007-07-10 01:15:11 +03:00
struct AVFrac pts ;
2005-08-22 01:31:01 +03:00
/**
2007-12-21 13:50:18 +02:00
* This is the fundamental unit of time ( in seconds ) in terms
2012-02-27 11:41:31 +03:00
* of which frame timestamps are represented .
*
2011-01-29 14:53:14 +02:00
* decoding : set by libavformat
2012-10-17 22:45:23 +03:00
* encoding : set by libavformat in avformat_write_header . The muxer may use the
2012-02-27 11:41:31 +03:00
* user - provided value of @ ref AVCodecContext . time_base " codec->time_base "
* as a hint .
2005-08-22 01:31:01 +03:00
*/
2004-05-21 23:43:21 +03:00
AVRational time_base ;
2010-07-27 18:20:02 +03:00
2007-08-16 15:07:05 +03:00
/**
2011-09-23 00:20:21 +03:00
* Decoding : pts of the first frame of the stream in presentation order , in stream time base .
2007-12-21 13:50:18 +02:00
* Only set this if you are absolutely 100 % sure that the value you set
* it to really is the pts of the first frame .
2007-08-18 03:31:32 +03:00
* This may be undefined ( AV_NOPTS_VALUE ) .
2011-03-18 14:16:14 +02:00
* @ note The ASF header does NOT contain a correct start_time the ASF
* demuxer must NOT set this .
2007-08-16 15:07:05 +03:00
*/
2005-12-17 20:14:38 +02:00
int64_t start_time ;
2010-07-27 18:20:02 +03:00
2007-08-18 03:35:43 +03:00
/**
2007-12-21 13:50:18 +02:00
* Decoding : duration of the stream , in stream time base .
2007-08-18 03:35:43 +03:00
* If a source file does not specify a duration , but does specify
2008-09-27 22:51:53 +03:00
* a bitrate , this value will be estimated from bitrate and file size .
2007-08-18 03:35:43 +03:00
*/
2003-08-08 20:49:27 +03:00
int64_t duration ;
2003-11-10 20:37:55 +02:00
2005-06-24 14:38:22 +03:00
int64_t nb_frames ; ///< number of frames in this stream if known or 0
2006-08-31 00:18:17 +03:00
2008-09-27 22:51:53 +03:00
int disposition ; /**< AV_DISPOSITION_* bit field */
2008-07-12 21:42:00 +03:00
2012-02-28 00:40:11 +03:00
enum AVDiscard discard ; ///< Selects which packets can be discarded at will and do not need to be demuxed.
2008-08-24 02:13:58 +03:00
/**
* sample aspect ratio ( 0 if unknown )
* - encoding : Set by user .
* - decoding : Set by libavformat .
*/
AVRational sample_aspect_ratio ;
2009-01-05 00:31:55 +02:00
2011-05-22 13:46:29 +03:00
AVDictionary * metadata ;
2009-01-23 01:35:31 +02:00
2009-12-13 17:52:11 +02:00
/**
* Average framerate
*/
AVRational avg_frame_rate ;
2010-02-23 17:07:18 +02:00
2012-02-25 20:05:55 +03:00
/**
* For streams with AV_DISPOSITION_ATTACHED_PIC disposition , this packet
* will contain the attached picture .
*
* decoding : set by libavformat , must not be modified by the caller .
* encoding : unused
*/
AVPacket attached_pic ;
2011-10-19 21:00:09 +03:00
/*****************************************************************
* All fields below this line are not part of the public API . They
* may not be used outside of libavformat and can be changed and
* removed at will .
* New public fields should be added right above .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
2010-10-09 01:01:19 +03:00
/**
2011-10-05 15:12:42 +03:00
* Stream information used internally by av_find_stream_info ( )
2010-10-09 01:01:19 +03:00
*/
2012-04-09 19:56:46 +03:00
# define MAX_STD_TIMEBASES (60*12+6)
2010-10-09 01:01:19 +03:00
struct {
int64_t last_dts ;
int64_t duration_gcd ;
int duration_count ;
2013-02-24 00:25:49 +03:00
double ( * duration_error ) [ 2 ] [ MAX_STD_TIMEBASES ] ;
2010-10-09 01:01:19 +03:00
int64_t codec_info_duration ;
2012-10-14 19:53:05 +03:00
int64_t codec_info_duration_fields ;
2012-02-28 02:02:10 +03:00
int found_decoder ;
2012-06-28 16:49:51 +03:00
2013-03-04 20:01:32 +03:00
int64_t last_duration ;
2012-06-28 16:49:51 +03:00
/**
* Those are used for average framerate estimation .
*/
int64_t fps_first_dts ;
int fps_first_dts_idx ;
int64_t fps_last_dts ;
int fps_last_dts_idx ;
2010-10-09 01:01:19 +03:00
} * info ;
2012-02-28 00:40:11 +03:00
int pts_wrap_bits ; /**< number of bits in pts (used for wrapping control) */
2011-10-19 21:00:09 +03:00
2013-10-28 16:59:20 +03:00
# if FF_API_REFERENCE_DTS
2013-10-29 22:44:41 +03:00
/* a hack to keep ABI compatibility for ffmpeg and other applications, which accesses parser even
2013-10-28 16:59:20 +03:00
* though it should not */
int64_t do_not_use ;
# endif
2011-10-19 21:00:09 +03:00
// Timestamp generation support:
/**
* Timestamp corresponding to the last dts sync point .
*
* Initialized when AVCodecParserContext . dts_sync_point > = 0 and
* a DTS is received from the underlying container . Otherwise set to
* AV_NOPTS_VALUE by default .
*/
int64_t first_dts ;
int64_t cur_dts ;
int64_t last_IP_pts ;
2012-02-28 00:40:11 +03:00
int last_IP_duration ;
2011-10-19 21:00:09 +03:00
/**
* Number of packets to buffer for codec probing
*/
# define MAX_PROBE_PACKETS 2500
int probe_packets ;
2012-02-28 00:40:11 +03:00
/**
* Number of frames that have been demuxed during av_find_stream_info ( )
*/
int codec_info_nb_frames ;
/* av_read_frame() support */
enum AVStreamParseType need_parsing ;
struct AVCodecParserContext * parser ;
2011-10-19 21:00:09 +03:00
/**
* last packet in packet_buffer for this stream when muxing .
*/
struct AVPacketList * last_in_packet_buffer ;
AVProbeData probe_data ;
# define MAX_REORDER_DELAY 16
int64_t pts_buffer [ MAX_REORDER_DELAY + 1 ] ;
AVIndexEntry * index_entries ; /**< Only used if the format does not
support seeking natively . */
int nb_index_entries ;
unsigned int index_entries_allocated_size ;
2013-07-09 19:34:01 +03:00
/**
* Real base framerate of the stream .
* This is the lowest framerate with which all timestamps can be
* represented accurately ( it is the least common multiple of all
* framerates in the stream ) . Note , this value is just a guess !
* For example , if the time base is 1 / 90000 and all frames have either
* approximately 3600 or 1800 timer ticks , then r_frame_rate will be 50 / 1.
*
* Code outside avformat should access this field using :
* av_stream_get / set_r_frame_rate ( stream )
*/
AVRational r_frame_rate ;
/**
* Stream Identifier
* This is the MPEG - TS stream identifier + 1
* 0 means unknown
*/
int stream_identifier ;
int64_t interleaver_chunk_size ;
int64_t interleaver_chunk_duration ;
2012-01-28 06:23:26 +03:00
/**
2012-09-23 02:07:15 +03:00
* stream probing state
* - 1 - > probing finished
* 0 - > no probing requested
* rest - > perform probing with request_probe being the minimum score to accept .
2012-01-28 06:23:26 +03:00
* NOT PART OF PUBLIC API
*/
int request_probe ;
2012-04-14 01:17:30 +03:00
/**
* Indicates that everything up to the next keyframe
* should be discarded .
*/
int skip_to_keyframe ;
2012-07-04 23:00:50 +03:00
/**
* Number of samples to skip at the start of the frame decoded from the next packet .
*/
int skip_samples ;
2012-08-04 16:38:05 +03:00
/**
* Number of internally decoded frames , used internally in libavformat , do not access
2013-02-15 01:45:48 +03:00
* its lifetime differs from info which is why it is not in that structure .
2012-08-04 16:38:05 +03:00
*/
int nb_decoded_frames ;
2012-09-26 16:55:16 +03:00
/**
* Timestamp offset added to timestamps before muxing
* NOT PART OF PUBLIC API
*/
int64_t mux_ts_offset ;
2012-12-02 21:27:21 +03:00
/**
* Internal data to check for wrapping of the time stamp
*/
int64_t pts_wrap_reference ;
/**
* Options for behavior , when a wrap is detected .
*
* Defined by AV_PTS_WRAP_ values .
*
* If correction is enabled , there are two possibilities :
* If the first time stamp is near the wrap point , the wrap offset
* will be subtracted , which will create negative time stamps .
* Otherwise the offset will be added .
*/
int pts_wrap_behavior ;
2001-07-22 17:18:56 +03:00
} AVStream ;
2013-03-12 17:26:35 +03:00
AVRational av_stream_get_r_frame_rate ( const AVStream * s ) ;
void av_stream_set_r_frame_rate ( AVStream * s , AVRational r ) ;
2007-09-25 23:45:46 +03:00
# define AV_PROGRAM_RUNNING 1
2007-12-20 11:59:07 +02:00
/**
* New fields can be added to the end with minor version bumps .
2007-12-21 13:50:18 +02:00
* Removal , reordering and changes to existing fields require a major
2007-12-20 11:59:07 +02:00
* version bump .
2007-12-21 13:50:18 +02:00
* sizeof ( AVProgram ) must not be used outside libav * .
2007-12-20 11:59:07 +02:00
*/
2007-09-25 23:45:46 +03:00
typedef struct AVProgram {
int id ;
int flags ;
enum AVDiscard discard ; ///< selects which program to discard and which to feed to the caller
2007-10-20 11:25:13 +03:00
unsigned int * stream_index ;
unsigned int nb_stream_indexes ;
2011-05-22 13:46:29 +03:00
AVDictionary * metadata ;
2011-03-04 21:22:09 +02:00
int program_num ;
int pmt_pid ;
2011-03-11 14:39:55 +02:00
int pcr_pid ;
2012-10-23 19:11:26 +03:00
/*****************************************************************
* All fields below this line are not part of the public API . They
* may not be used outside of libavformat and can be changed and
* removed at will .
* New public fields should be added right above .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
int64_t start_time ;
int64_t end_time ;
2012-12-02 21:27:21 +03:00
int64_t pts_wrap_reference ; ///< reference dts for wrap detection
int pts_wrap_behavior ; ///< behavior on wrap detection
2007-09-25 23:45:46 +03:00
} AVProgram ;
2007-03-05 02:23:23 +02:00
# define AVFMTCTX_NOHEADER 0x0001 / **< signal that no header is present
2003-10-29 16:20:56 +02:00
( streams are added dynamically ) */
2008-05-23 01:00:21 +03:00
typedef struct AVChapter {
2008-09-27 22:51:53 +03:00
int id ; ///< unique ID to identify the chapter
AVRational time_base ; ///< time base in which the start/end timestamps are specified
2008-05-23 15:45:03 +03:00
int64_t start , end ; ///< chapter start/end time in time_base units
2011-05-22 13:46:29 +03:00
AVDictionary * metadata ;
2008-05-23 01:00:21 +03:00
} AVChapter ;
2012-06-23 02:03:18 +03:00
/**
* The duration of a video can be estimated through various ways , and this enum can be used
* to know how the duration was estimated .
*/
enum AVDurationEstimationMethod {
AVFMT_DURATION_FROM_PTS , ///< Duration accurately estimated from PTSes
AVFMT_DURATION_FROM_STREAM , ///< Duration estimated from a stream with a known duration
AVFMT_DURATION_FROM_BITRATE ///< Duration estimated from bitrate (less accurate)
} ;
2007-12-20 11:43:01 +02:00
/**
2008-09-27 22:51:53 +03:00
* Format I / O context .
2007-12-20 11:43:01 +02:00
* New fields can be added to the end with minor version bumps .
2007-12-21 13:50:18 +02:00
* Removal , reordering and changes to existing fields require a major
2007-12-20 11:43:01 +02:00
* version bump .
2011-11-06 17:16:18 +03:00
* sizeof ( AVFormatContext ) must not be used outside libav * , use
* avformat_alloc_context ( ) to create an AVFormatContext .
2007-12-20 11:43:01 +02:00
*/
2001-07-22 17:18:56 +03:00
typedef struct AVFormatContext {
2011-11-06 17:16:18 +03:00
/**
* A class for logging and AVOptions . Set by avformat_alloc_context ( ) .
* Exports ( de ) muxer private options if they exist .
*/
const AVClass * av_class ;
/**
* Can only be iformat or oformat , not both at the same time .
*
* decoding : set by avformat_open_input ( ) .
* encoding : set by the user .
*/
2002-05-20 19:28:47 +03:00
struct AVInputFormat * iformat ;
struct AVOutputFormat * oformat ;
2011-11-06 17:16:18 +03:00
/**
* Format private data . This is an AVOptions - enabled struct
* if and only if iformat / oformat . priv_class is not NULL .
*/
2001-07-22 17:18:56 +03:00
void * priv_data ;
2011-11-06 17:16:18 +03:00
2012-05-07 13:21:19 +03:00
/**
2011-11-06 17:16:18 +03:00
* I / O context .
*
* decoding : either set by the user before avformat_open_input ( ) ( then
* the user must close it manually ) or set by avformat_open_input ( ) .
* encoding : set by the user .
*
* Do NOT set this field if AVFMT_NOFILE flag is set in
* iformat / oformat . flags . In such a case , the ( de ) muxer will handle
* I / O in some other way and this field will be NULL .
*/
2011-02-20 12:04:12 +02:00
AVIOContext * pb ;
2011-11-06 17:16:18 +03:00
2012-02-28 00:40:11 +03:00
/* stream info */
int ctx_flags ; /**< Format-specific flags, see AVFMTCTX_xx */
2011-11-06 17:16:18 +03:00
/**
* A list of all streams in the file . New streams are created with
* avformat_new_stream ( ) .
*
* decoding : streams are created by libavformat in avformat_open_input ( ) .
* If AVFMTCTX_NOHEADER is set in ctx_flags , then new streams may also
* appear in av_read_frame ( ) .
* encoding : streams are created by the user before avformat_write_header ( ) .
*/
2007-01-17 00:31:10 +02:00
unsigned int nb_streams ;
2010-10-06 23:56:14 +03:00
AVStream * * streams ;
2011-11-06 17:16:18 +03:00
2007-03-05 02:23:23 +02:00
char filename [ 1024 ] ; /**< input or output filename */
2003-08-08 20:49:27 +03:00
2010-07-27 18:20:02 +03:00
/**
* Decoding : position of the first frame of the component , in
* AV_TIME_BASE fractional seconds . NEVER set this value directly :
* It is deduced from the AVStream values .
*/
2005-12-17 20:14:38 +02:00
int64_t start_time ;
2010-07-27 18:20:02 +03:00
/**
* Decoding : duration of the stream , in AV_TIME_BASE fractional
* seconds . Only set this value if you know none of the individual stream
2011-10-05 15:12:42 +03:00
* durations and also do not set any of them . This is deduced from the
2010-07-27 18:20:02 +03:00
* AVStream values if not set .
*/
2003-08-08 20:49:27 +03:00
int64_t duration ;
2010-07-27 18:20:02 +03:00
/**
* Decoding : total stream bitrate in bit / s , 0 if not
* available . Never set it directly if the file_size and the
2011-04-18 00:57:50 +03:00
* duration are known as FFmpeg can compute it automatically .
2010-07-27 18:20:02 +03:00
*/
2003-08-08 20:49:27 +03:00
int bit_rate ;
2003-11-10 20:37:55 +02:00
2009-06-22 19:52:02 +03:00
unsigned int packet_size ;
2004-10-17 00:27:42 +03:00
int max_delay ;
2005-06-18 04:52:24 +03:00
2005-08-15 17:22:43 +03:00
int flags ;
2009-02-25 21:10:39 +02:00
# define AVFMT_FLAG_GENPTS 0x0001 ///< Generate missing pts even if it requires parsing future frames.
2008-09-27 22:51:53 +03:00
# define AVFMT_FLAG_IGNIDX 0x0002 ///< Ignore index.
# define AVFMT_FLAG_NONBLOCK 0x0004 ///< Do not block when reading packets from input.
2010-01-31 00:55:12 +02:00
# define AVFMT_FLAG_IGNDTS 0x0008 ///< Ignore DTS on frames that contain both DTS & PTS
2010-03-31 15:55:16 +03:00
# define AVFMT_FLAG_NOFILLIN 0x0010 ///< Do not infer any values from other values, just return what is stored in the container
# define AVFMT_FLAG_NOPARSE 0x0020 ///< Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled
2012-07-27 02:35:12 +03:00
# define AVFMT_FLAG_NOBUFFER 0x0040 ///< Do not buffer frames when possible
2011-05-22 09:37:25 +03:00
# define AVFMT_FLAG_CUSTOM_IO 0x0080 ///< The caller has supplied a custom AVIOContext, don't avio_close() it.
2011-07-24 17:28:33 +03:00
# define AVFMT_FLAG_DISCARD_CORRUPT 0x0100 ///< Discard frames marked corrupted
2013-09-11 15:02:06 +03:00
# define AVFMT_FLAG_FLUSH_PACKETS 0x0200 ///< Flush the AVIOContext every packet.
2011-06-18 05:40:18 +03:00
# define AVFMT_FLAG_MP4A_LATM 0x8000 ///< Enable RTP MP4A-LATM payload
2011-04-24 22:29:35 +03:00
# define AVFMT_FLAG_SORT_DTS 0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
2011-04-30 22:35:48 +03:00
# define AVFMT_FLAG_PRIV_OPT 0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted)
2012-07-06 02:38:53 +03:00
# define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Don't merge side data but keep it separate.
2006-07-14 00:13:49 +03:00
2010-07-27 18:20:02 +03:00
/**
* decoding : size of data to probe ; encoding : unused .
*/
2006-08-27 15:21:19 +03:00
unsigned int probesize ;
2007-01-23 19:34:26 +02:00
/**
2011-11-06 17:16:18 +03:00
* decoding : maximum time ( in AV_TIME_BASE units ) during which the input should
* be analyzed in avformat_find_stream_info ( ) .
2007-01-23 19:34:26 +02:00
*/
int max_analyze_duration ;
2007-02-11 14:37:28 +02:00
const uint8_t * key ;
int keylen ;
2007-09-25 23:45:46 +03:00
unsigned int nb_programs ;
AVProgram * * programs ;
2007-12-19 12:56:17 +02:00
/**
* Forced video codec_id .
2008-09-27 22:51:53 +03:00
* Demuxing : Set by user .
2007-12-19 12:56:17 +02:00
*/
2012-08-05 12:11:04 +03:00
enum AVCodecID video_codec_id ;
2010-07-27 18:20:02 +03:00
2007-12-19 12:56:17 +02:00
/**
* Forced audio codec_id .
2008-09-27 22:51:53 +03:00
* Demuxing : Set by user .
2007-12-19 12:56:17 +02:00
*/
2012-08-05 12:11:04 +03:00
enum AVCodecID audio_codec_id ;
2010-07-27 18:20:02 +03:00
2007-12-19 12:56:17 +02:00
/**
* Forced subtitle codec_id .
2008-09-27 22:51:53 +03:00
* Demuxing : Set by user .
2007-12-19 12:56:17 +02:00
*/
2012-08-05 12:11:04 +03:00
enum AVCodecID subtitle_codec_id ;
2008-01-13 15:33:37 +02:00
/**
2009-02-25 21:10:39 +02:00
* Maximum amount of memory in bytes to use for the index of each stream .
* If the index exceeds this size , entries will be discarded as
2008-01-13 15:33:37 +02:00
* needed to maintain a smaller size . This can lead to slower or less
* accurate seeking ( depends on demuxer ) .
2008-09-27 22:51:53 +03:00
* Demuxers for which a full in - memory index is mandatory will ignore
2008-01-13 15:33:37 +02:00
* this .
* muxing : unused
* demuxing : set by user
*/
unsigned int max_index_size ;
2008-03-08 23:59:11 +02:00
/**
2008-03-09 00:43:13 +02:00
* Maximum amount of memory in bytes to use for buffering frames
2008-09-27 22:51:53 +03:00
* obtained from realtime capture devices .
2008-03-08 23:59:11 +02:00
*/
unsigned int max_picture_buffer ;
2008-05-23 01:00:21 +03:00
2013-09-03 20:53:34 +03:00
/**
* Number of chapters in AVChapter array .
* When muxing , chapters are normally written in the file header ,
* so nb_chapters should normally be initialized before write_header
* is called . Some muxers ( e . g . mov and mkv ) can also write chapters
* in the trailer . To write chapters in the trailer , nb_chapters
* must be zero when write_header is called and non - zero when
* write_trailer is called .
* muxing : set by user
* demuxing : set by libavformat
*/
2008-05-23 16:08:44 +03:00
unsigned int nb_chapters ;
2008-05-23 01:00:21 +03:00
AVChapter * * chapters ;
2008-06-09 16:38:56 +03:00
2011-05-22 13:46:29 +03:00
AVDictionary * metadata ;
2009-06-25 21:48:57 +03:00
2010-03-15 12:29:37 +02:00
/**
* Start time of the stream in real world time , in microseconds
* since the unix epoch ( 00 : 00 1 st January 1970 ) . That is , pts = 0
* in the stream was captured at this real world time .
* - encoding : Set by user .
* - decoding : Unused .
*/
int64_t start_time_realtime ;
2011-05-10 00:34:23 +03:00
/**
* decoding : number of frames used to probe fps
*/
int fps_probe_size ;
2011-03-04 21:22:09 +02:00
2011-08-06 07:42:34 +03:00
/**
* Error recognition ; higher values will detect more errors but may
* misdetect some more or less valid parts as errors .
* - encoding : unused
* - decoding : Set by user .
*/
int error_recognition ;
2011-08-13 03:16:44 +03:00
2011-11-06 15:10:16 +03:00
/**
* Custom interrupt callbacks for the I / O layer .
*
* decoding : set by the user before avformat_open_input ( ) .
* encoding : set by the user before avformat_write_header ( )
* ( mainly useful for AVFMT_NOFILE formats ) . The callback
* should also be passed to avio_open2 ( ) if it ' s used to
* open the file .
*/
AVIOInterruptCB interrupt_callback ;
2012-02-28 00:40:11 +03:00
/**
* Flags to enable debugging .
*/
int debug ;
# define FF_FDEBUG_TS 0x0001
2012-02-29 02:30:35 +03:00
2011-03-04 21:22:09 +02:00
/**
* Transport stream id .
* This will be moved into demuxer private options . Thus no API / ABI compatibility
*/
int ts_id ;
2011-10-29 03:08:54 +03:00
2011-10-26 23:17:08 +03:00
/**
* Audio preload in microseconds .
* Note , not all formats support this and unpredictable things may happen if it is used when not supported .
* - encoding : Set by user via AVOptions ( NO direct access )
* - decoding : unused
*/
int audio_preload ;
2011-11-14 01:43:12 +03:00
2011-11-30 02:21:00 +03:00
/**
* Max chunk time in microseconds .
* Note , not all formats support this and unpredictable things may happen if it is used when not supported .
* - encoding : Set by user via AVOptions ( NO direct access )
* - decoding : unused
*/
int max_chunk_duration ;
/**
* Max chunk size in bytes
* Note , not all formats support this and unpredictable things may happen if it is used when not supported .
* - encoding : Set by user via AVOptions ( NO direct access )
* - decoding : unused
*/
int max_chunk_size ;
2012-08-17 01:08:51 +03:00
/**
* forces the use of wallclock timestamps as pts / dts of packets
* This has undefined results in the presence of B frames .
* - encoding : unused
* - decoding : Set by user via AVOptions ( NO direct access )
*/
int use_wallclock_as_timestamps ;
2012-09-26 16:55:16 +03:00
/**
2013-03-19 01:44:51 +03:00
* Avoid negative timestamps during muxing .
2012-09-26 16:55:16 +03:00
* 0 - > allow negative timestamps
* 1 - > avoid negative timestamps
* - 1 - > choose automatically ( default )
2013-03-19 01:44:51 +03:00
* Note , this only works when interleave_packet_per_dts is in use .
2012-09-26 16:55:16 +03:00
* - encoding : Set by user via AVOptions ( NO direct access )
* - decoding : unused
*/
int avoid_negative_ts ;
2012-09-26 16:24:00 +03:00
/**
* avio flags , used to force AVIO_FLAG_DIRECT .
* - encoding : unused
* - decoding : Set by user via AVOptions ( NO direct access )
*/
int avio_flags ;
/**
* The duration field can be estimated through various ways , and this field can be used
* to know how the duration was estimated .
* - encoding : unused
* - decoding : Read by user via AVOptions ( NO direct access )
*/
enum AVDurationEstimationMethod duration_estimation_method ;
2012-11-21 00:04:14 +03:00
/**
* Skip initial bytes when opening stream
* - encoding : unused
* - decoding : Set by user via AVOptions ( NO direct access )
*/
unsigned int skip_initial_bytes ;
2012-12-02 21:27:21 +03:00
/**
* Correct single timestamp overflows
* - encoding : unused
* - decoding : Set by user via AVOPtions ( NO direct access )
*/
unsigned int correct_ts_overflow ;
2012-08-06 02:25:57 +03:00
/**
* Force seeking to any ( also non key ) frames .
* - encoding : unused
* - decoding : Set by user via AVOPtions ( NO direct access )
*/
int seek2any ;
2013-03-12 18:54:42 +03:00
/**
* Flush the I / O context after each packet .
* - encoding : Set by user via AVOptions ( NO direct access )
* - decoding : unused
*/
int flush_packets ;
2013-08-08 23:39:49 +03:00
/**
* format probing score .
* The maximal score is AVPROBE_SCORE_MAX , its set when the demuxer probes
* the format .
* - encoding : unused
* - decoding : set by avformat , read by user via av_format_get_probe_score ( ) ( NO direct access )
*/
int probe_score ;
2011-10-19 21:00:09 +03:00
/*****************************************************************
* All fields below this line are not part of the public API . They
* may not be used outside of libavformat and can be changed and
* removed at will .
* New public fields should be added right above .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
/**
* This buffer is only needed when packets were already buffered but
* not decoded , for example to get the codec parameters in MPEG
* streams .
*/
struct AVPacketList * packet_buffer ;
struct AVPacketList * packet_buffer_end ;
/* av_seek_frame() support */
int64_t data_offset ; /**< offset of the first packet */
2012-02-28 00:40:11 +03:00
/**
* Raw packets from the demuxer , prior to parsing and decoding .
* This buffer is used for buffering packets until the codec can
* be identified , as parsing cannot be done without knowing the
* codec .
*/
struct AVPacketList * raw_packet_buffer ;
struct AVPacketList * raw_packet_buffer_end ;
2012-03-04 17:49:26 +03:00
/**
* Packets split by the parser get queued here .
*/
struct AVPacketList * parse_queue ;
struct AVPacketList * parse_queue_end ;
2012-02-28 00:40:11 +03:00
/**
* Remaining size available for raw_packet_buffer , in bytes .
*/
# define RAW_PACKET_BUFFER_SIZE 2500000
int raw_packet_buffer_remaining_size ;
2013-04-04 05:01:12 +03:00
2013-04-03 15:11:10 +03:00
/**
* Offset to remap timestamps to be non - negative .
* Expressed in timebase units .
2013-04-26 11:47:31 +03:00
* @ see AVStream . mux_ts_offset
2013-04-03 15:11:10 +03:00
*/
int64_t offset ;
/**
* Timebase for the timestamp offset .
*/
AVRational offset_timebase ;
2013-04-04 05:01:12 +03:00
/**
* IO repositioned flag .
* This is set by avformat when the underlaying IO context read pointer
* is repositioned , for example when doing byte based seeking .
* Demuxers can use the flag to detect such changes .
*/
int io_repositioned ;
2013-09-28 18:52:45 +03:00
/**
* Forced video codec .
* This allows forcing a specific decoder , even when there are multiple with
* the same codec_id .
* Demuxing : Set by user via av_format_set_video_codec ( NO direct access ) .
*/
AVCodec * video_codec ;
/**
* Forced audio codec .
* This allows forcing a specific decoder , even when there are multiple with
* the same codec_id .
* Demuxing : Set by user via av_format_set_audio_codec ( NO direct access ) .
*/
AVCodec * audio_codec ;
/**
* Forced subtitle codec .
* This allows forcing a specific decoder , even when there are multiple with
* the same codec_id .
* Demuxing : Set by user via av_format_set_subtitle_codec ( NO direct access ) .
*/
AVCodec * subtitle_codec ;
2001-07-22 17:18:56 +03:00
} AVFormatContext ;
2013-08-08 23:39:49 +03:00
int av_format_get_probe_score ( const AVFormatContext * s ) ;
2013-09-28 18:52:45 +03:00
AVCodec * av_format_get_video_codec ( const AVFormatContext * s ) ;
void av_format_set_video_codec ( AVFormatContext * s , AVCodec * c ) ;
AVCodec * av_format_get_audio_codec ( const AVFormatContext * s ) ;
void av_format_set_audio_codec ( AVFormatContext * s , AVCodec * c ) ;
AVCodec * av_format_get_subtitle_codec ( const AVFormatContext * s ) ;
void av_format_set_subtitle_codec ( AVFormatContext * s , AVCodec * c ) ;
2013-08-08 23:39:49 +03:00
2012-06-18 08:20:09 +03:00
/**
* Returns the method used to set ctx - > duration .
*
* @ return AVFMT_DURATION_FROM_PTS , AVFMT_DURATION_FROM_STREAM , or AVFMT_DURATION_FROM_BITRATE .
*/
2012-06-23 02:03:18 +03:00
enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method ( const AVFormatContext * ctx ) ;
2012-06-18 08:20:09 +03:00
2001-07-22 17:18:56 +03:00
typedef struct AVPacketList {
AVPacket pkt ;
struct AVPacketList * next ;
} AVPacketList ;
2011-12-11 09:55:21 +03:00
2009-02-15 11:04:08 +02:00
/**
2011-12-11 09:55:21 +03:00
* @ defgroup lavf_core Core functions
* @ ingroup libavf
*
* Functions for querying libavformat capabilities , allocating core structures ,
* etc .
* @ {
2009-02-15 11:04:08 +02:00
*/
/**
2011-12-11 09:55:21 +03:00
* Return the LIBAVFORMAT_VERSION_INT constant .
2009-02-15 11:04:08 +02:00
*/
2011-12-11 09:55:21 +03:00
unsigned avformat_version ( void ) ;
2009-12-31 18:38:21 +02:00
/**
2011-12-11 09:55:21 +03:00
* Return the libavformat build - time configuration .
2009-12-31 18:38:21 +02:00
*/
2011-12-11 09:55:21 +03:00
const char * avformat_configuration ( void ) ;
2007-03-03 14:23:20 +02:00
/**
2011-12-11 09:55:21 +03:00
* Return the libavformat license .
2007-03-03 14:23:20 +02:00
*/
2011-12-11 09:55:21 +03:00
const char * avformat_license ( void ) ;
2001-07-22 17:18:56 +03:00
2007-03-03 14:23:20 +02:00
/**
2011-12-11 09:55:21 +03:00
* Initialize libavformat and register all the muxers , demuxers and
* protocols . If you do not call this function , then you can select
* exactly which formats you want to support .
2007-03-12 16:17:26 +02:00
*
2011-12-11 09:55:21 +03:00
* @ see av_register_input_format ( )
* @ see av_register_output_format ( )
2007-03-03 14:23:20 +02:00
*/
2011-12-11 09:55:21 +03:00
void av_register_all ( void ) ;
void av_register_input_format ( AVInputFormat * format ) ;
void av_register_output_format ( AVOutputFormat * format ) ;
2007-03-03 14:23:20 +02:00
/**
2011-12-11 09:55:21 +03:00
* Do global initialization of network components . This is optional ,
* but recommended , since it avoids the overhead of implicitly
* doing the setup for each session .
2007-03-12 16:17:26 +02:00
*
2011-12-11 09:55:21 +03:00
* Calling this function will become mandatory if using network
* protocols at some major version bump .
2007-03-12 16:17:26 +02:00
*/
2011-12-11 09:55:21 +03:00
int avformat_network_init ( void ) ;
2007-03-12 16:17:26 +02:00
/**
2011-12-11 09:55:21 +03:00
* Undo the initialization done by avformat_network_init .
2007-03-03 14:23:20 +02:00
*/
2011-12-11 09:55:21 +03:00
int avformat_network_deinit ( void ) ;
2011-02-24 10:08:06 +02:00
2009-02-15 11:04:08 +02:00
/**
* If f is NULL , returns the first registered input format ,
2009-02-25 21:10:39 +02:00
* if f is non - NULL , returns the next registered input format after f
2009-02-15 11:04:08 +02:00
* or NULL if f is the last one .
*/
2007-12-12 21:01:58 +02:00
AVInputFormat * av_iformat_next ( AVInputFormat * f ) ;
2001-07-22 17:18:56 +03:00
2007-03-12 16:17:26 +02:00
/**
2009-02-15 11:04:08 +02:00
* If f is NULL , returns the first registered output format ,
2009-02-25 21:10:39 +02:00
* if f is non - NULL , returns the next registered output format after f
2009-02-15 11:04:08 +02:00
* or NULL if f is the last one .
2007-03-12 16:17:26 +02:00
*/
2007-12-12 21:01:58 +02:00
AVOutputFormat * av_oformat_next ( AVOutputFormat * f ) ;
2011-02-24 10:08:06 +02:00
2011-12-11 09:55:21 +03:00
/**
* Allocate an AVFormatContext .
* avformat_free_context ( ) can be used to free the context and everything
* allocated by the framework within it .
*/
AVFormatContext * avformat_alloc_context ( void ) ;
2007-03-12 16:17:26 +02:00
2009-01-25 18:44:45 +02:00
/**
2011-12-11 09:55:21 +03:00
* Free an AVFormatContext and all its streams .
* @ param s context to free
2009-01-25 18:44:45 +02:00
*/
2011-12-11 09:55:21 +03:00
void avformat_free_context ( AVFormatContext * s ) ;
2001-07-22 17:18:56 +03:00
2010-05-13 01:17:29 +03:00
/**
2011-12-11 09:55:21 +03:00
* Get the AVClass for AVFormatContext . It can be used in combination with
* AV_OPT_SEARCH_FAKE_OBJ for examining options .
2010-05-13 01:17:29 +03:00
*
2011-12-11 09:55:21 +03:00
* @ see av_opt_find ( ) .
2010-05-13 01:17:29 +03:00
*/
2011-12-11 09:55:21 +03:00
const AVClass * avformat_get_class ( void ) ;
2010-05-13 01:17:29 +03:00
/**
2011-12-11 09:55:21 +03:00
* Add a new stream to a media file .
2010-05-13 01:17:29 +03:00
*
2011-12-11 09:55:21 +03:00
* When demuxing , it is called by the demuxer in read_header ( ) . If the
* flag AVFMTCTX_NOHEADER is set in s . ctx_flags , then it may also
* be called in read_packet ( ) .
*
* When muxing , should be called by the user before avformat_write_header ( ) .
*
2013-07-24 09:50:02 +03:00
* User is required to call avcodec_close ( ) and avformat_free_context ( ) to
* clean up the allocation by avformat_new_stream ( ) .
*
2011-12-11 09:55:21 +03:00
* @ param c If non - NULL , the AVCodecContext corresponding to the new stream
* will be initialized to use this codec . This is needed for e . g . codec - specific
* defaults to be set , so codec should be provided if it is known .
*
* @ return newly created stream or NULL on error .
2010-05-13 01:17:29 +03:00
*/
2012-10-24 17:29:05 +03:00
AVStream * avformat_new_stream ( AVFormatContext * s , const AVCodec * c ) ;
2011-12-11 09:55:21 +03:00
AVProgram * av_new_program ( AVFormatContext * s , int id ) ;
2007-01-21 03:39:17 +02:00
2011-12-10 23:04:30 +03:00
/**
2011-12-11 09:55:21 +03:00
* @ }
2011-12-10 23:04:30 +03:00
*/
2011-12-11 09:55:21 +03:00
2011-12-11 02:40:09 +03:00
# if FF_API_ALLOC_OUTPUT_CONTEXT
/**
* @ deprecated deprecated in favor of avformat_alloc_output_context2 ( )
*/
attribute_deprecated
AVFormatContext * avformat_alloc_output_context ( const char * format ,
AVOutputFormat * oformat ,
const char * filename ) ;
# endif
/**
* Allocate an AVFormatContext for an output format .
* avformat_free_context ( ) can be used to free the context and
* everything allocated by the framework within it .
*
* @ param * ctx is set to the created format context , or to NULL in
* case of failure
* @ param oformat format to use for allocating the context , if NULL
* format_name and filename are used instead
* @ param format_name the name of output format to use for allocating the
* context , if NULL filename is used instead
* @ param filename the name of the filename to use for allocating the
* context , may be NULL
* @ return > = 0 in case of success , a negative AVERROR code in case of
* failure
*/
int avformat_alloc_output_context2 ( AVFormatContext * * ctx , AVOutputFormat * oformat ,
const char * format_name , const char * filename ) ;
2011-12-10 23:04:30 +03:00
/**
* @ addtogroup lavf_decoding
* @ {
*/
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Find AVInputFormat based on the short name of the input format .
2007-03-03 14:23:20 +02:00
*/
2002-05-20 19:28:47 +03:00
AVInputFormat * av_find_input_format ( const char * short_name ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Guess the file format .
2007-03-03 14:23:20 +02:00
*
2008-09-27 22:51:53 +03:00
* @ param is_opened Whether the file is already opened ; determines whether
* demuxers with or without AVFMT_NOFILE are probed .
2007-03-03 14:23:20 +02:00
*/
2002-07-25 19:01:46 +03:00
AVInputFormat * av_probe_input_format ( AVProbeData * pd , int is_opened ) ;
2007-03-03 14:23:20 +02:00
2010-05-01 16:49:35 +03:00
/**
2010-06-30 18:38:06 +03:00
* Guess the file format .
2010-05-01 16:49:35 +03:00
*
* @ param is_opened Whether the file is already opened ; determines whether
* demuxers with or without AVFMT_NOFILE are probed .
2010-05-01 18:36:51 +03:00
* @ param score_max A probe score larger that this is required to accept a
* detection , the variable is set to the actual detection
* score afterwards .
* If the score is < = AVPROBE_SCORE_MAX / 4 it is recommended
2010-05-01 16:49:35 +03:00
* to retry with a larger probe buffer .
*/
AVInputFormat * av_probe_input_format2 ( AVProbeData * pd , int is_opened , int * score_max ) ;
2011-03-04 02:12:17 +02:00
/**
* Guess the file format .
*
* @ param is_opened Whether the file is already opened ; determines whether
* demuxers with or without AVFMT_NOFILE are probed .
* @ param score_ret The score of the best detection .
*/
AVInputFormat * av_probe_input_format3 ( AVProbeData * pd , int is_opened , int * score_ret ) ;
2011-02-08 00:46:53 +02:00
/**
* Probe a bytestream to determine the input format . Each time a probe returns
* with a score that is too low , the probe buffer size is increased and another
* attempt is made . When the maximum probe size is reached , the input format
* with the highest score is returned .
*
* @ param pb the bytestream to probe
* @ param fmt the input format is put here
* @ param filename the filename of the stream
* @ param logctx the log context
* @ param offset the offset within the bytestream to probe from
* @ param max_probe_size the maximum probe buffer size ( zero for default )
2013-08-08 23:39:49 +03:00
* @ return the score in case of success , a negative value corresponding to an
* the maximal score is AVPROBE_SCORE_MAX
2011-02-08 00:46:53 +02:00
* AVERROR code otherwise
*/
2013-08-08 23:39:49 +03:00
int av_probe_input_buffer2 ( AVIOContext * pb , AVInputFormat * * fmt ,
const char * filename , void * logctx ,
unsigned int offset , unsigned int max_probe_size ) ;
/**
* Like av_probe_input_buffer2 ( ) but returns 0 on success
*/
2011-02-20 12:04:12 +02:00
int av_probe_input_buffer ( AVIOContext * pb , AVInputFormat * * fmt ,
2011-02-08 00:46:53 +02:00
const char * filename , void * logctx ,
unsigned int offset , unsigned int max_probe_size ) ;
2011-05-22 09:37:25 +03:00
/**
* Open an input stream and read the header . The codecs are not opened .
2013-08-20 13:23:24 +03:00
* The stream must be closed with avformat_close_input ( ) .
2011-05-22 09:37:25 +03:00
*
* @ param ps Pointer to user - supplied AVFormatContext ( allocated by avformat_alloc_context ) .
* May be a pointer to NULL , in which case an AVFormatContext is allocated by this
* function and written into ps .
* Note that a user - supplied AVFormatContext will be freed on failure .
* @ param filename Name of the stream to open .
* @ param fmt If non - NULL , this parameter forces a specific input format .
* Otherwise the format is autodetected .
* @ param options A dictionary filled with AVFormatContext and demuxer - private options .
* On return this parameter will be destroyed and replaced with a dict containing
* options that were not found . May be NULL .
*
* @ return 0 on success , a negative AVERROR on failure .
*
* @ note If you want to use custom IO , preallocate the format context and set its pb field .
*/
int avformat_open_input ( AVFormatContext * * ps , const char * filename , AVInputFormat * fmt , AVDictionary * * options ) ;
2009-02-08 10:16:40 +02:00
2012-01-28 06:23:26 +03:00
attribute_deprecated
int av_demuxer_open ( AVFormatContext * ic ) ;
2011-04-30 22:35:48 +03:00
2011-05-22 20:24:59 +03:00
# if FF_API_FORMAT_PARAMETERS
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Read packets of a media file to get stream information . This
2007-03-03 14:23:20 +02:00
* is useful for file formats with no headers such as MPEG . This
2009-02-25 21:10:39 +02:00
* function also computes the real framerate in case of MPEG - 2 repeat
2007-03-03 14:23:20 +02:00
* 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
2008-09-27 22:51:53 +03:00
* @ return > = 0 if OK , AVERROR_xxx on error
* @ todo Let the user decide somehow what information is needed so that
* we do not waste time getting stuff the user does not need .
2011-05-22 20:24:59 +03:00
*
* @ deprecated use avformat_find_stream_info .
2007-03-03 14:23:20 +02:00
*/
2011-07-17 14:59:04 +03:00
attribute_deprecated
2002-05-20 19:28:47 +03:00
int av_find_stream_info ( AVFormatContext * ic ) ;
2011-05-22 20:24:59 +03:00
# endif
/**
* 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 framerate in case of MPEG - 2 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
* @ param options If non - NULL , an ic . nb_streams long array of pointers to
* dictionaries , where i - th member contains options for
* codec corresponding to i - th stream .
* On return each dictionary will be filled with options that were not found .
* @ return > = 0 if OK , AVERROR_xxx on error
*
* @ note this function isn ' t guaranteed to open all the codecs , so
* options being non - empty at return is a perfectly normal behavior .
*
* @ todo Let the user decide somehow what information is needed so that
* we do not waste time getting stuff the user does not need .
*/
int avformat_find_stream_info ( AVFormatContext * ic , AVDictionary * * options ) ;
2007-03-03 14:23:20 +02:00
2011-08-23 00:42:19 +03:00
/**
* Find the programs which belong to a given stream .
*
* @ param ic media file handle
* @ param last the last found program , the search will start after this
* program , or from the beginning if it is NULL
* @ param s stream index
* @ return the next program which belongs to s , NULL if no program is found or
* the last program is not among the programs of ic .
*/
AVProgram * av_find_program_from_stream ( AVFormatContext * ic , AVProgram * last , int s ) ;
2010-12-27 11:08:20 +02:00
/**
* Find the " best " stream in the file .
* The best stream is determined according to various heuristics as the most
* likely to be what the user expects .
* If the decoder parameter is non - NULL , av_find_best_stream will find the
* default decoder for the stream ' s codec ; streams for which no decoder can
* be found are ignored .
*
* @ param ic media file handle
* @ param type stream type : video , audio , subtitles , etc .
* @ param wanted_stream_nb user - requested stream number ,
* or - 1 for automatic selection
* @ param related_stream try to find a stream related ( eg . in the same
* program ) to this one , or - 1 if none
* @ param decoder_ret if non - NULL , returns the decoder for the
* selected stream
* @ param flags flags ; none are currently defined
* @ return the non - negative stream number in case of success ,
* AVERROR_STREAM_NOT_FOUND if no stream with the requested type
* could be found ,
* AVERROR_DECODER_NOT_FOUND if streams were found but no decoder
* @ note If av_find_best_stream returns successfully and decoder_ret is not
* NULL , then * decoder_ret is guaranteed to be set to a valid AVCodec .
*/
int av_find_best_stream ( AVFormatContext * ic ,
enum AVMediaType type ,
int wanted_stream_nb ,
int related_stream ,
AVCodec * * decoder_ret ,
int flags ) ;
2012-03-04 23:41:59 +03:00
# if FF_API_READ_PACKET
2007-03-03 14:23:20 +02:00
/**
2012-03-04 23:41:59 +03:00
* @ deprecated use AVFMT_FLAG_NOFILLIN | AVFMT_FLAG_NOPARSE to read raw
* unprocessed packets
*
2010-06-30 18:38:06 +03:00
* Read a transport packet from a media file .
2007-03-03 14:23:20 +02:00
*
2007-06-05 00:05:58 +03:00
* This function is obsolete and should never be used .
2007-03-03 14:23:20 +02:00
* Use av_read_frame ( ) instead .
*
* @ param s media file handle
* @ param pkt is filled
2008-09-27 22:51:53 +03:00
* @ return 0 if OK , AVERROR_xxx on error
2007-03-03 14:23:20 +02:00
*/
2012-03-04 23:41:59 +03:00
attribute_deprecated
2001-07-22 17:18:56 +03:00
int av_read_packet ( AVFormatContext * s , AVPacket * pkt ) ;
2012-03-04 23:41:59 +03:00
# endif
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Return the next frame of a stream .
2010-09-15 01:20:46 +03:00
* This function returns what is stored in the file , and does not validate
* that what is there are valid frames for the decoder . It will split what is
* stored in the file into frames and return one for each call . It will not
* omit invalid data between valid frames so as to give the decoder the maximum
* information possible for decoding .
2007-03-03 14:23:20 +02:00
*
2012-10-31 10:53:18 +03:00
* If pkt - > buf is NULL , then the packet is valid until the next
2013-08-20 13:23:24 +03:00
* av_read_frame ( ) or until avformat_close_input ( ) . Otherwise the packet
* is valid indefinitely . In both cases the packet must be freed with
2012-10-31 21:59:53 +03:00
* av_free_packet when it is no longer needed . 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 .
2007-03-03 14:23:20 +02:00
*
* pkt - > pts , pkt - > dts and pkt - > duration are always set to correct
2009-02-25 21:10:39 +02:00
* values in AVStream . time_base units ( and guessed if the format cannot
2008-09-27 22:51:53 +03:00
* provide 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
2007-03-03 14:23:20 +02:00
* decompress the payload .
*
2008-09-27 22:51:53 +03:00
* @ return 0 if OK , < 0 on error or end of file
2007-03-03 14:23:20 +02:00
*/
2003-11-10 20:37:55 +02:00
int av_read_frame ( AVFormatContext * s , AVPacket * pkt ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Seek to the keyframe at timestamp .
2007-03-03 14:23:20 +02:00
* ' 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 .
2008-09-27 22:51:53 +03:00
* @ param timestamp Timestamp in AVStream . time_base units
* or , if no stream is specified , in AV_TIME_BASE units .
2007-03-03 14:23:20 +02:00
* @ param flags flags which select direction and seeking mode
* @ return > = 0 on success
*/
2008-09-27 23:05:12 +03:00
int av_seek_frame ( AVFormatContext * s , int stream_index , int64_t timestamp ,
int flags ) ;
2007-03-03 14:23:20 +02:00
2009-02-08 19:52:52 +02:00
/**
2010-06-30 18:38:06 +03:00
* Seek to timestamp ts .
2009-02-08 19:52:52 +02:00
* Seeking will be done so that the point from which all active streams
* can be presented successfully will be closest to ts and within min / max_ts .
* Active streams are all streams that have AVStream . discard < AVDISCARD_ALL .
*
2009-02-25 21:10:39 +02:00
* If flags contain AVSEEK_FLAG_BYTE , then all timestamps are in bytes and
2009-02-08 19:52:52 +02:00
* are the file position ( this may not be supported by all demuxers ) .
2009-02-25 21:10:39 +02:00
* If flags contain AVSEEK_FLAG_FRAME , then all timestamps are in frames
2009-02-08 19:52:52 +02:00
* in the stream with stream_index ( this may not be supported by all demuxers ) .
2009-02-25 21:10:39 +02:00
* Otherwise all timestamps are in units of the stream selected by stream_index
* or if stream_index is - 1 , in AV_TIME_BASE units .
* If flags contain AVSEEK_FLAG_ANY , then non - keyframes are treated as
2009-02-08 19:52:52 +02:00
* keyframes ( this may not be supported by all demuxers ) .
2013-05-03 11:31:33 +03:00
* If flags contain AVSEEK_FLAG_BACKWARD , it is ignored .
2009-02-08 19:52:52 +02:00
*
2009-02-25 21:10:39 +02:00
* @ param stream_index index of the stream which is used as time base reference
2009-02-08 19:52:52 +02:00
* @ param min_ts smallest acceptable timestamp
* @ param ts target timestamp
* @ param max_ts largest acceptable timestamp
* @ param flags flags
2010-03-30 18:50:57 +03:00
* @ return > = 0 on success , error code otherwise
2009-02-08 19:55:00 +02:00
*
2010-07-02 14:46:29 +03:00
* @ note This is part of the new seek API which is still under construction .
2009-02-25 21:10:39 +02:00
* Thus do not use this yet . It may change at any time , do not expect
* ABI compatibility yet !
2009-02-08 19:52:52 +02:00
*/
int avformat_seek_file ( AVFormatContext * s , int stream_index , int64_t min_ts , int64_t ts , int64_t max_ts , int flags ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Start playing a network - based stream ( e . g . RTSP stream ) at the
2008-09-27 22:51:53 +03:00
* current position .
2007-03-03 14:23:20 +02:00
*/
2003-11-10 20:37:55 +02:00
int av_read_play ( AVFormatContext * s ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Pause a network - based stream ( e . g . RTSP stream ) .
2007-03-03 14:23:20 +02:00
*
* Use av_read_play ( ) to resume it .
*/
2003-11-10 20:37:55 +02:00
int av_read_pause ( AVFormatContext * s ) ;
2007-03-03 14:23:20 +02:00
2011-12-11 12:34:08 +03:00
# if FF_API_CLOSE_INPUT_FILE
2007-03-03 14:23:20 +02:00
/**
2011-12-11 12:34:08 +03:00
* @ deprecated use avformat_close_input ( )
2010-06-30 18:38:06 +03:00
* Close a media file ( but not its codecs ) .
2007-03-03 14:23:20 +02:00
*
* @ param s media file handle
*/
2011-12-11 12:34:08 +03:00
attribute_deprecated
2001-07-22 17:18:56 +03:00
void av_close_input_file ( AVFormatContext * s ) ;
2011-12-11 12:34:08 +03:00
# endif
2011-12-10 23:04:30 +03:00
/**
2011-12-11 12:34:08 +03:00
* Close an opened input AVFormatContext . Free it and all its contents
* and set * s to NULL .
2011-12-10 23:04:30 +03:00
*/
2011-12-11 12:34:08 +03:00
void avformat_close_input ( AVFormatContext * * s ) ;
2011-02-04 12:04:16 +02:00
/**
2011-12-10 23:04:30 +03:00
* @ }
2011-02-04 12:04:16 +02:00
*/
2011-06-18 12:19:27 +03:00
# if FF_API_NEW_STREAM
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Add a new stream to a media file .
2007-03-03 14:23:20 +02:00
*
* 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
2008-09-27 22:51:53 +03:00
* @ param id file - format - dependent stream ID
2007-03-03 14:23:20 +02:00
*/
2011-06-18 12:19:27 +03:00
attribute_deprecated
2002-05-20 19:28:47 +03:00
AVStream * av_new_stream ( AVFormatContext * s , int id ) ;
2011-06-18 12:19:27 +03:00
# endif
2011-11-29 21:28:15 +03:00
# if FF_API_SET_PTS_INFO
2007-03-03 14:23:20 +02:00
/**
2011-11-29 21:28:15 +03:00
* @ deprecated this function is not supposed to be called outside of lavf
2007-03-03 14:23:20 +02:00
*/
2011-11-29 21:28:15 +03:00
attribute_deprecated
2004-05-21 23:43:21 +03:00
void av_set_pts_info ( AVStream * s , int pts_wrap_bits ,
2009-07-01 21:50:31 +03:00
unsigned int pts_num , unsigned int pts_den ) ;
2011-11-29 21:28:15 +03:00
# endif
2001-07-22 17:18:56 +03:00
2004-10-11 01:05:43 +03:00
# define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
# define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes
2008-09-27 22:51:53 +03:00
# define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non-keyframes
2009-08-10 23:48:05 +03:00
# define AVSEEK_FLAG_FRAME 8 ///< seeking based on frame number
2004-10-11 01:05:43 +03:00
2011-12-10 23:04:30 +03:00
/**
* @ addtogroup lavf_encoding
* @ {
*/
2011-05-22 14:53:33 +03:00
/**
* Allocate the stream private data and write the stream header to
* an output media file .
*
* @ param s Media file handle , must be allocated with avformat_alloc_context ( ) .
* Its oformat field must be set to the desired output format ;
2012-08-21 02:02:13 +03:00
* Its pb field must be set to an already opened AVIOContext .
2011-05-22 14:53:33 +03:00
* @ param options An AVDictionary filled with AVFormatContext and muxer - private options .
* On return this parameter will be destroyed and replaced with a dict containing
* options that were not found . May be NULL .
*
* @ return 0 on success , negative AVERROR on failure .
*
* @ see av_opt_find , av_dict_set , avio_open , av_oformat_next .
*/
int avformat_write_header ( AVFormatContext * s , AVDictionary * * options ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Write a packet to an output media file .
2007-03-03 14:23:20 +02:00
*
* The packet shall contain one audio or video frame .
2008-09-27 23:05:12 +03:00
* The packet must be correctly interleaved according to the container
* specification , if not then av_interleaved_write_frame must be used .
2007-03-03 14:23:20 +02:00
*
* @ param s media file handle
2008-09-27 23:05:12 +03:00
* @ param pkt The packet , which contains the stream_index , buf / buf_size ,
2012-01-20 20:27:33 +03:00
* dts / pts , . . .
* This can be NULL ( at any time , not just at the end ) , in
* order to immediately flush data buffered within the muxer ,
* for muxers that buffer up data internally before writing it
* to the output .
* @ return < 0 on error , = 0 if OK , 1 if flushed and there is no more data to flush
2007-03-03 14:23:20 +02:00
*/
2004-05-29 05:06:32 +03:00
int av_write_frame ( AVFormatContext * s , AVPacket * pkt ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Write a packet to an output media file ensuring correct interleaving .
2007-03-03 14:23:20 +02:00
*
* The packet must contain one audio or video frame .
2009-02-25 21:10:39 +02:00
* If the packets are already correctly interleaved , the application should
2007-06-12 21:50:50 +03:00
* 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 .
2007-03-03 14:23:20 +02:00
*
* @ param s media file handle
2012-10-31 10:53:18 +03:00
* @ param pkt The packet containing the data to be written . pkt - > buf must be set
* to a valid AVBufferRef describing the packet data . Libavformat takes
* ownership of this reference and will unref it when it sees fit . The caller
* must not access the data through this reference after this function returns .
2012-10-31 18:54:16 +03:00
* This can be NULL ( at any time , not just at the end ) , to flush the
* interleaving queues .
2012-01-18 09:59:02 +03:00
* Packet ' s @ ref AVPacket . stream_index " stream_index " field must be set to the
* index of the corresponding stream in @ ref AVFormatContext . streams
* " s.streams " .
* It is very strongly recommended that timing information ( @ ref AVPacket . pts
* " pts " , @ ref AVPacket . dts " dts " @ ref AVPacket . duration " duration " ) is set to
* correct values .
*
* @ return 0 on success , a negative AVERROR on error .
2007-03-03 14:23:20 +02:00
*/
2004-05-29 21:50:31 +03:00
int av_interleaved_write_frame ( AVFormatContext * s , AVPacket * pkt ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Write the stream trailer to an output media file and free the
2009-06-29 00:05:46 +03:00
* file private data .
2007-03-03 14:23:20 +02:00
*
2012-10-17 22:45:23 +03:00
* May only be called after a successful call to avformat_write_header .
2008-09-03 20:57:56 +03:00
*
2007-03-03 14:23:20 +02:00
* @ param s media file handle
2008-09-27 22:51:53 +03:00
* @ return 0 if OK , AVERROR_xxx on error
2007-03-03 14:23:20 +02:00
*/
2002-05-20 19:28:47 +03:00
int av_write_trailer ( AVFormatContext * s ) ;
2011-12-11 10:07:53 +03:00
2011-12-10 23:04:30 +03:00
/**
2011-12-11 10:07:53 +03:00
* Return the output format in the list of registered output formats
* which best matches the provided parameters , or return NULL if
* there is no match .
*
* @ param short_name if non - NULL checks if short_name matches with the
* names of the registered formats
* @ param filename if non - NULL checks if filename terminates with the
* extensions of the registered formats
* @ param mime_type if non - NULL checks if mime_type matches with the
* MIME type of the registered formats
*/
AVOutputFormat * av_guess_format ( const char * short_name ,
const char * filename ,
const char * mime_type ) ;
/**
* Guess the codec ID based upon muxer and filename .
2011-12-10 23:04:30 +03:00
*/
2012-08-05 12:11:04 +03:00
enum AVCodecID av_guess_codec ( AVOutputFormat * fmt , const char * short_name ,
2011-12-11 10:07:53 +03:00
const char * filename , const char * mime_type ,
enum AVMediaType type ) ;
2001-07-22 17:18:56 +03:00
2011-06-30 20:45:22 +03:00
/**
* Get timing information for the data currently output .
* The exact meaning of " currently output " depends on the format .
* It is mostly relevant for devices that have an internal buffer and / or
* work in real time .
* @ param s media file handle
* @ param stream stream in the media file
2012-11-21 11:54:15 +03:00
* @ param [ out ] dts DTS of the last packet output for the stream , in stream
2011-06-30 20:45:22 +03:00
* time_base units
2012-11-21 11:54:15 +03:00
* @ param [ out ] wall absolute time when that packet whas output ,
2011-06-30 20:45:22 +03:00
* in microsecond
* @ return 0 if OK , AVERROR ( ENOSYS ) if the format does not support it
* Note : some formats or devices may not allow to measure dts and wall
* atomically .
*/
int av_get_output_timestamp ( struct AVFormatContext * s , int stream ,
int64_t * dts , int64_t * wall ) ;
2011-12-13 02:29:25 +03:00
2011-12-10 23:04:30 +03:00
/**
* @ }
*/
2001-07-22 17:18:56 +03:00
2011-12-11 10:08:46 +03:00
/**
* @ defgroup lavf_misc Utility functions
* @ ingroup libavf
* @ {
*
2012-07-06 02:38:53 +03:00
* Miscellaneous utility functions related to both muxing and demuxing
2011-12-11 10:08:46 +03:00
* ( or neither ) .
*/
/**
* 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 .
* @ param buf buffer
* @ param size buffer size
*
* @ see av_hex_dump_log , av_pkt_dump2 , av_pkt_dump_log2
*/
2012-10-01 13:48:23 +03:00
void av_hex_dump ( FILE * f , const uint8_t * buf , int size ) ;
2011-12-11 10:08:46 +03:00
/**
* 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_dump2 , av_pkt_dump_log2
*/
2012-10-01 13:48:23 +03:00
void av_hex_dump_log ( void * avcl , int level , const uint8_t * buf , int size ) ;
2011-12-11 10:08:46 +03:00
/**
* 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 .
* @ param pkt packet to dump
* @ param dump_payload True if the payload must be displayed , too .
* @ param st AVStream that the packet belongs to
*/
void av_pkt_dump2 ( FILE * f , AVPacket * pkt , int dump_payload , AVStream * st ) ;
/**
* 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 .
* @ param st AVStream that the packet belongs to
*/
void av_pkt_dump_log2 ( void * avcl , int level , AVPacket * pkt , int dump_payload ,
AVStream * st ) ;
/**
2012-08-05 12:11:04 +03:00
* Get the AVCodecID for the given codec tag tag .
* If no codec id is found returns AV_CODEC_ID_NONE .
2011-12-11 10:08:46 +03:00
*
* @ param tags list of supported codec_id - codec_tag pairs , as stored
* in AVInputFormat . codec_tag and AVOutputFormat . codec_tag
*/
2012-08-05 12:11:04 +03:00
enum AVCodecID av_codec_get_id ( const struct AVCodecTag * const * tags , unsigned int tag ) ;
2011-12-11 10:08:46 +03:00
/**
* Get the codec tag for the given codec id id .
* If no codec tag is found returns 0.
*
* @ param tags list of supported codec_id - codec_tag pairs , as stored
* in AVInputFormat . codec_tag and AVOutputFormat . codec_tag
*/
2012-08-05 12:11:04 +03:00
unsigned int av_codec_get_tag ( const struct AVCodecTag * const * tags , enum AVCodecID id ) ;
2011-12-11 10:08:46 +03:00
2013-01-17 22:44:33 +03:00
/**
* Get the codec tag for the given codec id .
*
* @ param tags list of supported codec_id - codec_tag pairs , as stored
* in AVInputFormat . codec_tag and AVOutputFormat . codec_tag
* @ param id codec id that should be searched for in the list
* @ param tag A pointer to the found tag
* @ return 0 if id was not found in tags , > 0 if it was found
*/
int av_codec_get_tag2 ( const struct AVCodecTag * const * tags , enum AVCodecID id ,
unsigned int * tag ) ;
2011-12-11 10:08:46 +03:00
int av_find_default_stream_index ( AVFormatContext * s ) ;
/**
* Get 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
*/
int av_index_search_timestamp ( AVStream * st , int64_t timestamp , int flags ) ;
/**
* Add an index entry into a sorted list . Update the entry if the list
* already contains it .
*
* @ param timestamp timestamp in the time base of the given stream
*/
int av_add_index_entry ( AVStream * st , int64_t pos , int64_t timestamp ,
int size , int distance , int flags ) ;
/**
* Split a URL string into components .
*
* The pointers to buffers for storing individual components may be null ,
* in order to ignore that component . Buffers for components not found are
* set to empty strings . If the port is not found , it is set to a negative
* value .
*
* @ param proto the buffer for the protocol
* @ param proto_size the size of the proto buffer
* @ param authorization the buffer for the authorization
* @ param authorization_size the size of the authorization buffer
* @ param hostname the buffer for the host name
* @ param hostname_size the size of the hostname buffer
* @ param port_ptr a pointer to store the port number in
* @ param path the buffer for the path
* @ param path_size the size of the path buffer
* @ param url the URL to split
*/
void av_url_split ( char * proto , int proto_size ,
char * authorization , int authorization_size ,
char * hostname , int hostname_size ,
int * port_ptr ,
char * path , int path_size ,
const char * url ) ;
2011-02-16 10:52:35 +02:00
void av_dump_format ( AVFormatContext * ic ,
int index ,
const char * url ,
int is_output ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Return in ' buf ' the path with ' % d ' replaced by a number .
2008-09-27 22:51:53 +03:00
*
2007-03-03 14:23:20 +02:00
* Also handles the ' % 0 nd ' 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
2007-11-15 13:45:07 +02:00
* @ param number frame number
2008-09-27 22:51:53 +03:00
* @ return 0 if OK , - 1 on format error
2007-03-03 14:23:20 +02:00
*/
2006-09-04 12:57:47 +03:00
int av_get_frame_filename ( char * buf , int buf_size ,
const char * path , int number ) ;
2007-03-03 14:23:20 +02:00
/**
2010-06-30 18:38:06 +03:00
* Check whether filename actually is a numbered sequence generator .
2007-03-03 14:23:20 +02:00
*
* @ param filename possible numbered sequence string
2008-09-27 22:51:53 +03:00
* @ return 1 if a valid numbered sequence string , 0 otherwise
2007-03-03 14:23:20 +02:00
*/
2006-09-04 12:57:47 +03:00
int av_filename_number_test ( const char * filename ) ;
2001-09-25 02:25:28 +03:00
2007-07-27 01:34:26 +03:00
/**
2010-06-30 18:38:06 +03:00
* Generate an SDP for an RTP session .
2007-07-27 01:34:26 +03:00
*
2012-11-11 22:44:28 +03:00
* Note , this overwrites the id values of AVStreams in the muxer contexts
* for getting unique dynamic payload types .
*
2007-07-27 01:34:26 +03:00
* @ param ac array of AVFormatContexts describing the RTP streams . If the
* array is composed by only one context , such context can contain
* multiple AVStreams ( one AVStream per RTP stream ) . Otherwise ,
* all the contexts in the array ( an AVCodecContext per RTP stream )
2008-09-27 22:51:53 +03:00
* must contain only one AVStream .
2007-08-05 16:44:56 +03:00
* @ param n_files number of AVCodecContexts contained in ac
2011-04-08 13:22:39 +03:00
* @ param buf buffer where the SDP will be stored ( must be allocated by
* the caller )
2007-08-05 16:44:56 +03:00
* @ param size the size of the buffer
2008-09-27 22:51:53 +03:00
* @ return 0 if OK , AVERROR_xxx on error
2007-07-27 01:34:26 +03:00
*/
2011-04-08 13:22:39 +03:00
int av_sdp_create ( AVFormatContext * ac [ ] , int n_files , char * buf , int size ) ;
2011-04-08 12:36:12 +03:00
2010-03-31 22:03:03 +03:00
/**
2010-06-30 18:38:06 +03:00
* Return a positive value if the given filename has one of the given
2010-03-31 22:03:03 +03:00
* extensions , 0 otherwise .
*
* @ param extensions a comma - separated list of filename extensions
*/
int av_match_ext ( const char * filename , const char * extensions ) ;
2011-08-11 21:34:45 +03:00
/**
* Test if the given container can store a codec .
*
* @ param std_compliance standards compliance level , one of FF_COMPLIANCE_ *
*
* @ return 1 if codec with ID codec_id can be stored in ofmt , 0 if it cannot .
* A negative number if this information is not available .
*/
2012-08-05 12:11:04 +03:00
int avformat_query_codec ( AVOutputFormat * ofmt , enum AVCodecID codec_id , int std_compliance ) ;
2011-08-11 21:34:45 +03:00
2012-01-27 15:33:09 +03:00
/**
* @ defgroup riff_fourcc RIFF FourCCs
* @ {
2012-08-05 12:11:04 +03:00
* Get the tables mapping RIFF FourCCs to libavcodec AVCodecIDs . The tables are
2012-01-27 15:33:09 +03:00
* meant to be passed to av_codec_get_id ( ) / av_codec_get_tag ( ) as in the
* following code :
* @ code
* uint32_t tag = MKTAG ( ' H ' , ' 2 ' , ' 6 ' , ' 4 ' ) ;
* const struct AVCodecTag * table [ ] = { avformat_get_riff_video_tags ( ) , 0 } ;
2012-08-05 12:11:04 +03:00
* enum AVCodecID id = av_codec_get_id ( table , tag ) ;
2012-01-27 15:33:09 +03:00
* @ endcode
*/
/**
2012-08-05 12:11:04 +03:00
* @ return the table mapping RIFF FourCCs for video to libavcodec AVCodecID .
2012-01-27 15:33:09 +03:00
*/
const struct AVCodecTag * avformat_get_riff_video_tags ( void ) ;
/**
2012-08-05 12:11:04 +03:00
* @ return the table mapping RIFF FourCCs for audio to AVCodecID .
2012-01-27 15:33:09 +03:00
*/
const struct AVCodecTag * avformat_get_riff_audio_tags ( void ) ;
2012-05-07 21:27:08 +03:00
2012-05-30 20:36:58 +03:00
/**
* @ }
*/
2012-05-07 21:27:08 +03:00
/**
2012-07-24 10:41:48 +03:00
* Guess the sample aspect ratio of a frame , based on both the stream and the
2012-05-07 21:27:08 +03:00
* frame aspect ratio .
*
* Since the frame aspect ratio is set by the codec but the stream aspect ratio
* is set by the demuxer , these two may not be equal . This function tries to
* return the value that you should use if you would like to display the frame .
*
* Basic logic is to use the stream aspect ratio if it is set to something sane
* otherwise use the frame aspect ratio . This way a container setting , which is
* usually easy to modify can override the coded value in the frames .
*
* @ param format the format context which the stream is part of
* @ param stream the stream which the frame is part of
* @ param frame the frame with the aspect ratio to be determined
* @ return the guessed ( valid ) sample_aspect_ratio , 0 / 1 if no idea
*/
AVRational av_guess_sample_aspect_ratio ( AVFormatContext * format , AVStream * stream , AVFrame * frame ) ;
2013-03-28 00:08:53 +03:00
/**
* Guess the frame rate , based on both the container and codec information .
*
* @ param ctx the format context which the stream is part of
* @ param stream the stream which the frame is part of
* @ param frame the frame for which the frame rate should be determined , may be NULL
* @ return the guessed ( valid ) frame rate , 0 / 1 if no idea
*/
AVRational av_guess_frame_rate ( AVFormatContext * ctx , AVStream * stream , AVFrame * frame ) ;
2012-07-18 12:41:13 +03:00
/**
* Check if the stream st contained in s is matched by the stream specifier
* spec .
*
* See the " stream specifiers " chapter in the documentation for the syntax
* of spec .
*
* @ return > 0 if st is matched by spec ;
* 0 if st is not matched by spec ;
* AVERROR code if spec is invalid
*
* @ note A stream specifier can match several streams in the format .
*/
int avformat_match_stream_specifier ( AVFormatContext * s , AVStream * st ,
const char * spec ) ;
2013-03-08 19:28:42 +03:00
int avformat_queue_attached_pictures ( AVFormatContext * s ) ;
2012-08-14 03:01:38 +03:00
2011-08-23 08:23:52 +03:00
/**
2011-12-11 10:08:46 +03:00
* @ }
2011-11-01 14:40:04 +03:00
*/
2008-08-31 10:39:47 +03:00
# endif /* AVFORMAT_AVFORMAT_H */