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 "libavcodec/avcodec.h"
27 #include "libavcodec/bsf.h"
29 
30 #include "avformat.h"
31 #include "os_support.h"
32 
33 #define MAX_URL_SIZE 4096
34 
35 /** size of probe buffer, for guessing file type from file contents */
36 #define PROBE_BUF_MIN 2048
37 #define PROBE_BUF_MAX (1 << 20)
38 
39 #ifdef DEBUG
40 # define hex_dump_debug(class, buf, size) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size)
41 #else
42 # define hex_dump_debug(class, buf, size) do { if (0) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size); } while(0)
43 #endif
44 
45 /**
46  * For an AVInputFormat with this flag set read_close() needs to be called
47  * by the caller upon read_header() failure.
48  */
49 #define FF_FMT_INIT_CLEANUP (1 << 0)
50 
51 typedef struct AVCodecTag {
52  enum AVCodecID id;
53  unsigned int tag;
54 } AVCodecTag;
55 
56 typedef struct CodecMime{
57  char str[32];
58  enum AVCodecID id;
59 } CodecMime;
60 
61 /*************************************************/
62 /* fractional numbers for exact pts handling */
63 
64 /**
65  * The exact value of the fractional number is: 'val + num / den'.
66  * num is assumed to be 0 <= num < den.
67  */
68 typedef struct FFFrac {
69  int64_t val, num, den;
70 } FFFrac;
71 
72 
73 typedef struct FFFormatContext {
74  /**
75  * The public context.
76  */
78 
79  /**
80  * Number of streams relevant for interleaving.
81  * Muxing only.
82  */
84 
85  /**
86  * Whether the timestamp shift offset has already been determined.
87  * -1: disabled, 0: not yet determined, 1: determined.
88  */
89  enum {
94 #define AVOID_NEGATIVE_TS_ENABLED(status) ((status) >= 0)
95 
96  /**
97  * The interleavement function in use. Always set for muxers.
98  */
100  int flush, int has_packet);
101 
102  /**
103  * This buffer is only needed when packets were already buffered but
104  * not decoded, for example to get the codec parameters in MPEG
105  * streams.
106  */
108 
109  /* av_seek_frame() support */
110  int64_t data_offset; /**< offset of the first packet */
111 
112  /**
113  * Raw packets from the demuxer, prior to parsing and decoding.
114  * This buffer is used for buffering packets until the codec can
115  * be identified, as parsing cannot be done without knowing the
116  * codec.
117  */
119  /**
120  * Packets split by the parser get queued here.
121  */
123  /**
124  * The generic code uses this as a temporary packet
125  * to parse packets or for muxing, especially flushing.
126  * For demuxers, it may also be used for other means
127  * for short periods that are guaranteed not to overlap
128  * with calls to av_read_frame() (or ff_read_packet())
129  * or with each other.
130  * It may be used by demuxers as a replacement for
131  * stack packets (unless they call one of the aforementioned
132  * functions with their own AVFormatContext).
133  * Every user has to ensure that this packet is blank
134  * after using it.
135  */
137 
138  /**
139  * Used to hold temporary packets for the generic demuxing code.
140  * When muxing, it may be used by muxers to hold packets (even
141  * permanent ones).
142  */
144  /**
145  * Sum of the size of packets in raw_packet_buffer, in bytes.
146  */
148 
149 #if FF_API_COMPUTE_PKT_FIELDS2
150  int missing_ts_warning;
151 #endif
152 
154 
156 
157  /**
158  * Timestamp of the end of the shortest stream.
159  */
160  int64_t shortest_end;
161 
162  /**
163  * Whether or not avformat_init_output has already been called
164  */
166 
167  /**
168  * Whether or not avformat_init_output fully initialized streams
169  */
171 
172  /**
173  * ID3v2 tag useful for MP3 demuxing
174  */
176 
177  /*
178  * Prefer the codec framerate for avg_frame_rate computation.
179  */
181 
182  /**
183  * Set if chapter ids are strictly monotonic.
184  */
187 
189 {
190  return (FFFormatContext*)s;
191 }
192 
193 typedef struct FFStream {
194  /**
195  * The public context.
196  */
198 
199  /**
200  * Set to 1 if the codec allows reordering, so pts can be different
201  * from dts.
202  */
203  int reorder;
204 
205  /**
206  * bitstream filter to run on stream
207  * - encoding: Set by muxer using ff_stream_add_bitstream_filter
208  * - decoding: unused
209  */
211 
212  /**
213  * Whether or not check_bitstream should still be run on each packet
214  */
216 
217  /**
218  * The codec context used by avformat_find_stream_info, the parser, etc.
219  */
221  /**
222  * 1 if avctx has been initialized with the values from the codec parameters
223  */
225 
226  /* the context for extracting extradata in find_stream_info()
227  * inited=1/bsf=NULL signals that extracting is not possible (codec not
228  * supported) */
229  struct {
231  int inited;
233 
234  /**
235  * Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
236  */
238 
240 
242 
243 #define MAX_STD_TIMEBASES (30*12+30+3+6)
244  /**
245  * Stream information used internally by avformat_find_stream_info()
246  */
247  struct {
248  int64_t last_dts;
249  int64_t duration_gcd;
256 
257  /**
258  * 0 -> decoder has not been searched for yet.
259  * >0 -> decoder found
260  * <0 -> decoder with codec_id == -found_decoder has not been found
261  */
263 
264  int64_t last_duration;
265 
266  /**
267  * Those are used for average framerate estimation.
268  */
269  int64_t fps_first_dts;
271  int64_t fps_last_dts;
273 
274  } *info;
275 
276  AVIndexEntry *index_entries; /**< Only used if the format does not
277  support seeking natively. */
280 
283 
284  /**
285  * stream probing state
286  * -1 -> probing finished
287  * 0 -> no probing requested
288  * rest -> perform probing with request_probe being the minimum score to accept.
289  */
291  /**
292  * Indicates that everything up to the next keyframe
293  * should be discarded.
294  */
296 
297  /**
298  * Number of samples to skip at the start of the frame decoded from the next packet.
299  */
301 
302  /**
303  * If not 0, the number of samples that should be skipped from the start of
304  * the stream (the samples are removed from packets with pts==0, which also
305  * assumes negative timestamps do not happen).
306  * Intended for use with formats such as mp3 with ad-hoc gapless audio
307  * support.
308  */
310 
311  /**
312  * If not 0, the first audio sample that should be discarded from the stream.
313  * This is broken by design (needs global sample count), but can't be
314  * avoided for broken by design formats such as mp3 with ad-hoc gapless
315  * audio support.
316  */
318 
319  /**
320  * The sample after last sample that is intended to be discarded after
321  * first_discard_sample. Works on frame boundaries only. Used to prevent
322  * early EOF if the gapless info is broken (considered concatenated mp3s).
323  */
325 
326  /**
327  * Number of internally decoded frames, used internally in libavformat, do not access
328  * its lifetime differs from info which is why it is not in that structure.
329  */
331 
332  /**
333  * Timestamp offset added to timestamps before muxing
334  */
335  int64_t mux_ts_offset;
336 
337  /**
338  * Internal data to check for wrapping of the time stamp
339  */
341 
342  /**
343  * Options for behavior, when a wrap is detected.
344  *
345  * Defined by AV_PTS_WRAP_ values.
346  *
347  * If correction is enabled, there are two possibilities:
348  * If the first time stamp is near the wrap point, the wrap offset
349  * will be subtracted, which will create negative time stamps.
350  * Otherwise the offset will be added.
351  */
353 
354  /**
355  * Internal data to prevent doing update_initial_durations() twice
356  */
358 
359 #define MAX_REORDER_DELAY 16
360 
361  /**
362  * Internal data to generate dts from pts
363  */
366 
368 
369  /**
370  * Internal data to analyze DTS and detect faulty mpeg streams
371  */
373  uint8_t dts_ordered;
374  uint8_t dts_misordered;
375 
376  /**
377  * Internal data to inject global side data
378  */
380 
381  /**
382  * display aspect ratio (0 if unknown)
383  * - encoding: unused
384  * - decoding: Set by libavformat to calculate sample_aspect_ratio internally
385  */
387 
389 
390  /**
391  * last packet in packet_buffer for this stream when muxing.
392  */
394 
395  int64_t last_IP_pts;
397 
398  /**
399  * Number of packets to buffer for codec probing
400  */
402 
403  /* av_read_frame() support */
406 
407  /**
408  * Number of frames that have been demuxed during avformat_find_stream_info()
409  */
411 
412  /**
413  * Stream Identifier
414  * This is the MPEG-TS stream identifier +1
415  * 0 means unknown
416  */
418 
419  // Timestamp generation support:
420  /**
421  * Timestamp corresponding to the last dts sync point.
422  *
423  * Initialized when AVCodecParserContext.dts_sync_point >= 0 and
424  * a DTS is received from the underlying container. Otherwise set to
425  * AV_NOPTS_VALUE by default.
426  */
427  int64_t first_dts;
428  int64_t cur_dts;
429 } FFStream;
430 
432 {
433  return (FFStream*)st;
434 }
435 
436 static av_always_inline const FFStream *cffstream(const AVStream *st)
437 {
438  return (FFStream*)st;
439 }
440 
442 
443 #ifdef __GNUC__
444 #define dynarray_add(tab, nb_ptr, elem)\
445 do {\
446  __typeof__(tab) _tab = (tab);\
447  __typeof__(elem) _elem = (elem);\
448  (void)sizeof(**_tab == _elem); /* check that types are compatible */\
449  av_dynarray_add(_tab, nb_ptr, _elem);\
450 } while(0)
451 #else
452 #define dynarray_add(tab, nb_ptr, elem)\
453 do {\
454  av_dynarray_add((tab), nb_ptr, (elem));\
455 } while(0)
456 #endif
457 
458 #define RELATIVE_TS_BASE (INT64_MAX - (1LL << 48))
459 
460 static av_always_inline int is_relative(int64_t ts)
461 {
462  return ts > (RELATIVE_TS_BASE - (1LL << 48));
463 }
464 
465 /**
466  * Wrap a given time stamp, if there is an indication for an overflow
467  *
468  * @param st stream
469  * @param timestamp the time stamp to wrap
470  * @return resulting time stamp
471  */
472 int64_t ff_wrap_timestamp(const AVStream *st, int64_t timestamp);
473 
475 
476 /**
477  * Automatically create sub-directories
478  *
479  * @param path will create sub-directories by path
480  * @return 0, or < 0 on error
481  */
482 int ff_mkdir_p(const char *path);
483 
484 /**
485  * Write hexadecimal string corresponding to given binary data. The string
486  * is zero-terminated.
487  *
488  * @param buf the output string is written here;
489  * needs to be at least 2 * size + 1 bytes long.
490  * @param src the input data to be transformed.
491  * @param size the size (in byte) of src.
492  * @param lowercase determines whether to use the range [0-9a-f] or [0-9A-F].
493  * @return buf.
494  */
495 char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase);
496 
497 /**
498  * Parse a string of hexadecimal strings. Any space between the hexadecimal
499  * digits is ignored.
500  *
501  * @param data if non-null, the parsed data is written to this pointer
502  * @param p the string to parse
503  * @return the number of bytes written (or to be written, if data is null)
504  */
505 int ff_hex_to_data(uint8_t *data, const char *p);
506 
507 /**
508  * Add packet to an AVFormatContext's packet_buffer list, determining its
509  * interleaved position using compare() function argument.
510  * @return 0 on success, < 0 on error. pkt will always be blank on return.
511  */
513  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *));
514 
516 
517 #define NTP_OFFSET 2208988800ULL
518 #define NTP_OFFSET_US (NTP_OFFSET * 1000000ULL)
519 
520 /** Get the current time since NTP epoch in microseconds. */
521 uint64_t ff_ntp_time(void);
522 
523 /**
524  * Get the NTP time stamp formatted as per the RFC-5905.
525  *
526  * @param ntp_time NTP time in micro seconds (since NTP epoch)
527  * @return the formatted NTP time stamp
528  */
529 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us);
530 
531 /**
532  * Parse the NTP time in micro seconds (since NTP epoch).
533  *
534  * @param ntp_ts NTP time stamp formatted as per the RFC-5905.
535  * @return the time in micro seconds (since NTP epoch)
536  */
537 uint64_t ff_parse_ntp_time(uint64_t ntp_ts);
538 
539 /**
540  * Append the media-specific SDP fragment for the media stream c
541  * to the buffer buff.
542  *
543  * Note, the buffer needs to be initialized, since it is appended to
544  * existing content.
545  *
546  * @param buff the buffer to append the SDP fragment to
547  * @param size the size of the buff buffer
548  * @param st the AVStream of the media to describe
549  * @param idx the global stream index
550  * @param dest_addr the destination address of the media stream, may be NULL
551  * @param dest_type the destination address type, may be NULL
552  * @param port the destination port of the media stream, 0 if unknown
553  * @param ttl the time to live of the stream, 0 if not multicast
554  * @param fmt the AVFormatContext, which might contain options modifying
555  * the generated SDP
556  * @return 0 on success, a negative error code on failure
557  */
558 int ff_sdp_write_media(char *buff, int size, const AVStream *st, int idx,
559  const char *dest_addr, const char *dest_type,
560  int port, int ttl, AVFormatContext *fmt);
561 
562 /**
563  * Write a packet to another muxer than the one the user originally
564  * intended. Useful when chaining muxers, where one muxer internally
565  * writes a received packet to another muxer.
566  *
567  * @param dst the muxer to write the packet to
568  * @param dst_stream the stream index within dst to write the packet to
569  * @param pkt the packet to be written. It will be returned blank when
570  * av_interleaved_write_frame() is used, unchanged otherwise.
571  * @param src the muxer the packet originally was intended for
572  * @param interleave 0->use av_write_frame, 1->av_interleaved_write_frame
573  * @return the value av_write_frame returned
574  */
575 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
577 
578 /**
579  * Read a whole line of text from AVIOContext. Stop reading after reaching
580  * either a \\n, a \\0 or EOF. The returned string is always \\0-terminated,
581  * and may be truncated if the buffer is too small.
582  *
583  * @param s the read-only AVIOContext
584  * @param buf buffer to store the read line
585  * @param maxlen size of the buffer
586  * @return the length of the string written in the buffer, not including the
587  * final \\0
588  */
589 int ff_get_line(AVIOContext *s, char *buf, int maxlen);
590 
591 /**
592  * Same as ff_get_line but strip the white-space characters in the text tail
593  *
594  * @param s the read-only AVIOContext
595  * @param buf buffer to store the read line
596  * @param maxlen size of the buffer
597  * @return the length of the string written in the buffer
598  */
599 int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen);
600 
601 #define SPACE_CHARS " \t\r\n"
602 
603 /**
604  * Callback function type for ff_parse_key_value.
605  *
606  * @param key a pointer to the key
607  * @param key_len the number of bytes that belong to the key, including the '='
608  * char
609  * @param dest return the destination pointer for the value in *dest, may
610  * be null to ignore the value
611  * @param dest_len the length of the *dest buffer
612  */
613 typedef void (*ff_parse_key_val_cb)(void *context, const char *key,
614  int key_len, char **dest, int *dest_len);
615 /**
616  * Parse a string with comma-separated key=value pairs. The value strings
617  * may be quoted and may contain escaped characters within quoted strings.
618  *
619  * @param str the string to parse
620  * @param callback_get_buf function that returns where to store the
621  * unescaped value string.
622  * @param context the opaque context pointer to pass to callback_get_buf
623  */
624 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
625  void *context);
626 
627 /**
628  * Find stream index based on format-specific stream ID
629  * @return stream index, or < 0 on error
630  */
631 int ff_find_stream_index(const AVFormatContext *s, int id);
632 
633 /**
634  * Internal version of av_index_search_timestamp
635  */
636 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
637  int64_t wanted_timestamp, int flags);
638 
639 /**
640  * Internal version of av_add_index_entry
641  */
642 int ff_add_index_entry(AVIndexEntry **index_entries,
643  int *nb_index_entries,
644  unsigned int *index_entries_allocated_size,
645  int64_t pos, int64_t timestamp, int size, int distance, int flags);
646 
647 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance);
648 
649 /**
650  * Add a new chapter.
651  *
652  * @param s media file handle
653  * @param id unique ID for this chapter
654  * @param start chapter start time in time_base units
655  * @param end chapter end time in time_base units
656  * @param title chapter title
657  *
658  * @return AVChapter or NULL on error
659  */
660 AVChapter *avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base,
661  int64_t start, int64_t end, const char *title);
662 
663 /**
664  * Ensure the index uses less memory than the maximum specified in
665  * AVFormatContext.max_index_size by discarding entries if it grows
666  * too large.
667  */
668 void ff_reduce_index(AVFormatContext *s, int stream_index);
669 
670 enum AVCodecID ff_guess_image2_codec(const char *filename);
671 
673  enum AVCodecID codec_id);
674 /**
675  * Perform a binary search using av_index_search_timestamp() and
676  * AVInputFormat.read_timestamp().
677  *
678  * @param target_ts target timestamp in the time base of the given stream
679  * @param stream_index stream number
680  */
681 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
682  int64_t target_ts, int flags);
683 
684 /**
685  * Update cur_dts of all streams based on the given timestamp and AVStream.
686  *
687  * Stream ref_st unchanged, others set cur_dts in their native time base.
688  * Only needed for timestamp wrapping or if (dts not set and pts!=dts).
689  * @param timestamp new dts expressed in time_base of param ref_st
690  * @param ref_st reference stream giving time_base of param timestamp
691  */
692 void avpriv_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
693 
694 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
695  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
696 
697 /**
698  * Perform a binary search using read_timestamp().
699  *
700  * @param target_ts target timestamp in the time base of the given stream
701  * @param stream_index stream number
702  */
703 int64_t ff_gen_search(AVFormatContext *s, int stream_index,
704  int64_t target_ts, int64_t pos_min,
705  int64_t pos_max, int64_t pos_limit,
706  int64_t ts_min, int64_t ts_max,
707  int flags, int64_t *ts_ret,
708  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
709 
710 /**
711  * Set the time base and wrapping info for a given stream. This will be used
712  * to interpret the stream's timestamps. If the new time base is invalid
713  * (numerator or denominator are non-positive), it leaves the stream
714  * unchanged.
715  *
716  * @param st stream
717  * @param pts_wrap_bits number of bits effectively used by the pts
718  * (used for wrap control)
719  * @param pts_num time base numerator
720  * @param pts_den time base denominator
721  */
722 void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits,
723  unsigned int pts_num, unsigned int pts_den);
724 
725 /**
726  * Add side data to a packet for changing parameters to the given values.
727  * Parameters set to 0 aren't included in the change.
728  */
730  uint64_t channel_layout, int32_t sample_rate,
732 
733 /**
734  * Set the timebase for each stream from the corresponding codec timebase and
735  * print it.
736  */
738 
739 /**
740  * Read a transport packet from a media file.
741  *
742  * @param s media file handle
743  * @param pkt is filled
744  * @return 0 if OK, AVERROR_xxx on error
745  */
747 
748 /**
749  * Add an attached pic to an AVStream.
750  *
751  * @param st if set, the stream to add the attached pic to;
752  * if unset, a new stream will be added to s.
753  * @param pb AVIOContext to read data from if buf is unset.
754  * @param buf if set, it contains the data and size information to be used
755  * for the attached pic; if unset, data is read from pb.
756  * @param size the size of the data to read if buf is unset.
757  *
758  * @return 0 on success, < 0 on error. On error, this function removes
759  * the stream it has added (if any).
760  */
762  AVBufferRef **buf, int size);
763 
764 /**
765  * Interleave an AVPacket per dts so it can be muxed.
766  * See the documentation of AVOutputFormat.interleave_packet for details.
767  */
769  int flush, int has_packet);
770 
771 /**
772  * Interleave packets directly in the order in which they arrive
773  * without any sort of buffering.
774  */
776  int flush, int has_packet);
777 
779 
780 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id);
781 
782 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag);
783 
784 int ff_is_intra_only(enum AVCodecID id);
785 
786 /**
787  * Select a PCM codec based on the given parameters.
788  *
789  * @param bps bits-per-sample
790  * @param flt floating-point
791  * @param be big-endian
792  * @param sflags signed flags. each bit corresponds to one byte of bit depth.
793  * e.g. the 1st bit indicates if 8-bit should be signed or
794  * unsigned, the 2nd bit indicates if 16-bit should be signed or
795  * unsigned, etc... This is useful for formats such as WAVE where
796  * only 8-bit is unsigned and all other bit depths are signed.
797  * @return a PCM codec id or AV_CODEC_ID_NONE
798  */
799 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags);
800 
801 /**
802  * Chooses a timebase for muxing the specified stream.
803  *
804  * The chosen timebase allows sample accurate timestamps based
805  * on the framerate or sample rate for audio streams. It also is
806  * at least as precise as 1/min_precision would be.
807  */
808 AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision);
809 
810 /**
811  * Chooses a timebase for muxing the specified stream.
812  */
814 
815 /**
816  * Generate standard extradata for AVC-Intra based on width/height and field
817  * order.
818  */
820 
821 /**
822  * Add a bitstream filter to a stream.
823  *
824  * @param st output stream to add a filter to
825  * @param name the name of the filter to add
826  * @param args filter-specific argument string
827  * @return >0 on success;
828  * AVERROR code on failure
829  */
830 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args);
831 
832 /**
833  * Copy encoding parameters from source to destination stream
834  *
835  * @param dst pointer to destination AVStream
836  * @param src pointer to source AVStream
837  * @return >=0 on success, AVERROR code on error
838  */
840 
841 /**
842  * Copy side data from source to destination stream
843  *
844  * @param dst pointer to destination AVStream
845  * @param src pointer to source AVStream
846  * @return >=0 on success, AVERROR code on error
847  */
849 
850 /**
851  * Wrap ffurl_move() and log if error happens.
852  *
853  * @param url_src source path
854  * @param url_dst destination path
855  * @return 0 or AVERROR on failure
856  */
857 int ff_rename(const char *url_src, const char *url_dst, void *logctx);
858 
859 /**
860  * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
861  * which is always set to 0.
862  *
863  * Previously allocated extradata in par will be freed.
864  *
865  * @param size size of extradata
866  * @return 0 if OK, AVERROR_xxx on error
867  */
869 
870 /**
871  * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
872  * which is always set to 0 and fill it from pb.
873  *
874  * @param size size of extradata
875  * @return >= 0 if OK, AVERROR_xxx on error
876  */
878 
879 /**
880  * add frame for rfps calculation.
881  *
882  * @param dts timestamp of the i-th frame
883  * @return 0 if OK, AVERROR_xxx on error
884  */
885 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts);
886 
888 
889 /**
890  * Flags for AVFormatContext.write_uncoded_frame()
891  */
893 
894  /**
895  * Query whether the feature is possible on this stream.
896  * The frame argument is ignored.
897  */
899 
900 };
901 
902 /**
903  * Copies the whilelists from one context to the other
904  */
906 
907 /**
908  * Returned by demuxers to indicate that data was consumed but discarded
909  * (ignored streams or junk data). The framework will re-call the demuxer.
910  */
911 #define FFERROR_REDO FFERRTAG('R','E','D','O')
912 
913 /**
914  * Utility function to open IO stream of output format.
915  *
916  * @param s AVFormatContext
917  * @param url URL or file name to open for writing
918  * @options optional options which will be passed to io_open callback
919  * @return >=0 on success, negative AVERROR in case of failure
920  */
922 
923 /*
924  * A wrapper around AVFormatContext.io_close that should be used
925  * instead of calling the pointer directly.
926  *
927  * @param s AVFormatContext
928  * @param *pb the AVIOContext to be closed and freed. Can be NULL.
929  * @return >=0 on success, negative AVERROR in case of failure
930  */
932 
933 /* Default io_close callback, not to be used directly, use ff_format_io_close
934  * instead. */
936 
937 /**
938  * Utility function to check if the file uses http or https protocol
939  *
940  * @param s AVFormatContext
941  * @param filename URL or file name to open for writing
942  */
943 int ff_is_http_proto(const char *filename);
944 
945 /**
946  * Parse creation_time in AVFormatContext metadata if exists and warn if the
947  * parsing fails.
948  *
949  * @param s AVFormatContext
950  * @param timestamp parsed timestamp in microseconds, only set on successful parsing
951  * @param return_seconds set this to get the number of seconds in timestamp instead of microseconds
952  * @return 1 if OK, 0 if the metadata was not present, AVERROR(EINVAL) on parse error
953  */
954 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds);
955 
956 /**
957  * Standardize creation_time metadata in AVFormatContext to an ISO-8601
958  * timestamp string.
959  *
960  * @param s AVFormatContext
961  * @return <0 on error
962  */
964 
965 #define CONTAINS_PAL 2
966 /**
967  * Reshuffles the lines to use the user specified stride.
968  *
969  * @param ppkt input and output packet
970  * @return negative error code or
971  * 0 if no new packet was allocated
972  * non-zero if a new packet was allocated and ppkt has to be freed
973  * CONTAINS_PAL if in addition to a new packet the old contained a palette
974  */
975 int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride);
976 
977 /**
978  * Retrieves the palette from a packet, either from side data, or
979  * appended to the video data in the packet itself (raw video only).
980  * It is commonly used after a call to ff_reshuffle_raw_rgb().
981  *
982  * Use 0 for the ret parameter to check for side data only.
983  *
984  * @param pkt pointer to packet before calling ff_reshuffle_raw_rgb()
985  * @param ret return value from ff_reshuffle_raw_rgb(), or 0
986  * @param palette pointer to palette buffer
987  * @return negative error code or
988  * 1 if the packet has a palette, else 0
989  */
990 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette);
991 
992 struct AVBPrint;
993 /**
994  * Finalize buf into extradata and set its size appropriately.
995  */
996 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf);
997 
998 /**
999  * Find the next packet in the interleaving queue for the given stream.
1000  *
1001  * @return a pointer to a packet if one was found, NULL otherwise.
1002  */
1003 const AVPacket *ff_interleaved_peek(AVFormatContext *s, int stream);
1004 
1005 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset);
1006 
1007 int ff_lock_avformat(void);
1008 int ff_unlock_avformat(void);
1009 
1010 /**
1011  * Set AVFormatContext url field to the provided pointer. The pointer must
1012  * point to a valid string. The existing url field is freed if necessary. Also
1013  * set the legacy filename field to the same string which was provided in url.
1014  */
1015 void ff_format_set_url(AVFormatContext *s, char *url);
1016 
1017 void avpriv_register_devices(const AVOutputFormat * const o[], const AVInputFormat * const i[]);
1018 
1019 /**
1020  * Make shift_size amount of space at read_start by shifting data in the output
1021  * at read_start until the current IO position. The underlying IO context must
1022  * be seekable.
1023  */
1024 int ff_format_shift_data(AVFormatContext *s, int64_t read_start, int shift_size);
1025 
1026 #endif /* AVFORMAT_INTERNAL_H */
be
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
AVCodec
AVCodec.
Definition: codec.h:202
FFStream::skip_samples
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet.
Definition: internal.h:300
ff_get_pcm_codec_id
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:368
name
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 name
Definition: writing_filters.txt:88
ff_rfps_add_frame
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts)
add frame for rfps calculation.
Definition: demux.c:2147
ff_find_decoder
const AVCodec * ff_find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:135
FFStream::inject_global_side_data
int inject_global_side_data
Internal data to inject global side data.
Definition: internal.h:379
ff_ntp_time
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:950
FFFormatContext::interleave_packet
int(* interleave_packet)(struct AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
The interleavement function in use.
Definition: internal.h:99
FFFormatContext::prefer_codec_framerate
int prefer_codec_framerate
Definition: internal.h:180
ff_get_extradata
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:469
FFStream::first_dts
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: internal.h:427
FFStream::rfps_duration_sum
int64_t rfps_duration_sum
Definition: internal.h:251
FFStream::duration_gcd
int64_t duration_gcd
Definition: internal.h:249
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
FFStream::last_IP_pts
int64_t last_IP_pts
Definition: internal.h:395
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
ff_find_last_ts
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: seek.c:352
ff_format_output_open
int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
Utility function to open IO stream of output format.
Definition: utils.c:1832
FFStream::codec_info_duration_fields
int64_t codec_info_duration_fields
Definition: internal.h:254
AVCodecTag::id
enum AVCodecID id
Definition: internal.h:52
MAX_STD_TIMEBASES
#define MAX_STD_TIMEBASES
Definition: internal.h:243
ff_gen_search
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: seek.c:390
FFStream::codec_info_duration
int64_t codec_info_duration
Definition: internal.h:253
ff_get_formatted_ntp_time
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:955
ff_free_stream
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:680
FFStream::first_discard_sample
int64_t first_discard_sample
If not 0, the first audio sample that should be discarded from the stream.
Definition: internal.h:317
FFStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: internal.h:281
ff_add_index_entry
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: seek.c:59
PacketList
Definition: packet_internal.h:31
data
const char data[16]
Definition: mxf.c:143
FFFormatContext::AVOID_NEGATIVE_TS_DISABLED
@ AVOID_NEGATIVE_TS_DISABLED
Definition: internal.h:90
FFFormatContext::initialized
int initialized
Whether or not avformat_init_output has already been called.
Definition: internal.h:165
ff_parse_creation_time_metadata
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:1865
ff_parse_ntp_time
uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
Parse the NTP time in micro seconds (since NTP epoch).
Definition: utils.c:977
FFStream::fps_last_dts
int64_t fps_last_dts
Definition: internal.h:271
FFStream::bsfc
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:210
AVDictionary
Definition: dict.c:30
ff_get_chomp_line
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:815
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:436
ff_choose_chroma_location
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:106
FFStream::last_dts_for_order_check
int64_t last_dts_for_order_check
Internal data to analyze DTS and detect faulty mpeg streams.
Definition: internal.h:372
AVWriteUncodedFrameFlags
AVWriteUncodedFrameFlags
Flags for AVFormatContext.write_uncoded_frame()
Definition: internal.h:892
ff_interleave_packet_per_dts
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Interleave an AVPacket per dts so it can be muxed.
Definition: mux.c:946
os_support.h
sample_rate
sample_rate
Definition: ffmpeg_filter.c:153
AVBSFContext
The bitstream filter state.
Definition: bsf.h:47
AVIndexEntry
Definition: avformat.h:801
FFFormatContext::AVOID_NEGATIVE_TS_UNKNOWN
@ AVOID_NEGATIVE_TS_UNKNOWN
Definition: internal.h:91
FFStream::bsf
AVBSFContext * bsf
Definition: internal.h:230
ff_seek_frame_binary
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: seek.c:282
FFFormatContext::shortest_end
int64_t shortest_end
Timestamp of the end of the shortest stream.
Definition: internal.h:160
ff_bprint_to_codecpar_extradata
int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:1915
ff_unlock_avformat
int ff_unlock_avformat(void)
Definition: utils.c:82
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:287
CodecMime
Definition: internal.h:56
FFStream::is_intra_only
int is_intra_only
Definition: internal.h:239
ff_guess_image2_codec
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:109
FFStream::dts_ordered
uint8_t dts_ordered
Definition: internal.h:373
FFStream::last_IP_duration
int last_IP_duration
Definition: internal.h:396
RELATIVE_TS_BASE
#define RELATIVE_TS_BASE
Definition: internal.h:458
bsf.h
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:431
FFStream::inited
int inited
Definition: internal.h:231
AVStreamParseType
AVStreamParseType
Definition: avformat.h:790
FFStream::index_entries_allocated_size
unsigned int index_entries_allocated_size
Definition: internal.h:279
ff_get_line
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:798
AVChapter
Definition: avformat.h:1159
ff_read_packet
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: demux.c:524
type
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 type
Definition: writing_filters.txt:86
ff_data_to_hex
char * ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase)
Write hexadecimal string corresponding to given binary data.
Definition: utils.c:1146
AVCodecParserContext::dts
int64_t dts
Definition: avcodec.h:2793
FFStream::priv_pts
FFFrac * priv_pts
Definition: internal.h:241
pkt
AVPacket * pkt
Definition: movenc.c:59
ff_stream_side_data_copy
int ff_stream_side_data_copy(AVStream *dst, const AVStream *src)
Copy side data from source to destination stream.
Definition: utils.c:614
AVInputFormat
Definition: avformat.h:650
AVCodecTag
Definition: internal.h:51
ff_write_chained
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:1335
ff_framehash_write_header
int ff_framehash_write_header(AVFormatContext *s)
Set the timebase for each stream from the corresponding codec timebase and print it.
Definition: framehash.c:24
FFStream::duration_count
int duration_count
Definition: internal.h:250
FFFormatContext::parse_queue
PacketList parse_queue
Packets split by the parser get queued here.
Definition: internal.h:122
width
#define width
FFFormatContext::AVOID_NEGATIVE_TS_KNOWN
@ AVOID_NEGATIVE_TS_KNOWN
Definition: internal.h:92
FFStream::duration_error
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: internal.h:252
s
#define s(width, name)
Definition: cbs_vp9.c:257
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:107
FFStream::frame_delay_evidence
int frame_delay_evidence
Definition: internal.h:255
ff_rename
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap ffurl_move() and log if error happens.
Definition: avio.c:665
avpriv_stream_set_need_parsing
void avpriv_stream_set_need_parsing(AVStream *st, enum AVStreamParseType type)
Definition: utils.c:100
FFStream::nb_decoded_frames
int nb_decoded_frames
Number of internally decoded frames, used internally in libavformat, do not access its lifetime diffe...
Definition: internal.h:330
FFFormatContext::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:110
ff_interleave_add_packet
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
Add packet to an AVFormatContext's packet_buffer list, determining its interleaved position using com...
Definition: mux.c:842
FFStream::codec_info_nb_frames
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: internal.h:410
channels
channels
Definition: aptx.h:33
FFStream::pts_reorder_error_count
uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1]
Definition: internal.h:365
FFStream::display_aspect_ratio
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: internal.h:386
FFStream::extract_extradata
struct FFStream::@260 extract_extradata
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
key
const char * key
Definition: hwcontext_opencl.c:168
FFStream::pts_reorder_error
int64_t pts_reorder_error[MAX_REORDER_DELAY+1]
Internal data to generate dts from pts.
Definition: internal.h:364
ff_hex_to_data
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:1167
FFFormatContext
Definition: internal.h:73
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:404
context
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 context
Definition: writing_filters.txt:91
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
FFStream::pub
AVStream pub
The public context.
Definition: internal.h:197
avpriv_update_cur_dts
void avpriv_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: seek.c:32
FFStream::bitstream_checked
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:215
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
FFStream::avctx_inited
int avctx_inited
1 if avctx has been initialized with the values from the codec parameters
Definition: internal.h:224
ff_choose_timebase
AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:91
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_get_muxer_ts_offset
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1068
ff_stream_add_bitstream_filter
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:1789
FFStream::nb_index_entries
int nb_index_entries
Definition: internal.h:278
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:447
FFStream::fps_last_dts_idx
int fps_last_dts_idx
Definition: internal.h:272
ff_reshuffle_raw_rgb
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
FFStream::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: internal.h:282
FFFormatContext::inject_global_side_data
int inject_global_side_data
Definition: internal.h:153
FFFormatContext::avoid_negative_ts_status
enum FFFormatContext::@259 avoid_negative_ts_status
Whether the timestamp shift offset has already been determined.
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
FFStream::fps_first_dts
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: internal.h:269
FFFormatContext::id3v2_meta
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:175
interleave
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:108
options
const OptionDef options[]
FFStream::found_decoder
int found_decoder
0 -> decoder has not been searched for yet.
Definition: internal.h:262
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
FFFormatContext::parse_pkt
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
Definition: internal.h:136
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:357
FFFrac::val
int64_t val
Definition: internal.h:69
FFStream
Definition: internal.h:193
FFStream::last_discard_sample
int64_t last_discard_sample
The sample after last sample that is intended to be discarded after first_discard_sample.
Definition: internal.h:324
bps
unsigned bps
Definition: movenc.c:1597
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:115
ff_format_io_close_default
void ff_format_io_close_default(AVFormatContext *s, AVIOContext *pb)
Definition: utils.c:1842
size
int size
Definition: twinvq_data.h:10344
ff_lock_avformat
int ff_lock_avformat(void)
Definition: utils.c:77
FFStream::dts_misordered
uint8_t dts_misordered
Definition: internal.h:374
ff_is_http_proto
int ff_is_http_proto(const char *filename)
Utility function to check if the file uses http or https protocol.
Definition: utils.c:1860
height
#define height
MAX_REORDER_DELAY
#define MAX_REORDER_DELAY
Definition: internal.h:359
offset
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 offset
Definition: writing_filters.txt:86
FFStream::pts_wrap_behavior
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: internal.h:352
FFFormatContext::raw_packet_buffer_size
int raw_packet_buffer_size
Sum of the size of packets in raw_packet_buffer, in bytes.
Definition: internal.h:147
FFStream::update_initial_durations_done
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: internal.h:357
FFStream::start_skip_samples
int64_t start_skip_samples
If not 0, the number of samples that should be skipped from the start of the stream (the samples are ...
Definition: internal.h:309
ff_interleaved_peek
const AVPacket * ff_interleaved_peek(AVFormatContext *s, int stream)
Find the next packet in the interleaving queue for the given stream.
Definition: mux.c:1084
FFStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:401
ff_wrap_timestamp
int64_t ff_wrap_timestamp(const AVStream *st, int64_t timestamp)
Wrap a given time stamp, if there is an indication for an overflow.
Definition: demux.c:63
FFStream::probe_data
AVProbeData probe_data
Definition: internal.h:388
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:616
FFStream::skip_to_keyframe
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: internal.h:295
ff_standardize_creation_time
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:1882
FFFormatContext::raw_packet_buffer
PacketList raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
Definition: internal.h:118
PacketListEntry
Definition: packet_internal.h:26
FFStream::mux_ts_offset
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: internal.h:335
AVOutputFormat
Definition: avformat.h:503
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
ff_flush_packet_queue
void ff_flush_packet_queue(AVFormatContext *s)
Definition: utils.c:299
FFStream::reorder
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:203
FFStream::fps_first_dts_idx
int fps_first_dts_idx
Definition: internal.h:270
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFStream::pts_buffer
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: internal.h:367
avpriv_new_chapter
AVChapter * avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:883
FFStream::last_in_packet_buffer
PacketListEntry * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:393
ff_add_param_change
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:1322
avcodec.h
ff_sdp_write_media
int ff_sdp_write_media(char *buff, int size, const 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:913
AVCodecParserContext
Definition: avcodec.h:2773
ff_rfps_calculate
void ff_rfps_calculate(AVFormatContext *ic)
Definition: demux.c:2207
tag
uint32_t tag
Definition: movenc.c:1596
ff_find_stream_index
int ff_find_stream_index(const AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:1275
FFStream::last_duration
int64_t last_duration
Definition: internal.h:264
ret
ret
Definition: filter_design.txt:187
ff_get_packet_palette
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:1891
AVStream
Stream structure.
Definition: avformat.h:935
lowercase
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
Definition: writing_filters.txt:89
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
ff_format_set_url
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: utils.c:2002
FFFormatContext::chapter_ids_monotonic
int chapter_ids_monotonic
Set if chapter ids are strictly monotonic.
Definition: internal.h:185
AVCodecContext
main external API structure.
Definition: avcodec.h:383
compare
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:95
ff_stream_encode_params_copy
int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
Copy encoding parameters from source to destination stream.
Definition: utils.c:586
ff_reduce_index
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: seek.c:45
FFStream::avctx
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:220
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:347
ff_parse_key_val_cb
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:613
ff_interleave_packet_passthrough
int ff_interleave_packet_passthrough(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Interleave packets directly in the order in which they arrive without any sort of buffering.
Definition: mux.c:1062
ff_index_search_timestamp
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: seek.c:127
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, 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:1195
CodecMime::str
char str[32]
Definition: internal.h:57
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:276
CodecMime::id
enum AVCodecID id
Definition: internal.h:58
FFFormatContext::streams_initialized
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:170
FFFrac::num
int64_t num
Definition: internal.h:69
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
packet_internal.h
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:143
FFStream::info
struct FFStream::@261 * info
Stream information used internally by avformat_find_stream_info()
ff_mkdir_p
int ff_mkdir_p(const char *path)
Automatically create sub-directories.
Definition: utils.c:1112
ff_generate_avci_extradata
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:1586
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:290
AVPacket
This structure stores compressed data.
Definition: packet.h:350
ff_read_frame_flush
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: seek.c:714
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: internal.h:898
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:428
int32_t
int32_t
Definition: audioconvert.c:56
convert_header.str
string str
Definition: convert_header.py:20
FFStream::stream_identifier
int stream_identifier
Stream Identifier This is the MPEG-TS stream identifier +1 0 means unknown.
Definition: internal.h:417
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:233
FFStream::need_context_update
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
Definition: internal.h:237
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
FFStream::last_dts
int64_t last_dts
Definition: internal.h:248
FFStream::parser
struct AVCodecParserContext * parser
Definition: internal.h:405
read_timestamp
static int64_t read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: seek.c:273
FFFrac
The exact value of the fractional number is: 'val + num / den'.
Definition: internal.h:68
FFFrac::den
int64_t den
Definition: internal.h:69
ff_format_shift_data
int ff_format_shift_data(AVFormatContext *s, int64_t read_start, int shift_size)
Make shift_size amount of space at read_start by shifting data in the output at read_start until the ...
Definition: utils.c:2038
AVCodecTag::tag
unsigned int tag
Definition: internal.h:53
int
int
Definition: ffmpeg_filter.c:153
FFFormatContext::pub
AVFormatContext pub
The public context.
Definition: internal.h:77
avpriv_register_devices
void avpriv_register_devices(const AVOutputFormat *const o[], const AVInputFormat *const i[])
Definition: allformats.c:583
FFStream::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: internal.h:340
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:1847
ff_configure_buffers_for_index
void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
Definition: seek.c:170
FFFormatContext::nb_interleaved_streams
int nb_interleaved_streams
Number of streams relevant for interleaving.
Definition: internal.h:83
ff_add_attached_pic
int ff_add_attached_pic(AVFormatContext *s, AVStream *st, AVIOContext *pb, AVBufferRef **buf, int size)
Add an attached pic to an AVStream.
Definition: utils.c:250
ff_parse_key_value
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:1221
ff_alloc_extradata
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:451
is_relative
static av_always_inline int is_relative(int64_t ts)
Definition: internal.h:460
FFFormatContext::avoid_negative_ts_use_pts
int avoid_negative_ts_use_pts
Definition: internal.h:155