2006-09-10 14:02:42 +00:00
|
|
|
/*
|
|
|
|
* copyright (c) 2001 Fabrice Bellard
|
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2006-09-10 14:02:42 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2006-09-10 14:02:42 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2006-09-10 14:02:42 +00:00
|
|
|
* 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
|
2006-10-07 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-09-10 14:02:42 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
2008-08-31 07:39:47 +00:00
|
|
|
#ifndef AVFORMAT_AVIO_H
|
|
|
|
#define AVFORMAT_AVIO_H
|
2002-07-24 17:49:11 +00:00
|
|
|
|
2009-02-26 22:28:42 +00:00
|
|
|
/**
|
2010-04-20 14:45:34 +00:00
|
|
|
* @file
|
2011-12-10 19:16:57 +00:00
|
|
|
* @ingroup lavf_io
|
2011-04-09 06:30:15 +00:00
|
|
|
* Buffered I/O operations
|
2009-02-26 22:28:42 +00:00
|
|
|
*/
|
|
|
|
|
2007-06-16 22:59:13 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2009-02-17 21:43:57 +00:00
|
|
|
#include "libavutil/common.h"
|
2011-11-06 21:03:45 +00:00
|
|
|
#include "libavutil/dict.h"
|
2010-06-23 11:26:33 +00:00
|
|
|
#include "libavutil/log.h"
|
2009-02-17 21:43:57 +00:00
|
|
|
|
2011-01-21 19:18:06 +00:00
|
|
|
#include "libavformat/version.h"
|
|
|
|
|
2016-09-27 13:37:54 +00:00
|
|
|
/**
|
|
|
|
* Seeking works like for a local file.
|
|
|
|
*/
|
|
|
|
#define AVIO_SEEKABLE_NORMAL (1 << 0)
|
2011-04-09 06:44:14 +00:00
|
|
|
|
2016-09-27 13:44:54 +00:00
|
|
|
/**
|
|
|
|
* Seeking by timestamp with avio_seek_time() is possible.
|
|
|
|
*/
|
|
|
|
#define AVIO_SEEKABLE_TIME (1 << 1)
|
|
|
|
|
2011-11-06 12:10:16 +00:00
|
|
|
/**
|
|
|
|
* Callback for checking whether to abort blocking functions.
|
|
|
|
* AVERROR_EXIT is returned in this case by the interrupted
|
|
|
|
* function. During blocking operations, callback is called with
|
|
|
|
* opaque as parameter. If the callback returns 1, the
|
|
|
|
* blocking operation will be aborted.
|
|
|
|
*
|
|
|
|
* No members can be added to this struct without a major bump, if
|
|
|
|
* new elements have been added after this struct in AVFormatContext
|
|
|
|
* or AVIOContext.
|
|
|
|
*/
|
2012-09-27 02:21:03 +00:00
|
|
|
typedef struct AVIOInterruptCB {
|
2011-11-06 12:10:16 +00:00
|
|
|
int (*callback)(void*);
|
|
|
|
void *opaque;
|
|
|
|
} AVIOInterruptCB;
|
|
|
|
|
2014-07-05 16:11:59 +00:00
|
|
|
/**
|
|
|
|
* Directory entry types.
|
|
|
|
*/
|
|
|
|
enum AVIODirEntryType {
|
|
|
|
AVIO_ENTRY_UNKNOWN,
|
|
|
|
AVIO_ENTRY_BLOCK_DEVICE,
|
|
|
|
AVIO_ENTRY_CHARACTER_DEVICE,
|
|
|
|
AVIO_ENTRY_DIRECTORY,
|
|
|
|
AVIO_ENTRY_NAMED_PIPE,
|
|
|
|
AVIO_ENTRY_SYMBOLIC_LINK,
|
|
|
|
AVIO_ENTRY_SOCKET,
|
2015-04-03 01:54:08 +00:00
|
|
|
AVIO_ENTRY_FILE,
|
|
|
|
AVIO_ENTRY_SERVER,
|
|
|
|
AVIO_ENTRY_SHARE,
|
|
|
|
AVIO_ENTRY_WORKGROUP,
|
2014-07-05 16:11:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Describes single entry of the directory.
|
|
|
|
*
|
|
|
|
* Only name and type fields are guaranteed be set.
|
|
|
|
* Rest of fields are protocol or/and platform dependent and might be unknown.
|
|
|
|
*/
|
|
|
|
typedef struct AVIODirEntry {
|
|
|
|
char *name; /**< Filename */
|
|
|
|
int type; /**< Type of the entry */
|
|
|
|
int utf8; /**< Set to 1 when name is encoded with UTF-8, 0 otherwise.
|
2015-06-13 19:34:40 +00:00
|
|
|
Name can be encoded with UTF-8 even though 0 is set. */
|
2014-07-05 16:11:59 +00:00
|
|
|
int64_t size; /**< File size in bytes, -1 if unknown. */
|
|
|
|
int64_t modification_timestamp; /**< Time of last modification in microseconds since unix
|
|
|
|
epoch, -1 if unknown. */
|
|
|
|
int64_t access_timestamp; /**< Time of last access in microseconds since unix epoch,
|
|
|
|
-1 if unknown. */
|
|
|
|
int64_t status_change_timestamp; /**< Time of last status change in microseconds since unix
|
|
|
|
epoch, -1 if unknown. */
|
|
|
|
int64_t user_id; /**< User ID of owner, -1 if unknown. */
|
|
|
|
int64_t group_id; /**< Group ID of owner, -1 if unknown. */
|
|
|
|
int64_t filemode; /**< Unix file mode, -1 if unknown. */
|
|
|
|
} AVIODirEntry;
|
|
|
|
|
|
|
|
typedef struct AVIODirContext {
|
|
|
|
struct URLContext *url_context;
|
|
|
|
} AVIODirContext;
|
|
|
|
|
2016-05-04 14:18:35 +00:00
|
|
|
/**
|
|
|
|
* Different data types that can be returned via the AVIO
|
|
|
|
* write_data_type callback.
|
|
|
|
*/
|
|
|
|
enum AVIODataMarkerType {
|
|
|
|
/**
|
|
|
|
* Header data; this needs to be present for the stream to be decodeable.
|
|
|
|
*/
|
|
|
|
AVIO_DATA_MARKER_HEADER,
|
|
|
|
/**
|
|
|
|
* A point in the output bytestream where a decoder can start decoding
|
|
|
|
* (i.e. a keyframe). A demuxer/decoder given the data flagged with
|
|
|
|
* AVIO_DATA_MARKER_HEADER, followed by any AVIO_DATA_MARKER_SYNC_POINT,
|
|
|
|
* should give decodeable results.
|
|
|
|
*/
|
|
|
|
AVIO_DATA_MARKER_SYNC_POINT,
|
|
|
|
/**
|
|
|
|
* A point in the output bytestream where a demuxer can start parsing
|
|
|
|
* (for non self synchronizing bytestream formats). That is, any
|
|
|
|
* non-keyframe packet start point.
|
|
|
|
*/
|
|
|
|
AVIO_DATA_MARKER_BOUNDARY_POINT,
|
|
|
|
/**
|
|
|
|
* This is any, unlabelled data. It can either be a muxer not marking
|
|
|
|
* any positions at all, it can be an actual boundary/sync point
|
|
|
|
* that the muxer chooses not to mark, or a later part of a packet/fragment
|
|
|
|
* that is cut into multiple write callbacks due to limited IO buffer size.
|
|
|
|
*/
|
|
|
|
AVIO_DATA_MARKER_UNKNOWN,
|
|
|
|
/**
|
|
|
|
* Trailer data, which doesn't contain actual content, but only for
|
|
|
|
* finalizing the output file.
|
|
|
|
*/
|
2017-06-18 12:38:39 +00:00
|
|
|
AVIO_DATA_MARKER_TRAILER,
|
|
|
|
/**
|
|
|
|
* A point in the output bytestream where the underlying AVIOContext might
|
|
|
|
* flush the buffer depending on latency or buffering requirements. Typically
|
|
|
|
* means the end of a packet.
|
|
|
|
*/
|
|
|
|
AVIO_DATA_MARKER_FLUSH_POINT,
|
2016-05-04 14:18:35 +00:00
|
|
|
};
|
|
|
|
|
2011-04-09 06:44:14 +00:00
|
|
|
/**
|
|
|
|
* Bytestream IO Context.
|
|
|
|
* New fields can be added to the end with minor version bumps.
|
|
|
|
* Removal, reordering and changes to existing fields require a major
|
|
|
|
* version bump.
|
|
|
|
* sizeof(AVIOContext) must not be used outside libav*.
|
2011-04-10 06:14:26 +00:00
|
|
|
*
|
|
|
|
* @note None of the function pointers in AVIOContext should be called
|
|
|
|
* directly, they should only be set by the client application
|
|
|
|
* when implementing custom I/O. Normally these are set to the
|
|
|
|
* function pointers specified in avio_alloc_context()
|
2011-04-09 06:44:14 +00:00
|
|
|
*/
|
2012-09-27 02:21:03 +00:00
|
|
|
typedef struct AVIOContext {
|
2011-11-06 21:03:45 +00:00
|
|
|
/**
|
|
|
|
* A class for private options.
|
|
|
|
*
|
|
|
|
* If this AVIOContext is created by avio_open2(), av_class is set and
|
|
|
|
* passes the options down to protocols.
|
|
|
|
*
|
|
|
|
* If this AVIOContext is manually allocated, then av_class may be set by
|
|
|
|
* the caller.
|
|
|
|
*
|
|
|
|
* warning -- this field can be NULL, be sure to not pass this AVIOContext
|
|
|
|
* to any av_opt_* functions in that case.
|
|
|
|
*/
|
2012-04-18 20:01:15 +00:00
|
|
|
const AVClass *av_class;
|
2015-11-16 02:02:11 +00:00
|
|
|
|
|
|
|
/*
|
avformat/aviobuf: fix flushing write buffers after seeking backward or forward
This patch makes aviobuf work more like traditinal file IO, which is how people
think about it.
For example, in the past, aviobuf only flushed buffers until the current buffer
position, even if more data was written to it previously, and a backward seek
was used to reposition the IO context.
From now, aviobuf will keep track of the written data, so no explicit seek will
be required till the end of the buffer, or till the end of file before flushing.
This fixes at least one regression, fate-vsynth3-flv was broken if
flush_packets option was set to false, an explicit seek was removed in
4e3cc4bdd8acedbcc703607ed0efbb64bb5c3cc4.
Also from now on, if a forward seek in the write buffer were to cause a gap
between the already written data and the new file position, a flush will
happen.
The must_flush varable is also removed, which might have caused needless
flushes with multiple seeks whithin the write buffer. Since we know the amount
of data written to it, we will know when to flush.
Signed-off-by: Marton Balint <cus@passwd.hu>
2017-06-03 23:15:50 +00:00
|
|
|
* The following shows the relationship between buffer, buf_ptr,
|
|
|
|
* buf_ptr_max, buf_end, buf_size, and pos, when reading and when writing
|
|
|
|
* (since AVIOContext is used for both):
|
2015-11-16 02:02:11 +00:00
|
|
|
*
|
|
|
|
**********************************************************************************
|
|
|
|
* READING
|
|
|
|
**********************************************************************************
|
|
|
|
*
|
|
|
|
* | buffer_size |
|
|
|
|
* |---------------------------------------|
|
|
|
|
* | |
|
|
|
|
*
|
|
|
|
* buffer buf_ptr buf_end
|
|
|
|
* +---------------+-----------------------+
|
|
|
|
* |/ / / / / / / /|/ / / / / / /| |
|
|
|
|
* read buffer: |/ / consumed / | to be read /| |
|
|
|
|
* |/ / / / / / / /|/ / / / / / /| |
|
|
|
|
* +---------------+-----------------------+
|
|
|
|
*
|
|
|
|
* pos
|
|
|
|
* +-------------------------------------------+-----------------+
|
|
|
|
* input file: | | |
|
|
|
|
* +-------------------------------------------+-----------------+
|
|
|
|
*
|
|
|
|
*
|
|
|
|
**********************************************************************************
|
|
|
|
* WRITING
|
|
|
|
**********************************************************************************
|
|
|
|
*
|
avformat/aviobuf: fix flushing write buffers after seeking backward or forward
This patch makes aviobuf work more like traditinal file IO, which is how people
think about it.
For example, in the past, aviobuf only flushed buffers until the current buffer
position, even if more data was written to it previously, and a backward seek
was used to reposition the IO context.
From now, aviobuf will keep track of the written data, so no explicit seek will
be required till the end of the buffer, or till the end of file before flushing.
This fixes at least one regression, fate-vsynth3-flv was broken if
flush_packets option was set to false, an explicit seek was removed in
4e3cc4bdd8acedbcc703607ed0efbb64bb5c3cc4.
Also from now on, if a forward seek in the write buffer were to cause a gap
between the already written data and the new file position, a flush will
happen.
The must_flush varable is also removed, which might have caused needless
flushes with multiple seeks whithin the write buffer. Since we know the amount
of data written to it, we will know when to flush.
Signed-off-by: Marton Balint <cus@passwd.hu>
2017-06-03 23:15:50 +00:00
|
|
|
* | buffer_size |
|
|
|
|
* |--------------------------------------|
|
|
|
|
* | |
|
2015-11-16 02:02:11 +00:00
|
|
|
*
|
avformat/aviobuf: fix flushing write buffers after seeking backward or forward
This patch makes aviobuf work more like traditinal file IO, which is how people
think about it.
For example, in the past, aviobuf only flushed buffers until the current buffer
position, even if more data was written to it previously, and a backward seek
was used to reposition the IO context.
From now, aviobuf will keep track of the written data, so no explicit seek will
be required till the end of the buffer, or till the end of file before flushing.
This fixes at least one regression, fate-vsynth3-flv was broken if
flush_packets option was set to false, an explicit seek was removed in
4e3cc4bdd8acedbcc703607ed0efbb64bb5c3cc4.
Also from now on, if a forward seek in the write buffer were to cause a gap
between the already written data and the new file position, a flush will
happen.
The must_flush varable is also removed, which might have caused needless
flushes with multiple seeks whithin the write buffer. Since we know the amount
of data written to it, we will know when to flush.
Signed-off-by: Marton Balint <cus@passwd.hu>
2017-06-03 23:15:50 +00:00
|
|
|
* buf_ptr_max
|
|
|
|
* buffer (buf_ptr) buf_end
|
|
|
|
* +-----------------------+--------------+
|
|
|
|
* |/ / / / / / / / / / / /| |
|
|
|
|
* write buffer: | / / to be flushed / / | |
|
|
|
|
* |/ / / / / / / / / / / /| |
|
|
|
|
* +-----------------------+--------------+
|
|
|
|
* buf_ptr can be in this
|
|
|
|
* due to a backward seek
|
2015-11-16 02:02:11 +00:00
|
|
|
*
|
avformat/aviobuf: fix flushing write buffers after seeking backward or forward
This patch makes aviobuf work more like traditinal file IO, which is how people
think about it.
For example, in the past, aviobuf only flushed buffers until the current buffer
position, even if more data was written to it previously, and a backward seek
was used to reposition the IO context.
From now, aviobuf will keep track of the written data, so no explicit seek will
be required till the end of the buffer, or till the end of file before flushing.
This fixes at least one regression, fate-vsynth3-flv was broken if
flush_packets option was set to false, an explicit seek was removed in
4e3cc4bdd8acedbcc703607ed0efbb64bb5c3cc4.
Also from now on, if a forward seek in the write buffer were to cause a gap
between the already written data and the new file position, a flush will
happen.
The must_flush varable is also removed, which might have caused needless
flushes with multiple seeks whithin the write buffer. Since we know the amount
of data written to it, we will know when to flush.
Signed-off-by: Marton Balint <cus@passwd.hu>
2017-06-03 23:15:50 +00:00
|
|
|
* pos
|
|
|
|
* +-------------+----------------------------------------------+
|
|
|
|
* output file: | | |
|
|
|
|
* +-------------+----------------------------------------------+
|
2015-11-16 02:02:11 +00:00
|
|
|
*
|
|
|
|
*/
|
2011-04-09 10:20:04 +00:00
|
|
|
unsigned char *buffer; /**< Start of the buffer. */
|
|
|
|
int buffer_size; /**< Maximum buffer size */
|
|
|
|
unsigned char *buf_ptr; /**< Current position in the buffer */
|
|
|
|
unsigned char *buf_end; /**< End of the data, may be less than
|
|
|
|
buffer+buffer_size if the read function returned
|
|
|
|
less data than requested, e.g. for streams where
|
|
|
|
no more data has been received yet. */
|
|
|
|
void *opaque; /**< A private pointer, passed to the read/write/seek/...
|
|
|
|
functions. */
|
2011-04-09 06:44:14 +00:00
|
|
|
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
|
|
|
|
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
|
|
|
|
int64_t (*seek)(void *opaque, int64_t offset, int whence);
|
2011-04-09 10:21:36 +00:00
|
|
|
int64_t pos; /**< position in the file of the current buffer */
|
2018-12-08 22:05:45 +00:00
|
|
|
int eof_reached; /**< true if was unable to read due to error or eof */
|
2011-04-09 10:21:36 +00:00
|
|
|
int write_flag; /**< true if open for writing */
|
2011-04-09 06:44:14 +00:00
|
|
|
int max_packet_size;
|
|
|
|
unsigned long checksum;
|
|
|
|
unsigned char *checksum_ptr;
|
|
|
|
unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
|
2011-04-09 10:21:36 +00:00
|
|
|
int error; /**< contains the error code or 0 if no error happened */
|
2011-04-10 06:14:26 +00:00
|
|
|
/**
|
|
|
|
* Pause or resume playback for network streaming protocols - e.g. MMS.
|
|
|
|
*/
|
2011-04-09 06:44:14 +00:00
|
|
|
int (*read_pause)(void *opaque, int pause);
|
2011-04-10 06:14:26 +00:00
|
|
|
/**
|
|
|
|
* Seek to a given timestamp in stream with the specified stream_index.
|
|
|
|
* Needed for some network streaming protocols which don't support seeking
|
|
|
|
* to byte position.
|
|
|
|
*/
|
2011-04-09 06:44:14 +00:00
|
|
|
int64_t (*read_seek)(void *opaque, int stream_index,
|
|
|
|
int64_t timestamp, int flags);
|
|
|
|
/**
|
|
|
|
* A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
|
|
|
|
*/
|
|
|
|
int seekable;
|
2011-12-16 04:54:03 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* max filesize, used to limit allocations
|
|
|
|
* This field is internal to libavformat and access from outside is not allowed.
|
|
|
|
*/
|
2013-04-08 12:08:58 +00:00
|
|
|
int64_t maxsize;
|
2012-03-25 09:58:55 +00:00
|
|
|
|
2013-04-08 12:08:58 +00:00
|
|
|
/**
|
|
|
|
* avio_read and avio_write should if possible be satisfied directly
|
|
|
|
* instead of going through a buffer, and avio_seek will always
|
|
|
|
* call the underlying seek function directly.
|
|
|
|
*/
|
|
|
|
int direct;
|
2012-06-02 21:01:13 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Bytes read statistic
|
|
|
|
* This field is internal to libavformat and access from outside is not allowed.
|
|
|
|
*/
|
2013-04-08 12:08:58 +00:00
|
|
|
int64_t bytes_read;
|
2012-06-02 21:01:13 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* seek statistic
|
|
|
|
* This field is internal to libavformat and access from outside is not allowed.
|
|
|
|
*/
|
2013-04-08 12:08:58 +00:00
|
|
|
int seek_count;
|
2013-04-08 11:21:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* writeout statistic
|
|
|
|
* This field is internal to libavformat and access from outside is not allowed.
|
|
|
|
*/
|
2013-04-08 12:08:58 +00:00
|
|
|
int writeout_count;
|
2014-03-26 22:58:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Original buffer size
|
|
|
|
* used internally after probing and ensure seekback to reset the buffer size
|
|
|
|
* This field is internal to libavformat and access from outside is not allowed.
|
|
|
|
*/
|
|
|
|
int orig_buffer_size;
|
2015-06-02 16:40:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Threshold to favor readahead over seek.
|
|
|
|
* This is current internal only, do not use from outside.
|
|
|
|
*/
|
|
|
|
int short_seek_threshold;
|
2016-01-30 01:17:50 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ',' separated list of allowed protocols.
|
|
|
|
*/
|
|
|
|
const char *protocol_whitelist;
|
2016-03-03 17:14:26 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ',' separated list of disallowed protocols.
|
|
|
|
*/
|
|
|
|
const char *protocol_blacklist;
|
2016-06-23 13:27:00 +00:00
|
|
|
|
2016-05-04 14:18:35 +00:00
|
|
|
/**
|
|
|
|
* A callback that is used instead of write_packet.
|
|
|
|
*/
|
|
|
|
int (*write_data_type)(void *opaque, uint8_t *buf, int buf_size,
|
|
|
|
enum AVIODataMarkerType type, int64_t time);
|
|
|
|
/**
|
|
|
|
* If set, don't call write_data_type separately for AVIO_DATA_MARKER_BOUNDARY_POINT,
|
|
|
|
* but ignore them and treat them as AVIO_DATA_MARKER_UNKNOWN (to avoid needlessly
|
|
|
|
* small chunks of data returned from the callback).
|
|
|
|
*/
|
|
|
|
int ignore_boundary_point;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Internal, not meant to be used from outside of AVIOContext.
|
|
|
|
*/
|
|
|
|
enum AVIODataMarkerType current_type;
|
|
|
|
int64_t last_time;
|
HTTP: improve performance by reducing forward seeks
This commit optimizes HTTP performance by reducing forward seeks, instead
favoring a read-ahead and discard on the current connection (referred to
as a short seek) for seeks that are within a TCP window's worth of data.
This improves performance because with TCP flow control, a window's worth
of data will be in the local socket buffer already or in-flight from the
sender once congestion control on the sender is fully utilizing the window.
Note: this approach doesn't attempt to differentiate from a newly opened
connection which may not be fully utilizing the window due to congestion
control vs one that is. The receiver can't get at this information, so we
assume worst case; that full window is in use (we did advertise it after all)
and that data could be in-flight
The previous behavior of closing the connection, then opening a new
with a new HTTP range value results in a massive amounts of discarded
and re-sent data when large TCP windows are used. This has been observed
on MacOS/iOS which starts with an initial window of 256KB and grows up to
1MB depending on the bandwidth-product delay.
When seeking within a window's worth of data and we close the connection,
then open a new one within the same window's worth of data, we discard
from the current offset till the end of the window. Then on the new
connection the server ends up re-sending the previous data from new
offset till the end of old window.
Example (assumes full window utilization):
TCP window size: 64KB
Position: 32KB
Forward seek position: 40KB
* (Next window)
32KB |--------------| 96KB |---------------| 160KB
*
40KB |---------------| 104KB
Re-sent amount: 96KB - 40KB = 56KB
For a real world test example, I have MP4 file of ~25MB, which ffplay
only reads ~16MB and performs 177 seeks. With current ffmpeg, this results
in 177 HTTP GETs and ~73MB worth of TCP data communication. With this
patch, ffmpeg issues 4 HTTP GETs and 3 seeks for a total of ~22MB of TCP data
communication.
To support this feature, the short seek logic in avio_seek() has been
extended to call a function to get the short seek threshold value. This
callback has been plumbed to the URLProtocol structure, which now has
infrastructure in HTTP and TCP to get the underlying receiver window size
via SO_RCVBUF. If the underlying URL and protocol don't support returning
a short seek threshold, the default s->short_seek_threshold is used
This feature has been tested on Windows 7 and MacOS/iOS. Windows support
is slightly complicated by the fact that when TCP window auto-tuning is
enabled, SO_RCVBUF doesn't report the real window size, but it does if
SO_RCVBUF was manually set (disabling auto-tuning). So we can only use
this optimization on Windows in the later case
Signed-off-by: Joel Cunningham <joel.cunningham@me.com>
Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
2017-01-30 16:00:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* A callback that is used instead of short_seek_threshold.
|
|
|
|
* This is current internal only, do not use from outside.
|
|
|
|
*/
|
|
|
|
int (*short_seek_get)(void *opaque);
|
2017-04-13 22:49:20 +00:00
|
|
|
|
2016-12-06 01:56:24 +00:00
|
|
|
int64_t written;
|
avformat/aviobuf: fix flushing write buffers after seeking backward or forward
This patch makes aviobuf work more like traditinal file IO, which is how people
think about it.
For example, in the past, aviobuf only flushed buffers until the current buffer
position, even if more data was written to it previously, and a backward seek
was used to reposition the IO context.
From now, aviobuf will keep track of the written data, so no explicit seek will
be required till the end of the buffer, or till the end of file before flushing.
This fixes at least one regression, fate-vsynth3-flv was broken if
flush_packets option was set to false, an explicit seek was removed in
4e3cc4bdd8acedbcc703607ed0efbb64bb5c3cc4.
Also from now on, if a forward seek in the write buffer were to cause a gap
between the already written data and the new file position, a flush will
happen.
The must_flush varable is also removed, which might have caused needless
flushes with multiple seeks whithin the write buffer. Since we know the amount
of data written to it, we will know when to flush.
Signed-off-by: Marton Balint <cus@passwd.hu>
2017-06-03 23:15:50 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Maximum reached position before a backward seek in the write buffer,
|
|
|
|
* used keeping track of already written data for a later flush.
|
|
|
|
*/
|
|
|
|
unsigned char *buf_ptr_max;
|
2017-06-18 12:38:39 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Try to buffer at least this amount of data before flushing it
|
|
|
|
*/
|
|
|
|
int min_packet_size;
|
2011-04-09 06:44:14 +00:00
|
|
|
} AVIOContext;
|
|
|
|
|
2014-01-05 01:11:18 +00:00
|
|
|
/**
|
|
|
|
* Return the name of the protocol that will handle the passed URL.
|
|
|
|
*
|
|
|
|
* NULL is returned if no protocol could be found for the given URL.
|
|
|
|
*
|
|
|
|
* @return Name of the protocol or NULL.
|
|
|
|
*/
|
|
|
|
const char *avio_find_protocol_name(const char *url);
|
|
|
|
|
2011-04-08 16:32:25 +00:00
|
|
|
/**
|
2011-04-15 14:42:09 +00:00
|
|
|
* Return AVIO_FLAG_* access flags corresponding to the access permissions
|
2011-04-08 16:32:25 +00:00
|
|
|
* of the resource in url, or a negative value corresponding to an
|
|
|
|
* AVERROR code in case of failure. The returned access flags are
|
|
|
|
* masked by the value in flags.
|
|
|
|
*
|
|
|
|
* @note This function is intrinsically unsafe, in the sense that the
|
|
|
|
* checked resource may change its existence or permission status from
|
|
|
|
* one call to another. Thus you should not trust the returned value,
|
|
|
|
* unless you are sure that no other processes are accessing the
|
|
|
|
* checked resource.
|
|
|
|
*/
|
|
|
|
int avio_check(const char *url, int flags);
|
2011-04-09 06:52:35 +00:00
|
|
|
|
2015-06-17 18:12:00 +00:00
|
|
|
/**
|
|
|
|
* Move or rename a resource.
|
|
|
|
*
|
|
|
|
* @note url_src and url_dst should share the same protocol and authority.
|
|
|
|
*
|
|
|
|
* @param url_src url to resource to be moved
|
|
|
|
* @param url_dst new url to resource if the operation succeeded
|
|
|
|
* @return >=0 on success or negative on error.
|
|
|
|
*/
|
2015-06-23 16:24:57 +00:00
|
|
|
int avpriv_io_move(const char *url_src, const char *url_dst);
|
2015-06-17 18:12:00 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Delete a resource.
|
|
|
|
*
|
|
|
|
* @param url resource to be deleted.
|
|
|
|
* @return >=0 on success or negative on error.
|
|
|
|
*/
|
2015-06-23 16:24:57 +00:00
|
|
|
int avpriv_io_delete(const char *url);
|
2015-06-17 18:12:00 +00:00
|
|
|
|
2014-07-05 16:11:59 +00:00
|
|
|
/**
|
|
|
|
* Open directory for reading.
|
|
|
|
*
|
|
|
|
* @param s directory read context. Pointer to a NULL pointer must be passed.
|
|
|
|
* @param url directory to be listed.
|
|
|
|
* @param options A dictionary filled with protocol-private options. On return
|
|
|
|
* this parameter will be destroyed and replaced with a dictionary
|
|
|
|
* containing options that were not found. May be NULL.
|
|
|
|
* @return >=0 on success or negative on error.
|
|
|
|
*/
|
|
|
|
int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get next directory entry.
|
|
|
|
*
|
|
|
|
* Returned entry must be freed with avio_free_directory_entry(). In particular
|
|
|
|
* it may outlive AVIODirContext.
|
|
|
|
*
|
|
|
|
* @param s directory read context.
|
|
|
|
* @param[out] next next entry or NULL when no more entries.
|
2015-03-27 20:17:30 +00:00
|
|
|
* @return >=0 on success or negative on error. End of list is not considered an
|
|
|
|
* error.
|
2014-07-05 16:11:59 +00:00
|
|
|
*/
|
|
|
|
int avio_read_dir(AVIODirContext *s, AVIODirEntry **next);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Close directory.
|
|
|
|
*
|
|
|
|
* @note Entries created using avio_read_dir() are not deleted and must be
|
|
|
|
* freeded with avio_free_directory_entry().
|
|
|
|
*
|
|
|
|
* @param s directory read context.
|
|
|
|
* @return >=0 on success or negative on error.
|
|
|
|
*/
|
|
|
|
int avio_close_dir(AVIODirContext **s);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Free entry allocated by avio_read_dir().
|
|
|
|
*
|
|
|
|
* @param entry entry to be freed.
|
|
|
|
*/
|
|
|
|
void avio_free_directory_entry(AVIODirEntry **entry);
|
|
|
|
|
2011-03-31 11:57:48 +00:00
|
|
|
/**
|
|
|
|
* Allocate and initialize an AVIOContext for buffered I/O. It must be later
|
2017-09-01 15:26:28 +00:00
|
|
|
* freed with avio_context_free().
|
2011-03-31 11:57:48 +00:00
|
|
|
*
|
|
|
|
* @param buffer Memory block for input/output operations via AVIOContext.
|
2011-05-14 09:34:28 +00:00
|
|
|
* The buffer must be allocated with av_malloc() and friends.
|
2014-11-25 08:35:29 +00:00
|
|
|
* It may be freed and replaced with a new buffer by libavformat.
|
|
|
|
* AVIOContext.buffer holds the buffer currently in use,
|
|
|
|
* which must be later freed with av_free().
|
2011-03-31 11:57:48 +00:00
|
|
|
* @param buffer_size The buffer size is very important for performance.
|
|
|
|
* For protocols with fixed blocksize it should be set to this blocksize.
|
|
|
|
* For others a typical size is a cache page, e.g. 4kb.
|
|
|
|
* @param write_flag Set to 1 if the buffer should be writable, 0 otherwise.
|
|
|
|
* @param opaque An opaque pointer to user-specific data.
|
|
|
|
* @param read_packet A function for refilling the buffer, may be NULL.
|
2017-10-27 18:46:28 +00:00
|
|
|
* For stream protocols, must never return 0 but rather
|
|
|
|
* a proper AVERROR code.
|
2011-03-31 11:57:48 +00:00
|
|
|
* @param write_packet A function for writing the buffer contents, may be NULL.
|
2012-07-27 23:15:48 +00:00
|
|
|
* The function may not change the input buffers content.
|
2011-03-31 11:57:48 +00:00
|
|
|
* @param seek A function for seeking to specified byte position, may be NULL.
|
|
|
|
*
|
|
|
|
* @return Allocated AVIOContext or NULL on failure.
|
|
|
|
*/
|
2011-02-20 14:03:29 +00:00
|
|
|
AVIOContext *avio_alloc_context(
|
2007-12-22 16:18:07 +00:00
|
|
|
unsigned char *buffer,
|
|
|
|
int buffer_size,
|
|
|
|
int write_flag,
|
|
|
|
void *opaque,
|
2003-02-11 16:35:48 +00:00
|
|
|
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
|
2004-10-08 20:09:52 +00:00
|
|
|
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t (*seek)(void *opaque, int64_t offset, int whence));
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2017-08-27 16:26:58 +00:00
|
|
|
/**
|
|
|
|
* Free the supplied IO context and everything associated with it.
|
|
|
|
*
|
|
|
|
* @param s Double pointer to the IO context. This function will write NULL
|
|
|
|
* into s.
|
|
|
|
*/
|
|
|
|
void avio_context_free(AVIOContext **s);
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_w8(AVIOContext *s, int b);
|
|
|
|
void avio_write(AVIOContext *s, const unsigned char *buf, int size);
|
|
|
|
void avio_wl64(AVIOContext *s, uint64_t val);
|
|
|
|
void avio_wb64(AVIOContext *s, uint64_t val);
|
|
|
|
void avio_wl32(AVIOContext *s, unsigned int val);
|
|
|
|
void avio_wb32(AVIOContext *s, unsigned int val);
|
|
|
|
void avio_wl24(AVIOContext *s, unsigned int val);
|
|
|
|
void avio_wb24(AVIOContext *s, unsigned int val);
|
|
|
|
void avio_wl16(AVIOContext *s, unsigned int val);
|
|
|
|
void avio_wb16(AVIOContext *s, unsigned int val);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2011-01-21 19:18:07 +00:00
|
|
|
/**
|
|
|
|
* Write a NULL-terminated string.
|
|
|
|
* @return number of bytes written.
|
|
|
|
*/
|
2011-02-20 10:04:12 +00:00
|
|
|
int avio_put_str(AVIOContext *s, const char *str);
|
2002-09-12 02:26:58 +00:00
|
|
|
|
2011-01-21 19:18:08 +00:00
|
|
|
/**
|
|
|
|
* Convert an UTF-8 string to UTF-16LE and write it.
|
2015-06-05 21:21:18 +00:00
|
|
|
* @param s the AVIOContext
|
|
|
|
* @param str NULL-terminated UTF-8 string
|
|
|
|
*
|
2011-01-21 19:18:08 +00:00
|
|
|
* @return number of bytes written.
|
|
|
|
*/
|
2011-02-20 10:04:12 +00:00
|
|
|
int avio_put_str16le(AVIOContext *s, const char *str);
|
2011-01-21 19:18:08 +00:00
|
|
|
|
2015-03-03 04:06:13 +00:00
|
|
|
/**
|
|
|
|
* Convert an UTF-8 string to UTF-16BE and write it.
|
2015-06-05 21:21:18 +00:00
|
|
|
* @param s the AVIOContext
|
|
|
|
* @param str NULL-terminated UTF-8 string
|
|
|
|
*
|
2015-03-03 04:06:13 +00:00
|
|
|
* @return number of bytes written.
|
|
|
|
*/
|
|
|
|
int avio_put_str16be(AVIOContext *s, const char *str);
|
|
|
|
|
2016-05-04 14:18:35 +00:00
|
|
|
/**
|
|
|
|
* Mark the written bytestream as a specific type.
|
|
|
|
*
|
|
|
|
* Zero-length ranges are omitted from the output.
|
|
|
|
*
|
|
|
|
* @param time the stream time the current bytestream pos corresponds to
|
|
|
|
* (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not
|
|
|
|
* applicable
|
|
|
|
* @param type the kind of data written starting at the current pos
|
|
|
|
*/
|
|
|
|
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type);
|
|
|
|
|
2011-03-31 15:26:09 +00:00
|
|
|
/**
|
2016-04-27 17:45:23 +00:00
|
|
|
* ORing this as the "whence" parameter to a seek function causes it to
|
2011-03-31 15:26:09 +00:00
|
|
|
* return the filesize without seeking anywhere. Supporting this is optional.
|
|
|
|
* If it is not supported then the seek function will return <0.
|
|
|
|
*/
|
|
|
|
#define AVSEEK_SIZE 0x10000
|
|
|
|
|
|
|
|
/**
|
2016-04-27 17:45:23 +00:00
|
|
|
* Passing this flag as the "whence" parameter to a seek function causes it to
|
2013-03-14 22:36:30 +00:00
|
|
|
* seek by any means (like reopening and linear reading) or other normally unreasonable
|
|
|
|
* means that can be extremely slow.
|
2011-03-31 15:26:09 +00:00
|
|
|
* This may be ignored by the seek code.
|
|
|
|
*/
|
|
|
|
#define AVSEEK_FORCE 0x20000
|
|
|
|
|
2008-03-21 11:27:07 +00:00
|
|
|
/**
|
2011-02-20 10:04:12 +00:00
|
|
|
* fseek() equivalent for AVIOContext.
|
2008-03-21 11:27:07 +00:00
|
|
|
* @return new position or AVERROR.
|
|
|
|
*/
|
2011-02-28 13:57:54 +00:00
|
|
|
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence);
|
2008-03-21 11:27:07 +00:00
|
|
|
|
2011-03-11 11:24:53 +00:00
|
|
|
/**
|
|
|
|
* Skip given number of bytes forward
|
|
|
|
* @return new position or AVERROR.
|
|
|
|
*/
|
|
|
|
int64_t avio_skip(AVIOContext *s, int64_t offset);
|
|
|
|
|
2008-03-21 11:27:07 +00:00
|
|
|
/**
|
2011-02-20 10:04:12 +00:00
|
|
|
* ftell() equivalent for AVIOContext.
|
2008-03-21 11:27:07 +00:00
|
|
|
* @return position or AVERROR.
|
|
|
|
*/
|
2011-03-14 19:39:01 +00:00
|
|
|
static av_always_inline int64_t avio_tell(AVIOContext *s)
|
|
|
|
{
|
|
|
|
return avio_seek(s, 0, SEEK_CUR);
|
|
|
|
}
|
2008-03-21 11:27:07 +00:00
|
|
|
|
|
|
|
/**
|
2010-06-30 15:38:06 +00:00
|
|
|
* Get the filesize.
|
2008-03-21 11:27:07 +00:00
|
|
|
* @return filesize or AVERROR
|
|
|
|
*/
|
2011-03-04 18:57:36 +00:00
|
|
|
int64_t avio_size(AVIOContext *s);
|
2008-03-21 11:27:07 +00:00
|
|
|
|
|
|
|
/**
|
2018-12-08 22:05:45 +00:00
|
|
|
* Similar to feof() but also returns nonzero on read errors.
|
|
|
|
* @return non zero if and only if at end of file or a read error happened when reading.
|
2008-03-21 11:27:07 +00:00
|
|
|
*/
|
2014-08-07 20:12:40 +00:00
|
|
|
int avio_feof(AVIOContext *s);
|
2008-03-21 11:27:07 +00:00
|
|
|
|
2015-12-23 23:05:32 +00:00
|
|
|
/** @warning Writes up to 4 KiB per call */
|
2011-06-17 07:31:11 +00:00
|
|
|
int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
|
2007-03-05 13:55:45 +00:00
|
|
|
|
2012-08-15 08:56:20 +00:00
|
|
|
/**
|
2014-09-30 16:46:48 +00:00
|
|
|
* Force flushing of buffered data.
|
2012-08-15 08:56:20 +00:00
|
|
|
*
|
2014-09-30 16:46:48 +00:00
|
|
|
* For write streams, force the buffered data to be immediately written to the output,
|
2012-08-15 08:56:20 +00:00
|
|
|
* without to wait to fill the internal buffer.
|
2014-09-30 16:46:48 +00:00
|
|
|
*
|
|
|
|
* For read streams, discard all currently buffered data, and advance the
|
|
|
|
* reported file position to that of the underlying stream. This does not
|
|
|
|
* read new data, and does not perform any seeks.
|
2012-08-15 08:56:20 +00:00
|
|
|
*/
|
2011-03-14 19:39:06 +00:00
|
|
|
void avio_flush(AVIOContext *s);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2008-03-21 22:17:56 +00:00
|
|
|
/**
|
2011-02-20 10:04:12 +00:00
|
|
|
* Read size bytes from AVIOContext into buf.
|
2010-03-30 15:50:57 +00:00
|
|
|
* @return number of bytes read or AVERROR
|
2008-03-21 22:17:56 +00:00
|
|
|
*/
|
2011-02-21 15:43:01 +00:00
|
|
|
int avio_read(AVIOContext *s, unsigned char *buf, int size);
|
2008-03-21 22:17:56 +00:00
|
|
|
|
2017-08-17 13:01:44 +00:00
|
|
|
/**
|
|
|
|
* Read size bytes from AVIOContext into buf. Unlike avio_read(), this is allowed
|
|
|
|
* to read fewer bytes than requested. The missing bytes can be read in the next
|
|
|
|
* call. This always tries to read at least 1 byte.
|
|
|
|
* Useful to reduce latency in certain cases.
|
|
|
|
* @return number of bytes read or AVERROR
|
|
|
|
*/
|
|
|
|
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size);
|
|
|
|
|
2011-04-09 06:55:53 +00:00
|
|
|
/**
|
2011-07-01 13:32:21 +00:00
|
|
|
* @name Functions for reading from AVIOContext
|
2011-04-09 06:55:53 +00:00
|
|
|
* @{
|
|
|
|
*
|
|
|
|
* @note return 0 if EOF, so you cannot use it if EOF handling is
|
|
|
|
* necessary
|
|
|
|
*/
|
2011-02-21 15:43:01 +00:00
|
|
|
int avio_r8 (AVIOContext *s);
|
|
|
|
unsigned int avio_rl16(AVIOContext *s);
|
|
|
|
unsigned int avio_rl24(AVIOContext *s);
|
|
|
|
unsigned int avio_rl32(AVIOContext *s);
|
|
|
|
uint64_t avio_rl64(AVIOContext *s);
|
2011-04-09 06:55:53 +00:00
|
|
|
unsigned int avio_rb16(AVIOContext *s);
|
|
|
|
unsigned int avio_rb24(AVIOContext *s);
|
|
|
|
unsigned int avio_rb32(AVIOContext *s);
|
|
|
|
uint64_t avio_rb64(AVIOContext *s);
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2011-03-03 12:51:55 +00:00
|
|
|
/**
|
|
|
|
* Read a string from pb into buf. The reading will terminate when either
|
|
|
|
* a NULL character was encountered, maxlen bytes have been read, or nothing
|
|
|
|
* more can be read from pb. The result is guaranteed to be NULL-terminated, it
|
|
|
|
* will be truncated if buf is too small.
|
|
|
|
* Note that the string is not interpreted or validated in any way, it
|
|
|
|
* might get truncated in the middle of a sequence for multi-byte encodings.
|
|
|
|
*
|
|
|
|
* @return number of bytes read (is always <= maxlen).
|
|
|
|
* If reading ends on EOF or error, the return value will be one more than
|
|
|
|
* bytes actually read.
|
|
|
|
*/
|
|
|
|
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen);
|
|
|
|
|
2011-01-23 11:38:27 +00:00
|
|
|
/**
|
|
|
|
* Read a UTF-16 string from pb and convert it to UTF-8.
|
|
|
|
* The reading will terminate when either a null or invalid character was
|
|
|
|
* encountered or maxlen bytes have been read.
|
|
|
|
* @return number of bytes read (is always <= maxlen)
|
|
|
|
*/
|
2011-02-20 10:04:12 +00:00
|
|
|
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen);
|
|
|
|
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
|
2011-01-23 11:38:27 +00:00
|
|
|
|
2007-03-05 13:55:45 +00:00
|
|
|
|
2011-04-04 18:11:19 +00:00
|
|
|
/**
|
2011-07-01 13:32:21 +00:00
|
|
|
* @name URL open modes
|
2011-04-04 18:11:19 +00:00
|
|
|
* The flags argument to avio_open must be one of the following
|
|
|
|
* constants, optionally ORed with other flags.
|
|
|
|
* @{
|
|
|
|
*/
|
2011-04-15 14:42:09 +00:00
|
|
|
#define AVIO_FLAG_READ 1 /**< read-only */
|
|
|
|
#define AVIO_FLAG_WRITE 2 /**< write-only */
|
|
|
|
#define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE) /**< read-write pseudo flag */
|
2011-04-04 18:11:19 +00:00
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Use non-blocking mode.
|
|
|
|
* If this flag is set, operations on the context will return
|
|
|
|
* AVERROR(EAGAIN) if they can not be performed immediately.
|
|
|
|
* If this flag is not set, operations on the context will never return
|
|
|
|
* AVERROR(EAGAIN).
|
|
|
|
* Note that this flag does not affect the opening/connecting of the
|
|
|
|
* context. Connecting a protocol will always block if necessary (e.g. on
|
|
|
|
* network protocols) but never hang (e.g. on busy devices).
|
|
|
|
* Warning: non-blocking protocols is work-in-progress; this flag may be
|
|
|
|
* silently ignored.
|
|
|
|
*/
|
2011-04-13 05:35:35 +00:00
|
|
|
#define AVIO_FLAG_NONBLOCK 8
|
2011-04-04 18:11:19 +00:00
|
|
|
|
2012-03-25 09:58:55 +00:00
|
|
|
/**
|
|
|
|
* Use direct mode.
|
|
|
|
* avio_read and avio_write should if possible be satisfied directly
|
|
|
|
* instead of going through a buffer, and avio_seek will always
|
|
|
|
* call the underlying seek function directly.
|
|
|
|
*/
|
|
|
|
#define AVIO_FLAG_DIRECT 0x8000
|
|
|
|
|
2010-02-09 18:59:34 +00:00
|
|
|
/**
|
2011-02-20 10:04:12 +00:00
|
|
|
* Create and initialize a AVIOContext for accessing the
|
2010-02-09 18:59:34 +00:00
|
|
|
* resource indicated by url.
|
|
|
|
* @note When the resource indicated by url has been opened in
|
2011-02-20 10:04:12 +00:00
|
|
|
* read+write mode, the AVIOContext can be used only for writing.
|
2010-02-09 18:59:34 +00:00
|
|
|
*
|
2011-02-20 10:04:12 +00:00
|
|
|
* @param s Used to return the pointer to the created AVIOContext.
|
2010-02-09 18:59:34 +00:00
|
|
|
* In case of failure the pointed to value is set to NULL.
|
2014-02-16 22:36:31 +00:00
|
|
|
* @param url resource to access
|
2010-02-09 18:59:34 +00:00
|
|
|
* @param flags flags which control how the resource indicated by url
|
|
|
|
* is to be opened
|
2013-09-15 13:25:09 +00:00
|
|
|
* @return >= 0 in case of success, a negative value corresponding to an
|
2010-02-09 18:59:34 +00:00
|
|
|
* AVERROR code in case of failure
|
|
|
|
*/
|
2011-02-21 21:45:20 +00:00
|
|
|
int avio_open(AVIOContext **s, const char *url, int flags);
|
2010-02-09 18:59:34 +00:00
|
|
|
|
2011-11-06 21:03:45 +00:00
|
|
|
/**
|
|
|
|
* Create and initialize a AVIOContext for accessing the
|
|
|
|
* resource indicated by url.
|
|
|
|
* @note When the resource indicated by url has been opened in
|
|
|
|
* read+write mode, the AVIOContext can be used only for writing.
|
|
|
|
*
|
|
|
|
* @param s Used to return the pointer to the created AVIOContext.
|
|
|
|
* In case of failure the pointed to value is set to NULL.
|
2014-02-16 22:36:31 +00:00
|
|
|
* @param url resource to access
|
2011-11-06 21:03:45 +00:00
|
|
|
* @param flags flags which control how the resource indicated by url
|
|
|
|
* is to be opened
|
|
|
|
* @param int_cb an interrupt callback to be used at the protocols level
|
|
|
|
* @param options A dictionary filled with protocol-private options. On return
|
|
|
|
* this parameter will be destroyed and replaced with a dict containing options
|
|
|
|
* that were not found. May be NULL.
|
2013-09-15 13:25:09 +00:00
|
|
|
* @return >= 0 in case of success, a negative value corresponding to an
|
2011-11-06 21:03:45 +00:00
|
|
|
* AVERROR code in case of failure
|
|
|
|
*/
|
|
|
|
int avio_open2(AVIOContext **s, const char *url, int flags,
|
|
|
|
const AVIOInterruptCB *int_cb, AVDictionary **options);
|
|
|
|
|
2007-03-05 15:18:50 +00:00
|
|
|
/**
|
2011-04-09 10:43:51 +00:00
|
|
|
* Close the resource accessed by the AVIOContext s and free it.
|
|
|
|
* This function can only be used if s was opened by avio_open().
|
|
|
|
*
|
2012-08-15 23:25:05 +00:00
|
|
|
* The internal buffer is automatically flushed before closing the
|
|
|
|
* resource.
|
|
|
|
*
|
2011-04-09 10:43:51 +00:00
|
|
|
* @return 0 on success, an AVERROR < 0 on error.
|
2012-10-09 23:39:06 +00:00
|
|
|
* @see avio_closep
|
2007-03-05 13:55:45 +00:00
|
|
|
*/
|
2011-02-21 21:45:20 +00:00
|
|
|
int avio_close(AVIOContext *s);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2012-10-09 23:39:06 +00:00
|
|
|
/**
|
|
|
|
* Close the resource accessed by the AVIOContext *s, free it
|
|
|
|
* and set the pointer pointing to it to NULL.
|
|
|
|
* This function can only be used if s was opened by avio_open().
|
|
|
|
*
|
|
|
|
* The internal buffer is automatically flushed before closing the
|
|
|
|
* resource.
|
|
|
|
*
|
|
|
|
* @return 0 on success, an AVERROR < 0 on error.
|
|
|
|
* @see avio_close
|
|
|
|
*/
|
|
|
|
int avio_closep(AVIOContext **s);
|
|
|
|
|
|
|
|
|
2007-03-05 15:18:50 +00:00
|
|
|
/**
|
2007-03-05 13:55:45 +00:00
|
|
|
* Open a write only memory stream.
|
|
|
|
*
|
|
|
|
* @param s new IO context
|
|
|
|
* @return zero if no error.
|
|
|
|
*/
|
2011-03-17 07:13:34 +00:00
|
|
|
int avio_open_dyn_buf(AVIOContext **s);
|
2007-03-05 13:55:45 +00:00
|
|
|
|
2017-01-05 00:33:26 +00:00
|
|
|
/**
|
|
|
|
* Return the written size and a pointer to the buffer.
|
|
|
|
* The AVIOContext stream is left intact.
|
|
|
|
* The buffer must NOT be freed.
|
|
|
|
* No padding is added to the buffer.
|
|
|
|
*
|
|
|
|
* @param s IO context
|
|
|
|
* @param pbuffer pointer to a byte buffer
|
|
|
|
* @return the length of the byte buffer
|
|
|
|
*/
|
|
|
|
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
|
|
|
|
|
2007-03-05 15:18:50 +00:00
|
|
|
/**
|
2007-03-05 13:55:45 +00:00
|
|
|
* Return the written size and a pointer to the buffer. The buffer
|
2011-03-17 07:19:54 +00:00
|
|
|
* must be freed with av_free().
|
2015-06-29 21:48:34 +00:00
|
|
|
* Padding of AV_INPUT_BUFFER_PADDING_SIZE is added to the buffer.
|
2010-07-01 20:15:49 +00:00
|
|
|
*
|
2007-03-05 13:55:45 +00:00
|
|
|
* @param s IO context
|
2007-11-15 11:44:15 +00:00
|
|
|
* @param pbuffer pointer to a byte buffer
|
2007-03-05 13:55:45 +00:00
|
|
|
* @return the length of the byte buffer
|
|
|
|
*/
|
2011-03-17 07:16:07 +00:00
|
|
|
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
|
2002-07-24 17:49:11 +00:00
|
|
|
|
2011-04-04 06:18:54 +00:00
|
|
|
/**
|
|
|
|
* Iterate through names of available protocols.
|
|
|
|
*
|
|
|
|
* @param opaque A private pointer representing current protocol.
|
|
|
|
* It must be a pointer to NULL on first iteration and will
|
|
|
|
* be updated by successive calls to avio_enum_protocols.
|
|
|
|
* @param output If set to 1, iterate over output protocols,
|
|
|
|
* otherwise over input protocols.
|
|
|
|
*
|
|
|
|
* @return A static string containing the name of current protocol or NULL
|
|
|
|
*/
|
|
|
|
const char *avio_enum_protocols(void **opaque, int output);
|
|
|
|
|
2011-04-12 07:37:10 +00:00
|
|
|
/**
|
|
|
|
* Pause and resume playing - only meaningful if using a network streaming
|
|
|
|
* protocol (e.g. MMS).
|
2014-02-16 22:36:31 +00:00
|
|
|
*
|
|
|
|
* @param h IO context from which to call the read_pause function pointer
|
2011-04-12 07:37:10 +00:00
|
|
|
* @param pause 1 for pause, 0 for resume
|
|
|
|
*/
|
|
|
|
int avio_pause(AVIOContext *h, int pause);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Seek to a given timestamp relative to some component stream.
|
|
|
|
* Only meaningful if using a network streaming protocol (e.g. MMS.).
|
2014-02-16 22:36:31 +00:00
|
|
|
*
|
|
|
|
* @param h IO context from which to call the seek function pointers
|
2011-04-12 07:37:10 +00:00
|
|
|
* @param stream_index The stream index that the timestamp is relative to.
|
|
|
|
* If stream_index is (-1) the timestamp should be in AV_TIME_BASE
|
|
|
|
* units from the beginning of the presentation.
|
|
|
|
* If a stream_index >= 0 is used and the protocol does not support
|
2011-12-21 03:52:34 +00:00
|
|
|
* seeking based on component streams, the call will fail.
|
2011-04-12 07:37:10 +00:00
|
|
|
* @param timestamp timestamp in AVStream.time_base units
|
|
|
|
* or if there is no stream specified then in AV_TIME_BASE units.
|
|
|
|
* @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE
|
|
|
|
* and AVSEEK_FLAG_ANY. The protocol may silently ignore
|
|
|
|
* AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will
|
2011-12-21 03:52:34 +00:00
|
|
|
* fail if used and not supported.
|
2011-04-12 07:37:10 +00:00
|
|
|
* @return >= 0 on success
|
|
|
|
* @see AVInputFormat::read_seek
|
|
|
|
*/
|
|
|
|
int64_t avio_seek_time(AVIOContext *h, int stream_index,
|
|
|
|
int64_t timestamp, int flags);
|
|
|
|
|
2014-08-09 13:51:04 +00:00
|
|
|
/* Avoid a warning. The header can not be included because it breaks c++. */
|
|
|
|
struct AVBPrint;
|
|
|
|
|
2014-07-23 13:12:38 +00:00
|
|
|
/**
|
|
|
|
* Read contents of h into print buffer, up to max_size bytes, or up to EOF.
|
|
|
|
*
|
|
|
|
* @return 0 for success (max_size bytes read or EOF reached), negative error
|
|
|
|
* code otherwise
|
|
|
|
*/
|
2014-07-24 07:34:10 +00:00
|
|
|
int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size);
|
2014-07-23 13:12:38 +00:00
|
|
|
|
2015-07-03 00:25:51 +00:00
|
|
|
/**
|
|
|
|
* Accept and allocate a client context on a server context.
|
|
|
|
* @param s the server context
|
|
|
|
* @param c the client context, must be unallocated
|
|
|
|
* @return >= 0 on success or a negative value corresponding
|
|
|
|
* to an AVERROR on failure
|
|
|
|
*/
|
|
|
|
int avio_accept(AVIOContext *s, AVIOContext **c);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Perform one step of the protocol handshake to accept a new client.
|
|
|
|
* This function must be called on a client returned by avio_accept() before
|
|
|
|
* using it as a read/write context.
|
|
|
|
* It is separate from avio_accept() because it may block.
|
|
|
|
* A step of the handshake is defined by places where the application may
|
|
|
|
* decide to change the proceedings.
|
|
|
|
* For example, on a protocol with a request header and a reply header, each
|
|
|
|
* one can constitute a step because the application may use the parameters
|
|
|
|
* from the request to change parameters in the reply; or each individual
|
|
|
|
* chunk of the request can constitute a step.
|
|
|
|
* If the handshake is already finished, avio_handshake() does nothing and
|
|
|
|
* returns 0 immediately.
|
|
|
|
*
|
|
|
|
* @param c the client context to perform the handshake on
|
|
|
|
* @return 0 on a complete and successful handshake
|
|
|
|
* > 0 if the handshake progressed, but is not complete
|
|
|
|
* < 0 for an AVERROR code
|
|
|
|
*/
|
|
|
|
int avio_handshake(AVIOContext *c);
|
2008-08-31 07:39:47 +00:00
|
|
|
#endif /* AVFORMAT_AVIO_H */
|