2 * default memory allocator for libavutil
3 * Copyright (c) 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
24 * default memory allocator for libavutil
27 #define _XOPEN_SOURCE 600
43 #include "intreadwrite.h"
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)
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
);
60 #endif /* MALLOC_PREFIX */
62 #define ALIGN (HAVE_AVX ? 32 : 16)
64 /* NOTE: if you want to override these functions with your own
65 * implementations (not recommended) you have to link libav* as
66 * dynamic libraries and remove -Wl,-Bsymbolic from the linker flags.
67 * Note that this will cost performance. */
69 static size_t max_alloc_size
= INT_MAX
;
71 void av_max_alloc(size_t max
){
75 void *av_malloc(size_t size
)
78 #if CONFIG_MEMALIGN_HACK
82 /* let's disallow possibly ambiguous cases */
83 if (size
> (max_alloc_size
- 32))
86 #if CONFIG_MEMALIGN_HACK
87 ptr
= malloc(size
+ ALIGN
);
90 diff
= ((~(long)ptr
)&(ALIGN
- 1)) + 1;
91 ptr
= (char *)ptr
+ diff
;
92 ((char *)ptr
)[-1] = diff
;
93 #elif HAVE_POSIX_MEMALIGN
94 if (size
) //OS X on SDK 10.6 has a broken posix_memalign implementation
95 if (posix_memalign(&ptr
, ALIGN
, size
))
97 #elif HAVE_ALIGNED_MALLOC
98 ptr
= _aligned_malloc(size
, ALIGN
);
101 ptr
= memalign(ALIGN
, size
);
103 ptr
= memalign(size
, ALIGN
);
106 * Indeed, we should align it:
109 * on 32 for 586, PPro - K6-III
110 * on 64 for K7 (maybe for P3 too).
111 * Because L1 and L2 caches are aligned on those values.
112 * But I don't want to code such logic here!
115 * For AVX ASM. SSE / NEON needs only 16.
116 * Why not larger? Because I did not see a difference in benchmarks ...
118 /* benchmarks with P3
119 * memalign(64) + 1 3071, 3051, 3032
120 * memalign(64) + 2 3051, 3032, 3041
121 * memalign(64) + 4 2911, 2896, 2915
122 * memalign(64) + 8 2545, 2554, 2550
123 * memalign(64) + 16 2543, 2572, 2563
124 * memalign(64) + 32 2546, 2545, 2571
125 * memalign(64) + 64 2570, 2533, 2558
127 * BTW, malloc seems to do 8-byte alignment by default here.
136 #if CONFIG_MEMORY_POISONING
138 memset(ptr
, FF_MEMORY_POISON
, size
);
143 void *av_realloc(void *ptr
, size_t size
)
145 #if CONFIG_MEMALIGN_HACK
149 /* let's disallow possibly ambiguous cases */
150 if (size
> (max_alloc_size
- 32))
153 #if CONFIG_MEMALIGN_HACK
154 //FIXME this isn't aligned correctly, though it probably isn't needed
156 return av_malloc(size
);
157 diff
= ((char *)ptr
)[-1];
158 av_assert0(diff
>0 && diff
<=ALIGN
);
159 ptr
= realloc((char *)ptr
- diff
, size
+ diff
);
161 ptr
= (char *)ptr
+ diff
;
163 #elif HAVE_ALIGNED_MALLOC
164 return _aligned_realloc(ptr
, size
+ !size
, ALIGN
);
166 return realloc(ptr
, size
+ !size
);
170 void *av_realloc_f(void *ptr
, size_t nelem
, size_t elsize
)
175 if (av_size_mult(elsize
, nelem
, &size
)) {
179 r
= av_realloc(ptr
, size
);
185 int av_reallocp(void *ptr
, size_t size
)
194 ret
= av_realloc(*ptrptr
, size
);
198 return AVERROR(ENOMEM
);
205 void *av_realloc_array(void *ptr
, size_t nmemb
, size_t size
)
207 if (!size
|| nmemb
>= INT_MAX
/ size
)
209 return av_realloc(ptr
, nmemb
* size
);
212 int av_reallocp_array(void *ptr
, size_t nmemb
, size_t size
)
215 *ptrptr
= av_realloc_f(*ptrptr
, nmemb
, size
);
216 if (!*ptrptr
&& nmemb
&& size
)
217 return AVERROR(ENOMEM
);
221 void av_free(void *ptr
)
223 #if CONFIG_MEMALIGN_HACK
225 int v
= ((char *)ptr
)[-1];
226 av_assert0(v
>0 && v
<=ALIGN
);
227 free((char *)ptr
- v
);
229 #elif HAVE_ALIGNED_MALLOC
236 void av_freep(void *arg
)
238 void **ptr
= (void **)arg
;
243 void *av_mallocz(size_t size
)
245 void *ptr
= av_malloc(size
);
247 memset(ptr
, 0, size
);
251 void *av_calloc(size_t nmemb
, size_t size
)
253 if (size
<= 0 || nmemb
>= INT_MAX
/ size
)
255 return av_mallocz(nmemb
* size
);
258 char *av_strdup(const char *s
)
262 int len
= strlen(s
) + 1;
263 ptr
= av_realloc(NULL
, len
);
270 char *av_strndup(const char *s
, size_t len
)
272 char *ret
= NULL
, *end
;
277 end
= memchr(s
, 0, len
);
281 ret
= av_realloc(NULL
, len
+ 1);
290 void *av_memdup(const void *p
, size_t size
)
294 ptr
= av_malloc(size
);
296 memcpy(ptr
, p
, size
);
301 int av_dynarray_add_nofree(void *tab_ptr
, int *nb_ptr
, void *elem
)
303 void **tab
= *(void ***)tab_ptr
;
305 AV_DYNARRAY_ADD(INT_MAX
, sizeof(*tab
), tab
, *nb_ptr
, {
307 *(void ***)tab_ptr
= tab
;
309 return AVERROR(ENOMEM
);
314 void av_dynarray_add(void *tab_ptr
, int *nb_ptr
, void *elem
)
316 void **tab
= *(void ***)tab_ptr
;
318 AV_DYNARRAY_ADD(INT_MAX
, sizeof(*tab
), tab
, *nb_ptr
, {
320 *(void ***)tab_ptr
= tab
;
327 void *av_dynarray2_add(void **tab_ptr
, int *nb_ptr
, size_t elem_size
,
328 const uint8_t *elem_data
)
330 uint8_t *tab_elem_data
= NULL
;
332 AV_DYNARRAY_ADD(INT_MAX
, elem_size
, *tab_ptr
, *nb_ptr
, {
333 tab_elem_data
= (uint8_t *)*tab_ptr
+ (*nb_ptr
) * elem_size
;
335 memcpy(tab_elem_data
, elem_data
, elem_size
);
336 else if (CONFIG_MEMORY_POISONING
)
337 memset(tab_elem_data
, FF_MEMORY_POISON
, elem_size
);
342 return tab_elem_data
;
345 static void fill16(uint8_t *dst
, int len
)
347 uint32_t v
= AV_RN16(dst
- 2);
363 static void fill24(uint8_t *dst
, int len
)
366 uint32_t v
= AV_RB24(dst
- 3);
367 uint32_t a
= v
<< 8 | v
>> 16;
368 uint32_t b
= v
<< 16 | v
>> 8;
369 uint32_t c
= v
<< 24 | v
;
371 uint32_t v
= AV_RL24(dst
- 3);
372 uint32_t a
= v
| v
<< 24;
373 uint32_t b
= v
>> 8 | v
<< 16;
374 uint32_t c
= v
>> 16 | v
<< 8;
403 static void fill32(uint8_t *dst
, int len
)
405 uint32_t v
= AV_RN32(dst
- 4);
419 void av_memcpy_backptr(uint8_t *dst
, int back
, int cnt
)
421 const uint8_t *src
= &dst
[-back
];
426 memset(dst
, *src
, cnt
);
427 } else if (back
== 2) {
429 } else if (back
== 3) {
431 } else if (back
== 4) {
436 while (cnt
> blocklen
) {
437 memcpy(dst
, src
, blocklen
);
442 memcpy(dst
, src
, cnt
);
446 AV_COPY32U(dst
, src
);
447 AV_COPY32U(dst
+ 4, src
+ 4);
453 AV_COPY32U(dst
, src
);
459 AV_COPY16U(dst
, src
);
469 void *av_fast_realloc(void *ptr
, unsigned int *size
, size_t min_size
)
471 if (min_size
< *size
)
474 min_size
= FFMAX(17 * min_size
/ 16 + 32, min_size
);
476 ptr
= av_realloc(ptr
, min_size
);
477 /* we could set this to the unmodified min_size but this is safer
478 * if the user lost the ptr and uses NULL now
488 static inline int ff_fast_malloc(void *ptr
, unsigned int *size
, size_t min_size
, int zero_realloc
)
491 if (min_size
< *size
)
493 min_size
= FFMAX(17 * min_size
/ 16 + 32, min_size
);
495 *p
= zero_realloc
? av_mallocz(min_size
) : av_malloc(min_size
);
502 void av_fast_malloc(void *ptr
, unsigned int *size
, size_t min_size
)
504 ff_fast_malloc(ptr
, size
, min_size
, 0);