*/
#define SHORT_SEEK_THRESHOLD 4096
-typedef struct AVIOInternal {
- URLContext *h;
-} AVIOInternal;
-
static void *ff_avio_child_next(void *obj, void *prev)
{
AVIOContext *s = obj;
- AVIOInternal *internal = s->opaque;
- return prev ? NULL : internal->h;
+ return prev ? NULL : s->opaque;
}
static const AVClass *ff_avio_child_class_next(const AVClass *prev)
if(!s)
return AVERROR(EINVAL);
+ if ((whence & AVSEEK_SIZE))
+ return s->seek ? s->seek(s->opaque, offset, AVSEEK_SIZE) : AVERROR(ENOSYS);
+
buffer_size = s->buf_end - s->buffer;
// pos is the absolute position that the beginning of s->buffer corresponds to in the file
pos = s->pos - (s->write_flag ? 0 : buffer_size);
}
/* make buffer smaller in case it ended up large after probing */
- if (s->read_packet && s->orig_buffer_size && s->buffer_size > s->orig_buffer_size) {
+ if (s->read_packet && s->orig_buffer_size && s->buffer_size > s->orig_buffer_size && len >= s->orig_buffer_size) {
if (dst == s->buffer && s->buf_ptr != dst) {
int ret = ffio_set_buf_size(s, s->orig_buffer_size);
if (ret < 0)
s->checksum_ptr = dst = s->buffer;
}
- av_assert0(len >= s->orig_buffer_size);
len = s->orig_buffer_size;
}
return val;
}
-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);
-}
-
-static int io_short_seek(void *opaque)
-{
- AVIOInternal *internal = opaque;
- return ffurl_get_short_seek(internal->h);
-}
-
-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);
-}
-
int ffio_fdopen(AVIOContext **s, URLContext *h)
{
- AVIOInternal *internal = NULL;
uint8_t *buffer = NULL;
int buffer_size, max_packet_size;
if (!buffer)
return AVERROR(ENOMEM);
- 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);
+ *s = avio_alloc_context(buffer, buffer_size, h->flags & AVIO_FLAG_WRITE, h,
+ (int (*)(void *, uint8_t *, int)) ffurl_read,
+ (int (*)(void *, uint8_t *, int)) ffurl_write,
+ (int64_t (*)(void *, int64_t, int))ffurl_seek);
if (!*s)
goto fail;
(*s)->max_packet_size = max_packet_size;
(*s)->min_packet_size = h->min_packet_size;
if(h->prot) {
- (*s)->read_pause = io_read_pause;
- (*s)->read_seek = io_read_seek;
+ (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;
+ (*s)->read_seek =
+ (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek;
if (h->prot->url_read_seek)
(*s)->seekable |= AVIO_SEEKABLE_TIME;
}
- (*s)->short_seek_get = io_short_seek;
+ (*s)->short_seek_get = (int (*)(void *))ffurl_get_short_seek;
(*s)->av_class = &ff_avio_class;
return 0;
fail:
- av_freep(&internal);
av_freep(&buffer);
return AVERROR(ENOMEM);
}
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;
+ if (s->opaque && s->read_packet == (int (*)(void *, uint8_t *, int))ffurl_read)
+ return s->opaque;
else
return NULL;
}
return 0;
}
+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;
+}
+
static int url_resetbuf(AVIOContext *s, int flags)
{
av_assert1(flags == AVIO_FLAG_WRITE || flags == AVIO_FLAG_READ);
URLContext *h;
int err;
+ *s = NULL;
+
err = ffurl_open_whitelist(&h, filename, flags, int_cb, options, whitelist, blacklist, NULL);
if (err < 0)
return err;
return ffio_open_whitelist(s, filename, flags, int_cb, options, NULL, NULL);
}
-int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
- const AVIOInterruptCB *int_cb, AVDictionary **options)
-{
- return ffio_open_whitelist(pb, url, flags, int_cb, options, s->protocol_whitelist, s->protocol_blacklist);
-}
-
int avio_close(AVIOContext *s)
{
- AVIOInternal *internal;
URLContext *h;
if (!s)
return 0;
avio_flush(s);
- internal = s->opaque;
- h = internal->h;
+ h = s->opaque;
+ s->opaque = NULL;
- av_freep(&s->opaque);
av_freep(&s->buffer);
if (s->write_flag)
av_log(s, AV_LOG_VERBOSE, "Statistics: %d seeks, %d writeouts\n", s->seek_count, s->writeout_count);
int avio_printf(AVIOContext *s, const char *fmt, ...)
{
va_list ap;
- char buf[4096]; /* update doc entry in avio.h if changed */
- int ret;
+ AVBPrint bp;
+ av_bprint_init(&bp, 0, INT_MAX);
va_start(ap, fmt);
- ret = vsnprintf(buf, sizeof(buf), fmt, ap);
+ av_vbprintf(&bp, fmt, ap);
va_end(ap);
- avio_write(s, buf, strlen(buf));
- return ret;
+ 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;
+}
+
+void avio_print_string_array(AVIOContext *s, const char *strings[])
+{
+ for(; *strings; strings++)
+ avio_write(s, (const unsigned char *)*strings, strlen(*strings));
}
int avio_pause(AVIOContext *s, int pause)
int avio_accept(AVIOContext *s, AVIOContext **c)
{
int ret;
- AVIOInternal *internal = s->opaque;
- URLContext *sc = internal->h;
+ URLContext *sc = s->opaque;
URLContext *cc = NULL;
ret = ffurl_accept(sc, &cc);
if (ret < 0)
int avio_handshake(AVIOContext *c)
{
- AVIOInternal *internal = c->opaque;
- URLContext *cc = internal->h;
+ URLContext *cc = c->opaque;
return ffurl_handshake(cc);
}
{
DynBuffer *d;
- if (!s) {
+ if (!s || s->error) {
*pbuffer = NULL;
return 0;
}
+ d = s->opaque;
+
+ if (!d->size) {
+ *pbuffer = d->io_buffer;
+ return FFMAX(s->buf_ptr, s->buf_ptr_max) - s->buffer;
+ }
avio_flush(s);
- d = s->opaque;
*pbuffer = d->buffer;
return d->size;
void ffio_free_dyn_buf(AVIOContext **s)
{
- uint8_t *tmp;
+ DynBuffer *d;
+
if (!*s)
return;
- avio_close_dyn_buf(*s, &tmp);
- av_free(tmp);
- *s = NULL;
+
+ d = (*s)->opaque;
+ av_free(d->buffer);
+ av_free(d);
+ avio_context_free(s);
}
static int null_buf_write(void *opaque, uint8_t *buf, int buf_size)
projects / ffmpeg / blobdiff