mirror of https://github.com/FFmpeg/FFmpeg.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
333 lines
7.7 KiB
333 lines
7.7 KiB
/* |
|
* This file is part of Libav. |
|
* |
|
* Libav is free software; you can redistribute it and/or |
|
* modify it under the terms of the GNU Lesser General Public |
|
* License as published by the Free Software Foundation; either |
|
* version 2.1 of the License, or (at your option) any later version. |
|
* |
|
* Libav is distributed in the hope that it will be useful, |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
* Lesser General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU Lesser General Public |
|
* License along with Libav; if not, write to the Free Software |
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
|
*/ |
|
|
|
#include <stdint.h> |
|
#include <string.h> |
|
|
|
#include "atomic.h" |
|
#include "buffer_internal.h" |
|
#include "common.h" |
|
#include "mem.h" |
|
#include "thread.h" |
|
|
|
AVBufferRef *av_buffer_create(uint8_t *data, int size, |
|
void (*free)(void *opaque, uint8_t *data), |
|
void *opaque, int flags) |
|
{ |
|
AVBufferRef *ref = NULL; |
|
AVBuffer *buf = NULL; |
|
|
|
buf = av_mallocz(sizeof(*buf)); |
|
if (!buf) |
|
return NULL; |
|
|
|
buf->data = data; |
|
buf->size = size; |
|
buf->free = free ? free : av_buffer_default_free; |
|
buf->opaque = opaque; |
|
buf->refcount = 1; |
|
|
|
if (flags & AV_BUFFER_FLAG_READONLY) |
|
buf->flags |= BUFFER_FLAG_READONLY; |
|
|
|
ref = av_mallocz(sizeof(*ref)); |
|
if (!ref) { |
|
av_freep(&buf); |
|
return NULL; |
|
} |
|
|
|
ref->buffer = buf; |
|
ref->data = data; |
|
ref->size = size; |
|
|
|
return ref; |
|
} |
|
|
|
void av_buffer_default_free(void *opaque, uint8_t *data) |
|
{ |
|
av_free(data); |
|
} |
|
|
|
AVBufferRef *av_buffer_alloc(int size) |
|
{ |
|
AVBufferRef *ret = NULL; |
|
uint8_t *data = NULL; |
|
|
|
data = av_malloc(size); |
|
if (!data) |
|
return NULL; |
|
|
|
ret = av_buffer_create(data, size, av_buffer_default_free, NULL, 0); |
|
if (!ret) |
|
av_freep(&data); |
|
|
|
return ret; |
|
} |
|
|
|
AVBufferRef *av_buffer_allocz(int size) |
|
{ |
|
AVBufferRef *ret = av_buffer_alloc(size); |
|
if (!ret) |
|
return NULL; |
|
|
|
memset(ret->data, 0, size); |
|
return ret; |
|
} |
|
|
|
AVBufferRef *av_buffer_ref(AVBufferRef *buf) |
|
{ |
|
AVBufferRef *ret = av_mallocz(sizeof(*ret)); |
|
|
|
if (!ret) |
|
return NULL; |
|
|
|
*ret = *buf; |
|
|
|
avpriv_atomic_int_add_and_fetch(&buf->buffer->refcount, 1); |
|
|
|
return ret; |
|
} |
|
|
|
void av_buffer_unref(AVBufferRef **buf) |
|
{ |
|
AVBuffer *b; |
|
|
|
if (!buf || !*buf) |
|
return; |
|
b = (*buf)->buffer; |
|
av_freep(buf); |
|
|
|
if (!avpriv_atomic_int_add_and_fetch(&b->refcount, -1)) { |
|
b->free(b->opaque, b->data); |
|
av_freep(&b); |
|
} |
|
} |
|
|
|
int av_buffer_is_writable(const AVBufferRef *buf) |
|
{ |
|
if (buf->buffer->flags & AV_BUFFER_FLAG_READONLY) |
|
return 0; |
|
|
|
return avpriv_atomic_int_add_and_fetch(&buf->buffer->refcount, 0) == 1; |
|
} |
|
|
|
int av_buffer_make_writable(AVBufferRef **pbuf) |
|
{ |
|
AVBufferRef *newbuf, *buf = *pbuf; |
|
|
|
if (av_buffer_is_writable(buf)) |
|
return 0; |
|
|
|
newbuf = av_buffer_alloc(buf->size); |
|
if (!newbuf) |
|
return AVERROR(ENOMEM); |
|
|
|
memcpy(newbuf->data, buf->data, buf->size); |
|
av_buffer_unref(pbuf); |
|
*pbuf = newbuf; |
|
|
|
return 0; |
|
} |
|
|
|
int av_buffer_realloc(AVBufferRef **pbuf, int size) |
|
{ |
|
AVBufferRef *buf = *pbuf; |
|
uint8_t *tmp; |
|
|
|
if (!buf) { |
|
/* allocate a new buffer with av_realloc(), so it will be reallocatable |
|
* later */ |
|
uint8_t *data = av_realloc(NULL, size); |
|
if (!data) |
|
return AVERROR(ENOMEM); |
|
|
|
buf = av_buffer_create(data, size, av_buffer_default_free, NULL, 0); |
|
if (!buf) { |
|
av_freep(&data); |
|
return AVERROR(ENOMEM); |
|
} |
|
|
|
buf->buffer->flags |= BUFFER_FLAG_REALLOCATABLE; |
|
*pbuf = buf; |
|
|
|
return 0; |
|
} else if (buf->size == size) |
|
return 0; |
|
|
|
if (!(buf->buffer->flags & BUFFER_FLAG_REALLOCATABLE) || |
|
!av_buffer_is_writable(buf) || buf->data != buf->buffer->data) { |
|
/* cannot realloc, allocate a new reallocable buffer and copy data */ |
|
AVBufferRef *new = NULL; |
|
|
|
av_buffer_realloc(&new, size); |
|
if (!new) |
|
return AVERROR(ENOMEM); |
|
|
|
memcpy(new->data, buf->data, FFMIN(size, buf->size)); |
|
|
|
av_buffer_unref(pbuf); |
|
*pbuf = new; |
|
return 0; |
|
} |
|
|
|
tmp = av_realloc(buf->buffer->data, size); |
|
if (!tmp) |
|
return AVERROR(ENOMEM); |
|
|
|
buf->buffer->data = buf->data = tmp; |
|
buf->buffer->size = buf->size = size; |
|
return 0; |
|
} |
|
|
|
AVBufferPool *av_buffer_pool_init2(int size, void *opaque, |
|
AVBufferRef* (*alloc)(void *opaque, int size), |
|
void (*pool_free)(void *opaque)) |
|
{ |
|
AVBufferPool *pool = av_mallocz(sizeof(*pool)); |
|
if (!pool) |
|
return NULL; |
|
|
|
ff_mutex_init(&pool->mutex, NULL); |
|
|
|
pool->size = size; |
|
pool->opaque = opaque; |
|
pool->alloc2 = alloc; |
|
pool->pool_free = pool_free; |
|
|
|
avpriv_atomic_int_set(&pool->refcount, 1); |
|
|
|
return pool; |
|
} |
|
|
|
AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size)) |
|
{ |
|
AVBufferPool *pool = av_mallocz(sizeof(*pool)); |
|
if (!pool) |
|
return NULL; |
|
|
|
ff_mutex_init(&pool->mutex, NULL); |
|
|
|
pool->size = size; |
|
pool->alloc = alloc ? alloc : av_buffer_alloc; |
|
|
|
avpriv_atomic_int_set(&pool->refcount, 1); |
|
|
|
return pool; |
|
} |
|
|
|
/* |
|
* This function gets called when the pool has been uninited and |
|
* all the buffers returned to it. |
|
*/ |
|
static void buffer_pool_free(AVBufferPool *pool) |
|
{ |
|
while (pool->pool) { |
|
BufferPoolEntry *buf = pool->pool; |
|
pool->pool = buf->next; |
|
|
|
buf->free(buf->opaque, buf->data); |
|
av_freep(&buf); |
|
} |
|
ff_mutex_destroy(&pool->mutex); |
|
|
|
if (pool->pool_free) |
|
pool->pool_free(pool->opaque); |
|
|
|
av_freep(&pool); |
|
} |
|
|
|
void av_buffer_pool_uninit(AVBufferPool **ppool) |
|
{ |
|
AVBufferPool *pool; |
|
|
|
if (!ppool || !*ppool) |
|
return; |
|
pool = *ppool; |
|
*ppool = NULL; |
|
|
|
if (!avpriv_atomic_int_add_and_fetch(&pool->refcount, -1)) |
|
buffer_pool_free(pool); |
|
} |
|
|
|
static void pool_release_buffer(void *opaque, uint8_t *data) |
|
{ |
|
BufferPoolEntry *buf = opaque; |
|
AVBufferPool *pool = buf->pool; |
|
|
|
ff_mutex_lock(&pool->mutex); |
|
buf->next = pool->pool; |
|
pool->pool = buf; |
|
ff_mutex_unlock(&pool->mutex); |
|
|
|
if (!avpriv_atomic_int_add_and_fetch(&pool->refcount, -1)) |
|
buffer_pool_free(pool); |
|
} |
|
|
|
/* allocate a new buffer and override its free() callback so that |
|
* it is returned to the pool on free */ |
|
static AVBufferRef *pool_alloc_buffer(AVBufferPool *pool) |
|
{ |
|
BufferPoolEntry *buf; |
|
AVBufferRef *ret; |
|
|
|
ret = pool->alloc2 ? pool->alloc2(pool->opaque, pool->size) : |
|
pool->alloc(pool->size); |
|
if (!ret) |
|
return NULL; |
|
|
|
buf = av_mallocz(sizeof(*buf)); |
|
if (!buf) { |
|
av_buffer_unref(&ret); |
|
return NULL; |
|
} |
|
|
|
buf->data = ret->buffer->data; |
|
buf->opaque = ret->buffer->opaque; |
|
buf->free = ret->buffer->free; |
|
buf->pool = pool; |
|
|
|
ret->buffer->opaque = buf; |
|
ret->buffer->free = pool_release_buffer; |
|
|
|
return ret; |
|
} |
|
|
|
AVBufferRef *av_buffer_pool_get(AVBufferPool *pool) |
|
{ |
|
AVBufferRef *ret; |
|
BufferPoolEntry *buf; |
|
|
|
ff_mutex_lock(&pool->mutex); |
|
buf = pool->pool; |
|
if (buf) { |
|
ret = av_buffer_create(buf->data, pool->size, pool_release_buffer, |
|
buf, 0); |
|
if (ret) { |
|
pool->pool = buf->next; |
|
buf->next = NULL; |
|
} |
|
} else { |
|
ret = pool_alloc_buffer(pool); |
|
} |
|
ff_mutex_unlock(&pool->mutex); |
|
|
|
if (ret) |
|
avpriv_atomic_int_add_and_fetch(&pool->refcount, 1); |
|
|
|
return ret; |
|
}
|
|
|