FFmpeg
internal.h
Go to the documentation of this file.
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 "libavutil/bprint.h"
27 #include "avformat.h"
28 #include "os_support.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 #define MAX_PROBE_PACKETS 2500
37 
38 #ifdef DEBUG
39 # define hex_dump_debug(class, buf, size) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size)
40 #else
41 # define hex_dump_debug(class, buf, size) do { if (0) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size); } while(0)
42 #endif
43 
44 typedef struct AVCodecTag {
45  enum AVCodecID id;
46  unsigned int tag;
47 } AVCodecTag;
48 
49 typedef struct CodecMime{
50  char str[32];
51  enum AVCodecID id;
52 } CodecMime;
53 
54 /*************************************************/
55 /* fractional numbers for exact pts handling */
56 
57 /**
58  * The exact value of the fractional number is: 'val + num / den'.
59  * num is assumed to be 0 <= num < den.
60  */
61 typedef struct FFFrac {
62  int64_t val, num, den;
63 } FFFrac;
64 
65 
67  /**
68  * Number of streams relevant for interleaving.
69  * Muxing only.
70  */
72 
73  /**
74  * This buffer is only needed when packets were already buffered but
75  * not decoded, for example to get the codec parameters in MPEG
76  * streams.
77  */
80 
81  /* av_seek_frame() support */
82  int64_t data_offset; /**< offset of the first packet */
83 
84  /**
85  * Raw packets from the demuxer, prior to parsing and decoding.
86  * This buffer is used for buffering packets until the codec can
87  * be identified, as parsing cannot be done without knowing the
88  * codec.
89  */
92  /**
93  * Packets split by the parser get queued here.
94  */
97  /**
98  * Remaining size available for raw_packet_buffer, in bytes.
99  */
100 #define RAW_PACKET_BUFFER_SIZE 2500000
102 
103  /**
104  * Offset to remap timestamps to be non-negative.
105  * Expressed in timebase units.
106  * @see AVStream.mux_ts_offset
107  */
108  int64_t offset;
109 
110  /**
111  * Timebase for the timestamp offset.
112  */
114 
115 #if FF_API_COMPUTE_PKT_FIELDS2
116  int missing_ts_warning;
117 #endif
118 
120 
122 
123  /**
124  * Timestamp of the end of the shortest stream.
125  */
126  int64_t shortest_end;
127 
128  /**
129  * Whether or not avformat_init_output has already been called
130  */
132 
133  /**
134  * Whether or not avformat_init_output fully initialized streams
135  */
137 
138  /**
139  * ID3v2 tag useful for MP3 demuxing
140  */
142 
143  /*
144  * Prefer the codec framerate for avg_frame_rate computation.
145  */
147 };
148 
150  /**
151  * Set to 1 if the codec allows reordering, so pts can be different
152  * from dts.
153  */
154  int reorder;
155 
156  /**
157  * bitstream filters to run on stream
158  * - encoding: Set by muxer using ff_stream_add_bitstream_filter
159  * - decoding: unused
160  */
162  int nb_bsfcs;
163 
164  /**
165  * Whether or not check_bitstream should still be run on each packet
166  */
168 
169  /**
170  * The codec context used by avformat_find_stream_info, the parser, etc.
171  */
173  /**
174  * 1 if avctx has been initialized with the values from the codec parameters
175  */
177 
178  enum AVCodecID orig_codec_id;
179 
180  /* the context for extracting extradata in find_stream_info()
181  * inited=1/bsf=NULL signals that extracting is not possible (codec not
182  * supported) */
183  struct {
186  int inited;
188 
189  /**
190  * Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
191  */
193 
195 };
196 
197 #ifdef __GNUC__
198 #define dynarray_add(tab, nb_ptr, elem)\
199 do {\
200  __typeof__(tab) _tab = (tab);\
201  __typeof__(elem) _elem = (elem);\
202  (void)sizeof(**_tab == _elem); /* check that types are compatible */\
203  av_dynarray_add(_tab, nb_ptr, _elem);\
204 } while(0)
205 #else
206 #define dynarray_add(tab, nb_ptr, elem)\
207 do {\
208  av_dynarray_add((tab), nb_ptr, (elem));\
209 } while(0)
210 #endif
211 
212 struct tm *ff_brktimegm(time_t secs, struct tm *tm);
213 
214 /**
215  * Automatically create sub-directories
216  *
217  * @param path will create sub-directories by path
218  * @return 0, or < 0 on error
219  */
220 int ff_mkdir_p(const char *path);
221 
222 char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase);
223 
224 /**
225  * Parse a string of hexadecimal strings. Any space between the hexadecimal
226  * digits is ignored.
227  *
228  * @param data if non-null, the parsed data is written to this pointer
229  * @param p the string to parse
230  * @return the number of bytes written (or to be written, if data is null)
231  */
232 int ff_hex_to_data(uint8_t *data, const char *p);
233 
234 /**
235  * Add packet to AVFormatContext->packet_buffer list, determining its
236  * interleaved position using compare() function argument.
237  * @return 0, or < 0 on error
238  */
240  int (*compare)(AVFormatContext *, AVPacket *, AVPacket *));
241 
243 
244 #define NTP_OFFSET 2208988800ULL
245 #define NTP_OFFSET_US (NTP_OFFSET * 1000000ULL)
246 
247 /** Get the current time since NTP epoch in microseconds. */
248 uint64_t ff_ntp_time(void);
249 
250 /**
251  * Get the NTP time stamp formatted as per the RFC-5905.
252  *
253  * @param ntp_time NTP time in micro seconds (since NTP epoch)
254  * @return the formatted NTP time stamp
255  */
256 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us);
257 
258 /**
259  * Append the media-specific SDP fragment for the media stream c
260  * to the buffer buff.
261  *
262  * Note, the buffer needs to be initialized, since it is appended to
263  * existing content.
264  *
265  * @param buff the buffer to append the SDP fragment to
266  * @param size the size of the buff buffer
267  * @param st the AVStream of the media to describe
268  * @param idx the global stream index
269  * @param dest_addr the destination address of the media stream, may be NULL
270  * @param dest_type the destination address type, may be NULL
271  * @param port the destination port of the media stream, 0 if unknown
272  * @param ttl the time to live of the stream, 0 if not multicast
273  * @param fmt the AVFormatContext, which might contain options modifying
274  * the generated SDP
275  */
276 void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
277  const char *dest_addr, const char *dest_type,
278  int port, int ttl, AVFormatContext *fmt);
279 
280 /**
281  * Write a packet to another muxer than the one the user originally
282  * intended. Useful when chaining muxers, where one muxer internally
283  * writes a received packet to another muxer.
284  *
285  * @param dst the muxer to write the packet to
286  * @param dst_stream the stream index within dst to write the packet to
287  * @param pkt the packet to be written
288  * @param src the muxer the packet originally was intended for
289  * @param interleave 0->use av_write_frame, 1->av_interleaved_write_frame
290  * @return the value av_write_frame returned
291  */
292 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
294 
295 /**
296  * Get the length in bytes which is needed to store val as v.
297  */
298 int ff_get_v_length(uint64_t val);
299 
300 /**
301  * Put val using a variable number of bytes.
302  */
303 void ff_put_v(AVIOContext *bc, uint64_t val);
304 
305 /**
306  * Read a whole line of text from AVIOContext. Stop reading after reaching
307  * either a \\n, a \\0 or EOF. The returned string is always \\0-terminated,
308  * and may be truncated if the buffer is too small.
309  *
310  * @param s the read-only AVIOContext
311  * @param buf buffer to store the read line
312  * @param maxlen size of the buffer
313  * @return the length of the string written in the buffer, not including the
314  * final \\0
315  */
316 int ff_get_line(AVIOContext *s, char *buf, int maxlen);
317 
318 /**
319  * Same as ff_get_line but strip the white-space characters in the text tail
320  *
321  * @param s the read-only AVIOContext
322  * @param buf buffer to store the read line
323  * @param maxlen size of the buffer
324  * @return the length of the string written in the buffer
325  */
326 int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen);
327 
328 /**
329  * Read a whole line of text from AVIOContext to an AVBPrint buffer. Stop
330  * reading after reaching a \\r, a \\n, a \\r\\n, a \\0 or EOF. The line
331  * ending characters are NOT included in the buffer, but they are skipped on
332  * the input.
333  *
334  * @param s the read-only AVIOContext
335  * @param bp the AVBPrint buffer
336  * @return the length of the read line, not including the line endings,
337  * negative on error.
338  */
339 int64_t ff_read_line_to_bprint(AVIOContext *s, AVBPrint *bp);
340 
341 /**
342  * Read a whole line of text from AVIOContext to an AVBPrint buffer overwriting
343  * its contents. Stop reading after reaching a \\r, a \\n, a \\r\\n, a \\0 or
344  * EOF. The line ending characters are NOT included in the buffer, but they
345  * are skipped on the input.
346  *
347  * @param s the read-only AVIOContext
348  * @param bp the AVBPrint buffer
349  * @return the length of the read line not including the line endings,
350  * negative on error, or if the buffer becomes truncated.
351  */
352 int64_t ff_read_line_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp);
353 
354 #define SPACE_CHARS " \t\r\n"
355 
356 /**
357  * Callback function type for ff_parse_key_value.
358  *
359  * @param key a pointer to the key
360  * @param key_len the number of bytes that belong to the key, including the '='
361  * char
362  * @param dest return the destination pointer for the value in *dest, may
363  * be null to ignore the value
364  * @param dest_len the length of the *dest buffer
365  */
366 typedef void (*ff_parse_key_val_cb)(void *context, const char *key,
367  int key_len, char **dest, int *dest_len);
368 /**
369  * Parse a string with comma-separated key=value pairs. The value strings
370  * may be quoted and may contain escaped characters within quoted strings.
371  *
372  * @param str the string to parse
373  * @param callback_get_buf function that returns where to store the
374  * unescaped value string.
375  * @param context the opaque context pointer to pass to callback_get_buf
376  */
377 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
378  void *context);
379 
380 /**
381  * Find stream index based on format-specific stream ID
382  * @return stream index, or < 0 on error
383  */
384 int ff_find_stream_index(AVFormatContext *s, int id);
385 
386 /**
387  * Internal version of av_index_search_timestamp
388  */
389 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
390  int64_t wanted_timestamp, int flags);
391 
392 /**
393  * Internal version of av_add_index_entry
394  */
395 int ff_add_index_entry(AVIndexEntry **index_entries,
396  int *nb_index_entries,
397  unsigned int *index_entries_allocated_size,
398  int64_t pos, int64_t timestamp, int size, int distance, int flags);
399 
400 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance);
401 
402 /**
403  * Add a new chapter.
404  *
405  * @param s media file handle
406  * @param id unique ID for this chapter
407  * @param start chapter start time in time_base units
408  * @param end chapter end time in time_base units
409  * @param title chapter title
410  *
411  * @return AVChapter or NULL on error
412  */
414  int64_t start, int64_t end, const char *title);
415 
416 /**
417  * Ensure the index uses less memory than the maximum specified in
418  * AVFormatContext.max_index_size by discarding entries if it grows
419  * too large.
420  */
421 void ff_reduce_index(AVFormatContext *s, int stream_index);
422 
423 enum AVCodecID ff_guess_image2_codec(const char *filename);
424 
425 /**
426  * Perform a binary search using av_index_search_timestamp() and
427  * AVInputFormat.read_timestamp().
428  *
429  * @param target_ts target timestamp in the time base of the given stream
430  * @param stream_index stream number
431  */
432 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
433  int64_t target_ts, int flags);
434 
435 /**
436  * Update cur_dts of all streams based on the given timestamp and AVStream.
437  *
438  * Stream ref_st unchanged, others set cur_dts in their native time base.
439  * Only needed for timestamp wrapping or if (dts not set and pts!=dts).
440  * @param timestamp new dts expressed in time_base of param ref_st
441  * @param ref_st reference stream giving time_base of param timestamp
442  */
443 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
444 
445 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
446  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
447 
448 /**
449  * Perform a binary search using read_timestamp().
450  *
451  * @param target_ts target timestamp in the time base of the given stream
452  * @param stream_index stream number
453  */
454 int64_t ff_gen_search(AVFormatContext *s, int stream_index,
455  int64_t target_ts, int64_t pos_min,
456  int64_t pos_max, int64_t pos_limit,
457  int64_t ts_min, int64_t ts_max,
458  int flags, int64_t *ts_ret,
459  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
460 
461 /**
462  * Set the time base and wrapping info for a given stream. This will be used
463  * to interpret the stream's timestamps. If the new time base is invalid
464  * (numerator or denominator are non-positive), it leaves the stream
465  * unchanged.
466  *
467  * @param s stream
468  * @param pts_wrap_bits number of bits effectively used by the pts
469  * (used for wrap control)
470  * @param pts_num time base numerator
471  * @param pts_den time base denominator
472  */
473 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
474  unsigned int pts_num, unsigned int pts_den);
475 
476 /**
477  * Add side data to a packet for changing parameters to the given values.
478  * Parameters set to 0 aren't included in the change.
479  */
481  uint64_t channel_layout, int32_t sample_rate,
483 
484 /**
485  * Set the timebase for each stream from the corresponding codec timebase and
486  * print it.
487  */
489 
490 /**
491  * Read a transport packet from a media file.
492  *
493  * @param s media file handle
494  * @param pkt is filled
495  * @return 0 if OK, AVERROR_xxx on error
496  */
498 
499 /**
500  * Interleave a packet per dts in an output media file.
501  *
502  * Packets with pkt->destruct == av_destruct_packet will be freed inside this
503  * function, so they cannot be used after it. Note that calling av_packet_unref()
504  * on them is still safe.
505  *
506  * @param s media file handle
507  * @param out the interleaved packet will be output here
508  * @param pkt the input packet
509  * @param flush 1 if no further packets are available as input and all
510  * remaining packets should be output
511  * @return 1 if a packet was output, 0 if no packet could be output,
512  * < 0 if an error occurred
513  */
515  AVPacket *pkt, int flush);
516 
518 
519 /**
520  * Return the frame duration in seconds. Return 0 if not available.
521  */
522 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
523  AVCodecParserContext *pc, AVPacket *pkt);
524 
525 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id);
526 
527 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag);
528 
529 /**
530  * Select a PCM codec based on the given parameters.
531  *
532  * @param bps bits-per-sample
533  * @param flt floating-point
534  * @param be big-endian
535  * @param sflags signed flags. each bit corresponds to one byte of bit depth.
536  * e.g. the 1st bit indicates if 8-bit should be signed or
537  * unsigned, the 2nd bit indicates if 16-bit should be signed or
538  * unsigned, etc... This is useful for formats such as WAVE where
539  * only 8-bit is unsigned and all other bit depths are signed.
540  * @return a PCM codec id or AV_CODEC_ID_NONE
541  */
542 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags);
543 
544 /**
545  * Chooses a timebase for muxing the specified stream.
546  *
547  * The chosen timebase allows sample accurate timestamps based
548  * on the framerate or sample rate for audio streams. It also is
549  * at least as precise as 1/min_precision would be.
550  */
551 AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision);
552 
553 /**
554  * Chooses a timebase for muxing the specified stream.
555  */
557 
558 /**
559  * Generate standard extradata for AVC-Intra based on width/height and field
560  * order.
561  */
563 
564 /**
565  * Add a bitstream filter to a stream.
566  *
567  * @param st output stream to add a filter to
568  * @param name the name of the filter to add
569  * @param args filter-specific argument string
570  * @return >0 on success;
571  * AVERROR code on failure
572  */
573 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args);
574 
575 /**
576  * Copy encoding parameters from source to destination stream
577  *
578  * @param dst pointer to destination AVStream
579  * @param src pointer to source AVStream
580  * @return >=0 on success, AVERROR code on error
581  */
583 
584 /**
585  * Wrap errno on rename() error.
586  *
587  * @param oldpath source path
588  * @param newpath destination path
589  * @return 0 or AVERROR on failure
590  */
591 static inline int ff_rename(const char *oldpath, const char *newpath, void *logctx)
592 {
593  int ret = 0;
594  if (rename(oldpath, newpath) == -1) {
595  ret = AVERROR(errno);
596  if (logctx) {
597  char err[AV_ERROR_MAX_STRING_SIZE] = {0};
599  av_log(logctx, AV_LOG_ERROR, "failed to rename file %s to %s: %s\n", oldpath, newpath, err);
600  }
601  }
602  return ret;
603 }
604 
605 /**
606  * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
607  * which is always set to 0.
608  *
609  * Previously allocated extradata in par will be freed.
610  *
611  * @param size size of extradata
612  * @return 0 if OK, AVERROR_xxx on error
613  */
615 
616 /**
617  * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
618  * which is always set to 0 and fill it from pb.
619  *
620  * @param size size of extradata
621  * @return >= 0 if OK, AVERROR_xxx on error
622  */
624 
625 /**
626  * add frame for rfps calculation.
627  *
628  * @param dts timestamp of the i-th frame
629  * @return 0 if OK, AVERROR_xxx on error
630  */
631 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts);
632 
634 
635 /**
636  * Flags for AVFormatContext.write_uncoded_frame()
637  */
639 
640  /**
641  * Query whether the feature is possible on this stream.
642  * The frame argument is ignored.
643  */
645 
646 };
647 
648 /**
649  * Copies the whilelists from one context to the other
650  */
652 
653 int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
655 
656 /**
657  * Returned by demuxers to indicate that data was consumed but discarded
658  * (ignored streams or junk data). The framework will re-call the demuxer.
659  */
660 #define FFERROR_REDO FFERRTAG('R','E','D','O')
661 
662 /**
663  * Utility function to open IO stream of output format.
664  *
665  * @param s AVFormatContext
666  * @param url URL or file name to open for writing
667  * @options optional options which will be passed to io_open callback
668  * @return >=0 on success, negative AVERROR in case of failure
669  */
670 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options);
671 
672 /*
673  * A wrapper around AVFormatContext.io_close that should be used
674  * instead of calling the pointer directly.
675  */
677 
678 /**
679  * Utility function to check if the file uses http or https protocol
680  *
681  * @param s AVFormatContext
682  * @param filename URL or file name to open for writing
683  */
684 int ff_is_http_proto(char *filename);
685 
686 /**
687  * Parse creation_time in AVFormatContext metadata if exists and warn if the
688  * parsing fails.
689  *
690  * @param s AVFormatContext
691  * @param timestamp parsed timestamp in microseconds, only set on successful parsing
692  * @param return_seconds set this to get the number of seconds in timestamp instead of microseconds
693  * @return 1 if OK, 0 if the metadata was not present, AVERROR(EINVAL) on parse error
694  */
695 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds);
696 
697 /**
698  * Standardize creation_time metadata in AVFormatContext to an ISO-8601
699  * timestamp string.
700  *
701  * @param s AVFormatContext
702  * @return <0 on error
703  */
705 
706 #define CONTAINS_PAL 2
707 /**
708  * Reshuffles the lines to use the user specified stride.
709  *
710  * @param ppkt input and output packet
711  * @return negative error code or
712  * 0 if no new packet was allocated
713  * non-zero if a new packet was allocated and ppkt has to be freed
714  * CONTAINS_PAL if in addition to a new packet the old contained a palette
715  */
716 int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride);
717 
718 /**
719  * Retrieves the palette from a packet, either from side data, or
720  * appended to the video data in the packet itself (raw video only).
721  * It is commonly used after a call to ff_reshuffle_raw_rgb().
722  *
723  * Use 0 for the ret parameter to check for side data only.
724  *
725  * @param pkt pointer to packet before calling ff_reshuffle_raw_rgb()
726  * @param ret return value from ff_reshuffle_raw_rgb(), or 0
727  * @param palette pointer to palette buffer
728  * @return negative error code or
729  * 1 if the packet has a palette, else 0
730  */
731 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette);
732 
733 /**
734  * Finalize buf into extradata and set its size appropriately.
735  */
736 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf);
737 
738 /**
739  * Find the next packet in the interleaving queue for the given stream.
740  * The pkt parameter is filled in with the queued packet, including
741  * references to the data (which the caller is not allowed to keep or
742  * modify).
743  *
744  * @return 0 if a packet was found, a negative value if no packet was found
745  */
746 int ff_interleaved_peek(AVFormatContext *s, int stream,
747  AVPacket *pkt, int add_offset);
748 
749 
750 int ff_lock_avformat(void);
751 int ff_unlock_avformat(void);
752 
753 /**
754  * Set AVFormatContext url field to the provided pointer. The pointer must
755  * point to a valid string. The existing url field is freed if necessary. Also
756  * set the legacy filename field to the same string which was provided in url.
757  */
758 void ff_format_set_url(AVFormatContext *s, char *url);
759 
760 #define FF_PACKETLIST_FLAG_REF_PACKET (1 << 0) /**< Create a new reference for the packet instead of
761  transferring the ownership of the existing one to the
762  list. */
763 
764 /**
765  * Append an AVPacket to the list.
766  *
767  * @param head List head element
768  * @param tail List tail element
769  * @param pkt The packet being appended
770  * @param flags Any combination of FF_PACKETLIST_FLAG_* flags
771  * @return 0 on success, negative AVERROR value on failure. On failure,
772  the list is unchanged
773  */
774 int ff_packet_list_put(AVPacketList **head, AVPacketList **tail,
775  AVPacket *pkt, int flags);
776 
777 /**
778  * Remove the oldest AVPacket in the list and return it.
779  *
780  * @note The pkt will be overwritten completely. The caller owns the
781  * packet and must unref it by itself.
782  *
783  * @param head List head element
784  * @param tail List tail element
785  * @param pkt Pointer to an initialized AVPacket struct
786  */
787 int ff_packet_list_get(AVPacketList **head, AVPacketList **tail,
788  AVPacket *pkt);
789 
790 /**
791  * Wipe the list and unref all the packets in it.
792  *
793  * @param head List head element
794  * @param tail List tail element
795  */
796 void ff_packet_list_free(AVPacketList **head, AVPacketList **tail);
797 
798 void avpriv_register_devices(const AVOutputFormat * const o[], const AVInputFormat * const i[]);
799 
800 #endif /* AVFORMAT_INTERNAL_H */
int ff_framehash_write_header(AVFormatContext *s)
Set the timebase for each stream from the corresponding codec timebase and print it.
Definition: framehash.c:23
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:105
void ff_put_v(AVIOContext *bc, uint64_t val)
Put val using a variable number of bytes.
Definition: aviobuf.c:447
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:141
const char const char void * val
Definition: avisynth_c.h:863
Bytestream IO Context.
Definition: avio.h:161
int ff_interleaved_peek(AVFormatContext *s, int stream, AVPacket *pkt, int add_offset)
Find the next packet in the interleaving queue for the given stream.
Definition: mux.c:1139
enum AVCodecID id
Definition: internal.h:45
struct AVPacketList * raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
Definition: internal.h:90
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:167
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
FFFrac * priv_pts
Definition: internal.h:194
static void flush(AVCodecContext *avctx)
int ff_packet_list_put(AVPacketList **head, AVPacketList **tail, AVPacket *pkt, int flags)
Append an AVPacket to the list.
Definition: utils.c:447
struct AVPacketList * parse_queue_end
Definition: internal.h:96
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3124
const char * fmt
Definition: avisynth_c.h:861
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:154
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4882
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:164
int64_t data_offset
offset of the first packet
Definition: internal.h:82
channels
Definition: aptx.c:30
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt, AVFormatContext *src, int interleave)
Write a packet to another muxer than the one the user originally intended.
Definition: mux.c:1311
int ff_mkdir_p(const char *path)
Automatically create sub-directories.
Definition: utils.c:4799
struct tm * ff_brktimegm(time_t secs, struct tm *tm)
Definition: cutils.c:31
The bitstream filter state.
Definition: avcodec.h:5759
int prefer_codec_framerate
Definition: internal.h:146
int64_t offset
Offset to remap timestamps to be non-negative.
Definition: internal.h:108
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3114
const char * key
int avoid_negative_ts_use_pts
Definition: internal.h:121
static AVPacket pkt
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition: utils.c:2048
int ff_is_http_proto(char *filename)
Utility function to check if the file uses http or https protocol.
Definition: utils.c:5644
#define src
Definition: vp8dsp.c:254
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3945
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4583
Format I/O context.
Definition: avformat.h:1358
void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: utils.c:1953
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:117
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: utils.c:1918
void ff_reduce_index(AVFormatContext *s, int stream_index)
Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...
Definition: utils.c:1967
uint8_t
int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Definition: aviobuf.c:1184
miscellaneous OS support macros and functions.
Query whether the feature is possible on this stream.
Definition: internal.h:644
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in lowercase
The exact value of the fractional number is: &#39;val + num / den&#39;.
Definition: internal.h:61
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5637
void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt)
Return the frame duration in seconds.
Definition: utils.c:948
#define height
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Interleave a packet per dts in an output media file.
Definition: mux.c:1020
int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
Utility function to open IO stream of output format.
Definition: utils.c:5627
void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
Definition: utils.c:2091
int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
Copy encoding parameters from source to destination stream.
Definition: utils.c:4268
ptrdiff_t size
Definition: opengl_enc.c:100
struct AVPacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:78
int raw_packet_buffer_remaining_size
Definition: internal.h:101
#define av_log(a,...)
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:3379
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:4641
Callback for checking whether to abort blocking functions.
Definition: avio.h:58
int avctx_inited
1 if avctx has been initialized with the values from the codec parameters
Definition: internal.h:176
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails...
Definition: utils.c:5649
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:481
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, AVPacket *, AVPacket *))
Add packet to AVFormatContext->packet_buffer list, determining its interleaved position using compare...
Definition: mux.c:919
int ff_add_param_change(AVPacket *pkt, int32_t channels, uint64_t channel_layout, int32_t sample_rate, int32_t width, int32_t height)
Add side data to a packet for changing parameters to the given values.
Definition: utils.c:5014
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5666
int64_t val
Definition: internal.h:62
AVPacket * pkt
Definition: internal.h:185
void avpriv_register_devices(const AVOutputFormat *const o[], const AVInputFormat *const i[])
Definition: allformats.c:632
static float distance(float x, float y, int band)
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:136
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5307
AVBSFContext ** bsfcs
bitstream filters to run on stream
Definition: internal.h:161
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:4966
static char * av_make_error_string(char *errbuf, size_t errbuf_size, int errnum)
Fill the provided buffer with a string containing an error string corresponding to the AVERROR code e...
Definition: error.h:109
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3287
int64_t shortest_end
Timestamp of the end of the shortest stream.
Definition: internal.h:126
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:4381
void(* ff_parse_key_val_cb)(void *context, const char *key, int key_len, char **dest, int *dest_len)
Callback function type for ff_parse_key_value.
Definition: internal.h:366
#define width
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
int ff_unlock_avformat(void)
Definition: utils.c:88
int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
Retrieves the palette from a packet, either from side data, or appended to the video data in the pack...
Definition: utils.c:5675
int32_t
#define s(width, name)
Definition: cbs_vp9.c:257
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: utils.c:5797
#define AV_ERROR_MAX_STRING_SIZE
Definition: error.h:83
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:831
Stream structure.
Definition: avformat.h:881
uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
Get the NTP time stamp formatted as per the RFC-5905.
Definition: utils.c:4646
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts)
add frame for rfps calculation.
Definition: utils.c:3321
sample_rate
int ff_add_index_entry(AVIndexEntry **index_entries, int *nb_index_entries, unsigned int *index_entries_allocated_size, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Internal version of av_add_index_entry.
Definition: utils.c:1980
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:103
main external API structure.
Definition: avcodec.h:1565
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now.Options-------Then comes the options array.This is what will define the user accessible options.For example
int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen)
Same as ff_get_line but strip the white-space characters in the text tail.
Definition: aviobuf.c:826
void * buf
Definition: avisynth_c.h:766
static int ff_rename(const char *oldpath, const char *newpath, void *logctx)
Wrap errno on rename() error.
Definition: internal.h:591
AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:102
int nb_interleaved_streams
Number of streams relevant for interleaving.
Definition: internal.h:71
int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Perform a binary search using read_timestamp().
Definition: utils.c:2269
int initialized
Whether or not avformat_init_output has already been called.
Definition: internal.h:131
static int extract_extradata(AVStream *st, AVPacket *pkt)
Definition: utils.c:3507
enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
Select a PCM codec based on the given parameters.
Definition: utils.c:3136
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:5700
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar) ...
Definition: internal.h:192
void ff_packet_list_free(AVPacketList **head, AVPacketList **tail)
Wipe the list and unref all the packets in it.
Definition: utils.c:1419
int inject_global_side_data
Definition: internal.h:119
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:4854
int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: utils.c:2231
#define flags(name, subs,...)
Definition: cbs_av1.c:561
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf, void *context)
Parse a string with comma-separated key=value pairs.
Definition: utils.c:4912
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:118
unsigned int tag
Definition: internal.h:46
struct AVPacketList * parse_queue
Packets split by the parser get queued here.
Definition: internal.h:95
AVRational offset_timebase
Timebase for the timestamp offset.
Definition: internal.h:113
int ff_get_v_length(uint64_t val)
Get the length in bytes which is needed to store val as v.
Definition: aviobuf.c:437
int ff_packet_list_get(AVPacketList **head, AVPacketList **tail, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: utils.c:1550
Main libavformat public API header.
const OptionDef options[]
Definition: ffmpeg_opt.c:3362
void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx, const char *dest_addr, const char *dest_type, int port, int ttl, AVFormatContext *fmt)
Append the media-specific SDP fragment for the media stream c to the buffer buff. ...
Definition: sdp.c:847
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c:3305
unsigned bps
Definition: movenc.c:1497
AVWriteUncodedFrameFlags
Flags for AVFormatContext.write_uncoded_frame()
Definition: internal.h:638
struct AVPacketList * packet_buffer_end
Definition: internal.h:79
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5512
int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride)
Reshuffles the lines to use the user specified stride.
Definition: rawutils.c:25
int64_t ff_read_line_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp)
Read a whole line of text from AVIOContext to an AVBPrint buffer overwriting its contents.
Definition: aviobuf.c:865
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:172
int ff_lock_avformat(void)
Definition: utils.c:83
FILE * out
Definition: movenc.c:54
void INT64 start
Definition: avisynth_c.h:766
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:541
int64_t ff_read_line_to_bprint(AVIOContext *s, AVBPrint *bp)
Read a whole line of text from AVIOContext to an AVBPrint buffer.
Definition: aviobuf.c:834
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:809
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVBSFContext * bsf
Definition: internal.h:184
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your local context
char * ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase)
Definition: utils.c:4833
This structure stores compressed data.
Definition: avcodec.h:1454
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Perform a binary search using av_index_search_timestamp() and AVInputFormat.read_timestamp().
Definition: utils.c:2163
struct AVPacketList * raw_packet_buffer_end
Definition: internal.h:91
const char * name
Definition: opengl_enc.c:102