virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

avformat/aviobuf: Avoid allocating buffer when using dynamic buffer

Browse Source 
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>
This commit is contained in:
Andreas Rheinhardt 2019-11-27 13:22:05 +01:00 committed by James Almer
parent 8aa143eaa8
commit 163bb9ac0a
1 changed files with 14 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
libavformat/aviobuf.c
View File

@ -1443,14 +1443,19 @@ int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
{
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;
@ -1488,12 +1493,15 @@ int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
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)