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 "attributes.h"
41 #include "avassert.h"
42 #include "dynarray.h"
43 #include "error.h"
44 #include "internal.h"
45 #include "intreadwrite.h"
46 #include "macros.h"
47 #include "mem.h"
48 
49 #ifdef MALLOC_PREFIX
50 
51 #define malloc AV_JOIN(MALLOC_PREFIX, malloc)
52 #define memalign AV_JOIN(MALLOC_PREFIX, memalign)
53 #define posix_memalign AV_JOIN(MALLOC_PREFIX, posix_memalign)
54 #define realloc AV_JOIN(MALLOC_PREFIX, realloc)
55 #define free AV_JOIN(MALLOC_PREFIX, free)
56 
57 void *malloc(size_t size);
58 void *memalign(size_t align, size_t size);
59 int posix_memalign(void **ptr, size_t align, size_t size);
60 void *realloc(void *ptr, size_t size);
61 void free(void *ptr);
62 
63 #endif /* MALLOC_PREFIX */
64 
65 #define ALIGN (HAVE_AVX512 ? 64 : (HAVE_AVX ? 32 : 16))
66 
67 /* NOTE: if you want to override these functions with your own
68  * implementations (not recommended) you have to link libav* as
69  * dynamic libraries and remove -Wl,-Bsymbolic from the linker flags.
70  * Note that this will cost performance. */
71 
73 
74 void av_max_alloc(size_t max){
75  atomic_store_explicit(&max_alloc_size, max, memory_order_relaxed);
76 }
77 
78 static int size_mult(size_t a, size_t b, size_t *r)
79 {
80  size_t t;
81 
82 #if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_mul_overflow)
83  if (__builtin_mul_overflow(a, b, &t))
84  return AVERROR(EINVAL);
85 #else
86  t = a * b;
87  /* Hack inspired from glibc: don't try the division if nelem and elsize
88  * are both less than sqrt(SIZE_MAX). */
89  if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
90  return AVERROR(EINVAL);
91 #endif
92  *r = t;
93  return 0;
94 }
95 
96 void *av_malloc(size_t size)
97 {
98  void *ptr = NULL;
99 
100  if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))
101  return NULL;
102 
103 #if HAVE_POSIX_MEMALIGN
104  if (size) //OS X on SDK 10.6 has a broken posix_memalign implementation
105  if (posix_memalign(&ptr, ALIGN, size))
106  ptr = NULL;
107 #elif HAVE_ALIGNED_MALLOC
108  ptr = _aligned_malloc(size, ALIGN);
109 #elif HAVE_MEMALIGN
110 #ifndef __DJGPP__
111  ptr = memalign(ALIGN, size);
112 #else
113  ptr = memalign(size, ALIGN);
114 #endif
115  /* Why 64?
116  * Indeed, we should align it:
117  * on 4 for 386
118  * on 16 for 486
119  * on 32 for 586, PPro - K6-III
120  * on 64 for K7 (maybe for P3 too).
121  * Because L1 and L2 caches are aligned on those values.
122  * But I don't want to code such logic here!
123  */
124  /* Why 32?
125  * For AVX ASM. SSE / NEON needs only 16.
126  * Why not larger? Because I did not see a difference in benchmarks ...
127  */
128  /* benchmarks with P3
129  * memalign(64) + 1 3071, 3051, 3032
130  * memalign(64) + 2 3051, 3032, 3041
131  * memalign(64) + 4 2911, 2896, 2915
132  * memalign(64) + 8 2545, 2554, 2550
133  * memalign(64) + 16 2543, 2572, 2563
134  * memalign(64) + 32 2546, 2545, 2571
135  * memalign(64) + 64 2570, 2533, 2558
136  *
137  * BTW, malloc seems to do 8-byte alignment by default here.
138  */
139 #else
140  ptr = malloc(size);
141 #endif
142  if(!ptr && !size) {
143  size = 1;
144  ptr= av_malloc(1);
145  }
146 #if CONFIG_MEMORY_POISONING
147  if (ptr)
148  memset(ptr, FF_MEMORY_POISON, size);
149 #endif
150  return ptr;
151 }
152 
153 void *av_realloc(void *ptr, size_t size)
154 {
155  void *ret;
156  if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))
157  return NULL;
158 
159 #if HAVE_ALIGNED_MALLOC
160  ret = _aligned_realloc(ptr, size + !size, ALIGN);
161 #else
162  ret = realloc(ptr, size + !size);
163 #endif
164 #if CONFIG_MEMORY_POISONING
165  if (ret && !ptr)
166  memset(ret, FF_MEMORY_POISON, size);
167 #endif
168  return ret;
169 }
170 
171 void *av_realloc_f(void *ptr, size_t nelem, size_t elsize)
172 {
173  size_t size;
174  void *r;
175 
176  if (size_mult(elsize, nelem, &size)) {
177  av_free(ptr);
178  return NULL;
179  }
180  r = av_realloc(ptr, size);
181  if (!r)
182  av_free(ptr);
183  return r;
184 }
185 
186 int av_reallocp(void *ptr, size_t size)
187 {
188  void *val;
189 
190  if (!size) {
191  av_freep(ptr);
192  return 0;
193  }
194 
195  memcpy(&val, ptr, sizeof(val));
196  val = av_realloc(val, size);
197 
198  if (!val) {
199  av_freep(ptr);
200  return AVERROR(ENOMEM);
201  }
202 
203  memcpy(ptr, &val, sizeof(val));
204  return 0;
205 }
206 
207 void *av_malloc_array(size_t nmemb, size_t size)
208 {
209  size_t result;
210  if (size_mult(nmemb, size, &result) < 0)
211  return NULL;
212  return av_malloc(result);
213 }
214 
215 void *av_realloc_array(void *ptr, size_t nmemb, size_t size)
216 {
217  size_t result;
218  if (size_mult(nmemb, size, &result) < 0)
219  return NULL;
220  return av_realloc(ptr, result);
221 }
222 
223 int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
224 {
225  void *val;
226 
227  memcpy(&val, ptr, sizeof(val));
228  val = av_realloc_f(val, nmemb, size);
229  memcpy(ptr, &val, sizeof(val));
230  if (!val && nmemb && size)
231  return AVERROR(ENOMEM);
232 
233  return 0;
234 }
235 
236 void av_free(void *ptr)
237 {
238 #if HAVE_ALIGNED_MALLOC
239  _aligned_free(ptr);
240 #else
241  free(ptr);
242 #endif
243 }
244 
245 void av_freep(void *arg)
246 {
247  void *val;
248 
249  memcpy(&val, arg, sizeof(val));
250  memcpy(arg, &(void *){ NULL }, sizeof(val));
251  av_free(val);
252 }
253 
254 void *av_mallocz(size_t size)
255 {
256  void *ptr = av_malloc(size);
257  if (ptr)
258  memset(ptr, 0, size);
259  return ptr;
260 }
261 
262 void *av_calloc(size_t nmemb, size_t size)
263 {
264  size_t result;
265  if (size_mult(nmemb, size, &result) < 0)
266  return NULL;
267  return av_mallocz(result);
268 }
269 
270 char *av_strdup(const char *s)
271 {
272  char *ptr = NULL;
273  if (s) {
274  size_t len = strlen(s) + 1;
275  ptr = av_realloc(NULL, len);
276  if (ptr)
277  memcpy(ptr, s, len);
278  }
279  return ptr;
280 }
281 
282 char *av_strndup(const char *s, size_t len)
283 {
284  char *ret = NULL, *end;
285 
286  if (!s)
287  return NULL;
288 
289  end = memchr(s, 0, len);
290  if (end)
291  len = end - s;
292 
293  ret = av_realloc(NULL, len + 1);
294  if (!ret)
295  return NULL;
296 
297  memcpy(ret, s, len);
298  ret[len] = 0;
299  return ret;
300 }
301 
302 void *av_memdup(const void *p, size_t size)
303 {
304  void *ptr = NULL;
305  if (p) {
306  ptr = av_malloc(size);
307  if (ptr)
308  memcpy(ptr, p, size);
309  }
310  return ptr;
311 }
312 
313 int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
314 {
315  void **tab;
316  memcpy(&tab, tab_ptr, sizeof(tab));
317 
318  FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, {
319  tab[*nb_ptr] = elem;
320  memcpy(tab_ptr, &tab, sizeof(tab));
321  }, {
322  return AVERROR(ENOMEM);
323  });
324  return 0;
325 }
326 
327 void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
328 {
329  void **tab;
330  memcpy(&tab, tab_ptr, sizeof(tab));
331 
332  FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, {
333  tab[*nb_ptr] = elem;
334  memcpy(tab_ptr, &tab, sizeof(tab));
335  }, {
336  *nb_ptr = 0;
337  av_freep(tab_ptr);
338  });
339 }
340 
341 void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
342  const uint8_t *elem_data)
343 {
344  uint8_t *tab_elem_data = NULL;
345 
346  FF_DYNARRAY_ADD(INT_MAX, elem_size, *tab_ptr, *nb_ptr, {
347  tab_elem_data = (uint8_t *)*tab_ptr + (*nb_ptr) * elem_size;
348  if (elem_data)
349  memcpy(tab_elem_data, elem_data, elem_size);
350  else if (CONFIG_MEMORY_POISONING)
351  memset(tab_elem_data, FF_MEMORY_POISON, elem_size);
352  }, {
353  av_freep(tab_ptr);
354  *nb_ptr = 0;
355  });
356  return tab_elem_data;
357 }
358 
359 static void fill16(uint8_t *dst, int len)
360 {
361  uint32_t v = AV_RN16(dst - 2);
362 
363  v |= v << 16;
364 
365  while (len >= 4) {
366  AV_WN32(dst, v);
367  dst += 4;
368  len -= 4;
369  }
370 
371  while (len--) {
372  *dst = dst[-2];
373  dst++;
374  }
375 }
376 
377 static void fill24(uint8_t *dst, int len)
378 {
379 #if HAVE_BIGENDIAN
380  uint32_t v = AV_RB24(dst - 3);
381  uint32_t a = v << 8 | v >> 16;
382  uint32_t b = v << 16 | v >> 8;
383  uint32_t c = v << 24 | v;
384 #else
385  uint32_t v = AV_RL24(dst - 3);
386  uint32_t a = v | v << 24;
387  uint32_t b = v >> 8 | v << 16;
388  uint32_t c = v >> 16 | v << 8;
389 #endif
390 
391  while (len >= 12) {
392  AV_WN32(dst, a);
393  AV_WN32(dst + 4, b);
394  AV_WN32(dst + 8, c);
395  dst += 12;
396  len -= 12;
397  }
398 
399  if (len >= 4) {
400  AV_WN32(dst, a);
401  dst += 4;
402  len -= 4;
403  }
404 
405  if (len >= 4) {
406  AV_WN32(dst, b);
407  dst += 4;
408  len -= 4;
409  }
410 
411  while (len--) {
412  *dst = dst[-3];
413  dst++;
414  }
415 }
416 
417 static void fill32(uint8_t *dst, int len)
418 {
419  uint32_t v = AV_RN32(dst - 4);
420 
421 #if HAVE_FAST_64BIT
422  uint64_t v2= v + ((uint64_t)v<<32);
423  while (len >= 32) {
424  AV_WN64(dst , v2);
425  AV_WN64(dst+ 8, v2);
426  AV_WN64(dst+16, v2);
427  AV_WN64(dst+24, v2);
428  dst += 32;
429  len -= 32;
430  }
431 #endif
432 
433  while (len >= 4) {
434  AV_WN32(dst, v);
435  dst += 4;
436  len -= 4;
437  }
438 
439  while (len--) {
440  *dst = dst[-4];
441  dst++;
442  }
443 }
444 
445 void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
446 {
447  const uint8_t *src = &dst[-back];
448  if (!back)
449  return;
450 
451  if (back == 1) {
452  memset(dst, *src, cnt);
453  } else if (back == 2) {
454  fill16(dst, cnt);
455  } else if (back == 3) {
456  fill24(dst, cnt);
457  } else if (back == 4) {
458  fill32(dst, cnt);
459  } else {
460  if (cnt >= 16) {
461  int blocklen = back;
462  while (cnt > blocklen) {
463  memcpy(dst, src, blocklen);
464  dst += blocklen;
465  cnt -= blocklen;
466  blocklen <<= 1;
467  }
468  memcpy(dst, src, cnt);
469  return;
470  }
471  if (cnt >= 8) {
472  AV_COPY32U(dst, src);
473  AV_COPY32U(dst + 4, src + 4);
474  src += 8;
475  dst += 8;
476  cnt -= 8;
477  }
478  if (cnt >= 4) {
479  AV_COPY32U(dst, src);
480  src += 4;
481  dst += 4;
482  cnt -= 4;
483  }
484  if (cnt >= 2) {
485  AV_COPY16U(dst, src);
486  src += 2;
487  dst += 2;
488  cnt -= 2;
489  }
490  if (cnt)
491  *dst = *src;
492  }
493 }
494 
495 void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
496 {
497  size_t max_size;
498 
499  if (min_size <= *size)
500  return ptr;
501 
502  max_size = atomic_load_explicit(&max_alloc_size, memory_order_relaxed);
503  /* *size is an unsigned, so the real maximum is <= UINT_MAX. */
504  max_size = FFMIN(max_size, UINT_MAX);
505 
506  if (min_size > max_size) {
507  *size = 0;
508  return NULL;
509  }
510 
511  min_size = FFMIN(max_size, FFMAX(min_size + min_size / 16 + 32, min_size));
512 
513  ptr = av_realloc(ptr, min_size);
514  /* we could set this to the unmodified min_size but this is safer
515  * if the user lost the ptr and uses NULL now
516  */
517  if (!ptr)
518  min_size = 0;
519 
520  *size = min_size;
521 
522  return ptr;
523 }
524 
525 static inline void fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
526 {
527  size_t max_size;
528  void *val;
529 
530  memcpy(&val, ptr, sizeof(val));
531  if (min_size <= *size) {
532  av_assert0(val || !min_size);
533  return;
534  }
535 
536  max_size = atomic_load_explicit(&max_alloc_size, memory_order_relaxed);
537  /* *size is an unsigned, so the real maximum is <= UINT_MAX. */
538  max_size = FFMIN(max_size, UINT_MAX);
539 
540  if (min_size > max_size) {
541  av_freep(ptr);
542  *size = 0;
543  return;
544  }
545  min_size = FFMIN(max_size, FFMAX(min_size + min_size / 16 + 32, min_size));
546  av_freep(ptr);
547  val = zero_realloc ? av_mallocz(min_size) : av_malloc(min_size);
548  memcpy(ptr, &val, sizeof(val));
549  if (!val)
550  min_size = 0;
551  *size = min_size;
552  return;
553 }
554 
555 void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
556 {
557  fast_malloc(ptr, size, min_size, 0);
558 }
559 
560 void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
561 {
562  fast_malloc(ptr, size, min_size, 1);
563 }
564 
565 int av_size_mult(size_t a, size_t b, size_t *r)
566 {
567  return size_mult(a, b, r);
568 }
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:565
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:126
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
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:341
ATOMIC_VAR_INIT
#define ATOMIC_VAR_INIT(value)
Definition: stdatomic.h:31
b
#define b
Definition: input.c:41
FF_MEMORY_POISON
#define FF_MEMORY_POISON
Definition: internal.h:86
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:525
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
av_max_alloc
void av_max_alloc(size_t max)
Set the maximum size that may be allocated in one block.
Definition: mem.c:74
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:171
macros.h
fill16
static void fill16(uint8_t *dst, int len)
Definition: mem.c:359
val
static double val(void *priv, double ch)
Definition: aeval.c:77
atomic_size_t
intptr_t atomic_size_t
Definition: stdatomic.h:80
avassert.h
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:445
av_malloc_array
void * av_malloc_array(size_t nmemb, size_t size)
Definition: mem.c:207
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:495
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:215
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:245
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:65
fill24
static void fill24(uint8_t *dst, int len)
Definition: mem.c:377
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
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:560
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
error.h
tab
static const uint8_t tab[16]
Definition: rka.c:668
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:327
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:186
fill32
static void fill32(uint8_t *dst, int len)
Definition: mem.c:417
AV_RL24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:93
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:411
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 an array through a pointer to a pointer.
Definition: mem.c:223
attributes.h
internal.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:254
len
int len
Definition: vorbis_enc_data.h:426
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
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:236
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:96
max_alloc_size
static atomic_size_t max_alloc_size
Definition: mem.c:72
size_mult
static int size_mult(size_t a, size_t b, size_t *r)
Definition: mem.c:78
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:313
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
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:555
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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:282
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153