LCOV - code coverage report
Current view: top level - libavformat - internal.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 4 7 57.1 %
Date: 2017-12-13 10:57:33 Functions: 1 1 100.0 %

          Line data    Source code
       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             : 
      66             : struct AVFormatInternal {
      67             :     /**
      68             :      * Number of streams relevant for interleaving.
      69             :      * Muxing only.
      70             :      */
      71             :     int nb_interleaved_streams;
      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             :      */
      78             :     struct AVPacketList *packet_buffer;
      79             :     struct AVPacketList *packet_buffer_end;
      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             :      */
      90             :     struct AVPacketList *raw_packet_buffer;
      91             :     struct AVPacketList *raw_packet_buffer_end;
      92             :     /**
      93             :      * Packets split by the parser get queued here.
      94             :      */
      95             :     struct AVPacketList *parse_queue;
      96             :     struct AVPacketList *parse_queue_end;
      97             :     /**
      98             :      * Remaining size available for raw_packet_buffer, in bytes.
      99             :      */
     100             : #define RAW_PACKET_BUFFER_SIZE 2500000
     101             :     int raw_packet_buffer_remaining_size;
     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             :      */
     113             :     AVRational offset_timebase;
     114             : 
     115             : #if FF_API_COMPUTE_PKT_FIELDS2
     116             :     int missing_ts_warning;
     117             : #endif
     118             : 
     119             :     int inject_global_side_data;
     120             : 
     121             :     int avoid_negative_ts_use_pts;
     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             :      */
     131             :     int initialized;
     132             : 
     133             :     /**
     134             :      * Whether or not avformat_init_output fully initialized streams
     135             :      */
     136             :     int streams_initialized;
     137             : 
     138             :     /**
     139             :      * ID3v2 tag useful for MP3 demuxing
     140             :      */
     141             :     AVDictionary *id3v2_meta;
     142             : 
     143             :     /*
     144             :      * Prefer the codec framerate for avg_frame_rate computation.
     145             :      */
     146             :     int prefer_codec_framerate;
     147             : };
     148             : 
     149             : struct AVStreamInternal {
     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             :      */
     161             :     AVBSFContext **bsfcs;
     162             :     int nb_bsfcs;
     163             : 
     164             :     /**
     165             :      * Whether or not check_bitstream should still be run on each packet
     166             :      */
     167             :     int bitstream_checked;
     168             : 
     169             :     /**
     170             :      * The codec context used by avformat_find_stream_info, the parser, etc.
     171             :      */
     172             :     AVCodecContext *avctx;
     173             :     /**
     174             :      * 1 if avctx has been initialized with the values from the codec parameters
     175             :      */
     176             :     int avctx_inited;
     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 {
     184             :         AVBSFContext *bsf;
     185             :         AVPacket     *pkt;
     186             :         int inited;
     187             :     } extract_extradata;
     188             : 
     189             :     /**
     190             :      * Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
     191             :      */
     192             :     int need_context_update;
     193             : 
     194             :     FFFrac *priv_pts;
     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             : char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase);
     215             : 
     216             : /**
     217             :  * Parse a string of hexadecimal strings. Any space between the hexadecimal
     218             :  * digits is ignored.
     219             :  *
     220             :  * @param data if non-null, the parsed data is written to this pointer
     221             :  * @param p the string to parse
     222             :  * @return the number of bytes written (or to be written, if data is null)
     223             :  */
     224             : int ff_hex_to_data(uint8_t *data, const char *p);
     225             : 
     226             : /**
     227             :  * Add packet to AVFormatContext->packet_buffer list, determining its
     228             :  * interleaved position using compare() function argument.
     229             :  * @return 0, or < 0 on error
     230             :  */
     231             : int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
     232             :                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *));
     233             : 
     234             : void ff_read_frame_flush(AVFormatContext *s);
     235             : 
     236             : #define NTP_OFFSET 2208988800ULL
     237             : #define NTP_OFFSET_US (NTP_OFFSET * 1000000ULL)
     238             : 
     239             : /** Get the current time since NTP epoch in microseconds. */
     240             : uint64_t ff_ntp_time(void);
     241             : 
     242             : /**
     243             :  * Append the media-specific SDP fragment for the media stream c
     244             :  * to the buffer buff.
     245             :  *
     246             :  * Note, the buffer needs to be initialized, since it is appended to
     247             :  * existing content.
     248             :  *
     249             :  * @param buff the buffer to append the SDP fragment to
     250             :  * @param size the size of the buff buffer
     251             :  * @param st the AVStream of the media to describe
     252             :  * @param idx the global stream index
     253             :  * @param dest_addr the destination address of the media stream, may be NULL
     254             :  * @param dest_type the destination address type, may be NULL
     255             :  * @param port the destination port of the media stream, 0 if unknown
     256             :  * @param ttl the time to live of the stream, 0 if not multicast
     257             :  * @param fmt the AVFormatContext, which might contain options modifying
     258             :  *            the generated SDP
     259             :  */
     260             : void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
     261             :                         const char *dest_addr, const char *dest_type,
     262             :                         int port, int ttl, AVFormatContext *fmt);
     263             : 
     264             : /**
     265             :  * Write a packet to another muxer than the one the user originally
     266             :  * intended. Useful when chaining muxers, where one muxer internally
     267             :  * writes a received packet to another muxer.
     268             :  *
     269             :  * @param dst the muxer to write the packet to
     270             :  * @param dst_stream the stream index within dst to write the packet to
     271             :  * @param pkt the packet to be written
     272             :  * @param src the muxer the packet originally was intended for
     273             :  * @param interleave 0->use av_write_frame, 1->av_interleaved_write_frame
     274             :  * @return the value av_write_frame returned
     275             :  */
     276             : int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
     277             :                      AVFormatContext *src, int interleave);
     278             : 
     279             : /**
     280             :  * Get the length in bytes which is needed to store val as v.
     281             :  */
     282             : int ff_get_v_length(uint64_t val);
     283             : 
     284             : /**
     285             :  * Put val using a variable number of bytes.
     286             :  */
     287             : void ff_put_v(AVIOContext *bc, uint64_t val);
     288             : 
     289             : /**
     290             :  * Read a whole line of text from AVIOContext. Stop reading after reaching
     291             :  * either a \\n, a \\0 or EOF. The returned string is always \\0-terminated,
     292             :  * and may be truncated if the buffer is too small.
     293             :  *
     294             :  * @param s the read-only AVIOContext
     295             :  * @param buf buffer to store the read line
     296             :  * @param maxlen size of the buffer
     297             :  * @return the length of the string written in the buffer, not including the
     298             :  *         final \\0
     299             :  */
     300             : int ff_get_line(AVIOContext *s, char *buf, int maxlen);
     301             : 
     302             : #define SPACE_CHARS " \t\r\n"
     303             : 
     304             : /**
     305             :  * Callback function type for ff_parse_key_value.
     306             :  *
     307             :  * @param key a pointer to the key
     308             :  * @param key_len the number of bytes that belong to the key, including the '='
     309             :  *                char
     310             :  * @param dest return the destination pointer for the value in *dest, may
     311             :  *             be null to ignore the value
     312             :  * @param dest_len the length of the *dest buffer
     313             :  */
     314             : typedef void (*ff_parse_key_val_cb)(void *context, const char *key,
     315             :                                     int key_len, char **dest, int *dest_len);
     316             : /**
     317             :  * Parse a string with comma-separated key=value pairs. The value strings
     318             :  * may be quoted and may contain escaped characters within quoted strings.
     319             :  *
     320             :  * @param str the string to parse
     321             :  * @param callback_get_buf function that returns where to store the
     322             :  *                         unescaped value string.
     323             :  * @param context the opaque context pointer to pass to callback_get_buf
     324             :  */
     325             : void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
     326             :                         void *context);
     327             : 
     328             : /**
     329             :  * Find stream index based on format-specific stream ID
     330             :  * @return stream index, or < 0 on error
     331             :  */
     332             : int ff_find_stream_index(AVFormatContext *s, int id);
     333             : 
     334             : /**
     335             :  * Internal version of av_index_search_timestamp
     336             :  */
     337             : int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
     338             :                               int64_t wanted_timestamp, int flags);
     339             : 
     340             : /**
     341             :  * Internal version of av_add_index_entry
     342             :  */
     343             : int ff_add_index_entry(AVIndexEntry **index_entries,
     344             :                        int *nb_index_entries,
     345             :                        unsigned int *index_entries_allocated_size,
     346             :                        int64_t pos, int64_t timestamp, int size, int distance, int flags);
     347             : 
     348             : void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance);
     349             : 
     350             : /**
     351             :  * Add a new chapter.
     352             :  *
     353             :  * @param s media file handle
     354             :  * @param id unique ID for this chapter
     355             :  * @param start chapter start time in time_base units
     356             :  * @param end chapter end time in time_base units
     357             :  * @param title chapter title
     358             :  *
     359             :  * @return AVChapter or NULL on error
     360             :  */
     361             : AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
     362             :                               int64_t start, int64_t end, const char *title);
     363             : 
     364             : /**
     365             :  * Ensure the index uses less memory than the maximum specified in
     366             :  * AVFormatContext.max_index_size by discarding entries if it grows
     367             :  * too large.
     368             :  */
     369             : void ff_reduce_index(AVFormatContext *s, int stream_index);
     370             : 
     371             : enum AVCodecID ff_guess_image2_codec(const char *filename);
     372             : 
     373             : /**
     374             :  * Perform a binary search using av_index_search_timestamp() and
     375             :  * AVInputFormat.read_timestamp().
     376             :  *
     377             :  * @param target_ts target timestamp in the time base of the given stream
     378             :  * @param stream_index stream number
     379             :  */
     380             : int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
     381             :                          int64_t target_ts, int flags);
     382             : 
     383             : /**
     384             :  * Update cur_dts of all streams based on the given timestamp and AVStream.
     385             :  *
     386             :  * Stream ref_st unchanged, others set cur_dts in their native time base.
     387             :  * Only needed for timestamp wrapping or if (dts not set and pts!=dts).
     388             :  * @param timestamp new dts expressed in time_base of param ref_st
     389             :  * @param ref_st reference stream giving time_base of param timestamp
     390             :  */
     391             : void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
     392             : 
     393             : int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
     394             :                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
     395             : 
     396             : /**
     397             :  * Perform a binary search using read_timestamp().
     398             :  *
     399             :  * @param target_ts target timestamp in the time base of the given stream
     400             :  * @param stream_index stream number
     401             :  */
     402             : int64_t ff_gen_search(AVFormatContext *s, int stream_index,
     403             :                       int64_t target_ts, int64_t pos_min,
     404             :                       int64_t pos_max, int64_t pos_limit,
     405             :                       int64_t ts_min, int64_t ts_max,
     406             :                       int flags, int64_t *ts_ret,
     407             :                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
     408             : 
     409             : /**
     410             :  * Set the time base and wrapping info for a given stream. This will be used
     411             :  * to interpret the stream's timestamps. If the new time base is invalid
     412             :  * (numerator or denominator are non-positive), it leaves the stream
     413             :  * unchanged.
     414             :  *
     415             :  * @param s stream
     416             :  * @param pts_wrap_bits number of bits effectively used by the pts
     417             :  *        (used for wrap control)
     418             :  * @param pts_num time base numerator
     419             :  * @param pts_den time base denominator
     420             :  */
     421             : void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
     422             :                          unsigned int pts_num, unsigned int pts_den);
     423             : 
     424             : /**
     425             :  * Add side data to a packet for changing parameters to the given values.
     426             :  * Parameters set to 0 aren't included in the change.
     427             :  */
     428             : int ff_add_param_change(AVPacket *pkt, int32_t channels,
     429             :                         uint64_t channel_layout, int32_t sample_rate,
     430             :                         int32_t width, int32_t height);
     431             : 
     432             : /**
     433             :  * Set the timebase for each stream from the corresponding codec timebase and
     434             :  * print it.
     435             :  */
     436             : int ff_framehash_write_header(AVFormatContext *s);
     437             : 
     438             : /**
     439             :  * Read a transport packet from a media file.
     440             :  *
     441             :  * @param s media file handle
     442             :  * @param pkt is filled
     443             :  * @return 0 if OK, AVERROR_xxx on error
     444             :  */
     445             : int ff_read_packet(AVFormatContext *s, AVPacket *pkt);
     446             : 
     447             : /**
     448             :  * Interleave a packet per dts in an output media file.
     449             :  *
     450             :  * Packets with pkt->destruct == av_destruct_packet will be freed inside this
     451             :  * function, so they cannot be used after it. Note that calling av_packet_unref()
     452             :  * on them is still safe.
     453             :  *
     454             :  * @param s media file handle
     455             :  * @param out the interleaved packet will be output here
     456             :  * @param pkt the input packet
     457             :  * @param flush 1 if no further packets are available as input and all
     458             :  *              remaining packets should be output
     459             :  * @return 1 if a packet was output, 0 if no packet could be output,
     460             :  *         < 0 if an error occurred
     461             :  */
     462             : int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
     463             :                                  AVPacket *pkt, int flush);
     464             : 
     465             : void ff_free_stream(AVFormatContext *s, AVStream *st);
     466             : 
     467             : /**
     468             :  * Return the frame duration in seconds. Return 0 if not available.
     469             :  */
     470             : void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
     471             :                                AVCodecParserContext *pc, AVPacket *pkt);
     472             : 
     473             : unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id);
     474             : 
     475             : enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag);
     476             : 
     477             : /**
     478             :  * Select a PCM codec based on the given parameters.
     479             :  *
     480             :  * @param bps     bits-per-sample
     481             :  * @param flt     floating-point
     482             :  * @param be      big-endian
     483             :  * @param sflags  signed flags. each bit corresponds to one byte of bit depth.
     484             :  *                e.g. the 1st bit indicates if 8-bit should be signed or
     485             :  *                unsigned, the 2nd bit indicates if 16-bit should be signed or
     486             :  *                unsigned, etc... This is useful for formats such as WAVE where
     487             :  *                only 8-bit is unsigned and all other bit depths are signed.
     488             :  * @return        a PCM codec id or AV_CODEC_ID_NONE
     489             :  */
     490             : enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags);
     491             : 
     492             : /**
     493             :  * Chooses a timebase for muxing the specified stream.
     494             :  *
     495             :  * The chosen timebase allows sample accurate timestamps based
     496             :  * on the framerate or sample rate for audio streams. It also is
     497             :  * at least as precise as 1/min_precision would be.
     498             :  */
     499             : AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision);
     500             : 
     501             : /**
     502             :  * Chooses a timebase for muxing the specified stream.
     503             :  */
     504             : enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st);
     505             : 
     506             : /**
     507             :  * Generate standard extradata for AVC-Intra based on width/height and field
     508             :  * order.
     509             :  */
     510             : int ff_generate_avci_extradata(AVStream *st);
     511             : 
     512             : /**
     513             :  * Add a bitstream filter to a stream.
     514             :  *
     515             :  * @param st output stream to add a filter to
     516             :  * @param name the name of the filter to add
     517             :  * @param args filter-specific argument string
     518             :  * @return  >0 on success;
     519             :  *          AVERROR code on failure
     520             :  */
     521             : int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args);
     522             : 
     523             : /**
     524             :  * Copy encoding parameters from source to destination stream
     525             :  *
     526             :  * @param dst pointer to destination AVStream
     527             :  * @param src pointer to source AVStream
     528             :  * @return >=0 on success, AVERROR code on error
     529             :  */
     530             : int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src);
     531             : 
     532             : /**
     533             :  * Wrap errno on rename() error.
     534             :  *
     535             :  * @param oldpath source path
     536             :  * @param newpath destination path
     537             :  * @return        0 or AVERROR on failure
     538             :  */
     539          14 : static inline int ff_rename(const char *oldpath, const char *newpath, void *logctx)
     540             : {
     541          14 :     int ret = 0;
     542          14 :     if (rename(oldpath, newpath) == -1) {
     543           0 :         ret = AVERROR(errno);
     544           0 :         if (logctx)
     545           0 :             av_log(logctx, AV_LOG_ERROR, "failed to rename file %s to %s\n", oldpath, newpath);
     546             :     }
     547          14 :     return ret;
     548             : }
     549             : 
     550             : /**
     551             :  * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
     552             :  * which is always set to 0.
     553             :  *
     554             :  * @param size size of extradata
     555             :  * @return 0 if OK, AVERROR_xxx on error
     556             :  */
     557             : int ff_alloc_extradata(AVCodecParameters *par, int size);
     558             : 
     559             : /**
     560             :  * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
     561             :  * which is always set to 0 and fill it from pb.
     562             :  *
     563             :  * @param size size of extradata
     564             :  * @return >= 0 if OK, AVERROR_xxx on error
     565             :  */
     566             : int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size);
     567             : 
     568             : /**
     569             :  * add frame for rfps calculation.
     570             :  *
     571             :  * @param dts timestamp of the i-th frame
     572             :  * @return 0 if OK, AVERROR_xxx on error
     573             :  */
     574             : int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts);
     575             : 
     576             : void ff_rfps_calculate(AVFormatContext *ic);
     577             : 
     578             : /**
     579             :  * Flags for AVFormatContext.write_uncoded_frame()
     580             :  */
     581             : enum AVWriteUncodedFrameFlags {
     582             : 
     583             :     /**
     584             :      * Query whether the feature is possible on this stream.
     585             :      * The frame argument is ignored.
     586             :      */
     587             :     AV_WRITE_UNCODED_FRAME_QUERY           = 0x0001,
     588             : 
     589             : };
     590             : 
     591             : /**
     592             :  * Copies the whilelists from one context to the other
     593             :  */
     594             : int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src);
     595             : 
     596             : int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
     597             :                        const AVIOInterruptCB *int_cb, AVDictionary **options);
     598             : 
     599             : /**
     600             :  * Returned by demuxers to indicate that data was consumed but discarded
     601             :  * (ignored streams or junk data). The framework will re-call the demuxer.
     602             :  */
     603             : #define FFERROR_REDO FFERRTAG('R','E','D','O')
     604             : 
     605             : /**
     606             :  * Utility function to open IO stream of output format.
     607             :  *
     608             :  * @param s AVFormatContext
     609             :  * @param url URL or file name to open for writing
     610             :  * @options optional options which will be passed to io_open callback
     611             :  * @return >=0 on success, negative AVERROR in case of failure
     612             :  */
     613             : int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options);
     614             : 
     615             : /*
     616             :  * A wrapper around AVFormatContext.io_close that should be used
     617             :  * instead of calling the pointer directly.
     618             :  */
     619             : void ff_format_io_close(AVFormatContext *s, AVIOContext **pb);
     620             : 
     621             : /**
     622             :  * Parse creation_time in AVFormatContext metadata if exists and warn if the
     623             :  * parsing fails.
     624             :  *
     625             :  * @param s AVFormatContext
     626             :  * @param timestamp parsed timestamp in microseconds, only set on successful parsing
     627             :  * @param return_seconds set this to get the number of seconds in timestamp instead of microseconds
     628             :  * @return 1 if OK, 0 if the metadata was not present, AVERROR(EINVAL) on parse error
     629             :  */
     630             : int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds);
     631             : 
     632             : /**
     633             :  * Standardize creation_time metadata in AVFormatContext to an ISO-8601
     634             :  * timestamp string.
     635             :  *
     636             :  * @param s AVFormatContext
     637             :  * @return <0 on error
     638             :  */
     639             : int ff_standardize_creation_time(AVFormatContext *s);
     640             : 
     641             : #define CONTAINS_PAL 2
     642             : /**
     643             :  * Reshuffles the lines to use the user specified stride.
     644             :  *
     645             :  * @param ppkt input and output packet
     646             :  * @return negative error code or
     647             :  *         0 if no new packet was allocated
     648             :  *         non-zero if a new packet was allocated and ppkt has to be freed
     649             :  *         CONTAINS_PAL if in addition to a new packet the old contained a palette
     650             :  */
     651             : int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride);
     652             : 
     653             : /**
     654             :  * Retrieves the palette from a packet, either from side data, or
     655             :  * appended to the video data in the packet itself (raw video only).
     656             :  * It is commonly used after a call to ff_reshuffle_raw_rgb().
     657             :  *
     658             :  * Use 0 for the ret parameter to check for side data only.
     659             :  *
     660             :  * @param pkt pointer to packet before calling ff_reshuffle_raw_rgb()
     661             :  * @param ret return value from ff_reshuffle_raw_rgb(), or 0
     662             :  * @param palette pointer to palette buffer
     663             :  * @return negative error code or
     664             :  *         1 if the packet has a palette, else 0
     665             :  */
     666             : int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette);
     667             : 
     668             : /**
     669             :  * Finalize buf into extradata and set its size appropriately.
     670             :  */
     671             : int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf);
     672             : 
     673             : /**
     674             :  * Find the next packet in the interleaving queue for the given stream.
     675             :  * The pkt parameter is filled in with the queued packet, including
     676             :  * references to the data (which the caller is not allowed to keep or
     677             :  * modify).
     678             :  *
     679             :  * @return 0 if a packet was found, a negative value if no packet was found
     680             :  */
     681             : int ff_interleaved_peek(AVFormatContext *s, int stream,
     682             :                         AVPacket *pkt, int add_offset);
     683             : 
     684             : #endif /* AVFORMAT_INTERNAL_H */

Generated by: LCOV version 1.13