2006-09-10 14:02:42 +00:00
/*
* copyright ( c ) 2001 Fabrice Bellard
*
2006-10-07 15:30:46 +00:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2006-09-10 14:02:42 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 15:30:46 +00:00
* version 2.1 of the License , or ( at your option ) any later version .
2006-09-10 14:02:42 +00:00
*
2006-10-07 15:30:46 +00:00
* FFmpeg is distributed in the hope that it will be useful ,
2006-09-10 14:02:42 +00: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 15:30:46 +00:00
* License along with FFmpeg ; if not , write to the Free Software
2006-09-10 14:02:42 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
2008-08-31 07:39:47 +00:00
# ifndef AVFORMAT_AVFORMAT_H
# define AVFORMAT_AVFORMAT_H
2001-07-22 14:18:56 +00:00
2011-12-10 19:16:57 +00:00
/**
* @ file
* @ ingroup libavf
* Main libavformat public API header
*/
2011-11-22 16:11:28 +00:00
/**
* @ defgroup libavf I / O and Muxing / Demuxing Library
* @ {
*
2011-12-11 08:05:11 +00: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 03:41:07 +00:00
* most Libavformat structures , its size is not part of public ABI , so it cannot be
2011-12-11 08:05:11 +00: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 07:34:55 +00: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 16:11:28 +00:00
* @ defgroup lavf_decoding Demuxing
* @ {
2011-12-11 08:51:19 +00:00
* Demuxers read a media file and split it into chunks of data ( @ em packets ) . A
2012-01-03 06:41:14 +00: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 08:51:19 +00: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 07:34:55 +00: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 08:51:19 +00: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 08:35:17 +00: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 07:53:18 +00:00
* If AVPacket . buf is set on the returned packet , then the packet is
2012-10-31 18:59:53 +00:00
* allocated dynamically and the user may keep it indefinitely .
2012-10-31 07:53:18 +00:00
* Otherwise , if AVPacket . buf is NULL , the packet data is backed by a
2012-10-31 18:59:53 +00: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 08:51:19 +00:00
*
* @ section lavf_decoding_seek Seeking
2011-11-22 16:11:28 +00:00
* @ }
*
* @ defgroup lavf_encoding Muxing
* @ {
2014-02-04 16:35:18 +00:00
* Muxers take encoded data in the form of @ ref AVPacket " AVPackets " and write
* it into files or other output bytestreams in the specified container format .
*
* The main API functions for muxing are avformat_write_header ( ) for writing the
* file header , av_write_frame ( ) / av_interleaved_write_frame ( ) for writing the
* packets and av_write_trailer ( ) for finalizing the file .
*
* At the beginning of the muxing process , the caller must first call
* avformat_alloc_context ( ) to create a muxing context . The caller then sets up
* the muxer by filling the various fields in this context :
*
* - The @ ref AVFormatContext . oformat " oformat " field must be set to select the
* muxer that will be used .
* - Unless the format is of the AVFMT_NOFILE type , the @ ref AVFormatContext . pb
* " pb " field must be set to an opened IO context , either returned from
* avio_open2 ( ) or a custom one .
* - Unless the format is of the AVFMT_NOSTREAMS type , at least one stream must
* be created with the avformat_new_stream ( ) function . The caller should fill
* the @ ref AVStream . codec " stream codec context " information , such as the
* codec @ ref AVCodecContext . codec_type " type " , @ ref AVCodecContext . codec_id
* " id " and other parameters ( e . g . width / height , the pixel or sample format ,
2014-07-09 10:26:03 +00:00
* etc . ) as known . The @ ref AVStream . time_base " stream timebase " should
2014-02-04 16:35:18 +00:00
* be set to the timebase that the caller desires to use for this stream ( note
* that the timebase actually used by the muxer can be different , as will be
* described later ) .
* - The caller may fill in additional information , such as @ ref
* AVFormatContext . metadata " global " or @ ref AVStream . metadata " per-stream "
* metadata , @ ref AVFormatContext . chapters " chapters " , @ ref
* AVFormatContext . programs " programs " , etc . as described in the
* AVFormatContext documentation . Whether such information will actually be
* stored in the output depends on what the container format and the muxer
* support .
*
* When the muxing context is fully set up , the caller must call
* avformat_write_header ( ) to initialize the muxer internals and write the file
* header . Whether anything actually is written to the IO context at this step
* depends on the muxer , but this function must always be called . Any muxer
* private options must be passed in the options parameter to this function .
*
* The data is then sent to the muxer by repeatedly calling av_write_frame ( ) or
* av_interleaved_write_frame ( ) ( consult those functions ' documentation for
* discussion on the difference between them ; only one of them may be used with
* a single muxing context , they should not be mixed ) . Do note that the timing
* information on the packets sent to the muxer must be in the corresponding
* AVStream ' s timebase . That timebase is set by the muxer ( in the
2014-07-09 10:26:03 +00:00
* avformat_write_header ( ) step ) and may be different from the timebase
* requested by the caller .
2014-02-04 16:35:18 +00:00
*
* Once all the data has been written , the caller must call av_write_trailer ( )
* to flush any buffered packets and finalize the output file , then close the IO
* context ( if any ) and finally free the muxing context with
* avformat_free_context ( ) .
2011-11-22 16:11:28 +00:00
* @ }
*
2011-12-10 19:09:04 +00:00
* @ defgroup lavf_io I / O Read / Write
2011-11-22 16:11:28 +00: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 19:30:21 +00:00
2003-09-08 21:20:55 +00:00
# include <time.h>
2003-11-13 22:15:11 +00:00
# include <stdio.h> /* FILE */
2008-02-25 09:22:11 +00:00
# include "libavcodec/avcodec.h"
2011-05-22 10:45:00 +00:00
# include "libavutil/dict.h"
2011-06-04 12:34:27 +00:00
# include "libavutil/log.h"
2001-07-22 14:18:56 +00:00
# include "avio.h"
2011-01-21 19:18:06 +00:00
# include "libavformat/version.h"
2001-07-22 14:18:56 +00:00
2009-02-28 23:34:16 +00:00
struct AVFormatContext ;
2014-02-16 19:06:23 +00:00
struct AVDeviceInfoList ;
2014-04-03 17:11:19 +00:00
struct AVDeviceCapabilitiesQuery ;
2009-01-04 18:58:49 +00:00
2011-07-01 18:49:14 +00:00
/**
* @ defgroup metadata_api Public Metadata API
* @ {
2011-12-10 19:06:49 +00:00
* @ ingroup libavf
2009-01-04 20:47:09 +00:00
* The metadata API allows libavformat to export metadata tags to a client
2011-12-10 19:39:39 +00: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-10 23:40:09 +00:00
* using the @ ref lavu_dict " AVDictionary " API . Like all strings in FFmpeg ,
2011-12-10 19:39:39 +00:00
* metadata is assumed to be UTF - 8 encoded Unicode . Note that metadata
2010-02-24 18:01:44 +00:00
* exported by demuxers isn ' t checked to be valid UTF - 8 in most cases .
2011-12-10 19:39:39 +00:00
*
2009-01-04 20:47:09 +00:00
* Important concepts to keep in mind :
2011-07-01 18:49:14 +00:00
* - Keys are unique ; there can never be 2 tags with the same key . This is
2009-01-04 20:47:09 +00: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 18:49:14 +00:00
* - Metadata is flat , not hierarchical ; there are no subtags . If you
2009-01-04 20:47:09 +00: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 18:49:14 +00:00
* - Several modifiers can be applied to the tag name . This is done by
2010-02-01 11:39:10 +00: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 18:49:14 +00:00
* - language - - a tag whose value is localized for a particular language
2010-02-01 11:39:10 +00: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 18:49:14 +00:00
* - sorting - - a modified version of a tag that should be used for
2010-02-01 11:39:10 +00:00
* sorting will have ' - sort ' appended . E . g . artist = " The Beatles " ,
* artist - sort = " Beatles, The " .
*
2011-07-01 18:49:14 +00:00
* - Demuxers attempt to export metadata in a generic format , however tags
2010-10-15 19:04:25 +00:00
* with no generic equivalents are left as they are stored in the container .
* Follows a list of generic tag names :
2010-02-01 11:39:10 +00:00
*
2011-07-01 18:49:14 +00: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 18:50:33 +00:00
* Look in the examples section for an application example how to use the Metadata API .
*
2011-07-01 18:49:14 +00:00
* @ }
2009-01-04 18:58:49 +00:00
*/
2001-07-22 14:18:56 +00:00
/* packet functions */
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Allocate and read the payload of a packet and initialize its
2009-06-28 21:01:51 +00:00
* fields with default values .
2007-03-03 12:23:20 +00:00
*
2014-02-16 22:36:31 +00:00
* @ param s associated IO context
2007-03-03 12:23:20 +00:00
* @ param pkt packet
2008-09-27 19:51:53 +00:00
* @ param size desired payload size
* @ return > 0 ( read size ) if OK , AVERROR_xxx otherwise
2007-03-03 12:23:20 +00:00
*/
2011-02-20 10:04:12 +00:00
int av_get_packet ( AVIOContext * s , AVPacket * pkt , int size ) ;
2007-03-03 12:23:20 +00:00
2001-07-22 14:18:56 +00:00
2010-11-21 10:24:48 +00:00
/**
2010-11-21 11:33:26 +00: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 10:24:48 +00: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 .
*
2014-02-16 22:36:31 +00:00
* @ param s associated IO context
2010-11-21 10:24:48 +00:00
* @ 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 10:04:12 +00:00
int av_append_packet ( AVIOContext * s , AVPacket * pkt , int size ) ;
2010-11-21 10:24:48 +00:00
2014-05-18 10:36:00 +00:00
# if FF_API_LAVF_FRAC
2002-10-21 15:54:49 +00:00
/*************************************************/
/* fractional numbers for exact pts handling */
2007-05-02 09:13:47 +00:00
/**
2008-09-27 19:51:53 +00:00
* The exact value of the fractional number is : ' val + num / den ' .
* num is assumed to be 0 < = num < den .
2009-02-11 00:25:30 +00:00
*/
2002-10-21 15:54:49 +00:00
typedef struct AVFrac {
2005-12-17 18:14:38 +00:00
int64_t val , num , den ;
2009-01-05 22:10:16 +00:00
} AVFrac ;
2014-05-18 10:36:00 +00:00
# endif
2002-10-21 15:54:49 +00:00
2001-07-22 14:18:56 +00:00
/*************************************************/
2002-05-20 16:28:47 +00:00
/* input/output formats */
2001-07-22 14:18:56 +00:00
2007-01-21 01:39:17 +00:00
struct AVCodecTag ;
2010-07-27 15:20:02 +00:00
/**
* This structure contains the data a format has to probe a file .
*/
2002-05-20 16:28:47 +00:00
typedef struct AVProbeData {
2003-02-10 09:35:32 +00:00
const char * filename ;
2009-09-09 22:55:10 +00: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 16:28:47 +00:00
} AVProbeData ;
2012-10-10 19:39:19 +00:00
# define AVPROBE_SCORE_RETRY (AVPROBE_SCORE_MAX / 4)
2014-02-02 22:48:37 +00:00
# define AVPROBE_SCORE_STREAM_RETRY (AVPROBE_SCORE_MAX / 4-1)
2013-03-25 15:12:51 +00:00
# define AVPROBE_SCORE_EXTENSION 50 ///< score for file extension
# define AVPROBE_SCORE_MAX 100 ///< maximum score
2007-04-08 11:34:15 +00:00
# define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer
2001-07-22 14:18:56 +00:00
2011-10-30 17:27:33 +00:00
/// Demuxer will use avio_open, no opened file should be provided by the caller.
2007-01-19 22:54:50 +00:00
# define AVFMT_NOFILE 0x0001
2008-09-27 19:51:53 +00: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 19:49:15 +00:00
# define AVFMT_TS_DISCONT 0x0200 /**< Format allows timestamp discontinuities. Note, muxers always require valid (monotone) timestamps */
2009-02-24 15:04:18 +00:00
# define AVFMT_VARIABLE_FPS 0x0400 /**< Format allows variable fps. */
2010-02-12 20:35:29 +00:00
# define AVFMT_NODIMENSIONS 0x0800 /**< Format does not need width/height */
2010-12-27 07:46:44 +00:00
# define AVFMT_NOSTREAMS 0x1000 /**< Format does not require any streams */
2012-08-20 23:02:13 +00: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 15:57:53 +00:00
# define AVFMT_NO_BYTE_SEEK 0x8000 /**< Format does not allow seeking by bytes */
2012-01-20 17:27:33 +00: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-21 21:53:39 +00: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 18:19:04 +00:00
increasing timestamps , but they must
still be monotonic */
2013-04-03 12:11:10 +00: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 09:52:51 +00:00
start from 0.
The user or muxer can override this through
AVFormatContext . avoid_negative_ts
*/
2002-05-20 16:28:47 +00:00
2012-04-30 13:47:58 +00:00
# define AVFMT_SEEK_TO_PTS 0x4000000 /**< Seeking is based on PTS */
2002-05-20 16:28:47 +00:00
2011-12-10 20:04:30 +00:00
/**
* @ addtogroup lavf_encoding
* @ {
*/
2002-05-20 16:28:47 +00:00
typedef struct AVOutputFormat {
2001-07-22 14:18:56 +00:00
const char * name ;
2008-06-03 16:20:54 +00:00
/**
* Descriptive name for the format , meant to be more human - readable
2009-05-25 22:05:43 +00:00
* than name . You should use the NULL_IF_CONFIG_SMALL ( ) macro
2008-06-03 16:20:54 +00:00
* to define it .
*/
2001-07-22 14:18:56 +00:00
const char * long_name ;
const char * mime_type ;
2008-09-27 19:51:53 +00:00
const char * extensions ; /**< comma-separated filename extensions */
2012-01-27 11:29:37 +00:00
/* output support */
2012-08-05 09:11:04 +00: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 11:29:37 +00:00
/**
* can use flags : AVFMT_NOFILE , AVFMT_NEEDNUMBER , AVFMT_RAWPICTURE ,
* AVFMT_GLOBALHEADER , AVFMT_NOTIMESTAMPS , AVFMT_VARIABLE_FPS ,
2011-05-26 18:19:04 +00:00
* AVFMT_NODIMENSIONS , AVFMT_NOSTREAMS , AVFMT_ALLOW_FLUSH ,
* AVFMT_TS_NONSTRICT
2012-01-27 11:29:37 +00:00
*/
int flags ;
/**
* List of supported codec_id - codec_tag pairs , ordered by " better
2012-08-05 09:11:04 +00:00
* choice first " . The arrays are all terminated by AV_CODEC_ID_NONE.
2012-01-27 11:29:37 +00: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 15:20:02 +00:00
/**
* size of private data so that it can be allocated in the wrapper
*/
2002-05-20 16:28:47 +00:00
int priv_data_size ;
2012-01-27 11:29:37 +00:00
2001-07-22 14:18:56 +00:00
int ( * write_header ) ( struct AVFormatContext * ) ;
2012-01-20 17:27:33 +00: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 02:06:32 +00:00
int ( * write_packet ) ( struct AVFormatContext * , AVPacket * pkt ) ;
2001-07-22 14:18:56 +00:00
int ( * write_trailer ) ( struct AVFormatContext * ) ;
2010-07-27 15:20:02 +00:00
/**
* Currently only used to set pixel format if not YUV420P .
*/
2008-09-27 20:05:12 +00:00
int ( * interleave_packet ) ( struct AVFormatContext * , AVPacket * out ,
AVPacket * in , int flush ) ;
2011-08-11 18:34:45 +00: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 16:59:03 +00:00
* MKTAG ( ' A ' , ' P ' , ' I ' , ' C ' ) if the codec is only supported as AV_DISPOSITION_ATTACHED_PIC
2011-08-11 18:34:45 +00:00
*/
2012-08-05 09:11:04 +00:00
int ( * query_codec ) ( enum AVCodecID id , int std_compliance ) ;
2011-08-11 18:34:45 +00:00
2011-06-30 17:45:22 +00:00
void ( * get_output_timestamp ) ( struct AVFormatContext * s , int stream ,
int64_t * dts , int64_t * wall ) ;
2014-01-19 15:11:09 +00:00
/**
* Allows sending messages from application to device .
*/
int ( * control_message ) ( struct AVFormatContext * s , int type ,
void * data , size_t data_size ) ;
2013-12-31 13:09:48 +00:00
/**
* Write an uncoded AVFrame .
*
* See av_write_uncoded_frame ( ) for details .
*
* The library will free * frame afterwards , but the muxer can prevent it
* by setting the pointer to NULL .
*/
int ( * write_uncoded_frame ) ( struct AVFormatContext * , int stream_index ,
AVFrame * * frame , unsigned flags ) ;
2014-02-16 19:06:23 +00:00
/**
* Returns device list with it properties .
* @ see avdevice_list_devices ( ) for more details .
*/
int ( * get_device_list ) ( struct AVFormatContext * s , struct AVDeviceInfoList * device_list ) ;
2014-04-03 17:11:19 +00:00
/**
* Initialize device capabilities submodule .
* @ see avdevice_capabilities_create ( ) for more details .
*/
int ( * create_device_capabilities ) ( struct AVFormatContext * s , struct AVDeviceCapabilitiesQuery * caps ) ;
/**
* Free device capabilities submodule .
* @ see avdevice_capabilities_free ( ) for more details .
*/
int ( * free_device_capabilities ) ( struct AVFormatContext * s , struct AVDeviceCapabilitiesQuery * caps ) ;
2002-05-20 16:28:47 +00:00
} AVOutputFormat ;
2011-12-10 20:04:30 +00:00
/**
* @ }
*/
2001-07-22 14:18:56 +00:00
2011-12-10 20:04:30 +00:00
/**
* @ addtogroup lavf_decoding
* @ {
*/
2002-05-20 16:28:47 +00:00
typedef struct AVInputFormat {
2010-07-27 15:20:02 +00:00
/**
* A comma separated list of short names for the format . New names
2010-07-27 14:13:24 +00:00
* may be appended with a minor bump .
*/
2002-05-20 16:28:47 +00:00
const char * name ;
2010-07-27 15:20:02 +00:00
2008-06-03 16:20:54 +00:00
/**
* Descriptive name for the format , meant to be more human - readable
2009-05-25 22:05:43 +00:00
* than name . You should use the NULL_IF_CONFIG_SMALL ( ) macro
2008-06-03 16:20:54 +00:00
* to define it .
*/
2002-05-20 16:28:47 +00:00
const char * long_name ;
2010-07-27 15:20:02 +00:00
2012-01-27 11:29:37 +00:00
/**
* Can use flags : AVFMT_NOFILE , AVFMT_NEEDNUMBER , AVFMT_SHOW_IDS ,
* AVFMT_GENERIC_INDEX , AVFMT_TS_DISCONT , AVFMT_NOBINSEARCH ,
2012-05-15 23:26:36 +00:00
* AVFMT_NOGENSEARCH , AVFMT_NO_BYTE_SEEK , AVFMT_SEEK_TO_PTS .
2012-01-27 11:29:37 +00: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 06:50:31 +00:00
* Raw demuxers store their codec ID here .
2012-01-27 11:29:37 +00:00
*/
2012-01-31 06:50:31 +00:00
int raw_codec_id ;
2012-01-27 11:29:37 +00:00
2010-07-27 15:20:02 +00:00
/**
* Size of private data so that it can be allocated in the wrapper .
*/
2002-05-20 16:28:47 +00:00
int priv_data_size ;
2010-07-27 15:20:02 +00:00
2007-08-10 16:15:23 +00:00
/**
2009-02-25 19:10:39 +00:00
* Tell if a given file has a chance of being parsed as this format .
2007-12-16 17:22:09 +00: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 16:15:23 +00:00
*/
2002-05-20 16:28:47 +00:00
int ( * read_probe ) ( AVProbeData * ) ;
2010-07-27 15:20:02 +00:00
/**
* Read the format header and initialize the AVFormatContext
2012-02-19 09:35:45 +00: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 15:20:02 +00:00
*/
2012-01-12 12:20:36 +00:00
int ( * read_header ) ( struct AVFormatContext * ) ;
2010-07-27 15:20:02 +00:00
/**
* Read one packet and put it in ' pkt ' . pts and flags are also
2012-02-19 09:35:45 +00:00
* set . ' avformat_new_stream ' can be called only if the flag
2010-10-06 20:49:25 +00:00
* AVFMTCTX_NOHEADER is used and only in the calling thread ( not in a
* background thread ) .
2010-07-27 15:20:02 +00: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 14:18:56 +00:00
int ( * read_packet ) ( struct AVFormatContext * , AVPacket * pkt ) ;
2010-07-27 15:20:02 +00:00
/**
* Close the stream . The AVFormatContext and AVStreams are not
* freed by this function
*/
2001-07-22 14:18:56 +00:00
int ( * read_close ) ( struct AVFormatContext * ) ;
2009-02-25 03:18:11 +00:00
2005-12-17 18:14:38 +00:00
/**
2008-09-27 19:51:53 +00:00
* Seek to a given timestamp relative to the frames in
* stream component stream_index .
2009-02-25 19:10:39 +00: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 02:08:04 +00:00
* @ return > = 0 on success ( but not necessarily the new offset )
2004-10-10 22:05:43 +00:00
*/
2012-01-12 08:36:11 +00:00
int ( * read_seek ) ( struct AVFormatContext * ,
int stream_index , int64_t timestamp , int flags ) ;
2004-04-12 16:50:03 +00:00
/**
2011-12-07 12:03:53 +00:00
* Get the next timestamp in stream [ stream_index ] . time_base units .
2008-03-22 01:06:57 +00:00
* @ return the timestamp or AV_NOPTS_VALUE if an error occurred
2004-04-12 16:50:03 +00:00
*/
int64_t ( * read_timestamp ) ( struct AVFormatContext * s , int stream_index ,
int64_t * pos , int64_t pos_limit ) ;
2010-07-27 15:20:02 +00:00
/**
* Start / resume playing - only meaningful if using a network - based format
* ( RTSP ) .
*/
2003-11-10 18:37:55 +00:00
int ( * read_play ) ( struct AVFormatContext * ) ;
2010-07-27 15:20:02 +00:00
/**
* Pause playing - only meaningful if using a network - based format
* ( RTSP ) .
*/
2003-11-10 18:37:55 +00:00
int ( * read_pause ) ( struct AVFormatContext * ) ;
2009-02-25 03:18:11 +00:00
/**
2010-06-30 15:38:06 +00:00
* Seek to timestamp ts .
2009-02-25 03:18:11 +00: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 10:45:08 +00:00
int ( * read_seek2 ) ( struct AVFormatContext * s , int stream_index , int64_t min_ts , int64_t ts , int64_t max_ts , int flags ) ;
2014-02-16 19:06:23 +00:00
/**
* Returns device list with it properties .
* @ see avdevice_list_devices ( ) for more details .
*/
int ( * get_device_list ) ( struct AVFormatContext * s , struct AVDeviceInfoList * device_list ) ;
2014-04-03 17:11:19 +00:00
/**
* Initialize device capabilities submodule .
* @ see avdevice_capabilities_create ( ) for more details .
*/
int ( * create_device_capabilities ) ( struct AVFormatContext * s , struct AVDeviceCapabilitiesQuery * caps ) ;
/**
* Free device capabilities submodule .
* @ see avdevice_capabilities_free ( ) for more details .
*/
int ( * free_device_capabilities ) ( struct AVFormatContext * s , struct AVDeviceCapabilitiesQuery * caps ) ;
2002-05-20 16:28:47 +00:00
} AVInputFormat ;
2011-12-10 20:04:30 +00:00
/**
* @ }
*/
2001-07-22 14:18:56 +00:00
2007-04-15 13:51:57 +00:00
enum AVStreamParseType {
AVSTREAM_PARSE_NONE ,
AVSTREAM_PARSE_FULL , /**< full parsing and repack */
2008-09-27 19:51:53 +00:00
AVSTREAM_PARSE_HEADERS , /**< Only parse headers, do not repack. */
2008-09-27 20:05:12 +00:00
AVSTREAM_PARSE_TIMESTAMPS , /**< full parsing and interpolation of timestamps for frames not starting on a packet boundary */
2010-05-26 04:20:32 +00:00
AVSTREAM_PARSE_FULL_ONCE , /**< full parsing and repack of the first frame only, only implemented for H.264 currently */
2012-07-24 15:34:13 +00: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 17:57:13 +00:00
just codec level data , otherwise position generation would fail */
2007-04-15 13:51:57 +00:00
} ;
2003-11-10 18:37:55 +00:00
typedef struct AVIndexEntry {
int64_t pos ;
2011-10-06 18:20:43 +00: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 18:37:55 +00:00
# define AVINDEX_KEYFRAME 0x0001
2006-03-01 11:29:55 +00:00
int flags : 2 ;
2008-09-27 19:51:53 +00: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 18:37:55 +00:00
} AVIndexEntry ;
2008-03-07 19:25:09 +00: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 15:20:02 +00: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 16:38:44 +00:00
# define AV_DISPOSITION_FORCED 0x0040
2011-02-10 06:25:13 +00: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 18:43:38 +00:00
# define AV_DISPOSITION_CLEAN_EFFECTS 0x0200 /**< stream without voice */
2012-02-25 17:05:55 +00: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 19:25:09 +00:00
2013-06-24 18:18:05 +00: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 18:27:21 +00: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 09:59:07 +00:00
/**
* Stream structure .
* New fields can be added to the end with minor version bumps .
2007-12-21 11:50:18 +00:00
* Removal , reordering and changes to existing fields require a major
2007-12-20 09:59:07 +00:00
* version bump .
2007-12-21 11:50:18 +00:00
* sizeof ( AVStream ) must not be used outside libav * .
2007-12-20 09:59:07 +00:00
*/
2001-07-22 14:18:56 +00:00
typedef struct AVStream {
2007-03-05 00:23:23 +00:00
int index ; /**< stream index in AVFormatContext */
2012-03-22 15:05:08 +00:00
/**
* Format - specific stream ID .
* decoding : set by libavformat
2012-11-10 15:20:30 +00:00
* encoding : set by the user , replaced by libavformat if left unset
2012-03-22 15:05:08 +00:00
*/
int id ;
2012-03-15 10:27:47 +00: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 14:18:56 +00:00
void * priv_data ;
2007-08-04 22:46:13 +00:00
2014-05-18 10:36:00 +00:00
# if FF_API_LAVF_FRAC
2010-07-27 15:20:02 +00:00
/**
2014-05-18 10:36:00 +00:00
* @ deprecated this field is unused
2010-07-27 15:20:02 +00:00
*/
2014-05-18 10:36:00 +00:00
attribute_deprecated
2007-07-09 22:15:11 +00:00
struct AVFrac pts ;
2014-05-18 10:36:00 +00:00
# endif
2005-08-21 22:31:01 +00:00
/**
2007-12-21 11:50:18 +00:00
* This is the fundamental unit of time ( in seconds ) in terms
2012-02-27 08:41:31 +00:00
* of which frame timestamps are represented .
*
2011-01-29 12:53:14 +00:00
* decoding : set by libavformat
2014-05-18 10:12:59 +00:00
* encoding : May be set by the caller before avformat_write_header ( ) to
* provide a hint to the muxer about the desired timebase . In
* avformat_write_header ( ) , the muxer will overwrite this field
* with the timebase that will actually be used for the timestamps
* written into the file ( which may or may not be related to the
* user - provided one , depending on the format ) .
2005-08-21 22:31:01 +00:00
*/
2004-05-21 20:43:21 +00:00
AVRational time_base ;
2010-07-27 15:20:02 +00:00
2007-08-16 12:07:05 +00:00
/**
2011-09-22 21:20:21 +00:00
* Decoding : pts of the first frame of the stream in presentation order , in stream time base .
2007-12-21 11:50:18 +00: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 00:31:32 +00:00
* This may be undefined ( AV_NOPTS_VALUE ) .
2011-03-18 12:16:14 +00:00
* @ note The ASF header does NOT contain a correct start_time the ASF
* demuxer must NOT set this .
2007-08-16 12:07:05 +00:00
*/
2005-12-17 18:14:38 +00:00
int64_t start_time ;
2010-07-27 15:20:02 +00:00
2007-08-18 00:35:43 +00:00
/**
2007-12-21 11:50:18 +00:00
* Decoding : duration of the stream , in stream time base .
2007-08-18 00:35:43 +00:00
* If a source file does not specify a duration , but does specify
2008-09-27 19:51:53 +00:00
* a bitrate , this value will be estimated from bitrate and file size .
2007-08-18 00:35:43 +00:00
*/
2003-08-08 17:49:27 +00:00
int64_t duration ;
2003-11-10 18:37:55 +00:00
2005-06-24 11:38:22 +00:00
int64_t nb_frames ; ///< number of frames in this stream if known or 0
2006-08-30 21:18:17 +00:00
2008-09-27 19:51:53 +00:00
int disposition ; /**< AV_DISPOSITION_* bit field */
2008-07-12 18:42:00 +00:00
2012-02-27 21:40:11 +00:00
enum AVDiscard discard ; ///< Selects which packets can be discarded at will and do not need to be demuxed.
2008-08-23 23:13:58 +00:00
/**
* sample aspect ratio ( 0 if unknown )
* - encoding : Set by user .
* - decoding : Set by libavformat .
*/
AVRational sample_aspect_ratio ;
2009-01-04 22:31:55 +00:00
2011-05-22 10:46:29 +00:00
AVDictionary * metadata ;
2009-01-22 23:35:31 +00:00
2009-12-13 15:52:11 +00:00
/**
* Average framerate
2014-05-11 15:58:05 +00:00
*
* - demuxing : May be set by libavformat when creating the stream or in
* avformat_find_stream_info ( ) .
* - muxing : May be set by the caller before avformat_write_header ( ) .
2009-12-13 15:52:11 +00:00
*/
AVRational avg_frame_rate ;
2010-02-23 15:07:18 +00:00
2012-02-25 17:05:55 +00: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 ;
2014-02-19 11:10:32 +00:00
/**
* An array of side data that applies to the whole stream ( i . e . the
* container does not allow it to change between packets ) .
*
* There may be no overlap between the side data in this array and side data
* in the packets . I . e . a given side data is either exported by the muxer
* ( demuxing ) / set by the caller ( muxing ) in this array , then it never
* appears in the packets , or the side data is exported / sent through
* the packets ( always in the first packet where the value becomes known or
* changes ) , then it does not appear in this array .
*
* - demuxing : Set by libavformat when the stream is created .
* - muxing : May be set by the caller before avformat_write_header ( ) .
*
* Freed by libavformat in avformat_free_context ( ) .
2014-04-13 17:20:17 +00:00
*
* @ see av_format_inject_global_side_data ( )
2014-02-19 11:10:32 +00:00
*/
AVPacketSideData * side_data ;
/**
* The number of elements in the AVStream . side_data array .
*/
int nb_side_data ;
2011-10-19 18:00:09 +00: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-08 22:01:19 +00:00
/**
2011-10-05 12:12:42 +00:00
* Stream information used internally by av_find_stream_info ( )
2010-10-08 22:01:19 +00:00
*/
2012-04-09 16:56:46 +00:00
# define MAX_STD_TIMEBASES (60*12+6)
2010-10-08 22:01:19 +00:00
struct {
int64_t last_dts ;
int64_t duration_gcd ;
int duration_count ;
2013-12-15 20:40:13 +00:00
int64_t rfps_duration_sum ;
2013-02-23 21:25:49 +00:00
double ( * duration_error ) [ 2 ] [ MAX_STD_TIMEBASES ] ;
2010-10-08 22:01:19 +00:00
int64_t codec_info_duration ;
2012-10-14 16:53:05 +00:00
int64_t codec_info_duration_fields ;
2014-04-21 01:38:07 +00:00
/**
* 0 - > decoder has not been searched for yet .
* > 0 - > decoder found
* < 0 - > decoder with codec_id = = - found_decoder has not been found
*/
2012-02-27 23:02:10 +00:00
int found_decoder ;
2012-06-28 13:49:51 +00:00
2013-03-04 17:01:32 +00:00
int64_t last_duration ;
2012-06-28 13:49:51 +00: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-08 22:01:19 +00:00
} * info ;
2012-02-27 21:40:11 +00:00
int pts_wrap_bits ; /**< number of bits in pts (used for wrapping control) */
2011-10-19 18:00:09 +00:00
2013-10-28 13:59:20 +00:00
# if FF_API_REFERENCE_DTS
2013-10-29 19:44:41 +00:00
/* a hack to keep ABI compatibility for ffmpeg and other applications, which accesses parser even
2013-10-28 13:59:20 +00:00
* though it should not */
int64_t do_not_use ;
# endif
2011-10-19 18:00:09 +00: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-27 21:40:11 +00:00
int last_IP_duration ;
2011-10-19 18:00:09 +00:00
/**
* Number of packets to buffer for codec probing
*/
# define MAX_PROBE_PACKETS 2500
int probe_packets ;
2012-02-27 21:40:11 +00: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 18:00:09 +00: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 16:34:01 +00: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 03:23:26 +00:00
/**
2012-09-22 23:07:15 +00: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 03:23:26 +00:00
* NOT PART OF PUBLIC API
*/
int request_probe ;
2012-04-13 22:17:30 +00:00
/**
* Indicates that everything up to the next keyframe
* should be discarded .
*/
int skip_to_keyframe ;
2012-07-04 20:00:50 +00:00
/**
* Number of samples to skip at the start of the frame decoded from the next packet .
*/
int skip_samples ;
2012-08-04 13:38:05 +00:00
/**
* Number of internally decoded frames , used internally in libavformat , do not access
2013-02-14 22:45:48 +00:00
* its lifetime differs from info which is why it is not in that structure .
2012-08-04 13:38:05 +00:00
*/
int nb_decoded_frames ;
2012-09-26 13:55:16 +00:00
/**
* Timestamp offset added to timestamps before muxing
* NOT PART OF PUBLIC API
*/
int64_t mux_ts_offset ;
2012-12-02 18:27:21 +00: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 ;
2013-12-31 07:36:14 +00:00
/**
* Internal data to prevent doing update_initial_durations ( ) twice
*/
int update_initial_durations_done ;
2014-02-22 12:04:18 +00:00
/**
* Internal data to generate dts from pts
*/
int64_t pts_reorder_error [ MAX_REORDER_DELAY + 1 ] ;
uint8_t pts_reorder_error_count [ MAX_REORDER_DELAY + 1 ] ;
2014-03-03 00:55:18 +00:00
/**
* Internal data to analyze DTS and detect faulty mpeg streams
*/
int64_t last_dts_for_order_check ;
uint8_t dts_ordered ;
uint8_t dts_misordered ;
2014-04-13 15:57:43 +00:00
/**
* Internal data to inject global side data
*/
2014-04-13 17:20:17 +00:00
int inject_global_side_data ;
2014-04-13 15:57:43 +00:00
2001-07-22 14:18:56 +00:00
} AVStream ;
2013-03-12 14:26:35 +00:00
AVRational av_stream_get_r_frame_rate ( const AVStream * s ) ;
void av_stream_set_r_frame_rate ( AVStream * s , AVRational r ) ;
2014-07-14 19:03:43 +00:00
struct AVCodecParserContext * av_stream_get_parser ( const AVStream * s ) ;
2013-03-12 14:26:35 +00:00
2014-05-19 18:16:01 +00:00
/**
* Returns the pts of the last muxed packet + its duration
*
* the retuned value is undefined when used with a demuxer .
*/
int64_t av_stream_get_end_pts ( const AVStream * st ) ;
2007-09-25 20:45:46 +00:00
# define AV_PROGRAM_RUNNING 1
2007-12-20 09:59:07 +00:00
/**
* New fields can be added to the end with minor version bumps .
2007-12-21 11:50:18 +00:00
* Removal , reordering and changes to existing fields require a major
2007-12-20 09:59:07 +00:00
* version bump .
2007-12-21 11:50:18 +00:00
* sizeof ( AVProgram ) must not be used outside libav * .
2007-12-20 09:59:07 +00:00
*/
2007-09-25 20:45:46 +00: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 08:25:13 +00:00
unsigned int * stream_index ;
unsigned int nb_stream_indexes ;
2011-05-22 10:46:29 +00:00
AVDictionary * metadata ;
2011-03-04 19:22:09 +00:00
int program_num ;
int pmt_pid ;
2011-03-11 12:39:55 +00:00
int pcr_pid ;
2012-10-23 16:11:26 +00: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 18:27:21 +00:00
int64_t pts_wrap_reference ; ///< reference dts for wrap detection
int pts_wrap_behavior ; ///< behavior on wrap detection
2007-09-25 20:45:46 +00:00
} AVProgram ;
2007-03-05 00:23:23 +00:00
# define AVFMTCTX_NOHEADER 0x0001 / **< signal that no header is present
2003-10-29 14:20:56 +00:00
( streams are added dynamically ) */
2008-05-22 22:00:21 +00:00
typedef struct AVChapter {
2008-09-27 19:51:53 +00: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 12:45:03 +00:00
int64_t start , end ; ///< chapter start/end time in time_base units
2011-05-22 10:46:29 +00:00
AVDictionary * metadata ;
2008-05-22 22:00:21 +00:00
} AVChapter ;
2012-06-22 23:03:18 +00:00
2014-01-19 15:12:07 +00:00
/**
* Callback used by devices to communicate with application .
*/
typedef int ( * av_format_control_message ) ( struct AVFormatContext * s , int type ,
void * data , size_t data_size ) ;
2012-06-22 23:03:18 +00: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)
} ;
2014-01-20 12:59:06 +00:00
typedef struct AVFormatInternal AVFormatInternal ;
2007-12-20 09:43:01 +00:00
/**
2008-09-27 19:51:53 +00:00
* Format I / O context .
2007-12-20 09:43:01 +00:00
* New fields can be added to the end with minor version bumps .
2007-12-21 11:50:18 +00:00
* Removal , reordering and changes to existing fields require a major
2007-12-20 09:43:01 +00:00
* version bump .
2011-11-06 14:16:18 +00:00
* sizeof ( AVFormatContext ) must not be used outside libav * , use
* avformat_alloc_context ( ) to create an AVFormatContext .
2007-12-20 09:43:01 +00:00
*/
2001-07-22 14:18:56 +00:00
typedef struct AVFormatContext {
2011-11-06 14:16:18 +00:00
/**
2014-02-04 17:11:40 +00:00
* A class for logging and @ ref avoptions . Set by avformat_alloc_context ( ) .
2011-11-06 14:16:18 +00:00
* Exports ( de ) muxer private options if they exist .
*/
const AVClass * av_class ;
/**
2014-02-04 17:11:40 +00:00
* The input container format .
2011-11-06 14:16:18 +00:00
*
2014-02-04 17:11:40 +00:00
* Demuxing only , set by avformat_open_input ( ) .
2011-11-06 14:16:18 +00:00
*/
2002-05-20 16:28:47 +00:00
struct AVInputFormat * iformat ;
2014-02-04 17:11:40 +00:00
/**
* The output container format .
*
* Muxing only , must be set by the caller before avformat_write_header ( ) .
*/
2002-05-20 16:28:47 +00:00
struct AVOutputFormat * oformat ;
2011-11-06 14:16:18 +00:00
/**
* Format private data . This is an AVOptions - enabled struct
* if and only if iformat / oformat . priv_class is not NULL .
2014-02-04 17:11:40 +00:00
*
* - muxing : set by avformat_write_header ( )
* - demuxing : set by avformat_open_input ( )
2011-11-06 14:16:18 +00:00
*/
2001-07-22 14:18:56 +00:00
void * priv_data ;
2011-11-06 14:16:18 +00:00
2012-05-07 10:21:19 +00:00
/**
2011-11-06 14:16:18 +00:00
* I / O context .
*
2014-02-04 17:11:40 +00:00
* - demuxing : either set by the user before avformat_open_input ( ) ( then
* the user must close it manually ) or set by avformat_open_input ( ) .
* - muxing : set by the user before avformat_write_header ( ) . The caller must
* take care of closing / freeing the IO context .
2011-11-06 14:16:18 +00:00
*
* 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 10:04:12 +00:00
AVIOContext * pb ;
2011-11-06 14:16:18 +00:00
2012-02-27 21:40:11 +00:00
/* stream info */
2014-05-01 08:03:54 +00:00
/**
* Flags signalling stream properties . A combination of AVFMTCTX_ * .
* Set by libavformat .
*/
int ctx_flags ;
2012-02-27 21:40:11 +00:00
2014-02-04 17:11:40 +00:00
/**
* Number of elements in AVFormatContext . streams .
*
* Set by avformat_new_stream ( ) , must not be modified by any other code .
*/
unsigned int nb_streams ;
2011-11-06 14:16:18 +00:00
/**
* A list of all streams in the file . New streams are created with
* avformat_new_stream ( ) .
*
2014-02-04 17:11:40 +00:00
* - demuxing : 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 ( ) .
* - muxing : streams are created by the user before avformat_write_header ( ) .
*
* Freed by libavformat in avformat_free_context ( ) .
2011-11-06 14:16:18 +00:00
*/
2010-10-06 20:56:14 +00:00
AVStream * * streams ;
2011-11-06 14:16:18 +00:00
2014-02-04 17:11:40 +00:00
/**
* input or output filename
*
* - demuxing : set by avformat_open_input ( )
* - muxing : may be set by the caller before avformat_write_header ( )
*/
char filename [ 1024 ] ;
2003-08-08 17:49:27 +00:00
2010-07-27 15:20:02 +00:00
/**
2014-02-04 17:11:40 +00:00
* Position of the first frame of the component , in
2010-07-27 15:20:02 +00:00
* AV_TIME_BASE fractional seconds . NEVER set this value directly :
* It is deduced from the AVStream values .
2014-02-04 17:11:40 +00:00
*
* Demuxing only , set by libavformat .
2010-07-27 15:20:02 +00:00
*/
2005-12-17 18:14:38 +00:00
int64_t start_time ;
2010-07-27 15:20:02 +00:00
/**
2014-02-04 17:11:40 +00:00
* Duration of the stream , in AV_TIME_BASE fractional
2010-07-27 15:20:02 +00:00
* seconds . Only set this value if you know none of the individual stream
2011-10-05 12:12:42 +00:00
* durations and also do not set any of them . This is deduced from the
2010-07-27 15:20:02 +00:00
* AVStream values if not set .
2014-02-04 17:11:40 +00:00
*
* Demuxing only , set by libavformat .
2010-07-27 15:20:02 +00:00
*/
2003-08-08 17:49:27 +00:00
int64_t duration ;
2010-07-27 15:20:02 +00:00
/**
2014-02-04 17:11:40 +00:00
* Total stream bitrate in bit / s , 0 if not
2010-07-27 15:20:02 +00:00
* available . Never set it directly if the file_size and the
2011-04-17 21:57:50 +00:00
* duration are known as FFmpeg can compute it automatically .
2010-07-27 15:20:02 +00:00
*/
2003-08-08 17:49:27 +00:00
int bit_rate ;
2003-11-10 18:37:55 +00:00
2009-06-22 16:52:02 +00:00
unsigned int packet_size ;
2004-10-16 21:27:42 +00:00
int max_delay ;
2005-06-18 01:52:24 +00:00
2014-05-01 08:03:54 +00:00
/**
* Flags modifying the ( de ) muxer behaviour . A combination of AVFMT_FLAG_ * .
* Set by the user before avformat_open_input ( ) / avformat_write_header ( ) .
*/
2005-08-15 14:22:43 +00:00
int flags ;
2009-02-25 19:10:39 +00:00
# define AVFMT_FLAG_GENPTS 0x0001 ///< Generate missing pts even if it requires parsing future frames.
2008-09-27 19:51:53 +00:00
# define AVFMT_FLAG_IGNIDX 0x0002 ///< Ignore index.
# define AVFMT_FLAG_NONBLOCK 0x0004 ///< Do not block when reading packets from input.
2010-01-30 22:55:12 +00:00
# define AVFMT_FLAG_IGNDTS 0x0008 ///< Ignore DTS on frames that contain both DTS & PTS
2010-03-31 12:55:16 +00: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-26 23:35:12 +00:00
# define AVFMT_FLAG_NOBUFFER 0x0040 ///< Do not buffer frames when possible
2011-05-22 06:37:25 +00:00
# define AVFMT_FLAG_CUSTOM_IO 0x0080 ///< The caller has supplied a custom AVIOContext, don't avio_close() it.
2011-07-24 14:28:33 +00:00
# define AVFMT_FLAG_DISCARD_CORRUPT 0x0100 ///< Discard frames marked corrupted
2013-09-11 12:02:06 +00:00
# define AVFMT_FLAG_FLUSH_PACKETS 0x0200 ///< Flush the AVIOContext every packet.
2014-05-01 08:43:10 +00:00
/**
* When muxing , try to avoid writing any random / volatile data to the output .
* This includes any random IDs , real - time timestamps / dates , muxer version , etc .
*
* This flag is mainly intended for testing .
*/
# define AVFMT_FLAG_BITEXACT 0x0400
2011-06-18 02:40:18 +00:00
# define AVFMT_FLAG_MP4A_LATM 0x8000 ///< Enable RTP MP4A-LATM payload
2011-04-24 19:29:35 +00:00
# define AVFMT_FLAG_SORT_DTS 0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
2011-04-30 19:35:48 +00: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-05 23:38:53 +00:00
# define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Don't merge side data but keep it separate.
2006-07-13 21:13:49 +00:00
2010-07-27 15:20:02 +00:00
/**
2014-02-04 17:11:40 +00:00
* Maximum size of the data read from input for determining
* the input container format .
* Demuxing only , set by the caller before avformat_open_input ( ) .
2010-07-27 15:20:02 +00:00
*/
2006-08-27 12:21:19 +00:00
unsigned int probesize ;
2007-01-23 17:34:26 +00:00
/**
2014-06-10 12:28:34 +00:00
* @ deprecated deprecated in favor of max_analyze_duration2
2007-01-23 17:34:26 +00:00
*/
2014-06-10 12:28:34 +00:00
attribute_deprecated
2007-01-23 17:34:26 +00:00
int max_analyze_duration ;
2007-02-11 12:37:28 +00:00
const uint8_t * key ;
int keylen ;
2007-09-25 20:45:46 +00:00
unsigned int nb_programs ;
AVProgram * * programs ;
2007-12-19 10:56:17 +00:00
/**
* Forced video codec_id .
2008-09-27 19:51:53 +00:00
* Demuxing : Set by user .
2007-12-19 10:56:17 +00:00
*/
2012-08-05 09:11:04 +00:00
enum AVCodecID video_codec_id ;
2010-07-27 15:20:02 +00:00
2007-12-19 10:56:17 +00:00
/**
* Forced audio codec_id .
2008-09-27 19:51:53 +00:00
* Demuxing : Set by user .
2007-12-19 10:56:17 +00:00
*/
2012-08-05 09:11:04 +00:00
enum AVCodecID audio_codec_id ;
2010-07-27 15:20:02 +00:00
2007-12-19 10:56:17 +00:00
/**
* Forced subtitle codec_id .
2008-09-27 19:51:53 +00:00
* Demuxing : Set by user .
2007-12-19 10:56:17 +00:00
*/
2012-08-05 09:11:04 +00:00
enum AVCodecID subtitle_codec_id ;
2008-01-13 13:33:37 +00:00
/**
2009-02-25 19:10:39 +00: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 13:33:37 +00:00
* needed to maintain a smaller size . This can lead to slower or less
* accurate seeking ( depends on demuxer ) .
2008-09-27 19:51:53 +00:00
* Demuxers for which a full in - memory index is mandatory will ignore
2008-01-13 13:33:37 +00:00
* this .
2014-02-04 17:11:40 +00:00
* - muxing : unused
* - demuxing : set by user
2008-01-13 13:33:37 +00:00
*/
unsigned int max_index_size ;
2008-03-08 21:59:11 +00:00
/**
2008-03-08 22:43:13 +00:00
* Maximum amount of memory in bytes to use for buffering frames
2008-09-27 19:51:53 +00:00
* obtained from realtime capture devices .
2008-03-08 21:59:11 +00:00
*/
unsigned int max_picture_buffer ;
2008-05-22 22:00:21 +00:00
2013-09-03 17:53:34 +00: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 .
2014-02-04 17:11:40 +00:00
* - muxing : set by user
* - demuxing : set by libavformat
2013-09-03 17:53:34 +00:00
*/
2008-05-23 13:08:44 +00:00
unsigned int nb_chapters ;
2008-05-22 22:00:21 +00:00
AVChapter * * chapters ;
2008-06-09 13:38:56 +00:00
2014-02-04 17:11:40 +00:00
/**
* Metadata that applies to the whole file .
*
* - demuxing : set by libavformat in avformat_open_input ( )
* - muxing : may be set by the caller before avformat_write_header ( )
*
* Freed by libavformat in avformat_free_context ( ) .
*/
2011-05-22 10:46:29 +00:00
AVDictionary * metadata ;
2009-06-25 18:48:57 +00:00
2010-03-15 10:29:37 +00:00
/**
* Start time of the stream in real world time , in microseconds
2014-02-04 17:11:40 +00:00
* since the Unix epoch ( 00 : 00 1 st January 1970 ) . That is , pts = 0 in the
* stream was captured at this real world time .
2014-03-11 23:58:34 +00:00
* - muxing : Set by the caller before avformat_write_header ( ) . If set to
* either 0 or AV_NOPTS_VALUE , then the current wall - time will
* be used .
* - demuxing : Set by libavformat . AV_NOPTS_VALUE if unknown . Note that
* the value may become known after some number of frames
* have been received .
2010-03-15 10:29:37 +00:00
*/
int64_t start_time_realtime ;
2011-05-09 21:34:23 +00:00
/**
2014-02-04 17:11:40 +00:00
* The number of frames used for determining the framerate in
* avformat_find_stream_info ( ) .
* Demuxing only , set by the caller before avformat_find_stream_info ( ) .
2011-05-09 21:34:23 +00:00
*/
int fps_probe_size ;
2011-03-04 19:22:09 +00:00
2011-08-06 04:42:34 +00:00
/**
* Error recognition ; higher values will detect more errors but may
* misdetect some more or less valid parts as errors .
2014-02-04 17:11:40 +00:00
* Demuxing only , set by the caller before avformat_open_input ( ) .
2011-08-06 04:42:34 +00:00
*/
int error_recognition ;
2011-08-13 00:16:44 +00:00
2011-11-06 12:10:16 +00:00
/**
* Custom interrupt callbacks for the I / O layer .
*
2014-02-04 17:11:40 +00:00
* demuxing : set by the user before avformat_open_input ( ) .
* muxing : set by the user before avformat_write_header ( )
2011-11-06 12:10:16 +00:00
* ( 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-27 21:40:11 +00:00
/**
* Flags to enable debugging .
*/
int debug ;
# define FF_FDEBUG_TS 0x0001
2012-02-28 23:30:35 +00:00
2014-01-20 12:28:37 +00:00
/**
* Maximum buffering duration for interleaving .
*
* To ensure all the streams are interleaved correctly ,
* av_interleaved_write_frame ( ) will wait until it has at least one packet
* for each stream before actually writing any packets to the output file .
* When some streams are " sparse " ( i . e . there are large gaps between
* successive packets ) , this can result in excessive buffering .
*
* This field specifies the maximum difference between the timestamps of the
* first and the last packet in the muxing queue , above which libavformat
* will output a packet regardless of whether it has queued a packet for all
* the streams .
*
* Muxing only , set by the caller before avformat_write_header ( ) .
*/
int64_t max_interleave_delta ;
2014-03-06 16:58:33 +00:00
/**
* Allow non - standard and experimental extension
* @ see AVCodecContext . strict_std_compliance
*/
int strict_std_compliance ;
2014-05-28 22:20:48 +00:00
2011-03-04 19:22:09 +00:00
/**
* Transport stream id .
* This will be moved into demuxer private options . Thus no API / ABI compatibility
*/
int ts_id ;
2011-10-29 00:08:54 +00:00
2011-10-26 20:17:08 +00: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-13 22:43:12 +00:00
2011-11-29 23:21:00 +00: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-16 22:08:51 +00: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 13:55:16 +00:00
/**
2013-03-18 22:44:51 +00:00
* Avoid negative timestamps during muxing .
2012-09-26 13:55:16 +00:00
* 0 - > allow negative timestamps
* 1 - > avoid negative timestamps
* - 1 - > choose automatically ( default )
2013-03-18 22:44:51 +00:00
* Note , this only works when interleave_packet_per_dts is in use .
2012-09-26 13:55:16 +00:00
* - encoding : Set by user via AVOptions ( NO direct access )
* - decoding : unused
*/
int avoid_negative_ts ;
2012-09-26 13:24:00 +00: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-20 21:04:14 +00:00
/**
* Skip initial bytes when opening stream
* - encoding : unused
* - decoding : Set by user via AVOptions ( NO direct access )
*/
2014-06-05 22:05:31 +00:00
int64_t skip_initial_bytes ;
2012-11-20 21:04:14 +00:00
2012-12-02 18:27:21 +00:00
/**
* Correct single timestamp overflows
* - encoding : unused
2014-02-02 11:55:40 +00:00
* - decoding : Set by user via AVOptions ( NO direct access )
2012-12-02 18:27:21 +00:00
*/
unsigned int correct_ts_overflow ;
2012-08-05 23:25:57 +00:00
/**
* Force seeking to any ( also non key ) frames .
* - encoding : unused
2014-02-02 11:55:40 +00:00
* - decoding : Set by user via AVOptions ( NO direct access )
2012-08-05 23:25:57 +00:00
*/
int seek2any ;
2013-03-12 15:54:42 +00: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 20:39:49 +00: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 ;
2014-01-27 22:09:38 +00:00
/**
* number of bytes to read maximally to identify format .
* - encoding : unused
* - decoding : set by user through AVOPtions ( NO direct access )
*/
int format_probesize ;
2011-10-19 18:00:09 +00: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-27 21:40:11 +00: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 14:49:26 +00:00
/**
* Packets split by the parser get queued here .
*/
struct AVPacketList * parse_queue ;
struct AVPacketList * parse_queue_end ;
2012-02-27 21:40:11 +00: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 02:01:12 +00:00
2013-04-03 12:11:10 +00:00
/**
* Offset to remap timestamps to be non - negative .
* Expressed in timebase units .
2013-04-26 08:47:31 +00:00
* @ see AVStream . mux_ts_offset
2013-04-03 12:11:10 +00:00
*/
int64_t offset ;
/**
* Timebase for the timestamp offset .
*/
AVRational offset_timebase ;
2014-01-20 12:59:06 +00:00
/**
* An opaque field for libavformat internal usage .
* Must not be accessed in any way by callers .
*/
AVFormatInternal * internal ;
2014-02-04 14:37:05 +00:00
2013-04-04 02:01:12 +00: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 15:52:45 +00: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 ;
2013-12-29 21:42:33 +00:00
/**
* Number of bytes to be written as padding in a metadata header .
* Demuxing : Unused .
* Muxing : Set by user via av_format_set_metadata_header_padding .
*/
int metadata_header_padding ;
2014-01-19 15:12:07 +00:00
/**
* User data .
* This is a place for some private data of the user .
* Mostly usable with control_message_cb or any future callbacks in device ' s context .
*/
void * opaque ;
/**
* Callback used by devices to communicate with application .
*/
av_format_control_message control_message_cb ;
2014-01-27 18:16:45 +00:00
/**
* Output timestamp offset , in microseconds .
* Muxing : set by user via AVOptions ( NO direct access )
*/
int64_t output_ts_offset ;
2014-06-10 12:28:34 +00:00
/**
* Maximum duration ( in AV_TIME_BASE units ) of the data read
* from input in avformat_find_stream_info ( ) .
* Demuxing only , set by the caller before avformat_find_stream_info ( )
* via AVOptions ( NO direct access ) .
* Can be set to 0 to let avformat choose using a heuristic .
*/
int64_t max_analyze_duration2 ;
2001-07-22 14:18:56 +00:00
} AVFormatContext ;
2013-08-08 20:39:49 +00:00
int av_format_get_probe_score ( const AVFormatContext * s ) ;
2013-09-28 15:52:45 +00: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-12-29 21:42:33 +00:00
int av_format_get_metadata_header_padding ( const AVFormatContext * s ) ;
void av_format_set_metadata_header_padding ( AVFormatContext * s , int c ) ;
2014-01-19 15:12:07 +00:00
void * av_format_get_opaque ( const AVFormatContext * s ) ;
void av_format_set_opaque ( AVFormatContext * s , void * opaque ) ;
av_format_control_message av_format_get_control_message_cb ( const AVFormatContext * s ) ;
void av_format_set_control_message_cb ( AVFormatContext * s , av_format_control_message callback ) ;
2013-08-08 20:39:49 +00:00
2014-04-13 17:20:17 +00:00
/**
* This function will cause global side data to be injected in the next packet
* of each stream as well as after any subsequent seek .
*/
void av_format_inject_global_side_data ( AVFormatContext * s ) ;
2012-06-18 05:20:09 +00: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-22 23:03:18 +00:00
enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method ( const AVFormatContext * ctx ) ;
2012-06-18 05:20:09 +00:00
2001-07-22 14:18:56 +00:00
typedef struct AVPacketList {
AVPacket pkt ;
struct AVPacketList * next ;
} AVPacketList ;
2011-12-11 06:55:21 +00:00
2009-02-15 09:04:08 +00:00
/**
2011-12-11 06:55:21 +00:00
* @ defgroup lavf_core Core functions
* @ ingroup libavf
*
* Functions for querying libavformat capabilities , allocating core structures ,
* etc .
* @ {
2009-02-15 09:04:08 +00:00
*/
/**
2011-12-11 06:55:21 +00:00
* Return the LIBAVFORMAT_VERSION_INT constant .
2009-02-15 09:04:08 +00:00
*/
2011-12-11 06:55:21 +00:00
unsigned avformat_version ( void ) ;
2009-12-31 16:38:21 +00:00
/**
2011-12-11 06:55:21 +00:00
* Return the libavformat build - time configuration .
2009-12-31 16:38:21 +00:00
*/
2011-12-11 06:55:21 +00:00
const char * avformat_configuration ( void ) ;
2007-03-03 12:23:20 +00:00
/**
2011-12-11 06:55:21 +00:00
* Return the libavformat license .
2007-03-03 12:23:20 +00:00
*/
2011-12-11 06:55:21 +00:00
const char * avformat_license ( void ) ;
2001-07-22 14:18:56 +00:00
2007-03-03 12:23:20 +00:00
/**
2011-12-11 06:55:21 +00: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 14:17:26 +00:00
*
2011-12-11 06:55:21 +00:00
* @ see av_register_input_format ( )
* @ see av_register_output_format ( )
2007-03-03 12:23:20 +00:00
*/
2011-12-11 06:55:21 +00:00
void av_register_all ( void ) ;
void av_register_input_format ( AVInputFormat * format ) ;
void av_register_output_format ( AVOutputFormat * format ) ;
2007-03-03 12:23:20 +00:00
/**
2011-12-11 06:55:21 +00: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 14:17:26 +00:00
*
2011-12-11 06:55:21 +00:00
* Calling this function will become mandatory if using network
* protocols at some major version bump .
2007-03-12 14:17:26 +00:00
*/
2011-12-11 06:55:21 +00:00
int avformat_network_init ( void ) ;
2007-03-12 14:17:26 +00:00
/**
2011-12-11 06:55:21 +00:00
* Undo the initialization done by avformat_network_init .
2007-03-03 12:23:20 +00:00
*/
2011-12-11 06:55:21 +00:00
int avformat_network_deinit ( void ) ;
2011-02-24 08:08:06 +00:00
2009-02-15 09:04:08 +00:00
/**
* If f is NULL , returns the first registered input format ,
2009-02-25 19:10:39 +00:00
* if f is non - NULL , returns the next registered input format after f
2009-02-15 09:04:08 +00:00
* or NULL if f is the last one .
*/
2007-12-12 19:01:58 +00:00
AVInputFormat * av_iformat_next ( AVInputFormat * f ) ;
2001-07-22 14:18:56 +00:00
2007-03-12 14:17:26 +00:00
/**
2009-02-15 09:04:08 +00:00
* If f is NULL , returns the first registered output format ,
2009-02-25 19:10:39 +00:00
* if f is non - NULL , returns the next registered output format after f
2009-02-15 09:04:08 +00:00
* or NULL if f is the last one .
2007-03-12 14:17:26 +00:00
*/
2007-12-12 19:01:58 +00:00
AVOutputFormat * av_oformat_next ( AVOutputFormat * f ) ;
2011-02-24 08:08:06 +00:00
2011-12-11 06:55:21 +00: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 14:17:26 +00:00
2009-01-25 16:44:45 +00:00
/**
2011-12-11 06:55:21 +00:00
* Free an AVFormatContext and all its streams .
* @ param s context to free
2009-01-25 16:44:45 +00:00
*/
2011-12-11 06:55:21 +00:00
void avformat_free_context ( AVFormatContext * s ) ;
2001-07-22 14:18:56 +00:00
2010-05-12 22:17:29 +00:00
/**
2011-12-11 06:55:21 +00:00
* Get the AVClass for AVFormatContext . It can be used in combination with
* AV_OPT_SEARCH_FAKE_OBJ for examining options .
2010-05-12 22:17:29 +00:00
*
2011-12-11 06:55:21 +00:00
* @ see av_opt_find ( ) .
2010-05-12 22:17:29 +00:00
*/
2011-12-11 06:55:21 +00:00
const AVClass * avformat_get_class ( void ) ;
2010-05-12 22:17:29 +00:00
/**
2011-12-11 06:55:21 +00:00
* Add a new stream to a media file .
2010-05-12 22:17:29 +00:00
*
2011-12-11 06:55:21 +00: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 06:50:02 +00:00
* User is required to call avcodec_close ( ) and avformat_free_context ( ) to
* clean up the allocation by avformat_new_stream ( ) .
*
2014-02-16 22:36:31 +00:00
* @ param s media file handle
2011-12-11 06:55:21 +00: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-12 22:17:29 +00:00
*/
2012-10-24 14:29:05 +00:00
AVStream * avformat_new_stream ( AVFormatContext * s , const AVCodec * c ) ;
2011-12-11 06:55:21 +00:00
2014-05-19 14:29:30 +00:00
/**
* Get side information from stream .
*
* @ param stream stream
* @ param type desired side information type
* @ param size pointer for side information size to store ( optional )
* @ return pointer to data if present or NULL otherwise
*/
uint8_t * av_stream_get_side_data ( AVStream * stream ,
enum AVPacketSideDataType type , int * size ) ;
2011-12-11 06:55:21 +00:00
AVProgram * av_new_program ( AVFormatContext * s , int id ) ;
2007-01-21 01:39:17 +00:00
2011-12-10 20:04:30 +00:00
/**
2011-12-11 06:55:21 +00:00
* @ }
2011-12-10 20:04:30 +00:00
*/
2011-12-11 06:55:21 +00:00
2011-12-10 23:40:09 +00: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 20:04:30 +00:00
/**
* @ addtogroup lavf_decoding
* @ {
*/
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Find AVInputFormat based on the short name of the input format .
2007-03-03 12:23:20 +00:00
*/
2002-05-20 16:28:47 +00:00
AVInputFormat * av_find_input_format ( const char * short_name ) ;
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Guess the file format .
2007-03-03 12:23:20 +00:00
*
2014-02-16 22:36:31 +00:00
* @ param pd data to be probed
2008-09-27 19:51:53 +00:00
* @ param is_opened Whether the file is already opened ; determines whether
* demuxers with or without AVFMT_NOFILE are probed .
2007-03-03 12:23:20 +00:00
*/
2002-07-25 16:01:46 +00:00
AVInputFormat * av_probe_input_format ( AVProbeData * pd , int is_opened ) ;
2007-03-03 12:23:20 +00:00
2010-05-01 13:49:35 +00:00
/**
2010-06-30 15:38:06 +00:00
* Guess the file format .
2010-05-01 13:49:35 +00:00
*
2014-02-16 22:36:31 +00:00
* @ param pd data to be probed
2010-05-01 13:49:35 +00:00
* @ param is_opened Whether the file is already opened ; determines whether
* demuxers with or without AVFMT_NOFILE are probed .
2010-05-01 15:36:51 +00: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 13:49:35 +00:00
* to retry with a larger probe buffer .
*/
AVInputFormat * av_probe_input_format2 ( AVProbeData * pd , int is_opened , int * score_max ) ;
2011-03-04 00:12:17 +00: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-07 22:46:53 +00: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 20:39:49 +00:00
* @ return the score in case of success , a negative value corresponding to an
* the maximal score is AVPROBE_SCORE_MAX
2011-02-07 22:46:53 +00:00
* AVERROR code otherwise
*/
2013-08-08 20:39:49 +00: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 10:04:12 +00:00
int av_probe_input_buffer ( AVIOContext * pb , AVInputFormat * * fmt ,
2011-02-07 22:46:53 +00:00
const char * filename , void * logctx ,
unsigned int offset , unsigned int max_probe_size ) ;
2011-05-22 06:37:25 +00:00
/**
* Open an input stream and read the header . The codecs are not opened .
2013-08-20 10:23:24 +00:00
* The stream must be closed with avformat_close_input ( ) .
2011-05-22 06:37:25 +00: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 08:16:40 +00:00
2012-01-28 03:23:26 +00:00
attribute_deprecated
int av_demuxer_open ( AVFormatContext * ic ) ;
2011-04-30 19:35:48 +00:00
2011-05-22 17:24:59 +00:00
# if FF_API_FORMAT_PARAMETERS
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Read packets of a media file to get stream information . This
2007-03-03 12:23:20 +00:00
* is useful for file formats with no headers such as MPEG . This
2009-02-25 19:10:39 +00:00
* function also computes the real framerate in case of MPEG - 2 repeat
2007-03-03 12:23:20 +00: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 19:51:53 +00: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 17:24:59 +00:00
*
* @ deprecated use avformat_find_stream_info .
2007-03-03 12:23:20 +00:00
*/
2011-07-17 11:59:04 +00:00
attribute_deprecated
2002-05-20 16:28:47 +00:00
int av_find_stream_info ( AVFormatContext * ic ) ;
2011-05-22 17:24:59 +00: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 12:23:20 +00:00
2011-08-22 21:42:19 +00: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 09:08:20 +00: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 20:41:59 +00:00
# if FF_API_READ_PACKET
2007-03-03 12:23:20 +00:00
/**
2012-03-04 20:41:59 +00:00
* @ deprecated use AVFMT_FLAG_NOFILLIN | AVFMT_FLAG_NOPARSE to read raw
* unprocessed packets
*
2010-06-30 15:38:06 +00:00
* Read a transport packet from a media file .
2007-03-03 12:23:20 +00:00
*
2007-06-04 21:05:58 +00:00
* This function is obsolete and should never be used .
2007-03-03 12:23:20 +00:00
* Use av_read_frame ( ) instead .
*
* @ param s media file handle
* @ param pkt is filled
2008-09-27 19:51:53 +00:00
* @ return 0 if OK , AVERROR_xxx on error
2007-03-03 12:23:20 +00:00
*/
2012-03-04 20:41:59 +00:00
attribute_deprecated
2001-07-22 14:18:56 +00:00
int av_read_packet ( AVFormatContext * s , AVPacket * pkt ) ;
2012-03-04 20:41:59 +00:00
# endif
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Return the next frame of a stream .
2010-09-14 22:20:46 +00: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 12:23:20 +00:00
*
2012-10-31 07:53:18 +00:00
* If pkt - > buf is NULL , then the packet is valid until the next
2013-08-20 10:23:24 +00: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 18:59:53 +00: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 12:23:20 +00:00
*
* pkt - > pts , pkt - > dts and pkt - > duration are always set to correct
2009-02-25 19:10:39 +00:00
* values in AVStream . time_base units ( and guessed if the format cannot
2008-09-27 19:51:53 +00: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 12:23:20 +00:00
* decompress the payload .
*
2008-09-27 19:51:53 +00:00
* @ return 0 if OK , < 0 on error or end of file
2007-03-03 12:23:20 +00:00
*/
2003-11-10 18:37:55 +00:00
int av_read_frame ( AVFormatContext * s , AVPacket * pkt ) ;
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Seek to the keyframe at timestamp .
2007-03-03 12:23:20 +00:00
* ' timestamp ' in ' stream_index ' .
2014-02-16 22:36:31 +00:00
*
* @ param s media file handle
2007-03-03 12:23:20 +00:00
* @ 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 19:51:53 +00:00
* @ param timestamp Timestamp in AVStream . time_base units
* or , if no stream is specified , in AV_TIME_BASE units .
2007-03-03 12:23:20 +00:00
* @ param flags flags which select direction and seeking mode
* @ return > = 0 on success
*/
2008-09-27 20:05:12 +00:00
int av_seek_frame ( AVFormatContext * s , int stream_index , int64_t timestamp ,
int flags ) ;
2007-03-03 12:23:20 +00:00
2009-02-08 17:52:52 +00:00
/**
2010-06-30 15:38:06 +00:00
* Seek to timestamp ts .
2009-02-08 17:52:52 +00: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 19:10:39 +00:00
* If flags contain AVSEEK_FLAG_BYTE , then all timestamps are in bytes and
2009-02-08 17:52:52 +00:00
* are the file position ( this may not be supported by all demuxers ) .
2009-02-25 19:10:39 +00:00
* If flags contain AVSEEK_FLAG_FRAME , then all timestamps are in frames
2009-02-08 17:52:52 +00:00
* in the stream with stream_index ( this may not be supported by all demuxers ) .
2009-02-25 19:10:39 +00: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 17:52:52 +00:00
* keyframes ( this may not be supported by all demuxers ) .
2013-05-03 08:31:33 +00:00
* If flags contain AVSEEK_FLAG_BACKWARD , it is ignored .
2009-02-08 17:52:52 +00:00
*
2014-02-16 22:36:31 +00:00
* @ param s media file handle
2009-02-25 19:10:39 +00:00
* @ param stream_index index of the stream which is used as time base reference
2009-02-08 17:52:52 +00:00
* @ param min_ts smallest acceptable timestamp
* @ param ts target timestamp
* @ param max_ts largest acceptable timestamp
* @ param flags flags
2010-03-30 15:50:57 +00:00
* @ return > = 0 on success , error code otherwise
2009-02-08 17:55:00 +00:00
*
2010-07-02 11:46:29 +00:00
* @ note This is part of the new seek API which is still under construction .
2009-02-25 19:10:39 +00:00
* Thus do not use this yet . It may change at any time , do not expect
* ABI compatibility yet !
2009-02-08 17:52:52 +00: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 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Start playing a network - based stream ( e . g . RTSP stream ) at the
2008-09-27 19:51:53 +00:00
* current position .
2007-03-03 12:23:20 +00:00
*/
2003-11-10 18:37:55 +00:00
int av_read_play ( AVFormatContext * s ) ;
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Pause a network - based stream ( e . g . RTSP stream ) .
2007-03-03 12:23:20 +00:00
*
* Use av_read_play ( ) to resume it .
*/
2003-11-10 18:37:55 +00:00
int av_read_pause ( AVFormatContext * s ) ;
2007-03-03 12:23:20 +00:00
2011-12-11 09:34:08 +00:00
# if FF_API_CLOSE_INPUT_FILE
2007-03-03 12:23:20 +00:00
/**
2011-12-11 09:34:08 +00:00
* @ deprecated use avformat_close_input ( )
2010-06-30 15:38:06 +00:00
* Close a media file ( but not its codecs ) .
2007-03-03 12:23:20 +00:00
*
* @ param s media file handle
*/
2011-12-11 09:34:08 +00:00
attribute_deprecated
2001-07-22 14:18:56 +00:00
void av_close_input_file ( AVFormatContext * s ) ;
2011-12-11 09:34:08 +00:00
# endif
2011-12-10 20:04:30 +00:00
/**
2011-12-11 09:34:08 +00:00
* Close an opened input AVFormatContext . Free it and all its contents
* and set * s to NULL .
2011-12-10 20:04:30 +00:00
*/
2011-12-11 09:34:08 +00:00
void avformat_close_input ( AVFormatContext * * s ) ;
2011-02-04 10:04:16 +00:00
/**
2011-12-10 20:04:30 +00:00
* @ }
2011-02-04 10:04:16 +00:00
*/
2011-06-18 09:19:27 +00:00
# if FF_API_NEW_STREAM
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Add a new stream to a media file .
2007-03-03 12:23:20 +00: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 19:51:53 +00:00
* @ param id file - format - dependent stream ID
2007-03-03 12:23:20 +00:00
*/
2011-06-18 09:19:27 +00:00
attribute_deprecated
2002-05-20 16:28:47 +00:00
AVStream * av_new_stream ( AVFormatContext * s , int id ) ;
2011-06-18 09:19:27 +00:00
# endif
2011-11-29 18:28:15 +00:00
# if FF_API_SET_PTS_INFO
2007-03-03 12:23:20 +00:00
/**
2011-11-29 18:28:15 +00:00
* @ deprecated this function is not supposed to be called outside of lavf
2007-03-03 12:23:20 +00:00
*/
2011-11-29 18:28:15 +00:00
attribute_deprecated
2004-05-21 20:43:21 +00:00
void av_set_pts_info ( AVStream * s , int pts_wrap_bits ,
2009-07-01 18:50:31 +00:00
unsigned int pts_num , unsigned int pts_den ) ;
2011-11-29 18:28:15 +00:00
# endif
2001-07-22 14:18:56 +00:00
2004-10-10 22:05:43 +00:00
# define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
# define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes
2008-09-27 19:51:53 +00:00
# define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non-keyframes
2009-08-10 20:48:05 +00:00
# define AVSEEK_FLAG_FRAME 8 ///< seeking based on frame number
2004-10-10 22:05:43 +00:00
2011-12-10 20:04:30 +00:00
/**
* @ addtogroup lavf_encoding
* @ {
*/
2011-05-22 11:53:33 +00: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-20 23:02:13 +00:00
* Its pb field must be set to an already opened AVIOContext .
2011-05-22 11:53:33 +00: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 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Write a packet to an output media file .
2007-03-03 12:23:20 +00:00
*
2014-02-04 14:46:51 +00:00
* This function passes the packet directly to the muxer , without any buffering
* or reordering . The caller is responsible for correctly interleaving the
* packets if the format requires it . Callers that want libavformat to handle
* the interleaving should call av_interleaved_write_frame ( ) instead of this
* function .
2007-03-03 12:23:20 +00:00
*
* @ param s media file handle
2014-02-16 21:09:30 +00:00
* @ param pkt The packet containing the data to be written . Note that unlike
2014-02-04 14:46:51 +00:00
* av_interleaved_write_frame ( ) , this function does not take
* ownership of the packet passed to it ( though some muxers may make
* an internal reference to the input packet ) .
2014-02-16 21:09:30 +00:00
* < br >
2014-02-04 14:46:51 +00:00
* This parameter 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 .
2014-02-16 21:09:30 +00:00
* < br >
2014-02-04 14:46:51 +00: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 .
2012-01-20 17:27:33 +00:00
* @ return < 0 on error , = 0 if OK , 1 if flushed and there is no more data to flush
2014-02-04 14:46:51 +00:00
*
* @ see av_interleaved_write_frame ( )
2007-03-03 12:23:20 +00:00
*/
2004-05-29 02:06:32 +00:00
int av_write_frame ( AVFormatContext * s , AVPacket * pkt ) ;
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Write a packet to an output media file ensuring correct interleaving .
2007-03-03 12:23:20 +00:00
*
2014-02-04 14:46:51 +00:00
* This function will buffer the packets internally as needed to make sure the
* packets in the output file are properly interleaved in the order of
* increasing dts . Callers doing their own interleaving should call
* av_write_frame ( ) instead of this function .
2007-03-03 12:23:20 +00:00
*
* @ param s media file handle
2014-02-16 21:09:30 +00:00
* @ param pkt The packet containing the data to be written .
* < br >
2014-02-04 14:46:51 +00:00
* If the packet is reference - counted , this function will take
* ownership of this reference and unreference it later when it sees
* fit .
* The caller must not access the data through this reference after
* this function returns . If the packet is not reference - counted ,
* libavformat will make a copy .
2014-02-16 21:09:30 +00:00
* < br >
2014-02-04 14:46:51 +00:00
* This parameter can be NULL ( at any time , not just at the end ) , to
* flush the interleaving queues .
2014-02-16 21:09:30 +00:00
* < br >
2014-02-04 14:46:51 +00: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 .
2012-01-18 06:59:02 +00:00
*
2014-02-04 14:58:11 +00:00
* @ return 0 on success , a negative AVERROR on error . Libavformat will always
* take care of freeing the packet , even if this function fails .
2014-02-04 14:46:51 +00:00
*
* @ see av_write_frame ( ) , AVFormatContext . max_interleave_delta
2007-03-03 12:23:20 +00:00
*/
2004-05-29 18:50:31 +00:00
int av_interleaved_write_frame ( AVFormatContext * s , AVPacket * pkt ) ;
2007-03-03 12:23:20 +00:00
2013-12-31 13:09:48 +00:00
/**
* Write a uncoded frame to an output media file .
*
* The frame must be correctly interleaved according to the container
* specification ; if not , then av_interleaved_write_frame ( ) must be used .
*
* See av_interleaved_write_frame ( ) for details .
*/
int av_write_uncoded_frame ( AVFormatContext * s , int stream_index ,
AVFrame * frame ) ;
/**
* Write a uncoded frame to an output media file .
*
* If the muxer supports it , this function allows to write an AVFrame
* structure directly , without encoding it into a packet .
* It is mostly useful for devices and similar special muxers that use raw
* video or PCM data and will not serialize it into a byte stream .
*
* To test whether it is possible to use it with a given muxer and stream ,
* use av_write_uncoded_frame_query ( ) .
*
* The caller gives up ownership of the frame and must not access it
* afterwards .
*
* @ return > = 0 for success , a negative code on error
*/
int av_interleaved_write_uncoded_frame ( AVFormatContext * s , int stream_index ,
AVFrame * frame ) ;
/**
* Test whether a muxer supports uncoded frame .
*
* @ return > = 0 if an uncoded frame can be written to that muxer and stream ,
* < 0 if not
*/
int av_write_uncoded_frame_query ( AVFormatContext * s , int stream_index ) ;
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Write the stream trailer to an output media file and free the
2009-06-28 21:05:46 +00:00
* file private data .
2007-03-03 12:23:20 +00:00
*
2012-10-17 19:45:23 +00:00
* May only be called after a successful call to avformat_write_header .
2008-09-03 17:57:56 +00:00
*
2007-03-03 12:23:20 +00:00
* @ param s media file handle
2008-09-27 19:51:53 +00:00
* @ return 0 if OK , AVERROR_xxx on error
2007-03-03 12:23:20 +00:00
*/
2002-05-20 16:28:47 +00:00
int av_write_trailer ( AVFormatContext * s ) ;
2011-12-11 07:07:53 +00:00
2011-12-10 20:04:30 +00:00
/**
2011-12-11 07:07:53 +00: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 20:04:30 +00:00
*/
2012-08-05 09:11:04 +00:00
enum AVCodecID av_guess_codec ( AVOutputFormat * fmt , const char * short_name ,
2011-12-11 07:07:53 +00:00
const char * filename , const char * mime_type ,
enum AVMediaType type ) ;
2001-07-22 14:18:56 +00:00
2011-06-30 17:45:22 +00: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 08:54:15 +00:00
* @ param [ out ] dts DTS of the last packet output for the stream , in stream
2011-06-30 17:45:22 +00:00
* time_base units
2012-11-21 08:54:15 +00:00
* @ param [ out ] wall absolute time when that packet whas output ,
2011-06-30 17:45:22 +00: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-12 23:29:25 +00:00
2011-12-10 20:04:30 +00:00
/**
* @ }
*/
2001-07-22 14:18:56 +00:00
2011-12-11 07:08:46 +00:00
/**
* @ defgroup lavf_misc Utility functions
* @ ingroup libavf
* @ {
*
2012-07-05 23:38:53 +00:00
* Miscellaneous utility functions related to both muxing and demuxing
2011-12-11 07:08:46 +00: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 10:48:23 +00:00
void av_hex_dump ( FILE * f , const uint8_t * buf , int size ) ;
2011-12-11 07:08:46 +00: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 10:48:23 +00:00
void av_hex_dump_log ( void * avcl , int level , const uint8_t * buf , int size ) ;
2011-12-11 07:08:46 +00: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
*/
2014-04-03 10:44:43 +00:00
void av_pkt_dump2 ( FILE * f , const AVPacket * pkt , int dump_payload , const AVStream * st ) ;
2011-12-11 07:08:46 +00:00
/**
* 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
*/
2014-04-03 10:44:43 +00:00
void av_pkt_dump_log2 ( void * avcl , int level , const AVPacket * pkt , int dump_payload ,
const AVStream * st ) ;
2011-12-11 07:08:46 +00:00
/**
2012-08-05 09:11:04 +00:00
* Get the AVCodecID for the given codec tag tag .
* If no codec id is found returns AV_CODEC_ID_NONE .
2011-12-11 07:08:46 +00:00
*
* @ param tags list of supported codec_id - codec_tag pairs , as stored
* in AVInputFormat . codec_tag and AVOutputFormat . codec_tag
2014-02-16 22:36:31 +00:00
* @ param tag codec tag to match to a codec ID
2011-12-11 07:08:46 +00:00
*/
2012-08-05 09:11:04 +00:00
enum AVCodecID av_codec_get_id ( const struct AVCodecTag * const * tags , unsigned int tag ) ;
2011-12-11 07:08:46 +00: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
2014-02-16 22:36:31 +00:00
* @ param id codec ID to match to a codec tag
2011-12-11 07:08:46 +00:00
*/
2012-08-05 09:11:04 +00:00
unsigned int av_codec_get_tag ( const struct AVCodecTag * const * tags , enum AVCodecID id ) ;
2011-12-11 07:08:46 +00:00
2013-01-17 19:44:33 +00: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 07:08:46 +00:00
int av_find_default_stream_index ( AVFormatContext * s ) ;
/**
* Get the index for a specific timestamp .
2014-02-16 22:36:31 +00:00
*
* @ param st stream that the timestamp belongs to
* @ param timestamp timestamp to retrieve the index for
2011-12-11 07:08:46 +00:00
* @ 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 08:52:35 +00:00
2014-03-11 06:26:28 +00:00
/**
2014-06-08 15:56:34 +00:00
* Print detailed information about the input or output format , such as
* duration , bitrate , streams , container , programs , metadata , side data ,
* codec and time base .
*
* @ param ic the context to analyze
2014-07-03 11:38:28 +00:00
* @ param index index of the stream to dump information about
2014-06-08 15:56:34 +00:00
* @ param url the URL to print , such as source or destination file
2014-07-03 11:51:53 +00:00
* @ param is_output Select whether the specified context is an input ( 0 ) or output ( 1 )
2014-03-11 06:26:28 +00:00
*/
2011-02-16 08:52:35 +00:00
void av_dump_format ( AVFormatContext * ic ,
int index ,
const char * url ,
int is_output ) ;
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Return in ' buf ' the path with ' % d ' replaced by a number .
2008-09-27 19:51:53 +00:00
*
2007-03-03 12:23:20 +00: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 11:45:07 +00:00
* @ param number frame number
2008-09-27 19:51:53 +00:00
* @ return 0 if OK , - 1 on format error
2007-03-03 12:23:20 +00:00
*/
2006-09-04 09:57:47 +00:00
int av_get_frame_filename ( char * buf , int buf_size ,
const char * path , int number ) ;
2007-03-03 12:23:20 +00:00
/**
2010-06-30 15:38:06 +00:00
* Check whether filename actually is a numbered sequence generator .
2007-03-03 12:23:20 +00:00
*
* @ param filename possible numbered sequence string
2008-09-27 19:51:53 +00:00
* @ return 1 if a valid numbered sequence string , 0 otherwise
2007-03-03 12:23:20 +00:00
*/
2006-09-04 09:57:47 +00:00
int av_filename_number_test ( const char * filename ) ;
2001-09-24 23:25:28 +00:00
2007-07-26 22:34:26 +00:00
/**
2010-06-30 15:38:06 +00:00
* Generate an SDP for an RTP session .
2007-07-26 22:34:26 +00:00
*
2012-11-11 19:44:28 +00:00
* Note , this overwrites the id values of AVStreams in the muxer contexts
* for getting unique dynamic payload types .
*
2007-07-26 22:34:26 +00: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 19:51:53 +00:00
* must contain only one AVStream .
2007-08-05 13:44:56 +00:00
* @ param n_files number of AVCodecContexts contained in ac
2011-04-08 10:22:39 +00:00
* @ param buf buffer where the SDP will be stored ( must be allocated by
* the caller )
2007-08-05 13:44:56 +00:00
* @ param size the size of the buffer
2008-09-27 19:51:53 +00:00
* @ return 0 if OK , AVERROR_xxx on error
2007-07-26 22:34:26 +00:00
*/
2011-04-08 10:22:39 +00:00
int av_sdp_create ( AVFormatContext * ac [ ] , int n_files , char * buf , int size ) ;
2011-04-08 09:36:12 +00:00
2010-03-31 19:03:03 +00:00
/**
2010-06-30 15:38:06 +00:00
* Return a positive value if the given filename has one of the given
2010-03-31 19:03:03 +00:00
* extensions , 0 otherwise .
*
2014-02-16 22:36:31 +00:00
* @ param filename file name to check against the given extensions
2010-03-31 19:03:03 +00:00
* @ param extensions a comma - separated list of filename extensions
*/
int av_match_ext ( const char * filename , const char * extensions ) ;
2011-08-11 18:34:45 +00:00
/**
* Test if the given container can store a codec .
*
2014-02-16 22:36:31 +00:00
* @ param ofmt container to check for compatibility
* @ param codec_id codec to potentially store in container
2011-08-11 18:34:45 +00:00
* @ 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 09:11:04 +00:00
int avformat_query_codec ( AVOutputFormat * ofmt , enum AVCodecID codec_id , int std_compliance ) ;
2011-08-11 18:34:45 +00:00
2012-01-27 12:33:09 +00:00
/**
* @ defgroup riff_fourcc RIFF FourCCs
* @ {
2012-08-05 09:11:04 +00:00
* Get the tables mapping RIFF FourCCs to libavcodec AVCodecIDs . The tables are
2012-01-27 12:33:09 +00: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 09:11:04 +00:00
* enum AVCodecID id = av_codec_get_id ( table , tag ) ;
2012-01-27 12:33:09 +00:00
* @ endcode
*/
/**
2012-08-05 09:11:04 +00:00
* @ return the table mapping RIFF FourCCs for video to libavcodec AVCodecID .
2012-01-27 12:33:09 +00:00
*/
const struct AVCodecTag * avformat_get_riff_video_tags ( void ) ;
/**
2012-08-05 09:11:04 +00:00
* @ return the table mapping RIFF FourCCs for audio to AVCodecID .
2012-01-27 12:33:09 +00:00
*/
const struct AVCodecTag * avformat_get_riff_audio_tags ( void ) ;
2014-01-19 20:50:58 +00:00
/**
* @ return the table mapping MOV FourCCs for video to libavcodec AVCodecID .
*/
const struct AVCodecTag * avformat_get_mov_video_tags ( void ) ;
/**
* @ return the table mapping MOV FourCCs for audio to AVCodecID .
*/
const struct AVCodecTag * avformat_get_mov_audio_tags ( void ) ;
2012-05-07 18:27:08 +00:00
2012-05-30 17:36:58 +00:00
/**
* @ }
*/
2012-05-07 18:27:08 +00:00
/**
2012-07-24 07:41:48 +00:00
* Guess the sample aspect ratio of a frame , based on both the stream and the
2012-05-07 18:27:08 +00: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-27 21:08:53 +00: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 09:41:13 +00: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 16:28:42 +00:00
int avformat_queue_attached_pictures ( AVFormatContext * s ) ;
2012-08-14 00:01:38 +00:00
2011-08-23 05:23:52 +00:00
/**
2011-12-11 07:08:46 +00:00
* @ }
2011-11-01 11:40:04 +00:00
*/
2008-08-31 07:39:47 +00:00
# endif /* AVFORMAT_AVFORMAT_H */