#include "libavutil/intreadwrite.h"
#include "avformat.h"
#include "avio.h"
+#include "internal.h"
#include <stdarg.h>
#define IO_BUFFER_SIZE 32768
+/**
+ * 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
+
static void fill_buffer(ByteIOContext *s);
-#if LIBAVFORMAT_VERSION_MAJOR >= 53
+#if !FF_API_URL_RESETBUF
static int url_resetbuf(ByteIOContext *s, int flags);
#endif
offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
/* can do the seek inside the buffer */
s->buf_ptr = s->buffer + offset1;
- } else if(s->is_streamed && !s->write_flag && offset1 >= 0 &&
+ } else if ((s->is_streamed ||
+ offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) &&
+ !s->write_flag && offset1 >= 0 &&
(whence != SEEK_END || force)) {
while(s->pos < offset && !s->eof_reached)
fill_buffer(s);
return AVERROR_EOF;
s->buf_ptr = s->buf_end + offset - s->pos;
} else {
- int64_t res = AVERROR(EPIPE);
+ int64_t res;
#if CONFIG_MUXERS || CONFIG_NETWORK
if (s->write_flag) {
s->must_flush = 1;
}
#endif /* CONFIG_MUXERS || CONFIG_NETWORK */
- if (!s->seek || (res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
+ if (!s->seek)
+ return AVERROR(EPIPE);
+ if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
return res;
if (!s->write_flag)
s->buf_end = s->buffer;
return offset;
}
-void url_fskip(ByteIOContext *s, int64_t offset)
+int url_fskip(ByteIOContext *s, int64_t offset)
{
- url_fseek(s, offset, SEEK_CUR);
+ int64_t ret = url_fseek(s, offset, SEEK_CUR);
+ return ret < 0 ? ret : 0;
}
int64_t url_ftell(ByteIOContext *s)
return AVERROR(EINVAL);
if (!s->seek)
- return AVERROR(EPIPE);
+ return AVERROR(ENOSYS);
size = s->seek(s->opaque, 0, AVSEEK_SIZE);
if(size<0){
if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0)
put_byte(s, 0);
}
+int ff_get_v_length(uint64_t val){
+ int i=1;
+
+ while(val>>=7)
+ i++;
+
+ return i;
+}
+
+void ff_put_v(ByteIOContext *bc, uint64_t val){
+ int i= ff_get_v_length(val);
+
+ while(--i>0)
+ put_byte(bc, 128 | (val>>(7*i)));
+
+ put_byte(bc, val&127);
+}
+
void put_le64(ByteIOContext *s, uint64_t val)
{
put_le32(s, (uint32_t)(val & 0xffffffff));
int len= s->buffer_size - (dst - s->buffer);
int max_buffer_size = s->max_packet_size ? s->max_packet_size : IO_BUFFER_SIZE;
- assert(s->buf_ptr == s->buf_end);
-
/* no need to do anything if EOF already reached */
if (s->eof_reached)
return;
/* XXX: put an inline version */
int get_byte(ByteIOContext *s)
{
- if (s->buf_ptr < s->buf_end) {
- return *s->buf_ptr++;
- } else {
+ if (s->buf_ptr >= s->buf_end)
fill_buffer(s);
- if (s->buf_ptr < s->buf_end)
- return *s->buf_ptr++;
- else
- return 0;
- }
+ if (s->buf_ptr < s->buf_end)
+ return *s->buf_ptr++;
+ return 0;
}
int url_fgetc(ByteIOContext *s)
{
- if (s->buf_ptr < s->buf_end) {
- return *s->buf_ptr++;
- } else {
+ if (s->buf_ptr >= s->buf_end)
fill_buffer(s);
- if (s->buf_ptr < s->buf_end)
- return *s->buf_ptr++;
- else
- return URL_EOF;
- }
+ if (s->buf_ptr < s->buf_end)
+ return *s->buf_ptr++;
+ return URL_EOF;
}
int get_buffer(ByteIOContext *s, unsigned char *buf, int size)
return buf;
}
+int ff_get_line(ByteIOContext *s, char *buf, int maxlen)
+{
+ int i = 0;
+ char c;
+
+ do {
+ c = get_byte(s);
+ if (c && i < maxlen-1)
+ buf[i++] = c;
+ } while (c != '\n' && c);
+
+ buf[i] = 0;
+ return i;
+}
+
uint64_t get_be64(ByteIOContext *s)
{
uint64_t val;
return 0;
}
-#if LIBAVFORMAT_VERSION_MAJOR < 53
+#if FF_API_URL_RESETBUF
int url_resetbuf(ByteIOContext *s, int flags)
#else
static int url_resetbuf(ByteIOContext *s, int flags)
#endif
{
-#if LIBAVFORMAT_VERSION_MAJOR < 53
- URLContext *h = s->opaque;
- if ((flags & URL_RDWR) || (h && h->flags != flags && !h->flags & URL_RDWR))
+#if FF_API_URL_RESETBUF
+ if (flags & URL_RDWR)
return AVERROR(EINVAL);
#else
assert(flags == URL_WRONLY || flags == URL_RDONLY);
{
int64_t buffer_start;
int buffer_size;
- int overlap, new_size;
+ int overlap, new_size, alloc_size;
if (s->write_flag)
return AVERROR(EINVAL);
overlap = buf_size - buffer_start;
new_size = buf_size + buffer_size - overlap;
- if (new_size > buf_size) {
- if (!(buf = av_realloc(buf, new_size)))
+ alloc_size = FFMAX(s->buffer_size, new_size);
+ if (alloc_size > buf_size)
+ if (!(buf = av_realloc(buf, alloc_size)))
return AVERROR(ENOMEM);
+ if (new_size > buf_size) {
memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap);
buf_size = new_size;
}
av_free(s->buffer);
s->buf_ptr = s->buffer = buf;
- s->pos = s->buffer_size = buf_size;
+ s->buffer_size = alloc_size;
+ s->pos = buf_size;
s->buf_end = s->buf_ptr + buf_size;
s->eof_reached = 0;
s->must_flush = 0;
return AVERROR(ENOSYS);
ret = s->read_seek(h, stream_index, timestamp, flags);
if(ret >= 0) {
+ int64_t pos;
s->buf_ptr = s->buf_end; // Flush buffer
- s->pos = s->seek(h, 0, SEEK_CUR);
+ pos = s->seek(h, 0, SEEK_CUR);
+ if (pos >= 0)
+ s->pos = pos;
+ else if (pos != AVERROR(ENOSYS))
+ ret = pos;
}
return ret;
}
{
DynBuffer *d = s->opaque;
int size;
+ static const char padbuf[FF_INPUT_BUFFER_PADDING_SIZE] = {0};
+ int padding = 0;
+
+ /* don't attempt to pad fixed-size packet buffers */
+ if (!s->max_packet_size) {
+ put_buffer(s, padbuf, sizeof(padbuf));
+ padding = FF_INPUT_BUFFER_PADDING_SIZE;
+ }
put_flush_packet(s);
size = d->size;
av_free(d);
av_free(s);
- return size;
+ return size - padding;
}
#endif /* CONFIG_MUXERS || CONFIG_NETWORK */