21
21
#ifndef AVFORMAT_AVFORMAT_H
22
22
#define AVFORMAT_AVFORMAT_H
26
* Return the LIBAVFORMAT_VERSION_INT constant.
28
unsigned avformat_version(void);
31
* Return the libavformat build-time configuration.
33
const char *avformat_configuration(void);
36
* Return the libavformat license.
38
const char *avformat_license(void);
27
* Main libavformat public API header
31
* @defgroup libavf I/O and Muxing/Demuxing Library
34
* Libavformat (lavf) is a library for dealing with various media container
35
* formats. Its main two purposes are demuxing - i.e. splitting a media file
36
* into component streams, and the reverse process of muxing - writing supplied
37
* data in a specified container format. It also has an @ref lavf_io
38
* "I/O module" which supports a number of protocols for accessing the data (e.g.
39
* file, tcp, http and others). Before using lavf, you need to call
40
* av_register_all() to register all compiled muxers, demuxers and protocols.
41
* Unless you are absolutely sure you won't use libavformat's network
42
* capabilities, you should also call avformat_network_init().
44
* A supported input format is described by an AVInputFormat struct, conversely
45
* an output format is described by AVOutputFormat. You can iterate over all
46
* registered input/output formats using the av_iformat_next() /
47
* av_oformat_next() functions. The protocols layer is not part of the public
48
* API, so you can only get the names of supported protocols with the
49
* avio_enum_protocols() function.
51
* Main lavf structure used for both muxing and demuxing is AVFormatContext,
52
* which exports all information about the file being read or written. As with
53
* most Libav structures, its size is not part of public ABI, so it cannot be
54
* allocated on stack or directly with av_malloc(). To create an
55
* AVFormatContext, use avformat_alloc_context() (some functions, like
56
* avformat_open_input() might do that for you).
58
* Most importantly an AVFormatContext contains:
59
* @li the @ref AVFormatContext.iformat "input" or @ref AVFormatContext.oformat
60
* "output" format. It is either autodetected or set by user for input;
61
* always set by user for output.
62
* @li an @ref AVFormatContext.streams "array" of AVStreams, which describe all
63
* elementary streams stored in the file. AVStreams are typically referred to
64
* using their index in this array.
65
* @li an @ref AVFormatContext.pb "I/O context". It is either opened by lavf or
66
* set by user for input, always set by user for output (unless you are dealing
67
* with an AVFMT_NOFILE format).
69
* @defgroup lavf_decoding Demuxing
71
* Demuxers read a media file and split it into chunks of data (@em packets). A
72
* @ref AVPacket "packet" contains one or more frames which belong a single
73
* elementary stream. In lavf API this process is represented by the
74
* avformat_open_input() function for opening a file, av_read_frame() for
75
* reading a single packet and finally avformat_close_input(), which does the
78
* @section lavf_decoding_open Opening a media file
79
* The minimum information required to open a file is its URL or filename, which
80
* is passed to avformat_open_input(), as in the following code:
82
* const char *url = "in.mp3";
83
* AVFormatContext *s = NULL;
84
* int ret = avformat_open_input(&s, url, NULL, NULL);
88
* The above code attempts to allocate an AVFormatContext, open the
89
* specified file (autodetecting the format) and read the header, exporting the
90
* information stored there into s. Some formats do not have a header or do not
91
* store enough information there, so it is recommended that you call the
92
* avformat_find_stream_info() function which tries to read and decode a few
93
* frames to find missing information.
95
* In some cases you might want to preallocate an AVFormatContext yourself with
96
* avformat_alloc_context() and do some tweaking on it before passing it to
97
* avformat_open_input(). One such case is when you want to use custom functions
98
* for reading input data instead of lavf internal I/O layer.
99
* To do that, create your own AVIOContext with avio_alloc_context(), passing
100
* your reading callbacks to it. Then set the @em pb field of your
101
* AVFormatContext to newly created AVIOContext.
103
* After you have finished reading the file, you must close it with
104
* avformat_close_input(). It will free everything associated with the file.
106
* @section lavf_decoding_read Reading from an opened file
108
* @section lavf_decoding_seek Seeking
111
* @defgroup lavf_encoding Muxing
115
* @defgroup lavf_io I/O Read/Write
119
* @defgroup lavf_codec Demuxers
121
* @defgroup lavf_codec_native Native Demuxers
124
* @defgroup lavf_codec_wrappers External library wrappers
128
* @defgroup lavf_protos I/O Protocols
131
* @defgroup lavf_internal Internal
41
139
#include <stdio.h> /* FILE */
42
140
#include "libavcodec/avcodec.h"
43
141
#include "libavutil/dict.h"
142
#include "libavutil/log.h"
46
145
#include "libavformat/version.h"
48
147
struct AVFormatContext;
52
* Public Metadata API.
151
* @defgroup metadata_api Public Metadata API
53
154
* The metadata API allows libavformat to export metadata tags to a client
54
* application using a sequence of key/value pairs. Like all strings in Libav,
55
* metadata must be stored as UTF-8 encoded Unicode. Note that metadata
155
* application when demuxing. Conversely it allows a client application to
156
* set metadata when muxing.
158
* Metadata is exported or set as pairs of key/value strings in the 'metadata'
159
* fields of the AVFormatContext, AVStream, AVChapter and AVProgram structs
160
* using the @ref lavu_dict "AVDictionary" API. Like all strings in Libav,
161
* metadata is assumed to be UTF-8 encoded Unicode. Note that metadata
56
162
* exported by demuxers isn't checked to be valid UTF-8 in most cases.
57
164
* Important concepts to keep in mind:
58
* 1. Keys are unique; there can never be 2 tags with the same key. This is
165
* - Keys are unique; there can never be 2 tags with the same key. This is
59
166
* also meant semantically, i.e., a demuxer should not knowingly produce
60
167
* several keys that are literally different but semantically identical.
61
168
* E.g., key=Author5, key=Author6. In this example, all authors must be
62
169
* placed in the same tag.
63
* 2. Metadata is flat, not hierarchical; there are no subtags. If you
170
* - Metadata is flat, not hierarchical; there are no subtags. If you
64
171
* want to store, e.g., the email address of the child of producer Alice
65
172
* and actor Bob, that could have key=alice_and_bobs_childs_email_address.
66
* 3. Several modifiers can be applied to the tag name. This is done by
173
* - Several modifiers can be applied to the tag name. This is done by
67
174
* appending a dash character ('-') and the modifier name in the order
68
175
* they appear in the list below -- e.g. foo-eng-sort, not foo-sort-eng.
69
* a) language -- a tag whose value is localized for a particular language
176
* - language -- a tag whose value is localized for a particular language
70
177
* is appended with the ISO 639-2/B 3-letter language code.
71
178
* For example: Author-ger=Michael, Author-eng=Mike
72
179
* The original/default language is in the unqualified "Author" tag.
73
180
* A demuxer should set a default if it sets any translated tag.
74
* b) sorting -- a modified version of a tag that should be used for
181
* - sorting -- a modified version of a tag that should be used for
75
182
* sorting will have '-sort' appended. E.g. artist="The Beatles",
76
183
* artist-sort="Beatles, The".
78
* 4. Demuxers attempt to export metadata in a generic format, however tags
185
* - Demuxers attempt to export metadata in a generic format, however tags
79
186
* with no generic equivalents are left as they are stored in the container.
80
187
* Follows a list of generic tag names:
82
* album -- name of the set this work belongs to
83
* album_artist -- main creator of the set/album, if different from artist.
84
* e.g. "Various Artists" for compilation albums.
85
* artist -- main creator of the work
86
* comment -- any additional description of the file.
87
* composer -- who composed the work, if different from artist.
88
* copyright -- name of copyright holder.
89
* creation_time-- date when the file was created, preferably in ISO 8601.
90
* date -- date when the work was created, preferably in ISO 8601.
91
* disc -- number of a subset, e.g. disc in a multi-disc collection.
92
* encoder -- name/settings of the software/hardware that produced the file.
93
* encoded_by -- person/group who created the file.
94
* filename -- original name of the file.
95
* genre -- <self-evident>.
96
* language -- main language in which the work is performed, preferably
97
* in ISO 639-2 format. Multiple languages can be specified by
98
* separating them with commas.
99
* performer -- artist who performed the work, if different from artist.
100
* E.g for "Also sprach Zarathustra", artist would be "Richard
101
* Strauss" and performer "London Philharmonic Orchestra".
102
* publisher -- name of the label/publisher.
103
* service_name -- name of the service in broadcasting (channel name).
104
* service_provider -- name of the service provider in broadcasting.
105
* title -- name of the work.
106
* track -- number of this work in the set, can be in form current/total.
107
* variant_bitrate -- the total bitrate of the bitrate variant that the current stream is part of
190
album -- name of the set this work belongs to
191
album_artist -- main creator of the set/album, if different from artist.
192
e.g. "Various Artists" for compilation albums.
193
artist -- main creator of the work
194
comment -- any additional description of the file.
195
composer -- who composed the work, if different from artist.
196
copyright -- name of copyright holder.
197
creation_time-- date when the file was created, preferably in ISO 8601.
198
date -- date when the work was created, preferably in ISO 8601.
199
disc -- number of a subset, e.g. disc in a multi-disc collection.
200
encoder -- name/settings of the software/hardware that produced the file.
201
encoded_by -- person/group who created the file.
202
filename -- original name of the file.
203
genre -- <self-evident>.
204
language -- main language in which the work is performed, preferably
205
in ISO 639-2 format. Multiple languages can be specified by
206
separating them with commas.
207
performer -- artist who performed the work, if different from artist.
208
E.g for "Also sprach Zarathustra", artist would be "Richard
209
Strauss" and performer "London Philharmonic Orchestra".
210
publisher -- name of the label/publisher.
211
service_name -- name of the service in broadcasting (channel name).
212
service_provider -- name of the service provider in broadcasting.
213
title -- name of the work.
214
track -- number of this work in the set, can be in form current/total.
215
variant_bitrate -- the total bitrate of the bitrate variant that the current stream is part of
218
* Look in the examples section for an application example how to use the Metadata API.
110
223
#if FF_API_OLD_METADATA2
616
777
int duration_count;
617
778
double duration_error[MAX_STD_TIMEBASES];
618
779
int64_t codec_info_duration;
780
int nb_decoded_frames;
782
#if !FF_API_REORDER_PRIVATE
783
const uint8_t *cur_ptr;
787
// Timestamp generation support:
789
* Timestamp corresponding to the last dts sync point.
791
* Initialized when AVCodecParserContext.dts_sync_point >= 0 and
792
* a DTS is received from the underlying container. Otherwise set to
793
* AV_NOPTS_VALUE by default.
795
int64_t reference_dts;
798
int last_IP_duration;
802
* Number of packets to buffer for codec probing
804
#define MAX_PROBE_PACKETS 2500
808
* last packet in packet_buffer for this stream when muxing.
810
struct AVPacketList *last_in_packet_buffer;
811
AVProbeData probe_data;
812
#define MAX_REORDER_DELAY 16
813
int64_t pts_buffer[MAX_REORDER_DELAY+1];
814
/* av_read_frame() support */
815
enum AVStreamParseType need_parsing;
816
struct AVCodecParserContext *parser;
818
AVIndexEntry *index_entries; /**< Only used if the format does not
819
support seeking natively. */
820
int nb_index_entries;
821
unsigned int index_entries_allocated_size;
823
int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
622
827
#define AV_PROGRAM_RUNNING 1
651
856
* New fields can be added to the end with minor version bumps.
652
857
* Removal, reordering and changes to existing fields require a major
654
* sizeof(AVFormatContext) must not be used outside libav*.
859
* sizeof(AVFormatContext) must not be used outside libav*, use
860
* avformat_alloc_context() to create an AVFormatContext.
656
862
typedef struct AVFormatContext {
657
const AVClass *av_class; /**< Set by avformat_alloc_context. */
658
/* Can only be iformat or oformat, not both at the same time. */
864
* A class for logging and AVOptions. Set by avformat_alloc_context().
865
* Exports (de)muxer private options if they exist.
867
const AVClass *av_class;
870
* Can only be iformat or oformat, not both at the same time.
872
* decoding: set by avformat_open_input().
873
* encoding: set by the user.
659
875
struct AVInputFormat *iformat;
660
876
struct AVOutputFormat *oformat;
879
* Format private data. This is an AVOptions-enabled struct
880
* if and only if iformat/oformat.priv_class is not NULL.
887
* decoding: either set by the user before avformat_open_input() (then
888
* the user must close it manually) or set by avformat_open_input().
889
* encoding: set by the user.
891
* Do NOT set this field if AVFMT_NOFILE flag is set in
892
* iformat/oformat.flags. In such a case, the (de)muxer will handle
893
* I/O in some other way and this field will be NULL.
898
* A list of all streams in the file. New streams are created with
899
* avformat_new_stream().
901
* decoding: streams are created by libavformat in avformat_open_input().
902
* If AVFMTCTX_NOHEADER is set in ctx_flags, then new streams may also
903
* appear in av_read_frame().
904
* encoding: streams are created by the user before avformat_write_header().
663
906
unsigned int nb_streams;
664
907
AVStream **streams;
665
909
char filename[1024]; /**< input or output filename */
666
910
/* stream info */
913
* @deprecated use 'creation_time' metadata tag instead
915
attribute_deprecated int64_t timestamp;
669
918
int ctx_flags; /**< Format-specific flags, see AVFMTCTX_xx */
919
#if FF_API_REORDER_PRIVATE
670
920
/* private data for pts handling (do not modify directly). */
672
922
* This buffer is only needed when packets were already buffered but
829
1105
* decoding: number of frames used to probe fps
831
1107
int fps_probe_size;
1110
* Error recognition; higher values will detect more errors but may
1111
* misdetect some more or less valid parts as errors.
1112
* - encoding: unused
1113
* - decoding: Set by user.
1115
int error_recognition;
1118
* Custom interrupt callbacks for the I/O layer.
1120
* decoding: set by the user before avformat_open_input().
1121
* encoding: set by the user before avformat_write_header()
1122
* (mainly useful for AVFMT_NOFILE formats). The callback
1123
* should also be passed to avio_open2() if it's used to
1126
AVIOInterruptCB interrupt_callback;
1128
/*****************************************************************
1129
* All fields below this line are not part of the public API. They
1130
* may not be used outside of libavformat and can be changed and
1132
* New public fields should be added right above.
1133
*****************************************************************
1135
#if !FF_API_REORDER_PRIVATE
1137
* Raw packets from the demuxer, prior to parsing and decoding.
1138
* This buffer is used for buffering packets until the codec can
1139
* be identified, as parsing cannot be done without knowing the
1142
struct AVPacketList *raw_packet_buffer;
1143
struct AVPacketList *raw_packet_buffer_end;
1145
* Remaining size available for raw_packet_buffer, in bytes.
1147
#define RAW_PACKET_BUFFER_SIZE 2500000
1148
int raw_packet_buffer_remaining_size;
1151
* This buffer is only needed when packets were already buffered but
1152
* not decoded, for example to get the codec parameters in MPEG
1155
struct AVPacketList *packet_buffer;
1156
struct AVPacketList *packet_buffer_end;
1158
/* av_read_frame() support */
1161
/* av_seek_frame() support */
1162
int64_t data_offset; /**< offset of the first packet */
832
1164
} AVFormatContext;
834
1166
typedef struct AVPacketList {
836
1168
struct AVPacketList *next;
1173
* @defgroup lavf_core Core functions
1176
* Functions for querying libavformat capabilities, allocating core structures,
1182
* Return the LIBAVFORMAT_VERSION_INT constant.
1184
unsigned avformat_version(void);
1187
* Return the libavformat build-time configuration.
1189
const char *avformat_configuration(void);
1192
* Return the libavformat license.
1194
const char *avformat_license(void);
1197
* Initialize libavformat and register all the muxers, demuxers and
1198
* protocols. If you do not call this function, then you can select
1199
* exactly which formats you want to support.
1201
* @see av_register_input_format()
1202
* @see av_register_output_format()
1203
* @see av_register_protocol()
1205
void av_register_all(void);
1207
void av_register_input_format(AVInputFormat *format);
1208
void av_register_output_format(AVOutputFormat *format);
1211
* Do global initialization of network components. This is optional,
1212
* but recommended, since it avoids the overhead of implicitly
1213
* doing the setup for each session.
1215
* Calling this function will become mandatory if using network
1216
* protocols at some major version bump.
1218
int avformat_network_init(void);
1221
* Undo the initialization done by avformat_network_init.
1223
int avformat_network_deinit(void);
840
1226
* If f is NULL, returns the first registered input format,
841
1227
* if f is non-NULL, returns the next registered input format after f
851
1237
AVOutputFormat *av_oformat_next(AVOutputFormat *f);
1240
* Allocate an AVFormatContext.
1241
* avformat_free_context() can be used to free the context and everything
1242
* allocated by the framework within it.
1244
AVFormatContext *avformat_alloc_context(void);
1247
* Free an AVFormatContext and all its streams.
1248
* @param s context to free
1250
void avformat_free_context(AVFormatContext *s);
1253
* Get the AVClass for AVFormatContext. It can be used in combination with
1254
* AV_OPT_SEARCH_FAKE_OBJ for examining options.
1256
* @see av_opt_find().
1258
const AVClass *avformat_get_class(void);
1261
* Add a new stream to a media file.
1263
* When demuxing, it is called by the demuxer in read_header(). If the
1264
* flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also
1265
* be called in read_packet().
1267
* When muxing, should be called by the user before avformat_write_header().
1269
* @param c If non-NULL, the AVCodecContext corresponding to the new stream
1270
* will be initialized to use this codec. This is needed for e.g. codec-specific
1271
* defaults to be set, so codec should be provided if it is known.
1273
* @return newly created stream or NULL on error.
1275
AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c);
1277
AVProgram *av_new_program(AVFormatContext *s, int id);
853
1284
#if FF_API_GUESS_IMG2_CODEC
854
1285
attribute_deprecated enum CodecID av_guess_image2_codec(const char *filename);
857
/* XXX: Use automatic init with either ELF sections or C file parser */
861
void av_register_input_format(AVInputFormat *format);
862
void av_register_output_format(AVOutputFormat *format);
865
* Return the output format in the list of registered output formats
866
* which best matches the provided parameters, or return NULL if
869
* @param short_name if non-NULL checks if short_name matches with the
870
* names of the registered formats
871
* @param filename if non-NULL checks if filename terminates with the
872
* extensions of the registered formats
873
* @param mime_type if non-NULL checks if mime_type matches with the
874
* MIME type of the registered formats
876
AVOutputFormat *av_guess_format(const char *short_name,
877
const char *filename,
878
const char *mime_type);
881
* Guess the codec ID based upon muxer and filename.
883
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
884
const char *filename, const char *mime_type,
885
enum AVMediaType type);
888
* Send a nice hexadecimal dump of a buffer to the specified file stream.
890
* @param f The file stream pointer where the dump should be sent to.
892
* @param size buffer size
894
* @see av_hex_dump_log, av_pkt_dump2, av_pkt_dump_log2
896
void av_hex_dump(FILE *f, uint8_t *buf, int size);
899
* Send a nice hexadecimal dump of a buffer to the log.
901
* @param avcl A pointer to an arbitrary struct of which the first field is a
902
* pointer to an AVClass struct.
903
* @param level The importance level of the message, lower values signifying
906
* @param size buffer size
908
* @see av_hex_dump, av_pkt_dump2, av_pkt_dump_log2
910
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size);
913
* Send a nice dump of a packet to the specified file stream.
915
* @param f The file stream pointer where the dump should be sent to.
916
* @param pkt packet to dump
917
* @param dump_payload True if the payload must be displayed, too.
918
* @param st AVStream that the packet belongs to
920
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st);
924
* Send a nice dump of a packet to the log.
926
* @param avcl A pointer to an arbitrary struct of which the first field is a
927
* pointer to an AVClass struct.
928
* @param level The importance level of the message, lower values signifying
930
* @param pkt packet to dump
931
* @param dump_payload True if the payload must be displayed, too.
932
* @param st AVStream that the packet belongs to
934
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
937
1288
#if FF_API_PKT_DUMP
938
1289
attribute_deprecated void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload);
939
1290
attribute_deprecated void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt,
940
1291
int dump_payload);
944
* Initialize libavformat and register all the muxers, demuxers and
945
* protocols. If you do not call this function, then you can select
946
* exactly which formats you want to support.
948
* @see av_register_input_format()
949
* @see av_register_output_format()
950
* @see av_register_protocol()
952
void av_register_all(void);
955
* Get the CodecID for the given codec tag tag.
956
* If no codec id is found returns CODEC_ID_NONE.
958
* @param tags list of supported codec_id-codec_tag pairs, as stored
959
* in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
961
enum CodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);
964
* Get the codec tag for the given codec id id.
965
* If no codec tag is found returns 0.
967
* @param tags list of supported codec_id-codec_tag pairs, as stored
968
* in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
970
unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum CodecID id);
972
/* media file input */
1296
* @addtogroup lavf_decoding
975
1301
* Find AVInputFormat based on the short name of the input format.
1086
1406
* @return >=0 if OK, AVERROR_xxx on error
1087
1407
* @todo Let the user decide somehow what information is needed so that
1088
1408
* we do not waste time getting stuff the user does not need.
1410
* @deprecated use avformat_find_stream_info.
1412
attribute_deprecated
1090
1413
int av_find_stream_info(AVFormatContext *ic);
1417
* Read packets of a media file to get stream information. This
1418
* is useful for file formats with no headers such as MPEG. This
1419
* function also computes the real framerate in case of MPEG-2 repeat
1421
* The logical file position is not changed by this function;
1422
* examined packets may be buffered for later processing.
1424
* @param ic media file handle
1425
* @param options If non-NULL, an ic.nb_streams long array of pointers to
1426
* dictionaries, where i-th member contains options for
1427
* codec corresponding to i-th stream.
1428
* On return each dictionary will be filled with options that were not found.
1429
* @return >=0 if OK, AVERROR_xxx on error
1431
* @note this function isn't guaranteed to open all the codecs, so
1432
* options being non-empty at return is a perfectly normal behavior.
1434
* @todo Let the user decide somehow what information is needed so that
1435
* we do not waste time getting stuff the user does not need.
1437
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
1093
1440
* Find the "best" stream in the file.
1242
1601
* @param s media file handle
1243
1602
* @param id file-format-dependent stream ID
1604
attribute_deprecated
1245
1605
AVStream *av_new_stream(AVFormatContext *s, int id);
1246
AVProgram *av_new_program(AVFormatContext *s, int id);
1608
#if FF_API_SET_PTS_INFO
1249
* Set the pts for a given stream. If the new values would be invalid
1250
* (<= 0), it leaves the AVStream unchanged.
1253
* @param pts_wrap_bits number of bits effectively used by the pts
1254
* (used for wrap control, 33 is the value for MPEG)
1255
* @param pts_num numerator to convert to seconds (MPEG: 1)
1256
* @param pts_den denominator to convert to seconds (MPEG: 90000)
1610
* @deprecated this function is not supposed to be called outside of lavf
1612
attribute_deprecated
1258
1613
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
1259
1614
unsigned int pts_num, unsigned int pts_den);
1261
1617
#define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
1262
1618
#define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes
1263
1619
#define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non-keyframes
1264
1620
#define AVSEEK_FLAG_FRAME 8 ///< seeking based on frame number
1266
int av_find_default_stream_index(AVFormatContext *s);
1269
* Get the index for a specific timestamp.
1270
* @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond
1271
* to the timestamp which is <= the requested one, if backward
1272
* is 0, then it will be >=
1273
* if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1274
* @return < 0 if no such timestamp could be found
1276
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
1279
* Add an index entry into a sorted list. Update the entry if the list
1280
* already contains it.
1282
* @param timestamp timestamp in the time base of the given stream
1284
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1285
int size, int distance, int flags);
1288
* Perform a binary search using av_index_search_timestamp() and
1289
* AVInputFormat.read_timestamp().
1290
* This is not supposed to be called directly by a user application,
1292
* @param target_ts target timestamp in the time base of the given stream
1293
* @param stream_index stream number
1622
#if FF_API_SEEK_PUBLIC
1623
attribute_deprecated
1295
1624
int av_seek_frame_binary(AVFormatContext *s, int stream_index,
1296
1625
int64_t target_ts, int flags);
1299
* Update cur_dts of all streams based on the given timestamp and AVStream.
1301
* Stream ref_st unchanged, others set cur_dts in their native time base.
1302
* Only needed for timestamp wrapping or if (dts not set and pts!=dts).
1303
* @param timestamp new dts expressed in time_base of param ref_st
1304
* @param ref_st reference stream giving time_base of param timestamp
1626
attribute_deprecated
1306
1627
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
1309
* Perform a binary search using read_timestamp().
1310
* This is not supposed to be called directly by a user application,
1312
* @param target_ts target timestamp in the time base of the given stream
1313
* @param stream_index stream number
1628
attribute_deprecated
1315
1629
int64_t av_gen_search(AVFormatContext *s, int stream_index,
1316
1630
int64_t target_ts, int64_t pos_min,
1317
1631
int64_t pos_max, int64_t pos_limit,
1318
1632
int64_t ts_min, int64_t ts_max,
1319
1633
int flags, int64_t *ts_ret,
1320
1634
int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
1325
1637
#if FF_API_FORMAT_PARAMETERS
1327
1639
* @deprecated pass the options to avformat_write_header directly.
1333
* Split a URL string into components.
1335
* The pointers to buffers for storing individual components may be null,
1336
* in order to ignore that component. Buffers for components not found are
1337
* set to empty strings. If the port is not found, it is set to a negative
1340
* @param proto the buffer for the protocol
1341
* @param proto_size the size of the proto buffer
1342
* @param authorization the buffer for the authorization
1343
* @param authorization_size the size of the authorization buffer
1344
* @param hostname the buffer for the host name
1345
* @param hostname_size the size of the hostname buffer
1346
* @param port_ptr a pointer to store the port number in
1347
* @param path the buffer for the path
1348
* @param path_size the size of the path buffer
1349
* @param url the URL to split
1645
* @addtogroup lavf_encoding
1351
void av_url_split(char *proto, int proto_size,
1352
char *authorization, int authorization_size,
1353
char *hostname, int hostname_size,
1355
char *path, int path_size,
1359
1649
* Allocate the stream private data and write the stream header to
1360
1650
* an output media file.
1448
1738
int av_write_trailer(AVFormatContext *s);
1741
* Return the output format in the list of registered output formats
1742
* which best matches the provided parameters, or return NULL if
1743
* there is no match.
1745
* @param short_name if non-NULL checks if short_name matches with the
1746
* names of the registered formats
1747
* @param filename if non-NULL checks if filename terminates with the
1748
* extensions of the registered formats
1749
* @param mime_type if non-NULL checks if mime_type matches with the
1750
* MIME type of the registered formats
1752
AVOutputFormat *av_guess_format(const char *short_name,
1753
const char *filename,
1754
const char *mime_type);
1757
* Guess the codec ID based upon muxer and filename.
1759
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
1760
const char *filename, const char *mime_type,
1761
enum AVMediaType type);
1769
* @defgroup lavf_misc Utility functions
1773
* Miscelaneous utility functions related to both muxing and demuxing
1778
* Send a nice hexadecimal dump of a buffer to the specified file stream.
1780
* @param f The file stream pointer where the dump should be sent to.
1782
* @param size buffer size
1784
* @see av_hex_dump_log, av_pkt_dump2, av_pkt_dump_log2
1786
void av_hex_dump(FILE *f, uint8_t *buf, int size);
1789
* Send a nice hexadecimal dump of a buffer to the log.
1791
* @param avcl A pointer to an arbitrary struct of which the first field is a
1792
* pointer to an AVClass struct.
1793
* @param level The importance level of the message, lower values signifying
1794
* higher importance.
1796
* @param size buffer size
1798
* @see av_hex_dump, av_pkt_dump2, av_pkt_dump_log2
1800
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size);
1803
* Send a nice dump of a packet to the specified file stream.
1805
* @param f The file stream pointer where the dump should be sent to.
1806
* @param pkt packet to dump
1807
* @param dump_payload True if the payload must be displayed, too.
1808
* @param st AVStream that the packet belongs to
1810
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st);
1814
* Send a nice dump of a packet to the log.
1816
* @param avcl A pointer to an arbitrary struct of which the first field is a
1817
* pointer to an AVClass struct.
1818
* @param level The importance level of the message, lower values signifying
1819
* higher importance.
1820
* @param pkt packet to dump
1821
* @param dump_payload True if the payload must be displayed, too.
1822
* @param st AVStream that the packet belongs to
1824
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
1828
* Get the CodecID for the given codec tag tag.
1829
* If no codec id is found returns CODEC_ID_NONE.
1831
* @param tags list of supported codec_id-codec_tag pairs, as stored
1832
* in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
1834
enum CodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);
1837
* Get the codec tag for the given codec id id.
1838
* If no codec tag is found returns 0.
1840
* @param tags list of supported codec_id-codec_tag pairs, as stored
1841
* in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
1843
unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum CodecID id);
1845
int av_find_default_stream_index(AVFormatContext *s);
1848
* Get the index for a specific timestamp.
1849
* @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond
1850
* to the timestamp which is <= the requested one, if backward
1851
* is 0, then it will be >=
1852
* if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1853
* @return < 0 if no such timestamp could be found
1855
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
1858
* Add an index entry into a sorted list. Update the entry if the list
1859
* already contains it.
1861
* @param timestamp timestamp in the time base of the given stream
1863
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1864
int size, int distance, int flags);
1868
* Split a URL string into components.
1870
* The pointers to buffers for storing individual components may be null,
1871
* in order to ignore that component. Buffers for components not found are
1872
* set to empty strings. If the port is not found, it is set to a negative
1875
* @param proto the buffer for the protocol
1876
* @param proto_size the size of the proto buffer
1877
* @param authorization the buffer for the authorization
1878
* @param authorization_size the size of the authorization buffer
1879
* @param hostname the buffer for the host name
1880
* @param hostname_size the size of the hostname buffer
1881
* @param port_ptr a pointer to store the port number in
1882
* @param path the buffer for the path
1883
* @param path_size the size of the path buffer
1884
* @param url the URL to split
1886
void av_url_split(char *proto, int proto_size,
1887
char *authorization, int authorization_size,
1888
char *hostname, int hostname_size,
1890
char *path, int path_size,
1450
1893
#if FF_API_DUMP_FORMAT
1451
1894
attribute_deprecated void dump_format(AVFormatContext *ic,
added
removed
ffmpeg/libavformat/avformat.h
