/* * copyright (c) 2001 Fabrice Bellard * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef AVFORMAT_INTERNAL_H #define AVFORMAT_INTERNAL_H #include <stdint.h> #include "libavcodec/packet_internal.h" #include "avformat.h" #define MAX_URL_SIZE … /** size of probe buffer, for guessing file type from file contents */ #define PROBE_BUF_MIN … #define PROBE_BUF_MAX … #ifdef DEBUG #define hex_dump_debug … #else #define hex_dump_debug(class, buf, size) … #endif AVCodecTag; CodecMime; /*************************************************/ /* fractional numbers for exact pts handling */ /** * The exact value of the fractional number is: 'val + num / den'. * num is assumed to be 0 <= num < den. */ FFFrac; FFFormatContext; static av_always_inline FFFormatContext *ffformatcontext(AVFormatContext *s) { … } FFStream; static av_always_inline FFStream *ffstream(AVStream *st) { … } static av_always_inline const FFStream *cffstream(const AVStream *st) { … } FFStreamGroup; static av_always_inline FFStreamGroup *ffstreamgroup(AVStreamGroup *stg) { … } static av_always_inline const FFStreamGroup *cffstreamgroup(const AVStreamGroup *stg) { … } #ifdef __GNUC__ #define dynarray_add(tab, nb_ptr, elem) … #else #define dynarray_add … #endif void ff_flush_packet_queue(AVFormatContext *s); /** * Automatically create sub-directories * * @param path will create sub-directories by path * @return 0, or < 0 on error */ int ff_mkdir_p(const char *path); /** * Write hexadecimal string corresponding to given binary data. The string * is zero-terminated. * * @param buf the output string is written here; * needs to be at least 2 * size + 1 bytes long. * @param src the input data to be transformed. * @param size the size (in byte) of src. * @param lowercase determines whether to use the range [0-9a-f] or [0-9A-F]. * @return buf. */ char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase); /** * Parse a string of hexadecimal strings. Any space between the hexadecimal * digits is ignored. * * @param data if non-null, the parsed data is written to this pointer * @param p the string to parse * @return the number of bytes written (or to be written, if data is null) */ int ff_hex_to_data(uint8_t *data, const char *p); #define NTP_OFFSET … #define NTP_OFFSET_US … /** Get the current time since NTP epoch in microseconds. */ uint64_t ff_ntp_time(void); /** * Get the NTP time stamp formatted as per the RFC-5905. * * @param ntp_time NTP time in micro seconds (since NTP epoch) * @return the formatted NTP time stamp */ uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us); /** * Parse the NTP time in micro seconds (since NTP epoch). * * @param ntp_ts NTP time stamp formatted as per the RFC-5905. * @return the time in micro seconds (since NTP epoch) */ uint64_t ff_parse_ntp_time(uint64_t ntp_ts); /** * Append the media-specific SDP fragment for the media stream c * to the buffer buff. * * Note, the buffer needs to be initialized, since it is appended to * existing content. * * @param buff the buffer to append the SDP fragment to * @param size the size of the buff buffer * @param st the AVStream of the media to describe * @param idx the global stream index * @param dest_addr the destination address of the media stream, may be NULL * @param dest_type the destination address type, may be NULL * @param port the destination port of the media stream, 0 if unknown * @param ttl the time to live of the stream, 0 if not multicast * @param fmt the AVFormatContext, which might contain options modifying * the generated SDP * @return 0 on success, a negative error code on failure */ 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); /** * Read a whole line of text from AVIOContext. Stop reading after reaching * either a \\n, a \\0 or EOF. The returned string is always \\0-terminated, * and may be truncated if the buffer is too small. * * @param s the read-only AVIOContext * @param buf buffer to store the read line * @param maxlen size of the buffer * @return the length of the string written in the buffer, not including the * final \\0 */ int ff_get_line(AVIOContext *s, char *buf, int maxlen); /** * Same as ff_get_line but strip the white-space characters in the text tail * * @param s the read-only AVIOContext * @param buf buffer to store the read line * @param maxlen size of the buffer * @return the length of the string written in the buffer */ int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen); #define SPACE_CHARS … /** * Callback function type for ff_parse_key_value. * * @param key a pointer to the key * @param key_len the number of bytes that belong to the key, including the '=' * char * @param dest return the destination pointer for the value in *dest, may * be null to ignore the value * @param dest_len the length of the *dest buffer */ ff_parse_key_val_cb; /** * Parse a string with comma-separated key=value pairs. The value strings * may be quoted and may contain escaped characters within quoted strings. * * @param str the string to parse * @param callback_get_buf function that returns where to store the * unescaped value string. * @param context the opaque context pointer to pass to callback_get_buf */ void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf, void *context); enum AVCodecID ff_guess_image2_codec(const char *filename); const struct AVCodec *ff_find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id); /** * Set the time base and wrapping info for a given stream. This will be used * to interpret the stream's timestamps. If the new time base is invalid * (numerator or denominator are non-positive), it leaves the stream * unchanged. * * @param st stream * @param pts_wrap_bits number of bits effectively used by the pts * (used for wrap control) * @param pts_num time base numerator * @param pts_den time base denominator */ void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den); /** * Set the timebase for each stream from the corresponding codec timebase and * print it. */ int ff_framehash_write_header(AVFormatContext *s); /** * Frees a stream without modifying the corresponding AVFormatContext. * Must only be called if the latter doesn't matter or if the stream * is not yet attached to an AVFormatContext. */ void ff_free_stream(AVStream **st); /** * Remove a stream from its AVFormatContext and free it. * The stream must be the last stream of the AVFormatContext. */ void ff_remove_stream(AVFormatContext *s, AVStream *st); /** * Frees a stream group without modifying the corresponding AVFormatContext. * Must only be called if the latter doesn't matter or if the stream * is not yet attached to an AVFormatContext. */ void ff_free_stream_group(AVStreamGroup **pstg); /** * Remove a stream group from its AVFormatContext and free it. * The stream group must be the last stream group of the AVFormatContext. */ void ff_remove_stream_group(AVFormatContext *s, AVStreamGroup *stg); unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id); enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag); int ff_is_intra_only(enum AVCodecID id); /** * Select a PCM codec based on the given parameters. * * @param bps bits-per-sample * @param flt floating-point * @param be big-endian * @param sflags signed flags. each bit corresponds to one byte of bit depth. * e.g. the 1st bit indicates if 8-bit should be signed or * unsigned, the 2nd bit indicates if 16-bit should be signed or * unsigned, etc... This is useful for formats such as WAVE where * only 8-bit is unsigned and all other bit depths are signed. * @return a PCM codec id or AV_CODEC_ID_NONE */ enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags); /** * Copy side data from source to destination stream * * @param dst pointer to destination AVStream * @param src pointer to source AVStream * @return >=0 on success, AVERROR code on error */ int ff_stream_side_data_copy(AVStream *dst, const AVStream *src); /** * Create a new stream and copy to it all parameters from a source stream, with * the exception of the index field, which is set when the new stream is * created. * * @param dst_ctx pointer to the context in which the new stream is created * @param src pointer to source AVStream * @return pointer to the new stream or NULL on error */ AVStream *ff_stream_clone(AVFormatContext *dst_ctx, const AVStream *src); /** * Wrap ffurl_move() and log if error happens. * * @param url_src source path * @param url_dst destination path * @return 0 or AVERROR on failure */ int ff_rename(const char *url_src, const char *url_dst, void *logctx); /** * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end * which is always set to 0. * * Previously allocated extradata in par will be freed. * * @param size size of extradata * @return 0 if OK, AVERROR_xxx on error */ int ff_alloc_extradata(AVCodecParameters *par, int size); /** * Copies the whilelists from one context to the other */ int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src); /* * A wrapper around AVFormatContext.io_close that should be used * instead of calling the pointer directly. * * @param s AVFormatContext * @param *pb the AVIOContext to be closed and freed. Can be NULL. * @return >=0 on success, negative AVERROR in case of failure */ int ff_format_io_close(AVFormatContext *s, AVIOContext **pb); /** * Utility function to check if the file uses http or https protocol * * @param s AVFormatContext * @param filename URL or file name to open for writing */ int ff_is_http_proto(const char *filename); struct AVBPrint; /** * Finalize buf into extradata and set its size appropriately. */ int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf); /** * Set AVFormatContext url field to the provided pointer. The pointer must * point to a valid string. The existing url field is freed if necessary. Also * set the legacy filename field to the same string which was provided in url. */ void ff_format_set_url(AVFormatContext *s, char *url); /** * Return a positive value if the given url has one of the given * extensions, negative AVERROR on error, 0 otherwise. * * @param url url to check against the given extensions * @param extensions a comma-separated list of filename extensions */ int ff_match_url_ext(const char *url, const char *extensions); struct FFOutputFormat; struct FFInputFormat; void avpriv_register_devices(const struct FFOutputFormat * const o[], const struct FFInputFormat * const i[]); #endif /* AVFORMAT_INTERNAL_H */
Codebase Browser
chromium