LCOV - code coverage report
Current view: top level - libavformat - internal.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 4 9 44.4 %
Date: 2018-05-20 11:54:08 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             : /**
     303             :  * Same as ff_get_line but strip the white-space characters in the text tail
     304             :  *
     305             :  * @param s the read-only AVIOContext
     306             :  * @param buf buffer to store the read line
     307             :  * @param maxlen size of the buffer
     308             :  * @return the length of the string written in the buffer
     309             :  */
     310             : int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen);
     311             : 
     312             : /**
     313             :  * Read a whole line of text from AVIOContext to an AVBPrint buffer. Stop
     314             :  * reading after reaching a \\r, a \\n, a \\r\\n, a \\0 or EOF.  The line
     315             :  * ending characters are NOT included in the buffer, but they are skipped on
     316             :  * the input.
     317             :  *
     318             :  * @param s the read-only AVIOContext
     319             :  * @param bp the AVBPrint buffer
     320             :  * @return the length of the read line, not including the line endings,
     321             :  *         negative on error.
     322             :  */
     323             : int64_t ff_read_line_to_bprint(AVIOContext *s, AVBPrint *bp);
     324             : 
     325             : /**
     326             :  * Read a whole line of text from AVIOContext to an AVBPrint buffer overwriting
     327             :  * its contents. Stop reading after reaching a \\r, a \\n, a \\r\\n, a \\0 or
     328             :  * EOF. The line ending characters are NOT included in the buffer, but they
     329             :  * are skipped on the input.
     330             :  *
     331             :  * @param s the read-only AVIOContext
     332             :  * @param bp the AVBPrint buffer
     333             :  * @return the length of the read line not including the line endings,
     334             :  *         negative on error, or if the buffer becomes truncated.
     335             :  */
     336             : int64_t ff_read_line_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp);
     337             : 
     338             : #define SPACE_CHARS " \t\r\n"
     339             : 
     340             : /**
     341             :  * Callback function type for ff_parse_key_value.
     342             :  *
     343             :  * @param key a pointer to the key
     344             :  * @param key_len the number of bytes that belong to the key, including the '='
     345             :  *                char
     346             :  * @param dest return the destination pointer for the value in *dest, may
     347             :  *             be null to ignore the value
     348             :  * @param dest_len the length of the *dest buffer
     349             :  */
     350             : typedef void (*ff_parse_key_val_cb)(void *context, const char *key,
     351             :                                     int key_len, char **dest, int *dest_len);
     352             : /**
     353             :  * Parse a string with comma-separated key=value pairs. The value strings
     354             :  * may be quoted and may contain escaped characters within quoted strings.
     355             :  *
     356             :  * @param str the string to parse
     357             :  * @param callback_get_buf function that returns where to store the
     358             :  *                         unescaped value string.
     359             :  * @param context the opaque context pointer to pass to callback_get_buf
     360             :  */
     361             : void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
     362             :                         void *context);
     363             : 
     364             : /**
     365             :  * Find stream index based on format-specific stream ID
     366             :  * @return stream index, or < 0 on error
     367             :  */
     368             : int ff_find_stream_index(AVFormatContext *s, int id);
     369             : 
     370             : /**
     371             :  * Internal version of av_index_search_timestamp
     372             :  */
     373             : int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
     374             :                               int64_t wanted_timestamp, int flags);
     375             : 
     376             : /**
     377             :  * Internal version of av_add_index_entry
     378             :  */
     379             : int ff_add_index_entry(AVIndexEntry **index_entries,
     380             :                        int *nb_index_entries,
     381             :                        unsigned int *index_entries_allocated_size,
     382             :                        int64_t pos, int64_t timestamp, int size, int distance, int flags);
     383             : 
     384             : void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance);
     385             : 
     386             : /**
     387             :  * Add a new chapter.
     388             :  *
     389             :  * @param s media file handle
     390             :  * @param id unique ID for this chapter
     391             :  * @param start chapter start time in time_base units
     392             :  * @param end chapter end time in time_base units
     393             :  * @param title chapter title
     394             :  *
     395             :  * @return AVChapter or NULL on error
     396             :  */
     397             : AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
     398             :                               int64_t start, int64_t end, const char *title);
     399             : 
     400             : /**
     401             :  * Ensure the index uses less memory than the maximum specified in
     402             :  * AVFormatContext.max_index_size by discarding entries if it grows
     403             :  * too large.
     404             :  */
     405             : void ff_reduce_index(AVFormatContext *s, int stream_index);
     406             : 
     407             : enum AVCodecID ff_guess_image2_codec(const char *filename);
     408             : 
     409             : /**
     410             :  * Perform a binary search using av_index_search_timestamp() and
     411             :  * AVInputFormat.read_timestamp().
     412             :  *
     413             :  * @param target_ts target timestamp in the time base of the given stream
     414             :  * @param stream_index stream number
     415             :  */
     416             : int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
     417             :                          int64_t target_ts, int flags);
     418             : 
     419             : /**
     420             :  * Update cur_dts of all streams based on the given timestamp and AVStream.
     421             :  *
     422             :  * Stream ref_st unchanged, others set cur_dts in their native time base.
     423             :  * Only needed for timestamp wrapping or if (dts not set and pts!=dts).
     424             :  * @param timestamp new dts expressed in time_base of param ref_st
     425             :  * @param ref_st reference stream giving time_base of param timestamp
     426             :  */
     427             : void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
     428             : 
     429             : int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
     430             :                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
     431             : 
     432             : /**
     433             :  * Perform a binary search using read_timestamp().
     434             :  *
     435             :  * @param target_ts target timestamp in the time base of the given stream
     436             :  * @param stream_index stream number
     437             :  */
     438             : int64_t ff_gen_search(AVFormatContext *s, int stream_index,
     439             :                       int64_t target_ts, int64_t pos_min,
     440             :                       int64_t pos_max, int64_t pos_limit,
     441             :                       int64_t ts_min, int64_t ts_max,
     442             :                       int flags, int64_t *ts_ret,
     443             :                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
     444             : 
     445             : /**
     446             :  * Set the time base and wrapping info for a given stream. This will be used
     447             :  * to interpret the stream's timestamps. If the new time base is invalid
     448             :  * (numerator or denominator are non-positive), it leaves the stream
     449             :  * unchanged.
     450             :  *
     451             :  * @param s stream
     452             :  * @param pts_wrap_bits number of bits effectively used by the pts
     453             :  *        (used for wrap control)
     454             :  * @param pts_num time base numerator
     455             :  * @param pts_den time base denominator
     456             :  */
     457             : void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
     458             :                          unsigned int pts_num, unsigned int pts_den);
     459             : 
     460             : /**
     461             :  * Add side data to a packet for changing parameters to the given values.
     462             :  * Parameters set to 0 aren't included in the change.
     463             :  */
     464             : int ff_add_param_change(AVPacket *pkt, int32_t channels,
     465             :                         uint64_t channel_layout, int32_t sample_rate,
     466             :                         int32_t width, int32_t height);
     467             : 
     468             : /**
     469             :  * Set the timebase for each stream from the corresponding codec timebase and
     470             :  * print it.
     471             :  */
     472             : int ff_framehash_write_header(AVFormatContext *s);
     473             : 
     474             : /**
     475             :  * Read a transport packet from a media file.
     476             :  *
     477             :  * @param s media file handle
     478             :  * @param pkt is filled
     479             :  * @return 0 if OK, AVERROR_xxx on error
     480             :  */
     481             : int ff_read_packet(AVFormatContext *s, AVPacket *pkt);
     482             : 
     483             : /**
     484             :  * Interleave a packet per dts in an output media file.
     485             :  *
     486             :  * Packets with pkt->destruct == av_destruct_packet will be freed inside this
     487             :  * function, so they cannot be used after it. Note that calling av_packet_unref()
     488             :  * on them is still safe.
     489             :  *
     490             :  * @param s media file handle
     491             :  * @param out the interleaved packet will be output here
     492             :  * @param pkt the input packet
     493             :  * @param flush 1 if no further packets are available as input and all
     494             :  *              remaining packets should be output
     495             :  * @return 1 if a packet was output, 0 if no packet could be output,
     496             :  *         < 0 if an error occurred
     497             :  */
     498             : int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
     499             :                                  AVPacket *pkt, int flush);
     500             : 
     501             : void ff_free_stream(AVFormatContext *s, AVStream *st);
     502             : 
     503             : /**
     504             :  * Return the frame duration in seconds. Return 0 if not available.
     505             :  */
     506             : void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
     507             :                                AVCodecParserContext *pc, AVPacket *pkt);
     508             : 
     509             : unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id);
     510             : 
     511             : enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag);
     512             : 
     513             : /**
     514             :  * Select a PCM codec based on the given parameters.
     515             :  *
     516             :  * @param bps     bits-per-sample
     517             :  * @param flt     floating-point
     518             :  * @param be      big-endian
     519             :  * @param sflags  signed flags. each bit corresponds to one byte of bit depth.
     520             :  *                e.g. the 1st bit indicates if 8-bit should be signed or
     521             :  *                unsigned, the 2nd bit indicates if 16-bit should be signed or
     522             :  *                unsigned, etc... This is useful for formats such as WAVE where
     523             :  *                only 8-bit is unsigned and all other bit depths are signed.
     524             :  * @return        a PCM codec id or AV_CODEC_ID_NONE
     525             :  */
     526             : enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags);
     527             : 
     528             : /**
     529             :  * Chooses a timebase for muxing the specified stream.
     530             :  *
     531             :  * The chosen timebase allows sample accurate timestamps based
     532             :  * on the framerate or sample rate for audio streams. It also is
     533             :  * at least as precise as 1/min_precision would be.
     534             :  */
     535             : AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision);
     536             : 
     537             : /**
     538             :  * Chooses a timebase for muxing the specified stream.
     539             :  */
     540             : enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st);
     541             : 
     542             : /**
     543             :  * Generate standard extradata for AVC-Intra based on width/height and field
     544             :  * order.
     545             :  */
     546             : int ff_generate_avci_extradata(AVStream *st);
     547             : 
     548             : /**
     549             :  * Add a bitstream filter to a stream.
     550             :  *
     551             :  * @param st output stream to add a filter to
     552             :  * @param name the name of the filter to add
     553             :  * @param args filter-specific argument string
     554             :  * @return  >0 on success;
     555             :  *          AVERROR code on failure
     556             :  */
     557             : int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args);
     558             : 
     559             : /**
     560             :  * Copy encoding parameters from source to destination stream
     561             :  *
     562             :  * @param dst pointer to destination AVStream
     563             :  * @param src pointer to source AVStream
     564             :  * @return >=0 on success, AVERROR code on error
     565             :  */
     566             : int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src);
     567             : 
     568             : /**
     569             :  * Wrap errno on rename() error.
     570             :  *
     571             :  * @param oldpath source path
     572             :  * @param newpath destination path
     573             :  * @return        0 or AVERROR on failure
     574             :  */
     575          14 : static inline int ff_rename(const char *oldpath, const char *newpath, void *logctx)
     576             : {
     577          14 :     int ret = 0;
     578          14 :     if (rename(oldpath, newpath) == -1) {
     579           0 :         ret = AVERROR(errno);
     580           0 :         if (logctx) {
     581           0 :             char err[AV_ERROR_MAX_STRING_SIZE] = {0};
     582           0 :             av_make_error_string(err, AV_ERROR_MAX_STRING_SIZE, ret);
     583           0 :             av_log(logctx, AV_LOG_ERROR, "failed to rename file %s to %s: %s\n", oldpath, newpath, err);
     584             :         }
     585             :     }
     586          14 :     return ret;
     587             : }
     588             : 
     589             : /**
     590             :  * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
     591             :  * which is always set to 0.
     592             :  *
     593             :  * Previously allocated extradata in par will be freed.
     594             :  *
     595             :  * @param size size of extradata
     596             :  * @return 0 if OK, AVERROR_xxx on error
     597             :  */
     598             : int ff_alloc_extradata(AVCodecParameters *par, int size);
     599             : 
     600             : /**
     601             :  * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
     602             :  * which is always set to 0 and fill it from pb.
     603             :  *
     604             :  * @param size size of extradata
     605             :  * @return >= 0 if OK, AVERROR_xxx on error
     606             :  */
     607             : int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size);
     608             : 
     609             : /**
     610             :  * add frame for rfps calculation.
     611             :  *
     612             :  * @param dts timestamp of the i-th frame
     613             :  * @return 0 if OK, AVERROR_xxx on error
     614             :  */
     615             : int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts);
     616             : 
     617             : void ff_rfps_calculate(AVFormatContext *ic);
     618             : 
     619             : /**
     620             :  * Flags for AVFormatContext.write_uncoded_frame()
     621             :  */
     622             : enum AVWriteUncodedFrameFlags {
     623             : 
     624             :     /**
     625             :      * Query whether the feature is possible on this stream.
     626             :      * The frame argument is ignored.
     627             :      */
     628             :     AV_WRITE_UNCODED_FRAME_QUERY           = 0x0001,
     629             : 
     630             : };
     631             : 
     632             : /**
     633             :  * Copies the whilelists from one context to the other
     634             :  */
     635             : int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src);
     636             : 
     637             : int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
     638             :                        const AVIOInterruptCB *int_cb, AVDictionary **options);
     639             : 
     640             : /**
     641             :  * Returned by demuxers to indicate that data was consumed but discarded
     642             :  * (ignored streams or junk data). The framework will re-call the demuxer.
     643             :  */
     644             : #define FFERROR_REDO FFERRTAG('R','E','D','O')
     645             : 
     646             : /**
     647             :  * Utility function to open IO stream of output format.
     648             :  *
     649             :  * @param s AVFormatContext
     650             :  * @param url URL or file name to open for writing
     651             :  * @options optional options which will be passed to io_open callback
     652             :  * @return >=0 on success, negative AVERROR in case of failure
     653             :  */
     654             : int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options);
     655             : 
     656             : /*
     657             :  * A wrapper around AVFormatContext.io_close that should be used
     658             :  * instead of calling the pointer directly.
     659             :  */
     660             : void ff_format_io_close(AVFormatContext *s, AVIOContext **pb);
     661             : 
     662             : /**
     663             :  * Utility function to check if the file uses http or https protocol
     664             :  *
     665             :  * @param s AVFormatContext
     666             :  * @param filename URL or file name to open for writing
     667             :  */
     668             : int ff_is_http_proto(char *filename);
     669             : 
     670             : /**
     671             :  * Parse creation_time in AVFormatContext metadata if exists and warn if the
     672             :  * parsing fails.
     673             :  *
     674             :  * @param s AVFormatContext
     675             :  * @param timestamp parsed timestamp in microseconds, only set on successful parsing
     676             :  * @param return_seconds set this to get the number of seconds in timestamp instead of microseconds
     677             :  * @return 1 if OK, 0 if the metadata was not present, AVERROR(EINVAL) on parse error
     678             :  */
     679             : int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds);
     680             : 
     681             : /**
     682             :  * Standardize creation_time metadata in AVFormatContext to an ISO-8601
     683             :  * timestamp string.
     684             :  *
     685             :  * @param s AVFormatContext
     686             :  * @return <0 on error
     687             :  */
     688             : int ff_standardize_creation_time(AVFormatContext *s);
     689             : 
     690             : #define CONTAINS_PAL 2
     691             : /**
     692             :  * Reshuffles the lines to use the user specified stride.
     693             :  *
     694             :  * @param ppkt input and output packet
     695             :  * @return negative error code or
     696             :  *         0 if no new packet was allocated
     697             :  *         non-zero if a new packet was allocated and ppkt has to be freed
     698             :  *         CONTAINS_PAL if in addition to a new packet the old contained a palette
     699             :  */
     700             : int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride);
     701             : 
     702             : /**
     703             :  * Retrieves the palette from a packet, either from side data, or
     704             :  * appended to the video data in the packet itself (raw video only).
     705             :  * It is commonly used after a call to ff_reshuffle_raw_rgb().
     706             :  *
     707             :  * Use 0 for the ret parameter to check for side data only.
     708             :  *
     709             :  * @param pkt pointer to packet before calling ff_reshuffle_raw_rgb()
     710             :  * @param ret return value from ff_reshuffle_raw_rgb(), or 0
     711             :  * @param palette pointer to palette buffer
     712             :  * @return negative error code or
     713             :  *         1 if the packet has a palette, else 0
     714             :  */
     715             : int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette);
     716             : 
     717             : /**
     718             :  * Finalize buf into extradata and set its size appropriately.
     719             :  */
     720             : int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf);
     721             : 
     722             : /**
     723             :  * Find the next packet in the interleaving queue for the given stream.
     724             :  * The pkt parameter is filled in with the queued packet, including
     725             :  * references to the data (which the caller is not allowed to keep or
     726             :  * modify).
     727             :  *
     728             :  * @return 0 if a packet was found, a negative value if no packet was found
     729             :  */
     730             : int ff_interleaved_peek(AVFormatContext *s, int stream,
     731             :                         AVPacket *pkt, int add_offset);
     732             : 
     733             : 
     734             : int ff_lock_avformat(void);
     735             : int ff_unlock_avformat(void);
     736             : 
     737             : /**
     738             :  * Set AVFormatContext url field to the provided pointer. The pointer must
     739             :  * point to a valid string. The existing url field is freed if necessary. Also
     740             :  * set the legacy filename field to the same string which was provided in url.
     741             :  */
     742             : void ff_format_set_url(AVFormatContext *s, char *url);
     743             : 
     744             : #define FF_PACKETLIST_FLAG_REF_PACKET (1 << 0) /**< Create a new reference for the packet instead of
     745             :                                                     transferring the ownership of the existing one to the
     746             :                                                     list. */
     747             : 
     748             : /**
     749             :  * Append an AVPacket to the list.
     750             :  *
     751             :  * @param head  List head element
     752             :  * @param tail  List tail element
     753             :  * @param pkt   The packet being appended
     754             :  * @param flags Any combination of FF_PACKETLIST_FLAG_* flags
     755             :  * @return 0 on success, negative AVERROR value on failure. On failure,
     756             :            the list is unchanged
     757             :  */
     758             : int ff_packet_list_put(AVPacketList **head, AVPacketList **tail,
     759             :                        AVPacket *pkt, int flags);
     760             : 
     761             : /**
     762             :  * Remove the oldest AVPacket in the list and return it.
     763             :  *
     764             :  * @note The pkt will be overwritten completely. The caller owns the
     765             :  *       packet and must unref it by itself.
     766             :  *
     767             :  * @param head List head element
     768             :  * @param tail List tail element
     769             :  * @param pkt  Pointer to an initialized AVPacket struct
     770             :  */
     771             : int ff_packet_list_get(AVPacketList **head, AVPacketList **tail,
     772             :                        AVPacket *pkt);
     773             : 
     774             : /**
     775             :  * Wipe the list and unref all the packets in it.
     776             :  *
     777             :  * @param head List head element
     778             :  * @param tail List tail element
     779             :  */
     780             : void ff_packet_list_free(AVPacketList **head, AVPacketList **tail);
     781             : 
     782             : void avpriv_register_devices(const AVOutputFormat * const o[], const AVInputFormat * const i[]);
     783             : 
     784             : #endif /* AVFORMAT_INTERNAL_H */

Generated by: LCOV version 1.13