2001-07-22 14:18:56 +00:00
|
|
|
/*
|
2011-10-30 16:56:57 +00:00
|
|
|
* buffered I/O
|
2002-05-25 22:34:32 +00:00
|
|
|
* Copyright (c) 2000,2001 Fabrice Bellard
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2002-05-25 22:34:32 +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.
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2001-07-22 14:18:56 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2002-05-25 22:34:32 +00:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2002-05-25 22:34:32 +00:00
|
|
|
* 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-01-12 22:43:26 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2001-07-22 14:18:56 +00:00
|
|
|
*/
|
2008-05-09 11:56:36 +00:00
|
|
|
|
2014-07-24 07:34:10 +00:00
|
|
|
#include "libavutil/bprint.h"
|
2008-05-09 11:56:36 +00:00
|
|
|
#include "libavutil/crc.h"
|
2011-11-06 21:03:45 +00:00
|
|
|
#include "libavutil/dict.h"
|
2009-01-16 15:34:37 +00:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2011-11-06 21:03:45 +00:00
|
|
|
#include "libavutil/log.h"
|
|
|
|
#include "libavutil/opt.h"
|
2012-06-15 17:37:03 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2001-07-22 14:18:56 +00:00
|
|
|
#include "avformat.h"
|
2003-02-10 09:35:32 +00:00
|
|
|
#include "avio.h"
|
2011-02-20 10:04:13 +00:00
|
|
|
#include "avio_internal.h"
|
2010-07-09 12:14:33 +00:00
|
|
|
#include "internal.h"
|
2011-03-31 14:25:10 +00:00
|
|
|
#include "url.h"
|
2002-07-24 17:51:50 +00:00
|
|
|
#include <stdarg.h>
|
2001-07-22 14:18:56 +00:00
|
|
|
|
|
|
|
#define IO_BUFFER_SIZE 32768
|
|
|
|
|
2010-07-17 05:26:30 +00:00
|
|
|
/**
|
|
|
|
* Do seeks within this distance ahead of the current buffer by skipping
|
|
|
|
* data instead of calling the protocol seek function, for seekable
|
|
|
|
* protocols.
|
|
|
|
*/
|
|
|
|
#define SHORT_SEEK_THRESHOLD 4096
|
|
|
|
|
2016-03-14 10:38:20 +00:00
|
|
|
typedef struct AVIOInternal {
|
|
|
|
URLContext *h;
|
|
|
|
} AVIOInternal;
|
|
|
|
|
2015-02-27 23:06:28 +00:00
|
|
|
static void *ff_avio_child_next(void *obj, void *prev)
|
2011-11-06 21:03:45 +00:00
|
|
|
{
|
|
|
|
AVIOContext *s = obj;
|
2016-02-19 13:29:10 +00:00
|
|
|
AVIOInternal *internal = s->opaque;
|
|
|
|
return prev ? NULL : internal->h;
|
2011-11-06 21:03:45 +00:00
|
|
|
}
|
|
|
|
|
2015-02-27 23:06:28 +00:00
|
|
|
static const AVClass *ff_avio_child_class_next(const AVClass *prev)
|
2011-11-06 21:03:45 +00:00
|
|
|
{
|
|
|
|
return prev ? NULL : &ffurl_context_class;
|
|
|
|
}
|
|
|
|
|
2016-01-30 01:17:50 +00:00
|
|
|
#define OFFSET(x) offsetof(AVIOContext,x)
|
|
|
|
#define E AV_OPT_FLAG_ENCODING_PARAM
|
|
|
|
#define D AV_OPT_FLAG_DECODING_PARAM
|
2015-02-27 23:06:28 +00:00
|
|
|
static const AVOption ff_avio_options[] = {
|
2016-01-30 01:17:50 +00:00
|
|
|
{"protocol_whitelist", "List of protocols that are allowed to be used", OFFSET(protocol_whitelist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, D },
|
2011-11-06 21:03:45 +00:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
2015-02-27 23:06:28 +00:00
|
|
|
const AVClass ff_avio_class = {
|
2011-11-06 21:03:45 +00:00
|
|
|
.class_name = "AVIOContext",
|
|
|
|
.item_name = av_default_item_name,
|
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
2015-02-27 23:06:28 +00:00
|
|
|
.option = ff_avio_options,
|
|
|
|
.child_next = ff_avio_child_next,
|
|
|
|
.child_class_next = ff_avio_child_class_next,
|
2011-11-06 21:03:45 +00:00
|
|
|
};
|
2012-01-12 12:31:55 +00:00
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static void fill_buffer(AVIOContext *s);
|
|
|
|
static int url_resetbuf(AVIOContext *s, int flags);
|
2006-09-26 17:09:03 +00:00
|
|
|
|
2011-02-20 10:04:13 +00:00
|
|
|
int ffio_init_context(AVIOContext *s,
|
2001-07-22 14:18:56 +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
|
|
|
{
|
2018-02-14 23:56:21 +00:00
|
|
|
memset(s, 0, sizeof(AVIOContext));
|
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
s->buffer = buffer;
|
2014-03-26 22:58:48 +00:00
|
|
|
s->orig_buffer_size =
|
2001-07-22 14:18:56 +00:00
|
|
|
s->buffer_size = buffer_size;
|
2012-12-09 03:15:45 +00:00
|
|
|
s->buf_ptr = buffer;
|
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
|
|
|
s->buf_ptr_max = buffer;
|
2012-12-09 03:15:45 +00:00
|
|
|
s->opaque = opaque;
|
2012-12-09 13:08:01 +00:00
|
|
|
s->direct = 0;
|
2012-12-09 03:15:45 +00:00
|
|
|
|
2011-04-15 14:42:09 +00:00
|
|
|
url_resetbuf(s, write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
|
2012-12-09 03:15:45 +00:00
|
|
|
|
|
|
|
s->write_packet = write_packet;
|
|
|
|
s->read_packet = read_packet;
|
|
|
|
s->seek = seek;
|
|
|
|
s->pos = 0;
|
|
|
|
s->eof_reached = 0;
|
|
|
|
s->error = 0;
|
2013-07-23 09:25:34 +00:00
|
|
|
s->seekable = seek ? AVIO_SEEKABLE_NORMAL : 0;
|
2017-06-18 12:38:39 +00:00
|
|
|
s->min_packet_size = 0;
|
2002-07-24 17:51:50 +00:00
|
|
|
s->max_packet_size = 0;
|
2012-12-09 03:15:45 +00:00
|
|
|
s->update_checksum = NULL;
|
2015-06-02 16:40:53 +00:00
|
|
|
s->short_seek_threshold = SHORT_SEEK_THRESHOLD;
|
2012-12-09 03:15:45 +00:00
|
|
|
|
|
|
|
if (!read_packet && !write_flag) {
|
|
|
|
s->pos = buffer_size;
|
2006-10-20 09:32:48 +00:00
|
|
|
s->buf_end = s->buffer + buffer_size;
|
|
|
|
}
|
2007-11-28 19:46:49 +00:00
|
|
|
s->read_pause = NULL;
|
|
|
|
s->read_seek = NULL;
|
2012-12-09 03:15:45 +00:00
|
|
|
|
2016-05-04 14:18:35 +00:00
|
|
|
s->write_data_type = NULL;
|
|
|
|
s->ignore_boundary_point = 0;
|
|
|
|
s->current_type = AVIO_DATA_MARKER_UNKNOWN;
|
|
|
|
s->last_time = AV_NOPTS_VALUE;
|
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
|
|
|
s->short_seek_get = NULL;
|
2017-04-13 22:49:20 +00:00
|
|
|
s->written = 0;
|
2016-05-04 14:18:35 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
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,
|
|
|
|
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
|
|
|
|
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
|
2008-12-13 13:39:13 +00:00
|
|
|
int64_t (*seek)(void *opaque, int64_t offset, int whence))
|
|
|
|
{
|
2018-02-14 23:56:21 +00:00
|
|
|
AVIOContext *s = av_malloc(sizeof(AVIOContext));
|
2011-05-14 09:27:31 +00:00
|
|
|
if (!s)
|
|
|
|
return NULL;
|
2011-02-20 10:04:13 +00:00
|
|
|
ffio_init_context(s, buffer, buffer_size, write_flag, opaque,
|
2007-12-22 16:18:07 +00:00
|
|
|
read_packet, write_packet, seek);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2017-08-27 16:26:58 +00:00
|
|
|
void avio_context_free(AVIOContext **ps)
|
|
|
|
{
|
|
|
|
av_freep(ps);
|
|
|
|
}
|
|
|
|
|
2012-03-25 09:58:55 +00:00
|
|
|
static void writeout(AVIOContext *s, const uint8_t *data, int len)
|
|
|
|
{
|
2016-06-23 13:27:00 +00:00
|
|
|
if (!s->error) {
|
|
|
|
int ret = 0;
|
|
|
|
if (s->write_data_type)
|
|
|
|
ret = s->write_data_type(s->opaque, (uint8_t *)data,
|
|
|
|
len,
|
|
|
|
s->current_type,
|
|
|
|
s->last_time);
|
|
|
|
else if (s->write_packet)
|
|
|
|
ret = s->write_packet(s->opaque, (uint8_t *)data, len);
|
2012-12-09 13:08:01 +00:00
|
|
|
if (ret < 0) {
|
2012-03-25 09:58:55 +00:00
|
|
|
s->error = ret;
|
2017-04-13 22:49:20 +00:00
|
|
|
} else {
|
|
|
|
if (s->pos + len > s->written)
|
|
|
|
s->written = s->pos + len;
|
2012-03-25 09:58:55 +00:00
|
|
|
}
|
|
|
|
}
|
2016-06-23 13:27:00 +00:00
|
|
|
if (s->current_type == AVIO_DATA_MARKER_SYNC_POINT ||
|
|
|
|
s->current_type == AVIO_DATA_MARKER_BOUNDARY_POINT) {
|
|
|
|
s->current_type = AVIO_DATA_MARKER_UNKNOWN;
|
|
|
|
}
|
|
|
|
s->last_time = AV_NOPTS_VALUE;
|
2013-04-08 11:21:34 +00:00
|
|
|
s->writeout_count ++;
|
2012-03-25 09:58:55 +00:00
|
|
|
s->pos += len;
|
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static void flush_buffer(AVIOContext *s)
|
2001-07-22 14:18:56 +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
|
|
|
s->buf_ptr_max = FFMAX(s->buf_ptr, s->buf_ptr_max);
|
|
|
|
if (s->write_flag && s->buf_ptr_max > s->buffer) {
|
|
|
|
writeout(s, s->buffer, s->buf_ptr_max - s->buffer);
|
2012-12-09 03:15:45 +00:00
|
|
|
if (s->update_checksum) {
|
|
|
|
s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
|
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
|
|
|
s->buf_ptr_max - s->checksum_ptr);
|
2012-12-09 03:15:45 +00:00
|
|
|
s->checksum_ptr = s->buffer;
|
2004-04-05 12:02:10 +00:00
|
|
|
}
|
2001-07-22 14:18:56 +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
|
|
|
s->buf_ptr = s->buf_ptr_max = s->buffer;
|
2014-09-30 16:46:48 +00:00
|
|
|
if (!s->write_flag)
|
|
|
|
s->buf_end = s->buffer;
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_w8(AVIOContext *s, int b)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2012-10-15 14:02:14 +00:00
|
|
|
av_assert2(b>=-128 && b<=255);
|
2012-01-07 18:07:42 +00:00
|
|
|
*s->buf_ptr++ = b;
|
2005-12-17 18:14:38 +00:00
|
|
|
if (s->buf_ptr >= s->buf_end)
|
2001-07-22 14:18:56 +00:00
|
|
|
flush_buffer(s);
|
|
|
|
}
|
|
|
|
|
2011-02-21 19:02:20 +00:00
|
|
|
void ffio_fill(AVIOContext *s, int b, int count)
|
2011-01-02 10:45:07 +00:00
|
|
|
{
|
|
|
|
while (count > 0) {
|
|
|
|
int len = FFMIN(s->buf_end - s->buf_ptr, count);
|
|
|
|
memset(s->buf_ptr, b, len);
|
|
|
|
s->buf_ptr += len;
|
|
|
|
|
|
|
|
if (s->buf_ptr >= s->buf_end)
|
|
|
|
flush_buffer(s);
|
|
|
|
|
|
|
|
count -= len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2012-03-25 09:58:55 +00:00
|
|
|
if (s->direct && !s->update_checksum) {
|
|
|
|
avio_flush(s);
|
|
|
|
writeout(s, buf, size);
|
|
|
|
return;
|
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
while (size > 0) {
|
2009-10-12 16:38:08 +00:00
|
|
|
int len = FFMIN(s->buf_end - s->buf_ptr, size);
|
2001-07-22 14:18:56 +00:00
|
|
|
memcpy(s->buf_ptr, buf, len);
|
|
|
|
s->buf_ptr += len;
|
|
|
|
|
2005-12-17 18:14:38 +00:00
|
|
|
if (s->buf_ptr >= s->buf_end)
|
2001-07-22 14:18:56 +00:00
|
|
|
flush_buffer(s);
|
|
|
|
|
|
|
|
buf += len;
|
|
|
|
size -= len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-14 19:39:06 +00:00
|
|
|
void avio_flush(AVIOContext *s)
|
2001-07-22 14:18:56 +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
|
|
|
int seekback = s->write_flag ? FFMIN(0, s->buf_ptr - s->buf_ptr_max) : 0;
|
2001-07-22 14:18:56 +00:00
|
|
|
flush_buffer(s);
|
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
|
|
|
if (seekback)
|
|
|
|
avio_seek(s, seekback, SEEK_CUR);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-28 13:57:54 +00:00
|
|
|
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t offset1;
|
|
|
|
int64_t pos;
|
2010-03-24 10:41:58 +00:00
|
|
|
int force = whence & AVSEEK_FORCE;
|
2014-03-01 21:55:37 +00:00
|
|
|
int buffer_size;
|
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
|
|
|
int short_seek;
|
2010-03-24 10:41:58 +00:00
|
|
|
whence &= ~AVSEEK_FORCE;
|
2007-11-21 07:41:00 +00:00
|
|
|
|
|
|
|
if(!s)
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
2019-07-19 12:21:49 +00:00
|
|
|
if ((whence & AVSEEK_SIZE))
|
|
|
|
return s->seek ? s->seek(s->opaque, offset, AVSEEK_SIZE) : AVERROR(ENOSYS);
|
|
|
|
|
2014-03-01 21:55:37 +00:00
|
|
|
buffer_size = s->buf_end - s->buffer;
|
2015-11-16 02:02:11 +00:00
|
|
|
// pos is the absolute position that the beginning of s->buffer corresponds to in the file
|
2014-03-01 21:55:37 +00:00
|
|
|
pos = s->pos - (s->write_flag ? 0 : buffer_size);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
|
|
|
if (whence != SEEK_CUR && whence != SEEK_SET)
|
2007-02-13 18:26:14 +00:00
|
|
|
return AVERROR(EINVAL);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2006-09-22 10:03:04 +00:00
|
|
|
if (whence == SEEK_CUR) {
|
|
|
|
offset1 = pos + (s->buf_ptr - s->buffer);
|
|
|
|
if (offset == 0)
|
|
|
|
return offset1;
|
2017-08-20 18:56:47 +00:00
|
|
|
if (offset > INT64_MAX - offset1)
|
|
|
|
return AVERROR(EINVAL);
|
2006-09-22 10:03:04 +00:00
|
|
|
offset += offset1;
|
|
|
|
}
|
2014-12-14 16:26:11 +00:00
|
|
|
if (offset < 0)
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
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
|
|
|
if (s->short_seek_get) {
|
|
|
|
short_seek = s->short_seek_get(s->opaque);
|
|
|
|
/* fallback to default short seek */
|
|
|
|
if (short_seek <= 0)
|
|
|
|
short_seek = s->short_seek_threshold;
|
|
|
|
} else
|
|
|
|
short_seek = s->short_seek_threshold;
|
|
|
|
|
2015-11-16 02:02:11 +00:00
|
|
|
offset1 = offset - pos; // "offset1" is the relative offset from the beginning of s->buffer
|
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
|
|
|
s->buf_ptr_max = FFMAX(s->buf_ptr_max, s->buf_ptr);
|
|
|
|
if ((!s->direct || !s->seek) &&
|
|
|
|
offset1 >= 0 && offset1 <= (s->write_flag ? s->buf_ptr_max - s->buffer : buffer_size)) {
|
2006-09-22 10:03:04 +00:00
|
|
|
/* can do the seek inside the buffer */
|
|
|
|
s->buf_ptr = s->buffer + offset1;
|
2016-09-27 14:26:37 +00:00
|
|
|
} else if ((!(s->seekable & AVIO_SEEKABLE_NORMAL) ||
|
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
|
|
|
offset1 <= buffer_size + short_seek) &&
|
2010-07-17 05:26:30 +00:00
|
|
|
!s->write_flag && offset1 >= 0 &&
|
2012-03-25 09:58:55 +00:00
|
|
|
(!s->direct || !s->seek) &&
|
2010-04-08 09:47:32 +00:00
|
|
|
(whence != SEEK_END || force)) {
|
2006-09-26 17:09:03 +00:00
|
|
|
while(s->pos < offset && !s->eof_reached)
|
|
|
|
fill_buffer(s);
|
2007-12-16 17:52:46 +00:00
|
|
|
if (s->eof_reached)
|
2010-03-18 00:22:58 +00:00
|
|
|
return AVERROR_EOF;
|
2015-11-16 02:02:11 +00:00
|
|
|
s->buf_ptr = s->buf_end - (s->pos - offset);
|
2014-03-01 22:09:40 +00:00
|
|
|
} else if(!s->write_flag && offset1 < 0 && -offset1 < buffer_size>>1 && s->seek && offset > 0) {
|
2010-04-21 21:19:25 +00:00
|
|
|
int64_t res;
|
2007-01-30 10:48:39 +00:00
|
|
|
|
2014-03-01 22:09:40 +00:00
|
|
|
pos -= FFMIN(buffer_size>>1, pos);
|
|
|
|
if ((res = s->seek(s->opaque, pos, SEEK_SET)) < 0)
|
|
|
|
return res;
|
|
|
|
s->buf_end =
|
|
|
|
s->buf_ptr = s->buffer;
|
|
|
|
s->pos = pos;
|
|
|
|
s->eof_reached = 0;
|
|
|
|
fill_buffer(s);
|
|
|
|
return avio_seek(s, offset, SEEK_SET | force);
|
|
|
|
} else {
|
|
|
|
int64_t res;
|
2006-09-22 10:03:04 +00:00
|
|
|
if (s->write_flag) {
|
2001-07-22 14:18:56 +00:00
|
|
|
flush_buffer(s);
|
|
|
|
}
|
2010-04-21 21:19:25 +00:00
|
|
|
if (!s->seek)
|
|
|
|
return AVERROR(EPIPE);
|
|
|
|
if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
|
2007-01-30 10:48:39 +00:00
|
|
|
return res;
|
2012-06-02 21:01:13 +00:00
|
|
|
s->seek_count ++;
|
2008-07-31 19:40:06 +00:00
|
|
|
if (!s->write_flag)
|
|
|
|
s->buf_end = s->buffer;
|
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
|
|
|
s->buf_ptr = s->buf_ptr_max = s->buffer;
|
2006-09-22 10:03:04 +00:00
|
|
|
s->pos = offset;
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
2006-09-22 10:03:04 +00:00
|
|
|
s->eof_reached = 0;
|
2001-07-22 14:18:56 +00:00
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2011-03-11 11:24:53 +00:00
|
|
|
int64_t avio_skip(AVIOContext *s, int64_t offset)
|
|
|
|
{
|
|
|
|
return avio_seek(s, offset, SEEK_CUR);
|
|
|
|
}
|
|
|
|
|
2011-03-04 18:57:36 +00:00
|
|
|
int64_t avio_size(AVIOContext *s)
|
2005-05-19 00:06:27 +00:00
|
|
|
{
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t size;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
if (!s)
|
2007-11-21 07:41:00 +00:00
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
2016-12-06 01:56:24 +00:00
|
|
|
if (s->written)
|
|
|
|
return s->written;
|
|
|
|
|
2005-05-19 00:06:27 +00:00
|
|
|
if (!s->seek)
|
2010-04-18 17:37:21 +00:00
|
|
|
return AVERROR(ENOSYS);
|
2007-01-01 21:49:09 +00:00
|
|
|
size = s->seek(s->opaque, 0, AVSEEK_SIZE);
|
2012-12-09 03:15:45 +00:00
|
|
|
if (size < 0) {
|
2007-01-28 02:38:02 +00:00
|
|
|
if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0)
|
|
|
|
return size;
|
|
|
|
size++;
|
2007-01-01 21:49:50 +00:00
|
|
|
s->seek(s->opaque, s->pos, SEEK_SET);
|
2007-01-01 21:49:09 +00:00
|
|
|
}
|
2005-05-19 00:06:27 +00:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2014-08-07 20:12:40 +00:00
|
|
|
int avio_feof(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2007-11-21 07:41:00 +00:00
|
|
|
if(!s)
|
|
|
|
return 0;
|
2011-03-10 12:21:52 +00:00
|
|
|
if(s->eof_reached){
|
|
|
|
s->eof_reached=0;
|
|
|
|
fill_buffer(s);
|
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
return s->eof_reached;
|
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_wl32(AVIOContext *s, unsigned int val)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2012-10-15 14:01:55 +00:00
|
|
|
avio_w8(s, (uint8_t) val );
|
|
|
|
avio_w8(s, (uint8_t)(val >> 8 ));
|
|
|
|
avio_w8(s, (uint8_t)(val >> 16));
|
|
|
|
avio_w8(s, val >> 24 );
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_wb32(AVIOContext *s, unsigned int val)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2012-10-15 14:01:55 +00:00
|
|
|
avio_w8(s, val >> 24 );
|
|
|
|
avio_w8(s, (uint8_t)(val >> 16));
|
|
|
|
avio_w8(s, (uint8_t)(val >> 8 ));
|
|
|
|
avio_w8(s, (uint8_t) val );
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
int avio_put_str(AVIOContext *s, const char *str)
|
2011-01-21 19:18:07 +00:00
|
|
|
{
|
|
|
|
int len = 1;
|
|
|
|
if (str) {
|
|
|
|
len += strlen(str);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(s, (const unsigned char *) str, len);
|
2011-01-21 19:18:07 +00:00
|
|
|
} else
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(s, 0);
|
2011-01-21 19:18:07 +00:00
|
|
|
return len;
|
2002-09-12 02:26:58 +00:00
|
|
|
}
|
|
|
|
|
2015-03-03 04:06:13 +00:00
|
|
|
static inline int put_str16(AVIOContext *s, const char *str, const int be)
|
2011-01-21 19:18:08 +00:00
|
|
|
{
|
|
|
|
const uint8_t *q = str;
|
|
|
|
int ret = 0;
|
2013-11-13 17:48:38 +00:00
|
|
|
int err = 0;
|
2011-01-21 19:18:08 +00:00
|
|
|
|
|
|
|
while (*q) {
|
|
|
|
uint32_t ch;
|
|
|
|
uint16_t tmp;
|
|
|
|
|
2013-11-13 17:39:17 +00:00
|
|
|
GET_UTF8(ch, *q++, goto invalid;)
|
2015-03-03 04:06:13 +00:00
|
|
|
PUT_UTF16(ch, tmp, be ? avio_wb16(s, tmp) : avio_wl16(s, tmp);
|
|
|
|
ret += 2;)
|
2013-11-13 17:39:17 +00:00
|
|
|
continue;
|
|
|
|
invalid:
|
2016-07-17 16:10:27 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Invalid UTF8 sequence in avio_put_str16%s\n", be ? "be" : "le");
|
2013-11-13 17:48:38 +00:00
|
|
|
err = AVERROR(EINVAL);
|
2016-01-13 01:31:59 +00:00
|
|
|
if (!*(q-1))
|
|
|
|
break;
|
2011-01-21 19:18:08 +00:00
|
|
|
}
|
2015-03-03 04:06:13 +00:00
|
|
|
if (be)
|
|
|
|
avio_wb16(s, 0);
|
|
|
|
else
|
|
|
|
avio_wl16(s, 0);
|
2013-11-13 17:48:38 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
2011-01-21 19:18:08 +00:00
|
|
|
ret += 2;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-03-03 04:06:13 +00:00
|
|
|
#define PUT_STR16(type, big_endian) \
|
|
|
|
int avio_put_str16 ## type(AVIOContext *s, const char *str) \
|
|
|
|
{ \
|
|
|
|
return put_str16(s, str, big_endian); \
|
|
|
|
}
|
|
|
|
|
|
|
|
PUT_STR16(le, 0)
|
|
|
|
PUT_STR16(be, 1)
|
|
|
|
|
|
|
|
#undef PUT_STR16
|
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
int ff_get_v_length(uint64_t val)
|
|
|
|
{
|
|
|
|
int i = 1;
|
2010-07-09 12:14:33 +00:00
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
while (val >>= 7)
|
2010-07-09 12:14:33 +00:00
|
|
|
i++;
|
|
|
|
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
void ff_put_v(AVIOContext *bc, uint64_t val)
|
|
|
|
{
|
|
|
|
int i = ff_get_v_length(val);
|
2010-07-09 12:14:33 +00:00
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
while (--i > 0)
|
2012-12-09 13:08:01 +00:00
|
|
|
avio_w8(bc, 128 | (uint8_t)(val >> (7*i)));
|
2010-07-09 12:14:33 +00:00
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
avio_w8(bc, val & 127);
|
2010-07-09 12:14:33 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_wl64(AVIOContext *s, uint64_t val)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(s, (uint32_t)(val & 0xffffffff));
|
|
|
|
avio_wl32(s, (uint32_t)(val >> 32));
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_wb64(AVIOContext *s, uint64_t val)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, (uint32_t)(val >> 32));
|
|
|
|
avio_wb32(s, (uint32_t)(val & 0xffffffff));
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_wl16(AVIOContext *s, unsigned int val)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2012-10-15 14:01:55 +00:00
|
|
|
avio_w8(s, (uint8_t)val);
|
|
|
|
avio_w8(s, (int)val >> 8);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_wb16(AVIOContext *s, unsigned int val)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2012-10-15 14:01:55 +00:00
|
|
|
avio_w8(s, (int)val >> 8);
|
|
|
|
avio_w8(s, (uint8_t)val);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_wl24(AVIOContext *s, unsigned int val)
|
2006-02-09 22:52:23 +00:00
|
|
|
{
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(s, val & 0xffff);
|
2012-10-15 14:01:55 +00:00
|
|
|
avio_w8(s, (int)val >> 16);
|
2006-02-09 22:52:23 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
void avio_wb24(AVIOContext *s, unsigned int val)
|
2005-07-19 14:41:08 +00:00
|
|
|
{
|
2012-10-15 14:01:55 +00:00
|
|
|
avio_wb16(s, (int)val >> 8);
|
|
|
|
avio_w8(s, (uint8_t)val);
|
2005-07-19 14:41:08 +00:00
|
|
|
}
|
|
|
|
|
2016-05-04 14:18:35 +00:00
|
|
|
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
|
|
|
|
{
|
2017-06-18 12:38:39 +00:00
|
|
|
if (type == AVIO_DATA_MARKER_FLUSH_POINT) {
|
|
|
|
if (s->buf_ptr - s->buffer >= s->min_packet_size)
|
|
|
|
avio_flush(s);
|
|
|
|
return;
|
|
|
|
}
|
2016-05-04 14:18:35 +00:00
|
|
|
if (!s->write_data_type)
|
|
|
|
return;
|
|
|
|
// If ignoring boundary points, just treat it as unknown
|
|
|
|
if (type == AVIO_DATA_MARKER_BOUNDARY_POINT && s->ignore_boundary_point)
|
|
|
|
type = AVIO_DATA_MARKER_UNKNOWN;
|
|
|
|
// Avoid unnecessary flushes if we are already in non-header/trailer
|
|
|
|
// data and setting the type to unknown
|
|
|
|
if (type == AVIO_DATA_MARKER_UNKNOWN &&
|
|
|
|
(s->current_type != AVIO_DATA_MARKER_HEADER &&
|
|
|
|
s->current_type != AVIO_DATA_MARKER_TRAILER))
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case AVIO_DATA_MARKER_HEADER:
|
|
|
|
case AVIO_DATA_MARKER_TRAILER:
|
|
|
|
// For header/trailer, ignore a new marker of the same type;
|
|
|
|
// consecutive header/trailer markers can be merged.
|
|
|
|
if (type == s->current_type)
|
|
|
|
return;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we've reached here, we have a new, noteworthy marker.
|
|
|
|
// Flush the previous data and mark the start of the new data.
|
|
|
|
avio_flush(s);
|
|
|
|
s->current_type = type;
|
|
|
|
s->last_time = time;
|
|
|
|
}
|
|
|
|
|
2017-10-27 18:46:28 +00:00
|
|
|
static int read_packet_wrapper(AVIOContext *s, uint8_t *buf, int size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!s->read_packet)
|
2017-10-27 18:46:29 +00:00
|
|
|
return AVERROR(EINVAL);
|
2017-10-27 18:46:28 +00:00
|
|
|
ret = s->read_packet(s->opaque, buf, size);
|
|
|
|
#if FF_API_OLD_AVIO_EOF_0
|
|
|
|
if (!ret && !s->max_packet_size) {
|
|
|
|
av_log(NULL, AV_LOG_WARNING, "Invalid return value 0 for stream protocol\n");
|
|
|
|
ret = AVERROR_EOF;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
av_assert2(ret || s->max_packet_size);
|
|
|
|
#endif
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
/* Input stream */
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static void fill_buffer(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2012-12-09 03:15:45 +00:00
|
|
|
int max_buffer_size = s->max_packet_size ?
|
|
|
|
s->max_packet_size : IO_BUFFER_SIZE;
|
2013-06-30 16:15:50 +00:00
|
|
|
uint8_t *dst = s->buf_end - s->buffer + max_buffer_size < s->buffer_size ?
|
|
|
|
s->buf_end : s->buffer;
|
|
|
|
int len = s->buffer_size - (dst - s->buffer);
|
2008-10-18 17:30:37 +00:00
|
|
|
|
2012-07-05 23:38:53 +00:00
|
|
|
/* can't fill the buffer without read_packet, just set EOF if appropriate */
|
2012-01-03 17:11:36 +00:00
|
|
|
if (!s->read_packet && s->buf_ptr >= s->buf_end)
|
|
|
|
s->eof_reached = 1;
|
|
|
|
|
2002-07-24 17:51:50 +00:00
|
|
|
/* no need to do anything if EOF already reached */
|
|
|
|
if (s->eof_reached)
|
|
|
|
return;
|
2004-04-05 12:02:10 +00:00
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
if (s->update_checksum && dst == s->buffer) {
|
|
|
|
if (s->buf_end > s->checksum_ptr)
|
|
|
|
s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
|
|
|
|
s->buf_end - s->checksum_ptr);
|
|
|
|
s->checksum_ptr = s->buffer;
|
2004-04-05 12:02:10 +00:00
|
|
|
}
|
|
|
|
|
2010-04-08 09:02:27 +00:00
|
|
|
/* make buffer smaller in case it ended up large after probing */
|
2019-06-09 20:04:16 +00:00
|
|
|
if (s->read_packet && s->orig_buffer_size && s->buffer_size > s->orig_buffer_size && len >= s->orig_buffer_size) {
|
2017-05-19 18:52:44 +00:00
|
|
|
if (dst == s->buffer && s->buf_ptr != dst) {
|
2015-06-07 12:57:36 +00:00
|
|
|
int ret = ffio_set_buf_size(s, s->orig_buffer_size);
|
|
|
|
if (ret < 0)
|
|
|
|
av_log(s, AV_LOG_WARNING, "Failed to decrease buffer size\n");
|
2010-04-08 09:02:27 +00:00
|
|
|
|
2013-06-30 16:15:50 +00:00
|
|
|
s->checksum_ptr = dst = s->buffer;
|
|
|
|
}
|
2014-03-26 22:58:48 +00:00
|
|
|
len = s->orig_buffer_size;
|
2010-04-08 09:02:27 +00:00
|
|
|
}
|
|
|
|
|
2017-10-27 18:46:28 +00:00
|
|
|
len = read_packet_wrapper(s, dst, len);
|
2017-10-17 08:29:30 +00:00
|
|
|
if (len == AVERROR_EOF) {
|
2002-07-24 17:51:50 +00:00
|
|
|
/* do not modify buffer if EOF reached so that a seek back can
|
|
|
|
be done without rereading data */
|
2001-07-22 14:18:56 +00:00
|
|
|
s->eof_reached = 1;
|
2017-10-17 08:29:30 +00:00
|
|
|
} else if (len < 0) {
|
|
|
|
s->eof_reached = 1;
|
|
|
|
s->error= len;
|
2002-07-24 17:51:50 +00:00
|
|
|
} else {
|
|
|
|
s->pos += len;
|
2008-10-18 17:30:37 +00:00
|
|
|
s->buf_ptr = dst;
|
|
|
|
s->buf_end = dst + len;
|
2012-06-02 21:01:13 +00:00
|
|
|
s->bytes_read += len;
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-13 13:39:13 +00:00
|
|
|
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
2008-01-04 23:09:58 +00:00
|
|
|
return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len);
|
2007-10-30 00:01:25 +00:00
|
|
|
}
|
|
|
|
|
2016-08-04 19:17:09 +00:00
|
|
|
unsigned long ff_crcEDB88320_update(unsigned long checksum, const uint8_t *buf,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
|
|
|
return av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), checksum, buf, len);
|
|
|
|
}
|
|
|
|
|
2014-04-13 12:23:57 +00:00
|
|
|
unsigned long ff_crcA001_update(unsigned long checksum, const uint8_t *buf,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
|
|
|
return av_crc(av_crc_get_table(AV_CRC_16_ANSI_LE), checksum, buf, len);
|
|
|
|
}
|
|
|
|
|
2011-03-17 12:04:38 +00:00
|
|
|
unsigned long ffio_get_checksum(AVIOContext *s)
|
2008-12-13 13:39:13 +00:00
|
|
|
{
|
2012-12-09 03:15:45 +00:00
|
|
|
s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
|
|
|
|
s->buf_ptr - s->checksum_ptr);
|
|
|
|
s->update_checksum = NULL;
|
2004-04-05 12:02:10 +00:00
|
|
|
return s->checksum;
|
|
|
|
}
|
|
|
|
|
2011-03-17 11:56:25 +00:00
|
|
|
void ffio_init_checksum(AVIOContext *s,
|
2008-12-13 13:39:13 +00:00
|
|
|
unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
|
|
|
|
unsigned long checksum)
|
|
|
|
{
|
2012-12-09 03:15:45 +00:00
|
|
|
s->update_checksum = update_checksum;
|
|
|
|
if (s->update_checksum) {
|
|
|
|
s->checksum = checksum;
|
|
|
|
s->checksum_ptr = s->buf_ptr;
|
2004-04-06 17:40:17 +00:00
|
|
|
}
|
2004-04-05 12:02:10 +00:00
|
|
|
}
|
|
|
|
|
2002-07-24 17:51:50 +00:00
|
|
|
/* XXX: put an inline version */
|
2011-02-21 15:43:01 +00:00
|
|
|
int avio_r8(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2010-07-25 14:33:40 +00:00
|
|
|
if (s->buf_ptr >= s->buf_end)
|
2001-07-22 14:18:56 +00:00
|
|
|
fill_buffer(s);
|
2010-07-25 14:35:12 +00:00
|
|
|
if (s->buf_ptr < s->buf_end)
|
|
|
|
return *s->buf_ptr++;
|
|
|
|
return 0;
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
int avio_read(AVIOContext *s, unsigned char *buf, int size)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
|
|
|
int len, size1;
|
|
|
|
|
|
|
|
size1 = size;
|
|
|
|
while (size > 0) {
|
2015-11-16 02:02:11 +00:00
|
|
|
len = FFMIN(s->buf_end - s->buf_ptr, size);
|
2013-01-01 20:57:36 +00:00
|
|
|
if (len == 0 || s->write_flag) {
|
2015-11-16 02:02:11 +00:00
|
|
|
if((s->direct || size > s->buffer_size) && !s->update_checksum) {
|
|
|
|
// bypass the buffer and read data directly into buf
|
2017-10-27 18:46:28 +00:00
|
|
|
len = read_packet_wrapper(s, buf, size);
|
2017-10-17 08:29:30 +00:00
|
|
|
if (len == AVERROR_EOF) {
|
2005-03-24 22:07:54 +00:00
|
|
|
/* do not modify buffer if EOF reached so that a seek back can
|
|
|
|
be done without rereading data */
|
|
|
|
s->eof_reached = 1;
|
2017-10-17 08:29:30 +00:00
|
|
|
break;
|
|
|
|
} else if (len < 0) {
|
|
|
|
s->eof_reached = 1;
|
|
|
|
s->error= len;
|
2005-03-24 22:07:54 +00:00
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
s->pos += len;
|
2012-08-25 21:24:21 +00:00
|
|
|
s->bytes_read += len;
|
2005-03-24 22:07:54 +00:00
|
|
|
size -= len;
|
|
|
|
buf += len;
|
2015-11-16 02:02:11 +00:00
|
|
|
// reset the buffer
|
2005-03-24 22:07:54 +00:00
|
|
|
s->buf_ptr = s->buffer;
|
|
|
|
s->buf_end = s->buffer/* + len*/;
|
|
|
|
}
|
2012-12-09 03:15:45 +00:00
|
|
|
} else {
|
2005-03-24 22:07:54 +00:00
|
|
|
fill_buffer(s);
|
|
|
|
len = s->buf_end - s->buf_ptr;
|
|
|
|
if (len == 0)
|
|
|
|
break;
|
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
} else {
|
|
|
|
memcpy(buf, s->buf_ptr, len);
|
|
|
|
buf += len;
|
|
|
|
s->buf_ptr += len;
|
|
|
|
size -= len;
|
|
|
|
}
|
|
|
|
}
|
2009-10-02 06:36:39 +00:00
|
|
|
if (size1 == size) {
|
2011-03-15 15:18:40 +00:00
|
|
|
if (s->error) return s->error;
|
2014-08-27 20:30:07 +00:00
|
|
|
if (avio_feof(s)) return AVERROR_EOF;
|
2009-10-02 06:36:39 +00:00
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
return size1 - size;
|
|
|
|
}
|
|
|
|
|
2015-05-26 13:24:38 +00:00
|
|
|
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
|
|
|
|
{
|
|
|
|
int ret = avio_read(s, buf, size);
|
|
|
|
if (ret != size)
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-08-07 22:22:38 +00:00
|
|
|
int ffio_read_indirect(AVIOContext *s, unsigned char *buf, int size, const unsigned char **data)
|
2013-07-31 22:46:08 +00:00
|
|
|
{
|
|
|
|
if (s->buf_end - s->buf_ptr >= size && !s->write_flag) {
|
|
|
|
*data = s->buf_ptr;
|
|
|
|
s->buf_ptr += size;
|
|
|
|
return size;
|
|
|
|
} else {
|
|
|
|
*data = buf;
|
|
|
|
return avio_read(s, buf, size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-17 13:01:44 +00:00
|
|
|
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
|
2004-03-15 03:29:32 +00:00
|
|
|
{
|
|
|
|
int len;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
if (size < 0)
|
2005-01-12 00:16:25 +00:00
|
|
|
return -1;
|
2004-03-15 03:29:32 +00:00
|
|
|
|
2013-01-01 20:57:36 +00:00
|
|
|
if (s->read_packet && s->write_flag) {
|
2017-10-27 18:46:28 +00:00
|
|
|
len = read_packet_wrapper(s, buf, size);
|
2013-01-01 20:57:36 +00:00
|
|
|
if (len > 0)
|
|
|
|
s->pos += len;
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2004-03-15 03:29:32 +00:00
|
|
|
len = s->buf_end - s->buf_ptr;
|
|
|
|
if (len == 0) {
|
2013-01-01 22:25:37 +00:00
|
|
|
/* Reset the buf_end pointer to the start of the buffer, to make sure
|
|
|
|
* the fill_buffer call tries to read as much data as fits into the
|
|
|
|
* full buffer, instead of just what space is left after buf_end.
|
|
|
|
* This avoids returning partial packets at the end of the buffer,
|
|
|
|
* for packet based inputs.
|
|
|
|
*/
|
|
|
|
s->buf_end = s->buf_ptr = s->buffer;
|
2004-03-15 03:29:32 +00:00
|
|
|
fill_buffer(s);
|
|
|
|
len = s->buf_end - s->buf_ptr;
|
|
|
|
}
|
|
|
|
if (len > size)
|
|
|
|
len = size;
|
|
|
|
memcpy(buf, s->buf_ptr, len);
|
|
|
|
s->buf_ptr += len;
|
2009-10-02 06:36:39 +00:00
|
|
|
if (!len) {
|
2011-03-15 15:18:40 +00:00
|
|
|
if (s->error) return s->error;
|
2014-08-27 20:30:07 +00:00
|
|
|
if (avio_feof(s)) return AVERROR_EOF;
|
2009-10-02 06:36:39 +00:00
|
|
|
}
|
2004-03-15 03:29:32 +00:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
unsigned int avio_rl16(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
|
|
|
unsigned int val;
|
2011-02-21 15:43:01 +00:00
|
|
|
val = avio_r8(s);
|
|
|
|
val |= avio_r8(s) << 8;
|
2001-07-22 14:18:56 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
unsigned int avio_rl24(AVIOContext *s)
|
2006-02-09 22:52:23 +00:00
|
|
|
{
|
|
|
|
unsigned int val;
|
2011-02-21 15:43:01 +00:00
|
|
|
val = avio_rl16(s);
|
|
|
|
val |= avio_r8(s) << 16;
|
2006-02-09 22:52:23 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
unsigned int avio_rl32(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
|
|
|
unsigned int val;
|
2011-02-21 15:43:01 +00:00
|
|
|
val = avio_rl16(s);
|
|
|
|
val |= avio_rl16(s) << 16;
|
2001-07-22 14:18:56 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
uint64_t avio_rl64(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2003-02-11 16:35:48 +00:00
|
|
|
uint64_t val;
|
2011-02-21 15:43:01 +00:00
|
|
|
val = (uint64_t)avio_rl32(s);
|
|
|
|
val |= (uint64_t)avio_rl32(s) << 32;
|
2001-07-22 14:18:56 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
unsigned int avio_rb16(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
|
|
|
unsigned int val;
|
2011-02-21 15:43:01 +00:00
|
|
|
val = avio_r8(s) << 8;
|
|
|
|
val |= avio_r8(s);
|
2001-07-22 14:18:56 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
unsigned int avio_rb24(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
|
|
|
unsigned int val;
|
2011-02-21 15:43:01 +00:00
|
|
|
val = avio_rb16(s) << 8;
|
|
|
|
val |= avio_r8(s);
|
2001-07-22 14:18:56 +00:00
|
|
|
return val;
|
|
|
|
}
|
2011-02-21 15:43:01 +00:00
|
|
|
unsigned int avio_rb32(AVIOContext *s)
|
2005-07-19 14:41:08 +00:00
|
|
|
{
|
|
|
|
unsigned int val;
|
2011-02-21 15:43:01 +00:00
|
|
|
val = avio_rb16(s) << 16;
|
|
|
|
val |= avio_rb16(s);
|
2005-07-19 14:41:08 +00:00
|
|
|
return val;
|
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
|
2010-07-21 21:39:01 +00:00
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
char c;
|
|
|
|
|
|
|
|
do {
|
2011-02-21 15:43:01 +00:00
|
|
|
c = avio_r8(s);
|
2010-07-21 21:40:10 +00:00
|
|
|
if (c && i < maxlen-1)
|
2010-07-21 21:39:01 +00:00
|
|
|
buf[i++] = c;
|
2014-05-12 22:03:30 +00:00
|
|
|
} while (c != '\n' && c != '\r' && c);
|
2014-12-03 18:05:56 +00:00
|
|
|
if (c == '\r' && avio_r8(s) != '\n' && !avio_feof(s))
|
2014-05-12 22:03:30 +00:00
|
|
|
avio_skip(s, -1);
|
2010-07-21 21:39:01 +00:00
|
|
|
|
|
|
|
buf[i] = 0;
|
2010-07-21 21:40:10 +00:00
|
|
|
return i;
|
2010-07-21 21:39:01 +00:00
|
|
|
}
|
|
|
|
|
2018-04-09 15:05:42 +00:00
|
|
|
int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen)
|
|
|
|
{
|
|
|
|
int len = ff_get_line(s, buf, maxlen);
|
|
|
|
while (len > 0 && av_isspace(buf[len - 1]))
|
|
|
|
buf[--len] = '\0';
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2018-02-03 21:03:58 +00:00
|
|
|
int64_t ff_read_line_to_bprint(AVIOContext *s, AVBPrint *bp)
|
|
|
|
{
|
|
|
|
int len, end;
|
|
|
|
int64_t read = 0;
|
|
|
|
char tmp[1024];
|
|
|
|
char c;
|
|
|
|
|
|
|
|
do {
|
|
|
|
len = 0;
|
|
|
|
do {
|
|
|
|
c = avio_r8(s);
|
|
|
|
end = (c == '\r' || c == '\n' || c == '\0');
|
|
|
|
if (!end)
|
|
|
|
tmp[len++] = c;
|
|
|
|
} while (!end && len < sizeof(tmp));
|
|
|
|
av_bprint_append_data(bp, tmp, len);
|
|
|
|
read += len;
|
|
|
|
} while (!end);
|
|
|
|
|
|
|
|
if (c == '\r' && avio_r8(s) != '\n' && !avio_feof(s))
|
|
|
|
avio_skip(s, -1);
|
|
|
|
|
|
|
|
if (!c && s->error)
|
|
|
|
return s->error;
|
|
|
|
|
|
|
|
if (!c && !read && avio_feof(s))
|
|
|
|
return AVERROR_EOF;
|
|
|
|
|
|
|
|
return read;
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t ff_read_line_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp)
|
|
|
|
{
|
|
|
|
int64_t ret;
|
|
|
|
|
|
|
|
av_bprint_clear(bp);
|
|
|
|
ret = ff_read_line_to_bprint(s, bp);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (!av_bprint_is_complete(bp))
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
|
|
|
return bp->len;
|
|
|
|
}
|
|
|
|
|
2011-03-03 12:51:55 +00:00
|
|
|
int avio_get_str(AVIOContext *s, int maxlen, char *buf, int buflen)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2011-10-15 01:27:59 +00:00
|
|
|
if (buflen <= 0)
|
|
|
|
return AVERROR(EINVAL);
|
2011-03-03 12:51:55 +00:00
|
|
|
// reserve 1 byte for terminating 0
|
|
|
|
buflen = FFMIN(buflen - 1, maxlen);
|
|
|
|
for (i = 0; i < buflen; i++)
|
|
|
|
if (!(buf[i] = avio_r8(s)))
|
|
|
|
return i + 1;
|
2011-10-15 01:27:59 +00:00
|
|
|
buf[i] = 0;
|
2011-03-03 12:51:55 +00:00
|
|
|
for (; i < maxlen; i++)
|
|
|
|
if (!avio_r8(s))
|
|
|
|
return i + 1;
|
|
|
|
return maxlen;
|
|
|
|
}
|
|
|
|
|
2011-01-23 11:38:27 +00:00
|
|
|
#define GET_STR16(type, read) \
|
2011-02-20 10:04:12 +00:00
|
|
|
int avio_get_str16 ##type(AVIOContext *pb, int maxlen, char *buf, int buflen)\
|
2011-01-23 11:38:27 +00:00
|
|
|
{\
|
|
|
|
char* q = buf;\
|
|
|
|
int ret = 0;\
|
2011-10-15 01:27:59 +00:00
|
|
|
if (buflen <= 0) \
|
|
|
|
return AVERROR(EINVAL); \
|
2011-01-23 11:38:27 +00:00
|
|
|
while (ret + 1 < maxlen) {\
|
|
|
|
uint8_t tmp;\
|
|
|
|
uint32_t ch;\
|
|
|
|
GET_UTF16(ch, (ret += 2) <= maxlen ? read(pb) : 0, break;)\
|
|
|
|
if (!ch)\
|
|
|
|
break;\
|
|
|
|
PUT_UTF8(ch, tmp, if (q - buf < buflen - 1) *q++ = tmp;)\
|
|
|
|
}\
|
|
|
|
*q = 0;\
|
|
|
|
return ret;\
|
|
|
|
}\
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
GET_STR16(le, avio_rl16)
|
|
|
|
GET_STR16(be, avio_rb16)
|
2011-01-23 11:38:27 +00:00
|
|
|
|
|
|
|
#undef GET_STR16
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
uint64_t avio_rb64(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2003-02-11 16:35:48 +00:00
|
|
|
uint64_t val;
|
2011-02-21 15:43:01 +00:00
|
|
|
val = (uint64_t)avio_rb32(s) << 32;
|
|
|
|
val |= (uint64_t)avio_rb32(s);
|
2001-07-22 14:18:56 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2011-03-14 19:38:57 +00:00
|
|
|
uint64_t ffio_read_varlen(AVIOContext *bc){
|
2007-11-03 18:26:42 +00:00
|
|
|
uint64_t val = 0;
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
do{
|
2011-02-21 15:43:01 +00:00
|
|
|
tmp = avio_r8(bc);
|
2007-11-03 18:26:42 +00:00
|
|
|
val= (val<<7) + (tmp&127);
|
|
|
|
}while(tmp&128);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2016-02-19 13:29:10 +00:00
|
|
|
static int io_read_packet(void *opaque, uint8_t *buf, int buf_size)
|
|
|
|
{
|
|
|
|
AVIOInternal *internal = opaque;
|
|
|
|
return ffurl_read(internal->h, buf, buf_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int io_write_packet(void *opaque, uint8_t *buf, int buf_size)
|
|
|
|
{
|
|
|
|
AVIOInternal *internal = opaque;
|
|
|
|
return ffurl_write(internal->h, buf, buf_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t io_seek(void *opaque, int64_t offset, int whence)
|
|
|
|
{
|
|
|
|
AVIOInternal *internal = opaque;
|
|
|
|
return ffurl_seek(internal->h, offset, whence);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static int io_short_seek(void *opaque)
|
|
|
|
{
|
|
|
|
AVIOInternal *internal = opaque;
|
|
|
|
return ffurl_get_short_seek(internal->h);
|
|
|
|
}
|
|
|
|
|
2016-02-19 13:29:10 +00:00
|
|
|
static int io_read_pause(void *opaque, int pause)
|
|
|
|
{
|
|
|
|
AVIOInternal *internal = opaque;
|
|
|
|
if (!internal->h->prot->url_read_pause)
|
|
|
|
return AVERROR(ENOSYS);
|
|
|
|
return internal->h->prot->url_read_pause(internal->h, pause);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t io_read_seek(void *opaque, int stream_index, int64_t timestamp, int flags)
|
|
|
|
{
|
|
|
|
AVIOInternal *internal = opaque;
|
|
|
|
if (!internal->h->prot->url_read_seek)
|
|
|
|
return AVERROR(ENOSYS);
|
|
|
|
return internal->h->prot->url_read_seek(internal->h, stream_index, timestamp, flags);
|
|
|
|
}
|
|
|
|
|
2011-03-17 07:44:44 +00:00
|
|
|
int ffio_fdopen(AVIOContext **s, URLContext *h)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2016-02-19 13:29:10 +00:00
|
|
|
AVIOInternal *internal = NULL;
|
|
|
|
uint8_t *buffer = NULL;
|
2002-07-24 17:51:50 +00:00
|
|
|
int buffer_size, max_packet_size;
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2011-03-31 15:58:04 +00:00
|
|
|
max_packet_size = h->max_packet_size;
|
2002-07-24 17:51:50 +00:00
|
|
|
if (max_packet_size) {
|
|
|
|
buffer_size = max_packet_size; /* no need to bufferize more than one packet */
|
|
|
|
} else {
|
|
|
|
buffer_size = IO_BUFFER_SIZE;
|
|
|
|
}
|
2002-05-18 23:11:09 +00:00
|
|
|
buffer = av_malloc(buffer_size);
|
2001-07-22 14:18:56 +00:00
|
|
|
if (!buffer)
|
2007-02-13 18:26:14 +00:00
|
|
|
return AVERROR(ENOMEM);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2016-02-19 13:29:10 +00:00
|
|
|
internal = av_mallocz(sizeof(*internal));
|
|
|
|
if (!internal)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
internal->h = h;
|
|
|
|
|
|
|
|
*s = avio_alloc_context(buffer, buffer_size, h->flags & AVIO_FLAG_WRITE,
|
|
|
|
internal, io_read_packet, io_write_packet, io_seek);
|
|
|
|
if (!*s)
|
|
|
|
goto fail;
|
|
|
|
|
2016-01-30 01:17:50 +00:00
|
|
|
(*s)->protocol_whitelist = av_strdup(h->protocol_whitelist);
|
|
|
|
if (!(*s)->protocol_whitelist && h->protocol_whitelist) {
|
|
|
|
avio_closep(s);
|
2016-02-29 18:43:04 +00:00
|
|
|
goto fail;
|
2016-01-30 01:17:50 +00:00
|
|
|
}
|
2016-03-03 17:14:26 +00:00
|
|
|
(*s)->protocol_blacklist = av_strdup(h->protocol_blacklist);
|
|
|
|
if (!(*s)->protocol_blacklist && h->protocol_blacklist) {
|
|
|
|
avio_closep(s);
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-03-25 09:58:55 +00:00
|
|
|
(*s)->direct = h->flags & AVIO_FLAG_DIRECT;
|
2016-02-29 18:43:04 +00:00
|
|
|
|
2011-03-05 20:06:46 +00:00
|
|
|
(*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
|
2007-11-21 07:41:00 +00:00
|
|
|
(*s)->max_packet_size = max_packet_size;
|
2017-06-18 12:38:39 +00:00
|
|
|
(*s)->min_packet_size = h->min_packet_size;
|
2007-11-28 19:46:49 +00:00
|
|
|
if(h->prot) {
|
2016-02-19 13:29:10 +00:00
|
|
|
(*s)->read_pause = io_read_pause;
|
|
|
|
(*s)->read_seek = io_read_seek;
|
2016-09-27 13:44:54 +00:00
|
|
|
|
|
|
|
if (h->prot->url_read_seek)
|
|
|
|
(*s)->seekable |= AVIO_SEEKABLE_TIME;
|
2007-11-28 19:46:49 +00:00
|
|
|
}
|
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
|
|
|
(*s)->short_seek_get = io_short_seek;
|
2015-02-27 23:06:28 +00:00
|
|
|
(*s)->av_class = &ff_avio_class;
|
2001-07-22 14:18:56 +00:00
|
|
|
return 0;
|
2016-02-19 13:29:10 +00:00
|
|
|
fail:
|
|
|
|
av_freep(&internal);
|
|
|
|
av_freep(&buffer);
|
|
|
|
return AVERROR(ENOMEM);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2017-11-29 06:31:34 +00:00
|
|
|
URLContext* ffio_geturlcontext(AVIOContext *s)
|
|
|
|
{
|
|
|
|
AVIOInternal *internal;
|
|
|
|
if (!s)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
internal = s->opaque;
|
|
|
|
if (internal && s->read_packet == io_read_packet)
|
|
|
|
return internal->h;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-07-30 09:09:25 +00:00
|
|
|
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
|
2013-06-30 16:18:13 +00:00
|
|
|
{
|
|
|
|
uint8_t *buffer;
|
|
|
|
int max_buffer_size = s->max_packet_size ?
|
|
|
|
s->max_packet_size : IO_BUFFER_SIZE;
|
2014-03-26 22:52:09 +00:00
|
|
|
int filled = s->buf_end - s->buffer;
|
2015-06-16 22:21:02 +00:00
|
|
|
ptrdiff_t checksum_ptr_offset = s->checksum_ptr ? s->checksum_ptr - s->buffer : -1;
|
2013-06-30 16:18:13 +00:00
|
|
|
|
|
|
|
buf_size += s->buf_ptr - s->buffer + max_buffer_size;
|
|
|
|
|
2015-04-27 02:52:01 +00:00
|
|
|
if (buf_size < filled || s->seekable || !s->read_packet)
|
2013-06-30 16:18:13 +00:00
|
|
|
return 0;
|
|
|
|
av_assert0(!s->write_flag);
|
|
|
|
|
|
|
|
buffer = av_malloc(buf_size);
|
|
|
|
if (!buffer)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
2014-03-26 22:52:09 +00:00
|
|
|
memcpy(buffer, s->buffer, filled);
|
2013-06-30 16:18:13 +00:00
|
|
|
av_free(s->buffer);
|
|
|
|
s->buf_ptr = buffer + (s->buf_ptr - s->buffer);
|
|
|
|
s->buf_end = buffer + (s->buf_end - s->buffer);
|
|
|
|
s->buffer = buffer;
|
|
|
|
s->buffer_size = buf_size;
|
2015-06-16 22:21:02 +00:00
|
|
|
if (checksum_ptr_offset >= 0)
|
|
|
|
s->checksum_ptr = s->buffer + checksum_ptr_offset;
|
2013-06-30 16:18:13 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-03-14 19:38:58 +00:00
|
|
|
int ffio_set_buf_size(AVIOContext *s, int buf_size)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2003-02-11 16:35:48 +00:00
|
|
|
uint8_t *buffer;
|
2002-05-18 23:11:09 +00:00
|
|
|
buffer = av_malloc(buf_size);
|
2001-07-22 14:18:56 +00:00
|
|
|
if (!buffer)
|
2007-02-13 18:26:14 +00:00
|
|
|
return AVERROR(ENOMEM);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2002-05-18 23:11:09 +00:00
|
|
|
av_free(s->buffer);
|
2001-07-22 14:18:56 +00:00
|
|
|
s->buffer = buffer;
|
2014-03-26 22:58:48 +00:00
|
|
|
s->orig_buffer_size =
|
2001-07-22 14:18:56 +00:00
|
|
|
s->buffer_size = buf_size;
|
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
|
|
|
s->buf_ptr = s->buf_ptr_max = buffer;
|
2011-04-15 14:42:09 +00:00
|
|
|
url_resetbuf(s, s->write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
|
2007-10-11 14:57:47 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-04 03:58:41 +00:00
|
|
|
int ffio_realloc_buf(AVIOContext *s, int buf_size)
|
|
|
|
{
|
|
|
|
uint8_t *buffer;
|
|
|
|
int data_size;
|
|
|
|
|
|
|
|
if (!s->buffer_size)
|
|
|
|
return ffio_set_buf_size(s, buf_size);
|
|
|
|
|
|
|
|
if (buf_size <= s->buffer_size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
buffer = av_malloc(buf_size);
|
|
|
|
if (!buffer)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
|
|
|
data_size = s->write_flag ? (s->buf_ptr - s->buffer) : (s->buf_end - s->buf_ptr);
|
|
|
|
if (data_size > 0)
|
|
|
|
memcpy(buffer, s->write_flag ? s->buffer : s->buf_ptr, data_size);
|
|
|
|
av_free(s->buffer);
|
|
|
|
s->buffer = buffer;
|
|
|
|
s->orig_buffer_size = buf_size;
|
|
|
|
s->buffer_size = buf_size;
|
|
|
|
s->buf_ptr = s->write_flag ? (s->buffer + data_size) : s->buffer;
|
|
|
|
if (s->write_flag)
|
|
|
|
s->buf_ptr_max = s->buffer + data_size;
|
|
|
|
|
|
|
|
s->buf_end = s->write_flag ? (s->buffer + s->buffer_size) : (s->buf_ptr + data_size);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static int url_resetbuf(AVIOContext *s, int flags)
|
2007-10-11 14:57:47 +00:00
|
|
|
{
|
2012-06-15 17:37:03 +00:00
|
|
|
av_assert1(flags == AVIO_FLAG_WRITE || flags == AVIO_FLAG_READ);
|
2007-10-11 14:57:47 +00:00
|
|
|
|
2011-04-15 14:42:09 +00:00
|
|
|
if (flags & AVIO_FLAG_WRITE) {
|
2007-10-11 14:57:47 +00:00
|
|
|
s->buf_end = s->buffer + s->buffer_size;
|
|
|
|
s->write_flag = 1;
|
|
|
|
} else {
|
|
|
|
s->buf_end = s->buffer;
|
|
|
|
s->write_flag = 0;
|
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-13 00:08:59 +00:00
|
|
|
int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **bufp, int buf_size)
|
2010-04-08 09:02:27 +00:00
|
|
|
{
|
|
|
|
int64_t buffer_start;
|
|
|
|
int buffer_size;
|
2010-07-24 09:04:44 +00:00
|
|
|
int overlap, new_size, alloc_size;
|
2012-10-13 00:08:59 +00:00
|
|
|
uint8_t *buf = *bufp;
|
2010-04-08 09:02:27 +00:00
|
|
|
|
2012-10-13 00:08:59 +00:00
|
|
|
if (s->write_flag) {
|
|
|
|
av_freep(bufp);
|
2010-04-08 09:02:27 +00:00
|
|
|
return AVERROR(EINVAL);
|
2012-10-13 00:08:59 +00:00
|
|
|
}
|
2010-04-08 09:02:27 +00:00
|
|
|
|
|
|
|
buffer_size = s->buf_end - s->buffer;
|
|
|
|
|
|
|
|
/* the buffers must touch or overlap */
|
2012-10-13 00:08:59 +00:00
|
|
|
if ((buffer_start = s->pos - buffer_size) > buf_size) {
|
|
|
|
av_freep(bufp);
|
2010-04-08 09:02:27 +00:00
|
|
|
return AVERROR(EINVAL);
|
2012-10-13 00:08:59 +00:00
|
|
|
}
|
2010-04-08 09:02:27 +00:00
|
|
|
|
|
|
|
overlap = buf_size - buffer_start;
|
|
|
|
new_size = buf_size + buffer_size - overlap;
|
|
|
|
|
2010-07-24 09:04:44 +00:00
|
|
|
alloc_size = FFMAX(s->buffer_size, new_size);
|
|
|
|
if (alloc_size > buf_size)
|
2012-10-13 00:08:59 +00:00
|
|
|
if (!(buf = (*bufp) = av_realloc_f(buf, 1, alloc_size)))
|
2010-04-08 09:02:27 +00:00
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
2010-07-24 09:04:44 +00:00
|
|
|
if (new_size > buf_size) {
|
2010-04-08 09:02:27 +00:00
|
|
|
memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap);
|
|
|
|
buf_size = new_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_free(s->buffer);
|
|
|
|
s->buf_ptr = s->buffer = buf;
|
2010-07-24 09:04:44 +00:00
|
|
|
s->buffer_size = alloc_size;
|
|
|
|
s->pos = buf_size;
|
2010-04-08 09:02:27 +00:00
|
|
|
s->buf_end = s->buf_ptr + buf_size;
|
|
|
|
s->eof_reached = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-21 21:45:20 +00:00
|
|
|
int avio_open(AVIOContext **s, const char *filename, int flags)
|
2011-11-06 21:03:45 +00:00
|
|
|
{
|
|
|
|
return avio_open2(s, filename, flags, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
2016-01-30 01:17:50 +00:00
|
|
|
int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags,
|
|
|
|
const AVIOInterruptCB *int_cb, AVDictionary **options,
|
2016-03-03 17:14:26 +00:00
|
|
|
const char *whitelist, const char *blacklist
|
2016-01-30 01:17:50 +00:00
|
|
|
)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
|
|
|
URLContext *h;
|
|
|
|
int err;
|
|
|
|
|
2016-04-21 14:55:09 +00:00
|
|
|
err = ffurl_open_whitelist(&h, filename, flags, int_cb, options, whitelist, blacklist, NULL);
|
2001-07-22 14:18:56 +00:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2011-03-17 07:44:44 +00:00
|
|
|
err = ffio_fdopen(s, h);
|
2001-07-22 14:18:56 +00:00
|
|
|
if (err < 0) {
|
2011-03-31 15:36:06 +00:00
|
|
|
ffurl_close(h);
|
2001-07-22 14:18:56 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-30 01:17:50 +00:00
|
|
|
int avio_open2(AVIOContext **s, const char *filename, int flags,
|
|
|
|
const AVIOInterruptCB *int_cb, AVDictionary **options)
|
|
|
|
{
|
2016-03-03 17:14:26 +00:00
|
|
|
return ffio_open_whitelist(s, filename, flags, int_cb, options, NULL, NULL);
|
2016-01-30 01:17:50 +00:00
|
|
|
}
|
|
|
|
|
2011-02-21 21:45:20 +00:00
|
|
|
int avio_close(AVIOContext *s)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2016-02-19 13:29:10 +00:00
|
|
|
AVIOInternal *internal;
|
2012-04-27 17:53:04 +00:00
|
|
|
URLContext *h;
|
|
|
|
|
|
|
|
if (!s)
|
|
|
|
return 0;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-08-15 23:25:05 +00:00
|
|
|
avio_flush(s);
|
2016-02-19 13:29:10 +00:00
|
|
|
internal = s->opaque;
|
|
|
|
h = internal->h;
|
|
|
|
|
|
|
|
av_freep(&s->opaque);
|
2012-09-04 13:04:46 +00:00
|
|
|
av_freep(&s->buffer);
|
2013-04-08 11:21:34 +00:00
|
|
|
if (s->write_flag)
|
2018-06-14 09:21:31 +00:00
|
|
|
av_log(s, AV_LOG_VERBOSE, "Statistics: %d seeks, %d writeouts\n", s->seek_count, s->writeout_count);
|
2013-04-08 11:21:34 +00:00
|
|
|
else
|
2018-06-14 09:21:31 +00:00
|
|
|
av_log(s, AV_LOG_VERBOSE, "Statistics: %"PRId64" bytes read, %d seeks\n", s->bytes_read, s->seek_count);
|
2016-01-28 22:49:06 +00:00
|
|
|
av_opt_free(s);
|
2017-08-27 16:26:58 +00:00
|
|
|
|
|
|
|
avio_context_free(&s);
|
|
|
|
|
2011-03-31 15:36:06 +00:00
|
|
|
return ffurl_close(h);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2012-10-09 23:39:06 +00:00
|
|
|
int avio_closep(AVIOContext **s)
|
|
|
|
{
|
|
|
|
int ret = avio_close(*s);
|
|
|
|
*s = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-03-14 19:39:02 +00:00
|
|
|
int avio_printf(AVIOContext *s, const char *fmt, ...)
|
2002-07-24 17:51:50 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
2019-08-05 20:27:47 +00:00
|
|
|
AVBPrint bp;
|
2002-07-24 17:51:50 +00:00
|
|
|
|
2019-08-05 20:27:47 +00:00
|
|
|
av_bprint_init(&bp, 0, INT_MAX);
|
2002-07-24 17:51:50 +00:00
|
|
|
va_start(ap, fmt);
|
2019-08-05 20:27:47 +00:00
|
|
|
av_vbprintf(&bp, fmt, ap);
|
2002-07-24 17:51:50 +00:00
|
|
|
va_end(ap);
|
2019-08-05 20:27:47 +00:00
|
|
|
if (!av_bprint_is_complete(&bp)) {
|
|
|
|
av_bprint_finalize(&bp, NULL);
|
|
|
|
s->error = AVERROR(ENOMEM);
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
|
|
|
avio_write(s, bp.str, bp.len);
|
|
|
|
av_bprint_finalize(&bp, NULL);
|
|
|
|
return bp.len;
|
2002-07-24 17:51:50 +00:00
|
|
|
}
|
|
|
|
|
2019-08-05 19:50:42 +00:00
|
|
|
void avio_print_string_array(AVIOContext *s, const char *strings[])
|
|
|
|
{
|
|
|
|
for(; *strings; strings++)
|
|
|
|
avio_write(s, (const unsigned char *)*strings, strlen(*strings));
|
|
|
|
}
|
|
|
|
|
2011-04-12 07:37:10 +00:00
|
|
|
int avio_pause(AVIOContext *s, int pause)
|
2007-11-28 19:46:49 +00:00
|
|
|
{
|
|
|
|
if (!s->read_pause)
|
|
|
|
return AVERROR(ENOSYS);
|
2007-12-19 20:57:13 +00:00
|
|
|
return s->read_pause(s->opaque, pause);
|
2007-11-28 19:46:49 +00:00
|
|
|
}
|
|
|
|
|
2011-04-12 07:37:10 +00:00
|
|
|
int64_t avio_seek_time(AVIOContext *s, int stream_index,
|
2011-03-14 19:38:59 +00:00
|
|
|
int64_t timestamp, int flags)
|
2007-11-28 19:46:49 +00:00
|
|
|
{
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t ret;
|
2007-11-28 19:46:49 +00:00
|
|
|
if (!s->read_seek)
|
|
|
|
return AVERROR(ENOSYS);
|
2016-02-19 13:29:10 +00:00
|
|
|
ret = s->read_seek(s->opaque, stream_index, timestamp, flags);
|
2012-12-09 03:15:45 +00:00
|
|
|
if (ret >= 0) {
|
2010-04-12 15:03:30 +00:00
|
|
|
int64_t pos;
|
2007-11-28 19:46:49 +00:00
|
|
|
s->buf_ptr = s->buf_end; // Flush buffer
|
2016-02-19 13:29:10 +00:00
|
|
|
pos = s->seek(s->opaque, 0, SEEK_CUR);
|
2010-04-12 15:03:30 +00:00
|
|
|
if (pos >= 0)
|
|
|
|
s->pos = pos;
|
|
|
|
else if (pos != AVERROR(ENOSYS))
|
|
|
|
ret = pos;
|
2007-11-28 19:46:49 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-07-23 13:12:38 +00:00
|
|
|
int avio_read_to_bprint(AVIOContext *h, AVBPrint *pb, size_t max_size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char buf[1024];
|
|
|
|
while (max_size) {
|
|
|
|
ret = avio_read(h, buf, FFMIN(max_size, sizeof(buf)));
|
|
|
|
if (ret == AVERROR_EOF)
|
|
|
|
return 0;
|
|
|
|
if (ret <= 0)
|
|
|
|
return ret;
|
|
|
|
av_bprint_append_data(pb, buf, ret);
|
|
|
|
if (!av_bprint_is_complete(pb))
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
max_size -= ret;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-03 00:25:51 +00:00
|
|
|
int avio_accept(AVIOContext *s, AVIOContext **c)
|
|
|
|
{
|
|
|
|
int ret;
|
2016-09-30 19:17:54 +00:00
|
|
|
AVIOInternal *internal = s->opaque;
|
|
|
|
URLContext *sc = internal->h;
|
2015-07-03 00:25:51 +00:00
|
|
|
URLContext *cc = NULL;
|
|
|
|
ret = ffurl_accept(sc, &cc);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
return ffio_fdopen(c, cc);
|
|
|
|
}
|
|
|
|
|
|
|
|
int avio_handshake(AVIOContext *c)
|
|
|
|
{
|
2016-09-30 19:17:54 +00:00
|
|
|
AVIOInternal *internal = c->opaque;
|
|
|
|
URLContext *cc = internal->h;
|
2015-07-03 00:25:51 +00:00
|
|
|
return ffurl_handshake(cc);
|
|
|
|
}
|
|
|
|
|
2002-07-24 17:51:50 +00:00
|
|
|
/* output in a dynamic buffer */
|
|
|
|
|
|
|
|
typedef struct DynBuffer {
|
|
|
|
int pos, size, allocated_size;
|
2003-02-11 16:35:48 +00:00
|
|
|
uint8_t *buffer;
|
2002-07-24 17:51:50 +00:00
|
|
|
int io_buffer_size;
|
2003-02-11 16:35:48 +00:00
|
|
|
uint8_t io_buffer[1];
|
2002-07-24 17:51:50 +00:00
|
|
|
} DynBuffer;
|
|
|
|
|
2004-10-08 20:09:52 +00:00
|
|
|
static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
|
2002-07-24 17:51:50 +00:00
|
|
|
{
|
|
|
|
DynBuffer *d = opaque;
|
2008-10-04 21:11:58 +00:00
|
|
|
unsigned new_size, new_allocated_size;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2002-07-24 17:51:50 +00:00
|
|
|
/* reallocate buffer if needed */
|
|
|
|
new_size = d->pos + buf_size;
|
|
|
|
new_allocated_size = d->allocated_size;
|
2012-12-09 03:15:45 +00:00
|
|
|
if (new_size < d->pos || new_size > INT_MAX/2)
|
2005-01-08 14:21:33 +00:00
|
|
|
return -1;
|
2002-07-24 17:51:50 +00:00
|
|
|
while (new_size > new_allocated_size) {
|
|
|
|
if (!new_allocated_size)
|
|
|
|
new_allocated_size = new_size;
|
|
|
|
else
|
2005-12-17 18:14:38 +00:00
|
|
|
new_allocated_size += new_allocated_size / 2 + 1;
|
2002-07-24 17:51:50 +00:00
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2002-07-24 17:51:50 +00:00
|
|
|
if (new_allocated_size > d->allocated_size) {
|
2013-09-18 16:12:36 +00:00
|
|
|
int err;
|
2013-09-26 13:37:02 +00:00
|
|
|
if ((err = av_reallocp(&d->buffer, new_allocated_size)) < 0) {
|
|
|
|
d->allocated_size = 0;
|
|
|
|
d->size = 0;
|
2013-09-18 16:12:36 +00:00
|
|
|
return err;
|
2013-09-26 13:37:02 +00:00
|
|
|
}
|
2002-07-24 17:51:50 +00:00
|
|
|
d->allocated_size = new_allocated_size;
|
|
|
|
}
|
|
|
|
memcpy(d->buffer + d->pos, buf, buf_size);
|
|
|
|
d->pos = new_size;
|
|
|
|
if (d->pos > d->size)
|
|
|
|
d->size = d->pos;
|
2004-10-08 20:09:52 +00:00
|
|
|
return buf_size;
|
2002-07-24 17:51:50 +00:00
|
|
|
}
|
|
|
|
|
2004-10-08 20:09:52 +00:00
|
|
|
static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
|
2002-07-24 17:51:50 +00:00
|
|
|
{
|
|
|
|
unsigned char buf1[4];
|
2004-10-08 20:09:52 +00:00
|
|
|
int ret;
|
2002-07-24 17:51:50 +00:00
|
|
|
|
|
|
|
/* packetized write: output the header */
|
2009-01-16 15:34:37 +00:00
|
|
|
AV_WB32(buf1, buf_size);
|
2012-12-09 03:15:45 +00:00
|
|
|
ret = dyn_buf_write(opaque, buf1, 4);
|
|
|
|
if (ret < 0)
|
2004-10-08 20:09:52 +00:00
|
|
|
return ret;
|
2002-07-24 17:51:50 +00:00
|
|
|
|
|
|
|
/* then the data */
|
2004-10-08 20:09:52 +00:00
|
|
|
return dyn_buf_write(opaque, buf, buf_size);
|
2002-07-24 17:51:50 +00:00
|
|
|
}
|
|
|
|
|
2008-10-03 10:16:29 +00:00
|
|
|
static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
|
2002-07-24 17:51:50 +00:00
|
|
|
{
|
|
|
|
DynBuffer *d = opaque;
|
|
|
|
|
|
|
|
if (whence == SEEK_CUR)
|
|
|
|
offset += d->pos;
|
|
|
|
else if (whence == SEEK_END)
|
|
|
|
offset += d->size;
|
|
|
|
if (offset < 0 || offset > 0x7fffffffLL)
|
|
|
|
return -1;
|
|
|
|
d->pos = offset;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
|
2002-07-24 17:51:50 +00:00
|
|
|
{
|
|
|
|
DynBuffer *d;
|
2009-01-16 16:39:17 +00:00
|
|
|
unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-12-09 03:15:45 +00:00
|
|
|
if (sizeof(DynBuffer) + io_buffer_size < io_buffer_size)
|
2005-01-08 14:21:33 +00:00
|
|
|
return -1;
|
2009-01-16 15:32:33 +00:00
|
|
|
d = av_mallocz(sizeof(DynBuffer) + io_buffer_size);
|
2002-07-24 17:51:50 +00:00
|
|
|
if (!d)
|
2009-01-16 15:35:51 +00:00
|
|
|
return AVERROR(ENOMEM);
|
2011-04-03 20:55:31 +00:00
|
|
|
d->io_buffer_size = io_buffer_size;
|
|
|
|
*s = avio_alloc_context(d->io_buffer, d->io_buffer_size, 1, d, NULL,
|
|
|
|
max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
|
|
|
|
max_packet_size ? NULL : dyn_buf_seek);
|
2007-11-21 07:41:00 +00:00
|
|
|
if(!*s) {
|
|
|
|
av_free(d);
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
2011-04-03 20:55:31 +00:00
|
|
|
(*s)->max_packet_size = max_packet_size;
|
|
|
|
return 0;
|
2002-07-24 17:51:50 +00:00
|
|
|
}
|
|
|
|
|
2011-03-17 07:13:34 +00:00
|
|
|
int avio_open_dyn_buf(AVIOContext **s)
|
2002-07-24 17:51:50 +00:00
|
|
|
{
|
|
|
|
return url_open_dyn_buf_internal(s, 0);
|
|
|
|
}
|
|
|
|
|
2011-03-17 07:19:54 +00:00
|
|
|
int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
|
2002-07-24 17:51:50 +00:00
|
|
|
{
|
|
|
|
if (max_packet_size <= 0)
|
|
|
|
return -1;
|
|
|
|
return url_open_dyn_buf_internal(s, max_packet_size);
|
|
|
|
}
|
|
|
|
|
2017-01-05 00:33:26 +00:00
|
|
|
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
|
|
|
|
{
|
|
|
|
DynBuffer *d;
|
|
|
|
|
avformat/aviobuf: Avoid allocating buffer when using dynamic buffer
Up until now, using a dynamic buffer entailed at least three
allocations: One for the AVIOContext, one for the AVIOContext's opaque
(which, among other things, contains the small write buffer), and one
for the big buffer that is independently allocated that is returned when
calling avio_close_dyn_buf().
It is possible to avoid the third allocation if one doesn't use a
packetized dynamic buffer, if all the data written so far fit into the
write buffer and if one does not require the actual (big) buffer to have
an indefinite lifetime. This is done by making avio_get_dyn_buf() return
a pointer to the data in the write buffer if nothing has been written to
the main buffer yet. The dynamic buffer will then be freed using
ffio_free_dynamic_buffer (which needed to be modified not to call
avio_close_dyn_buf() internally).
So a typical use-case like:
size = avio_close_dyn_buf(dyn_pb, &buf);
do something with buf
av_free(buf);
can be converted to:
size = avio_get_dyn_buf(dyn_pb, &buf);
do something with buf
ffio_free_dynamic_buffer(&dyn_pb);
In more complex scenarios this can simplify freeing as well, because it
is now clear that freeing always has to be performed via
ffio_free_dynamic_buffer().
Of course, in case this saves an allocation it also saves a memcpy.
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
2019-11-27 12:22:05 +00:00
|
|
|
if (!s || s->error) {
|
2017-01-05 00:33:26 +00:00
|
|
|
*pbuffer = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
avformat/aviobuf: Avoid allocating buffer when using dynamic buffer
Up until now, using a dynamic buffer entailed at least three
allocations: One for the AVIOContext, one for the AVIOContext's opaque
(which, among other things, contains the small write buffer), and one
for the big buffer that is independently allocated that is returned when
calling avio_close_dyn_buf().
It is possible to avoid the third allocation if one doesn't use a
packetized dynamic buffer, if all the data written so far fit into the
write buffer and if one does not require the actual (big) buffer to have
an indefinite lifetime. This is done by making avio_get_dyn_buf() return
a pointer to the data in the write buffer if nothing has been written to
the main buffer yet. The dynamic buffer will then be freed using
ffio_free_dynamic_buffer (which needed to be modified not to call
avio_close_dyn_buf() internally).
So a typical use-case like:
size = avio_close_dyn_buf(dyn_pb, &buf);
do something with buf
av_free(buf);
can be converted to:
size = avio_get_dyn_buf(dyn_pb, &buf);
do something with buf
ffio_free_dynamic_buffer(&dyn_pb);
In more complex scenarios this can simplify freeing as well, because it
is now clear that freeing always has to be performed via
ffio_free_dynamic_buffer().
Of course, in case this saves an allocation it also saves a memcpy.
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
2019-11-27 12:22:05 +00:00
|
|
|
d = s->opaque;
|
|
|
|
|
|
|
|
if (!d->size) {
|
|
|
|
*pbuffer = d->io_buffer;
|
|
|
|
return FFMAX(s->buf_ptr, s->buf_ptr_max) - s->buffer;
|
|
|
|
}
|
2017-01-05 00:33:26 +00:00
|
|
|
|
|
|
|
avio_flush(s);
|
|
|
|
|
|
|
|
*pbuffer = d->buffer;
|
|
|
|
|
|
|
|
return d->size;
|
|
|
|
}
|
|
|
|
|
2011-03-17 07:16:07 +00:00
|
|
|
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
|
2002-07-24 17:51:50 +00:00
|
|
|
{
|
2013-12-11 15:16:04 +00:00
|
|
|
DynBuffer *d;
|
2002-07-24 17:51:50 +00:00
|
|
|
int size;
|
2015-06-29 21:48:34 +00:00
|
|
|
static const char padbuf[AV_INPUT_BUFFER_PADDING_SIZE] = {0};
|
2010-07-01 20:15:49 +00:00
|
|
|
int padding = 0;
|
|
|
|
|
2013-10-30 17:09:30 +00:00
|
|
|
if (!s) {
|
|
|
|
*pbuffer = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-01 20:15:49 +00:00
|
|
|
/* don't attempt to pad fixed-size packet buffers */
|
|
|
|
if (!s->max_packet_size) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(s, padbuf, sizeof(padbuf));
|
2015-06-29 21:48:34 +00:00
|
|
|
padding = AV_INPUT_BUFFER_PADDING_SIZE;
|
2010-07-01 20:15:49 +00:00
|
|
|
}
|
2002-07-24 17:51:50 +00:00
|
|
|
|
2011-03-14 19:39:06 +00:00
|
|
|
avio_flush(s);
|
2002-07-24 17:51:50 +00:00
|
|
|
|
2014-10-18 00:12:13 +00:00
|
|
|
d = s->opaque;
|
2002-07-24 17:51:50 +00:00
|
|
|
*pbuffer = d->buffer;
|
|
|
|
size = d->size;
|
|
|
|
av_free(d);
|
2017-08-27 16:26:58 +00:00
|
|
|
|
|
|
|
avio_context_free(&s);
|
|
|
|
|
2010-07-01 20:15:49 +00:00
|
|
|
return size - padding;
|
2002-07-24 17:51:50 +00:00
|
|
|
}
|
2013-09-18 18:50:50 +00:00
|
|
|
|
2015-02-24 11:23:30 +00:00
|
|
|
void ffio_free_dyn_buf(AVIOContext **s)
|
|
|
|
{
|
avformat/aviobuf: Avoid allocating buffer when using dynamic buffer
Up until now, using a dynamic buffer entailed at least three
allocations: One for the AVIOContext, one for the AVIOContext's opaque
(which, among other things, contains the small write buffer), and one
for the big buffer that is independently allocated that is returned when
calling avio_close_dyn_buf().
It is possible to avoid the third allocation if one doesn't use a
packetized dynamic buffer, if all the data written so far fit into the
write buffer and if one does not require the actual (big) buffer to have
an indefinite lifetime. This is done by making avio_get_dyn_buf() return
a pointer to the data in the write buffer if nothing has been written to
the main buffer yet. The dynamic buffer will then be freed using
ffio_free_dynamic_buffer (which needed to be modified not to call
avio_close_dyn_buf() internally).
So a typical use-case like:
size = avio_close_dyn_buf(dyn_pb, &buf);
do something with buf
av_free(buf);
can be converted to:
size = avio_get_dyn_buf(dyn_pb, &buf);
do something with buf
ffio_free_dynamic_buffer(&dyn_pb);
In more complex scenarios this can simplify freeing as well, because it
is now clear that freeing always has to be performed via
ffio_free_dynamic_buffer().
Of course, in case this saves an allocation it also saves a memcpy.
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
2019-11-27 12:22:05 +00:00
|
|
|
DynBuffer *d;
|
|
|
|
|
2015-02-24 11:23:30 +00:00
|
|
|
if (!*s)
|
|
|
|
return;
|
avformat/aviobuf: Avoid allocating buffer when using dynamic buffer
Up until now, using a dynamic buffer entailed at least three
allocations: One for the AVIOContext, one for the AVIOContext's opaque
(which, among other things, contains the small write buffer), and one
for the big buffer that is independently allocated that is returned when
calling avio_close_dyn_buf().
It is possible to avoid the third allocation if one doesn't use a
packetized dynamic buffer, if all the data written so far fit into the
write buffer and if one does not require the actual (big) buffer to have
an indefinite lifetime. This is done by making avio_get_dyn_buf() return
a pointer to the data in the write buffer if nothing has been written to
the main buffer yet. The dynamic buffer will then be freed using
ffio_free_dynamic_buffer (which needed to be modified not to call
avio_close_dyn_buf() internally).
So a typical use-case like:
size = avio_close_dyn_buf(dyn_pb, &buf);
do something with buf
av_free(buf);
can be converted to:
size = avio_get_dyn_buf(dyn_pb, &buf);
do something with buf
ffio_free_dynamic_buffer(&dyn_pb);
In more complex scenarios this can simplify freeing as well, because it
is now clear that freeing always has to be performed via
ffio_free_dynamic_buffer().
Of course, in case this saves an allocation it also saves a memcpy.
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
2019-11-27 12:22:05 +00:00
|
|
|
|
|
|
|
d = (*s)->opaque;
|
|
|
|
av_free(d->buffer);
|
|
|
|
av_free(d);
|
|
|
|
avio_context_free(s);
|
2015-02-24 11:23:30 +00:00
|
|
|
}
|
|
|
|
|
2013-09-18 18:50:50 +00:00
|
|
|
static int null_buf_write(void *opaque, uint8_t *buf, int buf_size)
|
|
|
|
{
|
|
|
|
DynBuffer *d = opaque;
|
|
|
|
|
|
|
|
d->pos += buf_size;
|
|
|
|
if (d->pos > d->size)
|
|
|
|
d->size = d->pos;
|
|
|
|
return buf_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ffio_open_null_buf(AVIOContext **s)
|
|
|
|
{
|
|
|
|
int ret = url_open_dyn_buf_internal(s, 0);
|
|
|
|
if (ret >= 0) {
|
|
|
|
AVIOContext *pb = *s;
|
|
|
|
pb->write_packet = null_buf_write;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ffio_close_null_buf(AVIOContext *s)
|
|
|
|
{
|
|
|
|
DynBuffer *d = s->opaque;
|
|
|
|
int size;
|
|
|
|
|
|
|
|
avio_flush(s);
|
|
|
|
|
|
|
|
size = d->size;
|
|
|
|
av_free(d);
|
2017-08-27 16:26:58 +00:00
|
|
|
|
|
|
|
avio_context_free(&s);
|
|
|
|
|
2013-09-18 18:50:50 +00:00
|
|
|
return size;
|
|
|
|
}
|