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