FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* copyright (c) 2001 Fabrice Bellard
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			#ifndef AVFORMAT_INTERNAL_H
22			#define AVFORMAT_INTERNAL_H
23
24			#include <stdint.h>
25
26			#include "libavcodec/packet_internal.h"
27
28			#include "avformat.h"
29
30			#define MAX_URL_SIZE 4096
31
32			/** size of probe buffer, for guessing file type from file contents */
33			#define PROBE_BUF_MIN 2048
34			#define PROBE_BUF_MAX (1 << 20)
35
36			#ifdef DEBUG
37			# define hex_dump_debug(class, buf, size) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size)
38			#else
39			# define hex_dump_debug(class, buf, size) do { if (0) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size); } while(0)
40			#endif
41
42			typedef struct AVCodecTag {
43			enum AVCodecID id;
44			unsigned int tag;
45			} AVCodecTag;
46
47			typedef struct CodecMime{
48			char str[32];
49			enum AVCodecID id;
50			} CodecMime;
51
52			/*************************************************/
53			/* fractional numbers for exact pts handling */
54
55			/**
56			* The exact value of the fractional number is: 'val + num / den'.
57			* num is assumed to be 0 <= num < den.
58			*/
59			typedef struct FFFrac {
60			int64_t val, num, den;
61			} FFFrac;
62
63
64			typedef struct FFFormatContext {
65			/**
66			* The public context.
67			*/
68			AVFormatContext pub;
69
70			/**
71			* Whether the timestamp shift offset has already been determined.
72			* -1: disabled, 0: not yet determined, 1: determined.
73			*/
74			enum {
75			AVOID_NEGATIVE_TS_DISABLED = -1,
76			AVOID_NEGATIVE_TS_UNKNOWN = 0,
77			AVOID_NEGATIVE_TS_KNOWN = 1,
78			} avoid_negative_ts_status;
79			#define AVOID_NEGATIVE_TS_ENABLED(status) ((status) >= 0)
80
81			/**
82			* This buffer is only needed when packets were already buffered but
83			* not decoded, for example to get the codec parameters in MPEG
84			* streams.
85			*/
86			PacketList packet_buffer;
87
88			/* av_seek_frame() support */
89			int64_t data_offset; /**< offset of the first packet */
90
91			/**
92			* The generic code uses this as a temporary packet
93			* to parse packets or for muxing, especially flushing.
94			* For demuxers, it may also be used for other means
95			* for short periods that are guaranteed not to overlap
96			* with calls to av_read_frame() (or ff_read_packet())
97			* or with each other.
98			* It may be used by demuxers as a replacement for
99			* stack packets (unless they call one of the aforementioned
100			* functions with their own AVFormatContext).
101			* Every user has to ensure that this packet is blank
102			* after using it.
103			*/
104			AVPacket *parse_pkt;
105
106			/**
107			* Used to hold temporary packets for the generic demuxing code.
108			* When muxing, it may be used by muxers to hold packets (even
109			* permanent ones).
110			*/
111			AVPacket *pkt;
112
113			int avoid_negative_ts_use_pts;
114
115			/**
116			* ID3v2 tag useful for MP3 demuxing
117			*/
118			AVDictionary *id3v2_meta;
119
120			int missing_streams;
121			} FFFormatContext;
122
123		1239547	static av_always_inline FFFormatContext *ffformatcontext(AVFormatContext *s)
124			{
125		1239547	return (FFFormatContext*)s;
126			}
127
128			typedef struct FFStream {
129			/**
130			* The public context.
131			*/
132			AVStream pub;
133
134			AVFormatContext *fmtctx;
135			/**
136			* Set to 1 if the codec allows reordering, so pts can be different
137			* from dts.
138			*/
139			int reorder;
140
141			/**
142			* bitstream filter to run on stream
143			* - encoding: Set by muxer using ff_stream_add_bitstream_filter
144			* - decoding: unused
145			*/
146			struct AVBSFContext *bsfc;
147
148			/**
149			* Whether or not check_bitstream should still be run on each packet
150			*/
151			int bitstream_checked;
152
153			/**
154			* The codec context used by avformat_find_stream_info, the parser, etc.
155			*/
156			struct AVCodecContext *avctx;
157			/**
158			* 1 if avctx has been initialized with the values from the codec parameters
159			*/
160			int avctx_inited;
161
162			/* the context for extracting extradata in find_stream_info()
163			* inited=1/bsf=NULL signals that extracting is not possible (codec not
164			* supported) */
165			struct {
166			struct AVBSFContext *bsf;
167			int inited;
168			} extract_extradata;
169
170			/**
171			* Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
172			*/
173			int need_context_update;
174
175			int is_intra_only;
176
177			FFFrac priv_pts;
178
179			/**
180			* Stream information used internally by avformat_find_stream_info()
181			*/
182			struct FFStreamInfo *info;
183
184			AVIndexEntry *index_entries; /**< Only used if the format does not
185			support seeking natively. */
186			int nb_index_entries;
187			unsigned int index_entries_allocated_size;
188
189			int64_t interleaver_chunk_size;
190			int64_t interleaver_chunk_duration;
191
192			/**
193			* stream probing state
194			* -1 -> probing finished
195			* 0 -> no probing requested
196			* rest -> perform probing with request_probe being the minimum score to accept.
197			*/
198			int request_probe;
199			/**
200			* Indicates that everything up to the next keyframe
201			* should be discarded.
202			*/
203			int skip_to_keyframe;
204
205			/**
206			* Number of samples to skip at the start of the frame decoded from the next packet.
207			*/
208			int skip_samples;
209
210			/**
211			* If not 0, the number of samples that should be skipped from the start of
212			* the stream (the samples are removed from packets with pts==0, which also
213			* assumes negative timestamps do not happen).
214			* Intended for use with formats such as mp3 with ad-hoc gapless audio
215			* support.
216			*/
217			int64_t start_skip_samples;
218
219			/**
220			* If not 0, the first audio sample that should be discarded from the stream.
221			* This is broken by design (needs global sample count), but can't be
222			* avoided for broken by design formats such as mp3 with ad-hoc gapless
223			* audio support.
224			*/
225			int64_t first_discard_sample;
226
227			/**
228			* The sample after last sample that is intended to be discarded after
229			* first_discard_sample. Works on frame boundaries only. Used to prevent
230			* early EOF if the gapless info is broken (considered concatenated mp3s).
231			*/
232			int64_t last_discard_sample;
233
234			/**
235			* Number of internally decoded frames, used internally in libavformat, do not access
236			* its lifetime differs from info which is why it is not in that structure.
237			*/
238			int nb_decoded_frames;
239
240			/**
241			* Timestamp offset added to timestamps before muxing
242			*/
243			int64_t mux_ts_offset;
244
245			/**
246			* This is the lowest ts allowed in this track; it may be set by the muxer
247			* during init or write_header and influences the automatic timestamp
248			* shifting code.
249			*/
250			int64_t lowest_ts_allowed;
251
252			/**
253			* Internal data to check for wrapping of the time stamp
254			*/
255			int64_t pts_wrap_reference;
256
257			/**
258			* Options for behavior, when a wrap is detected.
259			*
260			* Defined by AV_PTS_WRAP_ values.
261			*
262			* If correction is enabled, there are two possibilities:
263			* If the first time stamp is near the wrap point, the wrap offset
264			* will be subtracted, which will create negative time stamps.
265			* Otherwise the offset will be added.
266			*/
267			int pts_wrap_behavior;
268
269			/**
270			* Internal data to prevent doing update_initial_durations() twice
271			*/
272			int update_initial_durations_done;
273
274			#define MAX_REORDER_DELAY 16
275
276			/**
277			* Internal data to generate dts from pts
278			*/
279			int64_t pts_reorder_error[MAX_REORDER_DELAY+1];
280			uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1];
281
282			int64_t pts_buffer[MAX_REORDER_DELAY+1];
283
284			/**
285			* Internal data to analyze DTS and detect faulty mpeg streams
286			*/
287			int64_t last_dts_for_order_check;
288			uint8_t dts_ordered;
289			uint8_t dts_misordered;
290
291			/**
292			* display aspect ratio (0 if unknown)
293			* - encoding: unused
294			* - decoding: Set by libavformat to calculate sample_aspect_ratio internally
295			*/
296			AVRational display_aspect_ratio;
297
298			AVProbeData probe_data;
299
300			/**
301			* last packet in packet_buffer for this stream when muxing.
302			*/
303			PacketListEntry *last_in_packet_buffer;
304
305			int64_t last_IP_pts;
306			int last_IP_duration;
307
308			/**
309			* Number of packets to buffer for codec probing
310			*/
311			int probe_packets;
312
313			/* av_read_frame() support */
314			enum AVStreamParseType need_parsing;
315			struct AVCodecParserContext *parser;
316
317			/**
318			* The generic code uses this as a temporary packet
319			* to parse packets or for muxing, especially flushing.
320			* For demuxers, it may also be used for other means
321			* for short periods that are guaranteed not to overlap
322			* with calls to av_read_frame() (or ff_read_packet())
323			* or with each other.
324			* It may be used by demuxers as a replacement for
325			* stack packets (unless they call one of the aforementioned
326			* functions with their own AVFormatContext).
327			* Every user has to ensure that this packet is blank
328			* after using it.
329			*/
330			AVPacket *parse_pkt;
331
332			/**
333			* Number of frames that have been demuxed during avformat_find_stream_info()
334			*/
335			int codec_info_nb_frames;
336
337			/**
338			* Stream Identifier
339			* This is the MPEG-TS stream identifier +1
340			* 0 means unknown
341			*/
342			int stream_identifier;
343
344			// Timestamp generation support:
345			/**
346			* Timestamp corresponding to the last dts sync point.
347			*
348			* Initialized when AVCodecParserContext.dts_sync_point >= 0 and
349			* a DTS is received from the underlying container. Otherwise set to
350			* AV_NOPTS_VALUE by default.
351			*/
352			int64_t first_dts;
353			int64_t cur_dts;
354
355			const struct AVCodecDescriptor *codec_desc;
356
357			#if FF_API_INTERNAL_TIMING
358			AVRational transferred_mux_tb;
359			#endif
360			} FFStream;
361
362		14439312	static av_always_inline FFStream *ffstream(AVStream *st)
363			{
364		14439312	return (FFStream*)st;
365			}
366
367		3275980	static av_always_inline const FFStream *cffstream(const AVStream *st)
368			{
369		3275980	return (const FFStream*)st;
370			}
371
372			#if defined (__GNUC__) || defined (__clang__)
373			#define dynarray_add(tab, nb_ptr, elem)\
374			do {\
375			__typeof__(tab) _tab = (tab);\
376			__typeof__(elem) _elem = (elem);\
377			(void)sizeof(**_tab == _elem); /* check that types are compatible */\
378			av_dynarray_add(_tab, nb_ptr, _elem);\
379			} while(0)
380			#else
381			#define dynarray_add(tab, nb_ptr, elem)\
382			do {\
383			av_dynarray_add((tab), nb_ptr, (elem));\
384			} while(0)
385			#endif
386
387			/**
388			* Automatically create sub-directories
389			*
390			* @param path will create sub-directories by path
391			* @return 0, or < 0 on error
392			*/
393			int ff_mkdir_p(const char *path);
394
395			/**
396			* Write hexadecimal string corresponding to given binary data. The string
397			* is zero-terminated.
398			*
399			* @param buf the output string is written here;
400			* needs to be at least 2 * size + 1 bytes long.
401			* @param src the input data to be transformed.
402			* @param size the size (in byte) of src.
403			* @param lowercase determines whether to use the range [0-9a-f] or [0-9A-F].
404			* @return buf.
405			*/
406			char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase);
407
408			/**
409			* Parse a string of hexadecimal strings. Any space between the hexadecimal
410			* digits is ignored.
411			*
412			* @param data if non-null, the parsed data is written to this pointer
413			* @param p the string to parse
414			* @return the number of bytes written (or to be written, if data is null)
415			*/
416			int ff_hex_to_data(uint8_t *data, const char *p);
417
418			#define NTP_OFFSET 2208988800ULL
419			#define NTP_OFFSET_US (NTP_OFFSET * 1000000ULL)
420
421			/** Get the current time since NTP epoch in microseconds. */
422			uint64_t ff_ntp_time(void);
423
424			/**
425			* Get the NTP time stamp formatted as per the RFC-5905.
426			*
427			* @param ntp_time NTP time in micro seconds (since NTP epoch)
428			* @return the formatted NTP time stamp
429			*/
430			uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us);
431
432			/**
433			* Parse the NTP time in micro seconds (since NTP epoch).
434			*
435			* @param ntp_ts NTP time stamp formatted as per the RFC-5905.
436			* @return the time in micro seconds (since NTP epoch)
437			*/
438			uint64_t ff_parse_ntp_time(uint64_t ntp_ts);
439
440			/**
441			* Append the media-specific SDP fragment for the media stream c
442			* to the buffer buff.
443			*
444			* Note, the buffer needs to be initialized, since it is appended to
445			* existing content.
446			*
447			* @param buff the buffer to append the SDP fragment to
448			* @param size the size of the buff buffer
449			* @param st the AVStream of the media to describe
450			* @param idx the global stream index
451			* @param dest_addr the destination address of the media stream, may be NULL
452			* @param dest_type the destination address type, may be NULL
453			* @param port the destination port of the media stream, 0 if unknown
454			* @param ttl the time to live of the stream, 0 if not multicast
455			* @param fmt the AVFormatContext, which might contain options modifying
456			* the generated SDP
457			* @return 0 on success, a negative error code on failure
458			*/
459			int ff_sdp_write_media(char *buff, int size, const AVStream *st, int idx,
460			const char *dest_addr, const char *dest_type,
461			int port, int ttl, AVFormatContext *fmt);
462
463			/**
464			* Read a whole line of text from AVIOContext. Stop reading after reaching
465			* either a \\n, a \\0 or EOF. The returned string is always \\0-terminated,
466			* and may be truncated if the buffer is too small.
467			*
468			* @param s the read-only AVIOContext
469			* @param buf buffer to store the read line
470			* @param maxlen size of the buffer
471			* @return the length of the string written in the buffer, not including the
472			* final \\0
473			*/
474			int ff_get_line(AVIOContext *s, char *buf, int maxlen);
475
476			/**
477			* Same as ff_get_line but strip the white-space characters in the text tail
478			*
479			* @param s the read-only AVIOContext
480			* @param buf buffer to store the read line
481			* @param maxlen size of the buffer
482			* @return the length of the string written in the buffer
483			*/
484			int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen);
485
486			#define SPACE_CHARS " \t\r\n"
487
488			/**
489			* Callback function type for ff_parse_key_value.
490			*
491			* @param key a pointer to the key
492			* @param key_len the number of bytes that belong to the key, including the '='
493			* char
494			* @param dest return the destination pointer for the value in *dest, may
495			* be null to ignore the value
496			* @param dest_len the length of the *dest buffer
497			*/
498			typedef void (*ff_parse_key_val_cb)(void *context, const char *key,
499			int key_len, char **dest, int *dest_len);
500			/**
501			* Parse a string with comma-separated key=value pairs. The value strings
502			* may be quoted and may contain escaped characters within quoted strings.
503			*
504			* @param str the string to parse
505			* @param callback_get_buf function that returns where to store the
506			* unescaped value string.
507			* @param context the opaque context pointer to pass to callback_get_buf
508			*/
509			void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
510			void *context);
511
512			enum AVCodecID ff_guess_image2_codec(const char *filename);
513
514			/**
515			* Set the time base and wrapping info for a given stream. This will be used
516			* to interpret the stream's timestamps. If the new time base is invalid
517			* (numerator or denominator are non-positive), it leaves the stream
518			* unchanged.
519			*
520			* @param st stream
521			* @param pts_wrap_bits number of bits effectively used by the pts
522			* (used for wrap control)
523			* @param pts_num time base numerator
524			* @param pts_den time base denominator
525			*/
526			void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits,
527			unsigned int pts_num, unsigned int pts_den);
528
529			/**
530			* Set the timebase for each stream from the corresponding codec timebase and
531			* print it.
532			*/
533			int ff_framehash_write_header(AVFormatContext *s);
534
535			/**
536			* Remove a stream from its AVFormatContext and free it.
537			* The stream must be the last stream of the AVFormatContext.
538			*/
539			void ff_remove_stream(AVFormatContext *s, AVStream *st);
540
541			/**
542			* Remove a stream group from its AVFormatContext and free it.
543			* The stream group must be the last stream group of the AVFormatContext.
544			*/
545			void ff_remove_stream_group(AVFormatContext *s, AVStreamGroup *stg);
546
547			unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id);
548
549			enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag);
550
551			/**
552			* Select a PCM codec based on the given parameters.
553			*
554			* @param bps bits-per-sample
555			* @param flt floating-point
556			* @param be big-endian
557			* @param sflags signed flags. each bit corresponds to one byte of bit depth.
558			* e.g. the 1st bit indicates if 8-bit should be signed or
559			* unsigned, the 2nd bit indicates if 16-bit should be signed or
560			* unsigned, etc... This is useful for formats such as WAVE where
561			* only 8-bit is unsigned and all other bit depths are signed.
562			* @return a PCM codec id or AV_CODEC_ID_NONE
563			*/
564			enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags);
565
566			/**
567			* Create a new stream and copy to it all parameters from a source stream, with
568			* the exception of the index field, which is set when the new stream is
569			* created.
570			*
571			* @param dst_ctx pointer to the context in which the new stream is created
572			* @param src pointer to source AVStream
573			* @return pointer to the new stream or NULL on error
574			*/
575			AVStream *ff_stream_clone(AVFormatContext *dst_ctx, const AVStream *src);
576
577			/**
578			* Wrap ffurl_move() and log if error happens.
579			*
580			* @param url_src source path
581			* @param url_dst destination path
582			* @return 0 or AVERROR on failure
583			*/
584			int ff_rename(const char *url_src, const char *url_dst, void *logctx);
585
586			/**
587			* Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
588			* which is always set to 0.
589			*
590			* Previously allocated extradata in par will be freed.
591			*
592			* @param size size of extradata
593			* @return 0 if OK, AVERROR_xxx on error
594			*/
595			int ff_alloc_extradata(AVCodecParameters *par, int size);
596
597			/**
598			* Copies the whilelists from one context to the other
599			*/
600			int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src);
601
602			/*
603			* A wrapper around AVFormatContext.io_close that should be used
604			* instead of calling the pointer directly.
605			*
606			* @param s AVFormatContext
607			* @param *pb the AVIOContext to be closed and freed. Can be NULL.
608			* @return >=0 on success, negative AVERROR in case of failure
609			*/
610			int ff_format_io_close(AVFormatContext *s, AVIOContext **pb);
611
612			/**
613			* Utility function to check if the file uses http or https protocol
614			*
615			* @param s AVFormatContext
616			* @param filename URL or file name to open for writing
617			*/
618			int ff_is_http_proto(const char *filename);
619
620			struct AVBPrint;
621			/**
622			* Finalize buf into extradata and set its size appropriately.
623			*/
624			int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf);
625
626			/**
627			* Set AVFormatContext url field to the provided pointer. The pointer must
628			* point to a valid string. The existing url field is freed if necessary. Also
629			* set the legacy filename field to the same string which was provided in url.
630			*/
631			void ff_format_set_url(AVFormatContext *s, char *url);
632
633			/**
634			* Set AVFormatContext url field to a av_strdup of the provided pointer. The pointer must
635			* point to a valid string. The existing url field is freed if necessary.
636			*
637			* Checks protocol_whitelist/blacklist
638			*
639			* @returns a AVERROR code or non negative on success
640			*/
641			int ff_format_check_set_url(AVFormatContext *s, const char *url);
642
643			/**
644			* Return a positive value if the given url has one of the given
645			* extensions, negative AVERROR on error, 0 otherwise.
646			*
647			* @param url url to check against the given extensions
648			* @param extensions a comma-separated list of filename extensions
649			*/
650			int ff_match_url_ext(const char *url, const char *extensions);
651
652			/**
653			* Return in 'buf' the path with '%d' replaced by a number.
654			*
655			* Also handles the '%0nd' format where 'n' is the total number
656			* of digits and '%%'.
657			*
658			* @param buf destination buffer
659			* @param path path with substitution template
660			* @param number the number to substitute
661			* @param flags AV_FRAME_FILENAME_FLAGS_*
662			* @return 0 if OK, <0 on error.
663			*/
664			int ff_bprint_get_frame_filename(struct AVBPrint *buf, const char *path, int64_t number, int flags);
665
666			/**
667			* Set a dictionary value to an ISO-8601 compliant timestamp string.
668			*
669			* @param dict pointer to a pointer to a dictionary struct. If *dict is NULL
670			* a dictionary struct is allocated and put in *dict.
671			* @param key metadata key
672			* @param timestamp unix timestamp in microseconds
673			* @return <0 on error
674			*/
675			int ff_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp);
676
677			/**
678			* Set a list of query string options on an object. Only the objects own
679			* options will be set.
680			*
681			* @param obj the object to set options on
682			* @param str the query string
683			* @param allow_unknown ignore unknown query string options. This can be OK if
684			* nested protocols are used.
685			* @return <0 on error
686			*/
687			int ff_parse_opts_from_query_string(void *obj, const char *str, int allow_unkown);
688
689			/**
690			* Make a RFC 4281/6381 like string describing a codec.
691			*
692			* @param logctx a context for potential log messages; if NULL, nothing is
693			* logged
694			* @param par pointer to an AVCodecParameters struct describing the codec
695			* @param frame_rate an optional pointer to AVRational for the frame rate,
696			* for deciding the right profile for video codecs
697			* @param out the AVBPrint to write the output to
698			* @return <0 on error
699			*/
700			int ff_make_codec_str(void *logctx, const AVCodecParameters *par,
701			const AVRational *frame_rate, struct AVBPrint *out);
702
703			#endif /* AVFORMAT_INTERNAL_H */
704