FFmpeg
mem.c
Go to the documentation of this file.
1 /*
2  * default memory allocator for libavutil
3  * Copyright (c) 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * default memory allocator for libavutil
25  */
26 
27 #define _XOPEN_SOURCE 600
28 
29 #include "config.h"
30 
31 #include <limits.h>
32 #include <stdint.h>
33 #include <stdlib.h>
34 #include <stdatomic.h>
35 #include <string.h>
36 #if HAVE_MALLOC_H
37 #include <malloc.h>
38 #endif
39 
40 #include "avutil.h"
41 #include "common.h"
42 #include "dynarray.h"
43 #include "intreadwrite.h"
44 #include "mem.h"
45 
46 #ifdef MALLOC_PREFIX
47 
48 #define malloc AV_JOIN(MALLOC_PREFIX, malloc)
49 #define memalign AV_JOIN(MALLOC_PREFIX, memalign)
50 #define posix_memalign AV_JOIN(MALLOC_PREFIX, posix_memalign)
51 #define realloc AV_JOIN(MALLOC_PREFIX, realloc)
52 #define free AV_JOIN(MALLOC_PREFIX, free)
53 
54 void *malloc(size_t size);
55 void *memalign(size_t align, size_t size);
56 int posix_memalign(void **ptr, size_t align, size_t size);
57 void *realloc(void *ptr, size_t size);
58 void free(void *ptr);
59 
60 #endif /* MALLOC_PREFIX */
61 
62 #include "mem_internal.h"
63 
64 #define ALIGN (HAVE_AVX512 ? 64 : (HAVE_AVX ? 32 : 16))
65 
66 /* NOTE: if you want to override these functions with your own
67  * implementations (not recommended) you have to link libav* as
68  * dynamic libraries and remove -Wl,-Bsymbolic from the linker flags.
69  * Note that this will cost performance. */
70 
72 
73 void av_max_alloc(size_t max){
74  atomic_store_explicit(&max_alloc_size, max, memory_order_relaxed);
75 }
76 
77 static int size_mult(size_t a, size_t b, size_t *r)
78 {
79  size_t t;
80 
81 #if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_mul_overflow)
82  if (__builtin_mul_overflow(a, b, &t))
83  return AVERROR(EINVAL);
84 #else
85  t = a * b;
86  /* Hack inspired from glibc: don't try the division if nelem and elsize
87  * are both less than sqrt(SIZE_MAX). */
88  if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
89  return AVERROR(EINVAL);
90 #endif
91  *r = t;
92  return 0;
93 }
94 
95 void *av_malloc(size_t size)
96 {
97  void *ptr = NULL;
98 
99  if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))
100  return NULL;
101 
102 #if HAVE_POSIX_MEMALIGN
103  if (size) //OS X on SDK 10.6 has a broken posix_memalign implementation
104  if (posix_memalign(&ptr, ALIGN, size))
105  ptr = NULL;
106 #elif HAVE_ALIGNED_MALLOC
107  ptr = _aligned_malloc(size, ALIGN);
108 #elif HAVE_MEMALIGN
109 #ifndef __DJGPP__
110  ptr = memalign(ALIGN, size);
111 #else
112  ptr = memalign(size, ALIGN);
113 #endif
114  /* Why 64?
115  * Indeed, we should align it:
116  * on 4 for 386
117  * on 16 for 486
118  * on 32 for 586, PPro - K6-III
119  * on 64 for K7 (maybe for P3 too).
120  * Because L1 and L2 caches are aligned on those values.
121  * But I don't want to code such logic here!
122  */
123  /* Why 32?
124  * For AVX ASM. SSE / NEON needs only 16.
125  * Why not larger? Because I did not see a difference in benchmarks ...
126  */
127  /* benchmarks with P3
128  * memalign(64) + 1 3071, 3051, 3032
129  * memalign(64) + 2 3051, 3032, 3041
130  * memalign(64) + 4 2911, 2896, 2915
131  * memalign(64) + 8 2545, 2554, 2550
132  * memalign(64) + 16 2543, 2572, 2563
133  * memalign(64) + 32 2546, 2545, 2571
134  * memalign(64) + 64 2570, 2533, 2558
135  *
136  * BTW, malloc seems to do 8-byte alignment by default here.
137  */
138 #else
139  ptr = malloc(size);
140 #endif
141  if(!ptr && !size) {
142  size = 1;
143  ptr= av_malloc(1);
144  }
145 #if CONFIG_MEMORY_POISONING
146  if (ptr)
147  memset(ptr, FF_MEMORY_POISON, size);
148 #endif
149  return ptr;
150 }
151 
152 void *av_realloc(void *ptr, size_t size)
153 {
154  void *ret;
155  if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))
156  return NULL;
157 
158 #if HAVE_ALIGNED_MALLOC
159  ret = _aligned_realloc(ptr, size + !size, ALIGN);
160 #else
161  ret = realloc(ptr, size + !size);
162 #endif
163 #if CONFIG_MEMORY_POISONING
164  if (ret && !ptr)
165  memset(ret, FF_MEMORY_POISON, size);
166 #endif
167  return ret;
168 }
169 
170 void *av_realloc_f(void *ptr, size_t nelem, size_t elsize)
171 {
172  size_t size;
173  void *r;
174 
175  if (size_mult(elsize, nelem, &size)) {
176  av_free(ptr);
177  return NULL;
178  }
179  r = av_realloc(ptr, size);
180  if (!r)
181  av_free(ptr);
182  return r;
183 }
184 
185 int av_reallocp(void *ptr, size_t size)
186 {
187  void *val;
188 
189  if (!size) {
190  av_freep(ptr);
191  return 0;
192  }
193 
194  memcpy(&val, ptr, sizeof(val));
195  val = av_realloc(val, size);
196 
197  if (!val) {
198  av_freep(ptr);
199  return AVERROR(ENOMEM);
200  }
201 
202  memcpy(ptr, &val, sizeof(val));
203  return 0;
204 }
205 
206 void *av_malloc_array(size_t nmemb, size_t size)
207 {
208  size_t result;
209  if (size_mult(nmemb, size, &result) < 0)
210  return NULL;
211  return av_malloc(result);
212 }
213 
214 void *av_mallocz_array(size_t nmemb, size_t size)
215 {
216  size_t result;
217  if (size_mult(nmemb, size, &result) < 0)
218  return NULL;
219  return av_mallocz(result);
220 }
221 
222 void *av_realloc_array(void *ptr, size_t nmemb, size_t size)
223 {
224  size_t result;
225  if (size_mult(nmemb, size, &result) < 0)
226  return NULL;
227  return av_realloc(ptr, result);
228 }
229 
230 int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
231 {
232  void *val;
233 
234  memcpy(&val, ptr, sizeof(val));
235  val = av_realloc_f(val, nmemb, size);
236  memcpy(ptr, &val, sizeof(val));
237  if (!val && nmemb && size)
238  return AVERROR(ENOMEM);
239 
240  return 0;
241 }
242 
243 void av_free(void *ptr)
244 {
245 #if HAVE_ALIGNED_MALLOC
246  _aligned_free(ptr);
247 #else
248  free(ptr);
249 #endif
250 }
251 
252 void av_freep(void *arg)
253 {
254  void *val;
255 
256  memcpy(&val, arg, sizeof(val));
257  memcpy(arg, &(void *){ NULL }, sizeof(val));
258  av_free(val);
259 }
260 
261 void *av_mallocz(size_t size)
262 {
263  void *ptr = av_malloc(size);
264  if (ptr)
265  memset(ptr, 0, size);
266  return ptr;
267 }
268 
269 void *av_calloc(size_t nmemb, size_t size)
270 {
271  size_t result;
272  if (size_mult(nmemb, size, &result) < 0)
273  return NULL;
274  return av_mallocz(result);
275 }
276 
277 char *av_strdup(const char *s)
278 {
279  char *ptr = NULL;
280  if (s) {
281  size_t len = strlen(s) + 1;
282  ptr = av_realloc(NULL, len);
283  if (ptr)
284  memcpy(ptr, s, len);
285  }
286  return ptr;
287 }
288 
289 char *av_strndup(const char *s, size_t len)
290 {
291  char *ret = NULL, *end;
292 
293  if (!s)
294  return NULL;
295 
296  end = memchr(s, 0, len);
297  if (end)
298  len = end - s;
299 
300  ret = av_realloc(NULL, len + 1);
301  if (!ret)
302  return NULL;
303 
304  memcpy(ret, s, len);
305  ret[len] = 0;
306  return ret;
307 }
308 
309 void *av_memdup(const void *p, size_t size)
310 {
311  void *ptr = NULL;
312  if (p) {
313  ptr = av_malloc(size);
314  if (ptr)
315  memcpy(ptr, p, size);
316  }
317  return ptr;
318 }
319 
320 int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
321 {
322  void **tab;
323  memcpy(&tab, tab_ptr, sizeof(tab));
324 
325  FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, {
326  tab[*nb_ptr] = elem;
327  memcpy(tab_ptr, &tab, sizeof(tab));
328  }, {
329  return AVERROR(ENOMEM);
330  });
331  return 0;
332 }
333 
334 void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
335 {
336  void **tab;
337  memcpy(&tab, tab_ptr, sizeof(tab));
338 
339  FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, {
340  tab[*nb_ptr] = elem;
341  memcpy(tab_ptr, &tab, sizeof(tab));
342  }, {
343  *nb_ptr = 0;
344  av_freep(tab_ptr);
345  });
346 }
347 
348 void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
349  const uint8_t *elem_data)
350 {
351  uint8_t *tab_elem_data = NULL;
352 
353  FF_DYNARRAY_ADD(INT_MAX, elem_size, *tab_ptr, *nb_ptr, {
354  tab_elem_data = (uint8_t *)*tab_ptr + (*nb_ptr) * elem_size;
355  if (elem_data)
356  memcpy(tab_elem_data, elem_data, elem_size);
357  else if (CONFIG_MEMORY_POISONING)
358  memset(tab_elem_data, FF_MEMORY_POISON, elem_size);
359  }, {
360  av_freep(tab_ptr);
361  *nb_ptr = 0;
362  });
363  return tab_elem_data;
364 }
365 
366 static void fill16(uint8_t *dst, int len)
367 {
368  uint32_t v = AV_RN16(dst - 2);
369 
370  v |= v << 16;
371 
372  while (len >= 4) {
373  AV_WN32(dst, v);
374  dst += 4;
375  len -= 4;
376  }
377 
378  while (len--) {
379  *dst = dst[-2];
380  dst++;
381  }
382 }
383 
384 static void fill24(uint8_t *dst, int len)
385 {
386 #if HAVE_BIGENDIAN
387  uint32_t v = AV_RB24(dst - 3);
388  uint32_t a = v << 8 | v >> 16;
389  uint32_t b = v << 16 | v >> 8;
390  uint32_t c = v << 24 | v;
391 #else
392  uint32_t v = AV_RL24(dst - 3);
393  uint32_t a = v | v << 24;
394  uint32_t b = v >> 8 | v << 16;
395  uint32_t c = v >> 16 | v << 8;
396 #endif
397 
398  while (len >= 12) {
399  AV_WN32(dst, a);
400  AV_WN32(dst + 4, b);
401  AV_WN32(dst + 8, c);
402  dst += 12;
403  len -= 12;
404  }
405 
406  if (len >= 4) {
407  AV_WN32(dst, a);
408  dst += 4;
409  len -= 4;
410  }
411 
412  if (len >= 4) {
413  AV_WN32(dst, b);
414  dst += 4;
415  len -= 4;
416  }
417 
418  while (len--) {
419  *dst = dst[-3];
420  dst++;
421  }
422 }
423 
424 static void fill32(uint8_t *dst, int len)
425 {
426  uint32_t v = AV_RN32(dst - 4);
427 
428 #if HAVE_FAST_64BIT
429  uint64_t v2= v + ((uint64_t)v<<32);
430  while (len >= 32) {
431  AV_WN64(dst , v2);
432  AV_WN64(dst+ 8, v2);
433  AV_WN64(dst+16, v2);
434  AV_WN64(dst+24, v2);
435  dst += 32;
436  len -= 32;
437  }
438 #endif
439 
440  while (len >= 4) {
441  AV_WN32(dst, v);
442  dst += 4;
443  len -= 4;
444  }
445 
446  while (len--) {
447  *dst = dst[-4];
448  dst++;
449  }
450 }
451 
452 void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
453 {
454  const uint8_t *src = &dst[-back];
455  if (!back)
456  return;
457 
458  if (back == 1) {
459  memset(dst, *src, cnt);
460  } else if (back == 2) {
461  fill16(dst, cnt);
462  } else if (back == 3) {
463  fill24(dst, cnt);
464  } else if (back == 4) {
465  fill32(dst, cnt);
466  } else {
467  if (cnt >= 16) {
468  int blocklen = back;
469  while (cnt > blocklen) {
470  memcpy(dst, src, blocklen);
471  dst += blocklen;
472  cnt -= blocklen;
473  blocklen <<= 1;
474  }
475  memcpy(dst, src, cnt);
476  return;
477  }
478  if (cnt >= 8) {
479  AV_COPY32U(dst, src);
480  AV_COPY32U(dst + 4, src + 4);
481  src += 8;
482  dst += 8;
483  cnt -= 8;
484  }
485  if (cnt >= 4) {
486  AV_COPY32U(dst, src);
487  src += 4;
488  dst += 4;
489  cnt -= 4;
490  }
491  if (cnt >= 2) {
492  AV_COPY16U(dst, src);
493  src += 2;
494  dst += 2;
495  cnt -= 2;
496  }
497  if (cnt)
498  *dst = *src;
499  }
500 }
501 
502 void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
503 {
504  size_t max_size;
505 
506  if (min_size <= *size)
507  return ptr;
508 
509  max_size = atomic_load_explicit(&max_alloc_size, memory_order_relaxed);
510 
511  if (min_size > max_size) {
512  *size = 0;
513  return NULL;
514  }
515 
516  min_size = FFMIN(max_size, FFMAX(min_size + min_size / 16 + 32, min_size));
517 
518  ptr = av_realloc(ptr, min_size);
519  /* we could set this to the unmodified min_size but this is safer
520  * if the user lost the ptr and uses NULL now
521  */
522  if (!ptr)
523  min_size = 0;
524 
525  *size = min_size;
526 
527  return ptr;
528 }
529 
530 static inline void fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
531 {
532  size_t max_size;
533  void *val;
534 
535  memcpy(&val, ptr, sizeof(val));
536  if (min_size <= *size) {
537  av_assert0(val || !min_size);
538  return;
539  }
540 
541  max_size = atomic_load_explicit(&max_alloc_size, memory_order_relaxed);
542 
543  if (min_size > max_size) {
544  av_freep(ptr);
545  *size = 0;
546  return;
547  }
548  min_size = FFMIN(max_size, FFMAX(min_size + min_size / 16 + 32, min_size));
549  av_freep(ptr);
550  val = zero_realloc ? av_mallocz(min_size) : av_malloc(min_size);
551  memcpy(ptr, &val, sizeof(val));
552  if (!val)
553  min_size = 0;
554  *size = min_size;
555  return;
556 }
557 
558 void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
559 {
560  fast_malloc(ptr, size, min_size, 0);
561 }
562 
563 void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
564 {
565  fast_malloc(ptr, size, min_size, 1);
566 }
567 
568 int av_size_mult(size_t a, size_t b, size_t *r)
569 {
570  return size_mult(a, b, r);
571 }
av_size_mult
int av_size_mult(size_t a, size_t b, size_t *r)
Multiply two size_t values checking for overflow.
Definition: mem.c:568
FF_DYNARRAY_ADD
#define FF_DYNARRAY_ADD(av_size_max, av_elt_size, av_array, av_size, av_success, av_failure)
Add an element to a dynamic array.
Definition: dynarray.h:45
r
const char * r
Definition: vf_curves.c:116
AVERROR
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
mem_internal.h
AV_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:360
av_dynarray2_add
void * av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size, const uint8_t *elem_data)
Add an element of size elem_size to a dynamic array.
Definition: mem.c:348
ATOMIC_VAR_INIT
#define ATOMIC_VAR_INIT(value)
Definition: stdatomic.h:31
b
#define b
Definition: input.c:40
FF_MEMORY_POISON
#define FF_MEMORY_POISON
Definition: internal.h:87
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:214
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
fast_malloc
static void fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
Definition: mem.c:530
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:309
av_max_alloc
void av_max_alloc(size_t max)
Set the maximum size that may be allocated in one block.
Definition: mem.c:73
av_realloc_f
void * av_realloc_f(void *ptr, size_t nelem, size_t elsize)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:170
fill16
static void fill16(uint8_t *dst, int len)
Definition: mem.c:366
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
val
static double val(void *priv, double ch)
Definition: aeval.c:76
atomic_size_t
intptr_t atomic_size_t
Definition: stdatomic.h:80
AV_COPY32U
#define AV_COPY32U(d, s)
Definition: intreadwrite.h:572
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:452
av_malloc_array
void * av_malloc_array(size_t nmemb, size_t size)
Definition: mem.c:206
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:502
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:222
av_freep
void av_freep(void *arg)
Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family,...
Definition: mem.c:252
AV_COPY16U
#define AV_COPY16U(d, s)
Definition: intreadwrite.h:568
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
limits.h
arg
const char * arg
Definition: jacosubdec.c:67
ALIGN
#define ALIGN
Definition: mem.c:64
fill24
static void fill24(uint8_t *dst, int len)
Definition: mem.c:384
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
src
#define src
Definition: vp8dsp.c:255
av_fast_mallocz
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
Definition: mem.c:563
atomic_load_explicit
#define atomic_load_explicit(object, order)
Definition: stdatomic.h:96
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
av_dynarray_add
void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
Add the pointer to an element to a dynamic array.
Definition: mem.c:334
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
size
int size
Definition: twinvq_data.h:10344
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:185
fill32
static void fill32(uint8_t *dst, int len)
Definition: mem.c:424
AV_RL24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:93
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:230
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:152
common.h
atomic_store_explicit
#define atomic_store_explicit(object, desired, order)
Definition: stdatomic.h:90
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:261
len
int len
Definition: vorbis_enc_data.h:426
av_free
void av_free(void *ptr)
Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family.
Definition: mem.c:243
ret
ret
Definition: filter_design.txt:187
av_malloc
void * av_malloc(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:95
max_alloc_size
static atomic_size_t max_alloc_size
Definition: mem.c:71
size_mult
static int size_mult(size_t a, size_t b, size_t *r)
Definition: mem.c:77
dynarray.h
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:320
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Equivalent of av_mallocz_array().
Definition: mem.c:269
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:277
avutil.h
mem.h
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:558
AV_WN64
#define AV_WN64(p, v)
Definition: intreadwrite.h:380
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
av_strndup
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
Definition: mem.c:289