FFmpeg
buffer.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <stdatomic.h>
20 #include <stdint.h>
21 #include <string.h>
22 
23 #include "avassert.h"
24 #include "buffer_internal.h"
25 #include "common.h"
26 #include "mem.h"
27 #include "thread.h"
28 
30  void (*free)(void *opaque, uint8_t *data),
31  void *opaque, int flags)
32 {
33  AVBufferRef *ref = NULL;
34  AVBuffer *buf = NULL;
35 
36  buf = av_mallocz(sizeof(*buf));
37  if (!buf)
38  return NULL;
39 
40  buf->data = data;
41  buf->size = size;
42  buf->free = free ? free : av_buffer_default_free;
43  buf->opaque = opaque;
44 
45  atomic_init(&buf->refcount, 1);
46 
47  buf->flags = flags;
48 
49  ref = av_mallocz(sizeof(*ref));
50  if (!ref) {
51  av_freep(&buf);
52  return NULL;
53  }
54 
55  ref->buffer = buf;
56  ref->data = data;
57  ref->size = size;
58 
59  return ref;
60 }
61 
62 void av_buffer_default_free(void *opaque, uint8_t *data)
63 {
64  av_free(data);
65 }
66 
68 {
69  AVBufferRef *ret = NULL;
70  uint8_t *data = NULL;
71 
72  data = av_malloc(size);
73  if (!data)
74  return NULL;
75 
76  ret = av_buffer_create(data, size, av_buffer_default_free, NULL, 0);
77  if (!ret)
78  av_freep(&data);
79 
80  return ret;
81 }
82 
84 {
86  if (!ret)
87  return NULL;
88 
89  memset(ret->data, 0, size);
90  return ret;
91 }
92 
94 {
95  AVBufferRef *ret = av_mallocz(sizeof(*ret));
96 
97  if (!ret)
98  return NULL;
99 
100  *ret = *buf;
101 
102  atomic_fetch_add_explicit(&buf->buffer->refcount, 1, memory_order_relaxed);
103 
104  return ret;
105 }
106 
108 {
109  AVBuffer *b;
110 
111  b = (*dst)->buffer;
112 
113  if (src) {
114  **dst = **src;
115  av_freep(src);
116  } else
117  av_freep(dst);
118 
119  if (atomic_fetch_sub_explicit(&b->refcount, 1, memory_order_acq_rel) == 1) {
120  b->free(b->opaque, b->data);
121  av_freep(&b);
122  }
123 }
124 
126 {
127  if (!buf || !*buf)
128  return;
129 
130  buffer_replace(buf, NULL);
131 }
132 
134 {
136  return 0;
137 
138  return atomic_load(&buf->buffer->refcount) == 1;
139 }
140 
142 {
143  return buf->buffer->opaque;
144 }
145 
147 {
148  return atomic_load(&buf->buffer->refcount);
149 }
150 
152 {
153  AVBufferRef *newbuf, *buf = *pbuf;
154 
155  if (av_buffer_is_writable(buf))
156  return 0;
157 
158  newbuf = av_buffer_alloc(buf->size);
159  if (!newbuf)
160  return AVERROR(ENOMEM);
161 
162  memcpy(newbuf->data, buf->data, buf->size);
163 
164  buffer_replace(pbuf, &newbuf);
165 
166  return 0;
167 }
168 
169 int av_buffer_realloc(AVBufferRef **pbuf, int size)
170 {
171  AVBufferRef *buf = *pbuf;
172  uint8_t *tmp;
173  int ret;
174 
175  if (!buf) {
176  /* allocate a new buffer with av_realloc(), so it will be reallocatable
177  * later */
178  uint8_t *data = av_realloc(NULL, size);
179  if (!data)
180  return AVERROR(ENOMEM);
181 
182  buf = av_buffer_create(data, size, av_buffer_default_free, NULL, 0);
183  if (!buf) {
184  av_freep(&data);
185  return AVERROR(ENOMEM);
186  }
187 
189  *pbuf = buf;
190 
191  return 0;
192  } else if (buf->size == size)
193  return 0;
194 
196  !av_buffer_is_writable(buf) || buf->data != buf->buffer->data) {
197  /* cannot realloc, allocate a new reallocable buffer and copy data */
198  AVBufferRef *new = NULL;
199 
200  ret = av_buffer_realloc(&new, size);
201  if (ret < 0)
202  return ret;
203 
204  memcpy(new->data, buf->data, FFMIN(size, buf->size));
205 
206  buffer_replace(pbuf, &new);
207  return 0;
208  }
209 
210  tmp = av_realloc(buf->buffer->data, size);
211  if (!tmp)
212  return AVERROR(ENOMEM);
213 
214  buf->buffer->data = buf->data = tmp;
215  buf->buffer->size = buf->size = size;
216  return 0;
217 }
218 
220 {
221  AVBufferRef *dst = *pdst;
222  AVBufferRef *tmp;
223 
224  if (!src) {
225  av_buffer_unref(pdst);
226  return 0;
227  }
228 
229  if (dst && dst->buffer == src->buffer) {
230  /* make sure the data pointers match */
231  dst->data = src->data;
232  dst->size = src->size;
233  return 0;
234  }
235 
236  tmp = av_buffer_ref(src);
237  if (!tmp)
238  return AVERROR(ENOMEM);
239 
240  av_buffer_unref(pdst);
241  *pdst = tmp;
242  return 0;
243 }
244 
245 AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
246  AVBufferRef* (*alloc)(void *opaque, int size),
247  void (*pool_free)(void *opaque))
248 {
249  AVBufferPool *pool = av_mallocz(sizeof(*pool));
250  if (!pool)
251  return NULL;
252 
253  ff_mutex_init(&pool->mutex, NULL);
254 
255  pool->size = size;
256  pool->opaque = opaque;
257  pool->alloc2 = alloc;
258  pool->alloc = av_buffer_alloc; // fallback
259  pool->pool_free = pool_free;
260 
261  atomic_init(&pool->refcount, 1);
262 
263  return pool;
264 }
265 
266 AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size))
267 {
268  AVBufferPool *pool = av_mallocz(sizeof(*pool));
269  if (!pool)
270  return NULL;
271 
272  ff_mutex_init(&pool->mutex, NULL);
273 
274  pool->size = size;
275  pool->alloc = alloc ? alloc : av_buffer_alloc;
276 
277  atomic_init(&pool->refcount, 1);
278 
279  return pool;
280 }
281 
282 /*
283  * This function gets called when the pool has been uninited and
284  * all the buffers returned to it.
285  */
286 static void buffer_pool_free(AVBufferPool *pool)
287 {
288  while (pool->pool) {
289  BufferPoolEntry *buf = pool->pool;
290  pool->pool = buf->next;
291 
292  buf->free(buf->opaque, buf->data);
293  av_freep(&buf);
294  }
295  ff_mutex_destroy(&pool->mutex);
296 
297  if (pool->pool_free)
298  pool->pool_free(pool->opaque);
299 
300  av_freep(&pool);
301 }
302 
304 {
305  AVBufferPool *pool;
306 
307  if (!ppool || !*ppool)
308  return;
309  pool = *ppool;
310  *ppool = NULL;
311 
312  if (atomic_fetch_sub_explicit(&pool->refcount, 1, memory_order_acq_rel) == 1)
313  buffer_pool_free(pool);
314 }
315 
316 static void pool_release_buffer(void *opaque, uint8_t *data)
317 {
318  BufferPoolEntry *buf = opaque;
319  AVBufferPool *pool = buf->pool;
320 
321  if(CONFIG_MEMORY_POISONING)
322  memset(buf->data, FF_MEMORY_POISON, pool->size);
323 
324  ff_mutex_lock(&pool->mutex);
325  buf->next = pool->pool;
326  pool->pool = buf;
327  ff_mutex_unlock(&pool->mutex);
328 
329  if (atomic_fetch_sub_explicit(&pool->refcount, 1, memory_order_acq_rel) == 1)
330  buffer_pool_free(pool);
331 }
332 
333 /* allocate a new buffer and override its free() callback so that
334  * it is returned to the pool on free */
336 {
337  BufferPoolEntry *buf;
338  AVBufferRef *ret;
339 
340  av_assert0(pool->alloc || pool->alloc2);
341 
342  ret = pool->alloc2 ? pool->alloc2(pool->opaque, pool->size) :
343  pool->alloc(pool->size);
344  if (!ret)
345  return NULL;
346 
347  buf = av_mallocz(sizeof(*buf));
348  if (!buf) {
349  av_buffer_unref(&ret);
350  return NULL;
351  }
352 
353  buf->data = ret->buffer->data;
354  buf->opaque = ret->buffer->opaque;
355  buf->free = ret->buffer->free;
356  buf->pool = pool;
357 
358  ret->buffer->opaque = buf;
360 
361  return ret;
362 }
363 
365 {
366  AVBufferRef *ret;
367  BufferPoolEntry *buf;
368 
369  ff_mutex_lock(&pool->mutex);
370  buf = pool->pool;
371  if (buf) {
372  ret = av_buffer_create(buf->data, pool->size, pool_release_buffer,
373  buf, 0);
374  if (ret) {
375  pool->pool = buf->next;
376  buf->next = NULL;
377  }
378  } else {
379  ret = pool_alloc_buffer(pool);
380  }
381  ff_mutex_unlock(&pool->mutex);
382 
383  if (ret)
384  atomic_fetch_add_explicit(&pool->refcount, 1, memory_order_relaxed);
385 
386  return ret;
387 }
388 
390 {
391  BufferPoolEntry *buf = ref->buffer->opaque;
392  av_assert0(buf);
393  return buf->opaque;
394 }
int av_buffer_make_writable(AVBufferRef **pbuf)
Create a writable reference from a given buffer reference, avoiding data copy if possible.
Definition: buffer.c:151
#define NULL
Definition: coverity.c:32
static int ff_mutex_destroy(AVMutex *mutex)
Definition: thread.h:170
void * av_buffer_pool_buffer_get_opaque(AVBufferRef *ref)
Query the original opaque parameter of an allocated buffer in the pool.
Definition: buffer.c:389
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
atomic_uint refcount
Memory handling functions.
#define FF_MEMORY_POISON
Definition: internal.h:89
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:168
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
struct BufferPoolEntry * next
static AVBufferRef * pool_alloc_buffer(AVBufferPool *pool)
Definition: buffer.c:335
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t * data
data described by this buffer
uint8_t
#define av_malloc(s)
atomic_uint refcount
number of existing AVBufferRef instances referring to this buffer
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:113
ptrdiff_t size
Definition: opengl_enc.c:100
The buffer pool.
void av_buffer_default_free(void *opaque, uint8_t *data)
Default free callback, which calls av_free() on the buffer data.
Definition: buffer.c:62
#define src
Definition: vp8dsp.c:254
#define atomic_load(object)
Definition: stdatomic.h:93
simple assert() macros that are a bit more flexible than ISO C assert().
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
int av_buffer_realloc(AVBufferRef **pbuf, int size)
Reallocate a given buffer.
Definition: buffer.c:169
void(* pool_free)(void *opaque)
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:169
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
int av_buffer_is_writable(const AVBufferRef *buf)
Definition: buffer.c:133
AVBufferPool * av_buffer_pool_init2(int size, void *opaque, AVBufferRef *(*alloc)(void *opaque, int size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
Definition: buffer.c:245
int flags
A combination of AV_BUFFER_FLAG_*.
#define atomic_fetch_add_explicit(object, operand, order)
Definition: stdatomic.h:149
void(* free)(void *opaque, uint8_t *data)
a callback for freeing the data
static void pool_release_buffer(void *opaque, uint8_t *data)
Definition: buffer.c:316
#define atomic_fetch_sub_explicit(object, operand, order)
Definition: stdatomic.h:152
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
uint8_t * data
The data buffer.
Definition: buffer.h:89
int flags_internal
A combination of BUFFER_FLAG_*.
int av_buffer_get_ref_count(const AVBufferRef *buf)
Definition: buffer.c:146
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
AVBuffer * buffer
Definition: buffer.h:82
void * av_buffer_get_opaque(const AVBufferRef *buf)
Definition: buffer.c:141
static void buffer_pool_free(AVBufferPool *pool)
Definition: buffer.c:286
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:303
static void buffer_replace(AVBufferRef **dst, AVBufferRef **src)
Definition: buffer.c:107
A reference counted buffer type.
int size
Size of data in bytes.
Definition: buffer.h:93
#define flags(name, subs,...)
Definition: cbs_av1.c:560
void * opaque
an opaque pointer, to be used by the freeing callback
A reference to a data buffer.
Definition: buffer.h:81
common internal and external API header
AVBufferPool * pool
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
Definition: buffer.c:266
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
#define av_free(p)
int size
size of data in bytes
BufferPoolEntry * pool
#define atomic_init(obj, value)
Definition: stdatomic.h:33
#define av_freep(p)
AVBufferRef *(* alloc)(int size)
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:364
void(* free)(void *opaque, uint8_t *data)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define BUFFER_FLAG_REALLOCATABLE
The buffer was av_realloc()ed, so it is reallocatable.
AVBufferRef *(* alloc2)(void *opaque, int size)
static int ff_mutex_init(AVMutex *mutex, const void *attr)
Definition: thread.h:167
int av_buffer_replace(AVBufferRef **pdst, AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:219
static uint8_t tmp[11]
Definition: aes_ctr.c:26