Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> | |
3 | * | |
4 | * This file is part of FFmpeg. | |
5 | * | |
6 | * FFmpeg is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU Lesser General Public | |
8 | * License as published by the Free Software Foundation; either | |
9 | * version 2.1 of the License, or (at your option) any later version. | |
10 | * | |
11 | * FFmpeg is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * Lesser General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU Lesser General Public | |
17 | * License along with FFmpeg; if not, write to the Free Software | |
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
19 | */ | |
20 | ||
21 | /** | |
22 | * @file | |
23 | * memory handling functions | |
24 | */ | |
25 | ||
26 | #ifndef AVUTIL_MEM_H | |
27 | #define AVUTIL_MEM_H | |
28 | ||
29 | #include <limits.h> | |
30 | #include <stdint.h> | |
31 | ||
32 | #include "attributes.h" | |
33 | #include "error.h" | |
34 | #include "avutil.h" | |
35 | ||
36 | /** | |
37 | * @addtogroup lavu_mem | |
38 | * @{ | |
39 | */ | |
40 | ||
41 | ||
42 | #if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C) | |
43 | #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v | |
44 | #define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v | |
45 | #elif defined(__TI_COMPILER_VERSION__) | |
46 | #define DECLARE_ALIGNED(n,t,v) \ | |
47 | AV_PRAGMA(DATA_ALIGN(v,n)) \ | |
48 | t __attribute__((aligned(n))) v | |
49 | #define DECLARE_ASM_CONST(n,t,v) \ | |
50 | AV_PRAGMA(DATA_ALIGN(v,n)) \ | |
51 | static const t __attribute__((aligned(n))) v | |
52 | #elif defined(__GNUC__) | |
53 | #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v | |
54 | #define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v | |
55 | #elif defined(_MSC_VER) | |
56 | #define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v | |
57 | #define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v | |
58 | #else | |
59 | #define DECLARE_ALIGNED(n,t,v) t v | |
60 | #define DECLARE_ASM_CONST(n,t,v) static const t v | |
61 | #endif | |
62 | ||
63 | #if AV_GCC_VERSION_AT_LEAST(3,1) | |
64 | #define av_malloc_attrib __attribute__((__malloc__)) | |
65 | #else | |
66 | #define av_malloc_attrib | |
67 | #endif | |
68 | ||
69 | #if AV_GCC_VERSION_AT_LEAST(4,3) | |
70 | #define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__))) | |
71 | #else | |
72 | #define av_alloc_size(...) | |
73 | #endif | |
74 | ||
75 | /** | |
76 | * Allocate a block of size bytes with alignment suitable for all | |
77 | * memory accesses (including vectors if available on the CPU). | |
78 | * @param size Size in bytes for the memory block to be allocated. | |
79 | * @return Pointer to the allocated block, NULL if the block cannot | |
80 | * be allocated. | |
81 | * @see av_mallocz() | |
82 | */ | |
83 | void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1); | |
84 | ||
85 | /** | |
86 | * Allocate a block of size * nmemb bytes with av_malloc(). | |
87 | * @param nmemb Number of elements | |
88 | * @param size Size of the single element | |
89 | * @return Pointer to the allocated block, NULL if the block cannot | |
90 | * be allocated. | |
91 | * @see av_malloc() | |
92 | */ | |
93 | av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size) | |
94 | { | |
95 | if (!size || nmemb >= INT_MAX / size) | |
96 | return NULL; | |
97 | return av_malloc(nmemb * size); | |
98 | } | |
99 | ||
100 | /** | |
101 | * Allocate or reallocate a block of memory. | |
102 | * If ptr is NULL and size > 0, allocate a new block. If | |
103 | * size is zero, free the memory block pointed to by ptr. | |
104 | * @param ptr Pointer to a memory block already allocated with | |
105 | * av_realloc() or NULL. | |
106 | * @param size Size in bytes of the memory block to be allocated or | |
107 | * reallocated. | |
108 | * @return Pointer to a newly-reallocated block or NULL if the block | |
109 | * cannot be reallocated or the function is used to free the memory block. | |
110 | * @warning Pointers originating from the av_malloc() family of functions must | |
111 | * not be passed to av_realloc(). The former can be implemented using | |
112 | * memalign() (or other functions), and there is no guarantee that | |
113 | * pointers from such functions can be passed to realloc() at all. | |
114 | * The situation is undefined according to POSIX and may crash with | |
115 | * some libc implementations. | |
116 | * @see av_fast_realloc() | |
117 | */ | |
118 | void *av_realloc(void *ptr, size_t size) av_alloc_size(2); | |
119 | ||
120 | /** | |
121 | * Allocate or reallocate a block of memory. | |
122 | * This function does the same thing as av_realloc, except: | |
123 | * - It takes two arguments and checks the result of the multiplication for | |
124 | * integer overflow. | |
125 | * - It frees the input block in case of failure, thus avoiding the memory | |
126 | * leak with the classic "buf = realloc(buf); if (!buf) return -1;". | |
127 | */ | |
128 | void *av_realloc_f(void *ptr, size_t nelem, size_t elsize); | |
129 | ||
130 | /** | |
131 | * Allocate or reallocate a block of memory. | |
132 | * If *ptr is NULL and size > 0, allocate a new block. If | |
133 | * size is zero, free the memory block pointed to by ptr. | |
134 | * @param ptr Pointer to a pointer to a memory block already allocated | |
135 | * with av_realloc(), or pointer to a pointer to NULL. | |
136 | * The pointer is updated on success, or freed on failure. | |
137 | * @param size Size in bytes for the memory block to be allocated or | |
138 | * reallocated | |
139 | * @return Zero on success, an AVERROR error code on failure. | |
140 | * @warning Pointers originating from the av_malloc() family of functions must | |
141 | * not be passed to av_reallocp(). The former can be implemented using | |
142 | * memalign() (or other functions), and there is no guarantee that | |
143 | * pointers from such functions can be passed to realloc() at all. | |
144 | * The situation is undefined according to POSIX and may crash with | |
145 | * some libc implementations. | |
146 | */ | |
147 | int av_reallocp(void *ptr, size_t size); | |
148 | ||
149 | /** | |
150 | * Allocate or reallocate an array. | |
151 | * If ptr is NULL and nmemb > 0, allocate a new block. If | |
152 | * nmemb is zero, free the memory block pointed to by ptr. | |
153 | * @param ptr Pointer to a memory block already allocated with | |
154 | * av_realloc() or NULL. | |
155 | * @param nmemb Number of elements | |
156 | * @param size Size of the single element | |
157 | * @return Pointer to a newly-reallocated block or NULL if the block | |
158 | * cannot be reallocated or the function is used to free the memory block. | |
159 | * @warning Pointers originating from the av_malloc() family of functions must | |
160 | * not be passed to av_realloc(). The former can be implemented using | |
161 | * memalign() (or other functions), and there is no guarantee that | |
162 | * pointers from such functions can be passed to realloc() at all. | |
163 | * The situation is undefined according to POSIX and may crash with | |
164 | * some libc implementations. | |
165 | */ | |
166 | av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size); | |
167 | ||
168 | /** | |
169 | * Allocate or reallocate an array through a pointer to a pointer. | |
170 | * If *ptr is NULL and nmemb > 0, allocate a new block. If | |
171 | * nmemb is zero, free the memory block pointed to by ptr. | |
172 | * @param ptr Pointer to a pointer to a memory block already allocated | |
173 | * with av_realloc(), or pointer to a pointer to NULL. | |
174 | * The pointer is updated on success, or freed on failure. | |
175 | * @param nmemb Number of elements | |
176 | * @param size Size of the single element | |
177 | * @return Zero on success, an AVERROR error code on failure. | |
178 | * @warning Pointers originating from the av_malloc() family of functions must | |
179 | * not be passed to av_realloc(). The former can be implemented using | |
180 | * memalign() (or other functions), and there is no guarantee that | |
181 | * pointers from such functions can be passed to realloc() at all. | |
182 | * The situation is undefined according to POSIX and may crash with | |
183 | * some libc implementations. | |
184 | */ | |
185 | av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size); | |
186 | ||
187 | /** | |
188 | * Free a memory block which has been allocated with av_malloc(z)() or | |
189 | * av_realloc(). | |
190 | * @param ptr Pointer to the memory block which should be freed. | |
191 | * @note ptr = NULL is explicitly allowed. | |
192 | * @note It is recommended that you use av_freep() instead. | |
193 | * @see av_freep() | |
194 | */ | |
195 | void av_free(void *ptr); | |
196 | ||
197 | /** | |
198 | * Allocate a block of size bytes with alignment suitable for all | |
199 | * memory accesses (including vectors if available on the CPU) and | |
200 | * zero all the bytes of the block. | |
201 | * @param size Size in bytes for the memory block to be allocated. | |
202 | * @return Pointer to the allocated block, NULL if it cannot be allocated. | |
203 | * @see av_malloc() | |
204 | */ | |
205 | void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1); | |
206 | ||
207 | /** | |
208 | * Allocate a block of nmemb * size bytes with alignment suitable for all | |
209 | * memory accesses (including vectors if available on the CPU) and | |
210 | * zero all the bytes of the block. | |
211 | * The allocation will fail if nmemb * size is greater than or equal | |
212 | * to INT_MAX. | |
213 | * @param nmemb | |
214 | * @param size | |
215 | * @return Pointer to the allocated block, NULL if it cannot be allocated. | |
216 | */ | |
217 | void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib; | |
218 | ||
219 | /** | |
220 | * Allocate a block of size * nmemb bytes with av_mallocz(). | |
221 | * @param nmemb Number of elements | |
222 | * @param size Size of the single element | |
223 | * @return Pointer to the allocated block, NULL if the block cannot | |
224 | * be allocated. | |
225 | * @see av_mallocz() | |
226 | * @see av_malloc_array() | |
227 | */ | |
228 | av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size) | |
229 | { | |
230 | if (!size || nmemb >= INT_MAX / size) | |
231 | return NULL; | |
232 | return av_mallocz(nmemb * size); | |
233 | } | |
234 | ||
235 | /** | |
236 | * Duplicate the string s. | |
237 | * @param s string to be duplicated | |
238 | * @return Pointer to a newly-allocated string containing a | |
239 | * copy of s or NULL if the string cannot be allocated. | |
240 | */ | |
241 | char *av_strdup(const char *s) av_malloc_attrib; | |
242 | ||
243 | /** | |
244 | * Duplicate a substring of the string s. | |
245 | * @param s string to be duplicated | |
246 | * @param len the maximum length of the resulting string (not counting the | |
247 | * terminating byte). | |
248 | * @return Pointer to a newly-allocated string containing a | |
249 | * copy of s or NULL if the string cannot be allocated. | |
250 | */ | |
251 | char *av_strndup(const char *s, size_t len) av_malloc_attrib; | |
252 | ||
253 | /** | |
254 | * Duplicate the buffer p. | |
255 | * @param p buffer to be duplicated | |
256 | * @return Pointer to a newly allocated buffer containing a | |
257 | * copy of p or NULL if the buffer cannot be allocated. | |
258 | */ | |
259 | void *av_memdup(const void *p, size_t size); | |
260 | ||
261 | /** | |
262 | * Free a memory block which has been allocated with av_malloc(z)() or | |
263 | * av_realloc() and set the pointer pointing to it to NULL. | |
264 | * @param ptr Pointer to the pointer to the memory block which should | |
265 | * be freed. | |
266 | * @note passing a pointer to a NULL pointer is safe and leads to no action. | |
267 | * @see av_free() | |
268 | */ | |
269 | void av_freep(void *ptr); | |
270 | ||
271 | /** | |
272 | * Add an element to a dynamic array. | |
273 | * | |
274 | * The array to grow is supposed to be an array of pointers to | |
275 | * structures, and the element to add must be a pointer to an already | |
276 | * allocated structure. | |
277 | * | |
278 | * The array is reallocated when its size reaches powers of 2. | |
279 | * Therefore, the amortized cost of adding an element is constant. | |
280 | * | |
281 | * In case of success, the pointer to the array is updated in order to | |
282 | * point to the new grown array, and the number pointed to by nb_ptr | |
283 | * is incremented. | |
284 | * In case of failure, the array is freed, *tab_ptr is set to NULL and | |
285 | * *nb_ptr is set to 0. | |
286 | * | |
287 | * @param tab_ptr pointer to the array to grow | |
288 | * @param nb_ptr pointer to the number of elements in the array | |
289 | * @param elem element to add | |
290 | * @see av_dynarray_add_nofree(), av_dynarray2_add() | |
291 | */ | |
292 | void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem); | |
293 | ||
294 | /** | |
295 | * Add an element to a dynamic array. | |
296 | * | |
297 | * Function has the same functionality as av_dynarray_add(), | |
298 | * but it doesn't free memory on fails. It returns error code | |
299 | * instead and leave current buffer untouched. | |
300 | * | |
301 | * @param tab_ptr pointer to the array to grow | |
302 | * @param nb_ptr pointer to the number of elements in the array | |
303 | * @param elem element to add | |
304 | * @return >=0 on success, negative otherwise. | |
305 | * @see av_dynarray_add(), av_dynarray2_add() | |
306 | */ | |
307 | int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem); | |
308 | ||
309 | /** | |
310 | * Add an element of size elem_size to a dynamic array. | |
311 | * | |
312 | * The array is reallocated when its number of elements reaches powers of 2. | |
313 | * Therefore, the amortized cost of adding an element is constant. | |
314 | * | |
315 | * In case of success, the pointer to the array is updated in order to | |
316 | * point to the new grown array, and the number pointed to by nb_ptr | |
317 | * is incremented. | |
318 | * In case of failure, the array is freed, *tab_ptr is set to NULL and | |
319 | * *nb_ptr is set to 0. | |
320 | * | |
321 | * @param tab_ptr pointer to the array to grow | |
322 | * @param nb_ptr pointer to the number of elements in the array | |
323 | * @param elem_size size in bytes of the elements in the array | |
324 | * @param elem_data pointer to the data of the element to add. If NULL, the space of | |
325 | * the new added element is not filled. | |
326 | * @return pointer to the data of the element to copy in the new allocated space. | |
327 | * If NULL, the new allocated space is left uninitialized." | |
328 | * @see av_dynarray_add(), av_dynarray_add_nofree() | |
329 | */ | |
330 | void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size, | |
331 | const uint8_t *elem_data); | |
332 | ||
333 | /** | |
334 | * Multiply two size_t values checking for overflow. | |
335 | * @return 0 if success, AVERROR(EINVAL) if overflow. | |
336 | */ | |
337 | static inline int av_size_mult(size_t a, size_t b, size_t *r) | |
338 | { | |
339 | size_t t = a * b; | |
340 | /* Hack inspired from glibc: only try the division if nelem and elsize | |
341 | * are both greater than sqrt(SIZE_MAX). */ | |
342 | if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b) | |
343 | return AVERROR(EINVAL); | |
344 | *r = t; | |
345 | return 0; | |
346 | } | |
347 | ||
348 | /** | |
349 | * Set the maximum size that may me allocated in one block. | |
350 | */ | |
351 | void av_max_alloc(size_t max); | |
352 | ||
353 | /** | |
354 | * deliberately overlapping memcpy implementation | |
355 | * @param dst destination buffer | |
356 | * @param back how many bytes back we start (the initial size of the overlapping window), must be > 0 | |
357 | * @param cnt number of bytes to copy, must be >= 0 | |
358 | * | |
359 | * cnt > back is valid, this will copy the bytes we just copied, | |
360 | * thus creating a repeating pattern with a period length of back. | |
361 | */ | |
362 | void av_memcpy_backptr(uint8_t *dst, int back, int cnt); | |
363 | ||
364 | /** | |
365 | * Reallocate the given block if it is not large enough, otherwise do nothing. | |
366 | * | |
367 | * @see av_realloc | |
368 | */ | |
369 | void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size); | |
370 | ||
371 | /** | |
372 | * Allocate a buffer, reusing the given one if large enough. | |
373 | * | |
374 | * Contrary to av_fast_realloc the current buffer contents might not be | |
375 | * preserved and on error the old buffer is freed, thus no special | |
376 | * handling to avoid memleaks is necessary. | |
377 | * | |
378 | * @param ptr pointer to pointer to already allocated buffer, overwritten with pointer to new buffer | |
379 | * @param size size of the buffer *ptr points to | |
380 | * @param min_size minimum size of *ptr buffer after returning, *ptr will be NULL and | |
381 | * *size 0 if an error occurred. | |
382 | */ | |
383 | void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size); | |
384 | ||
385 | /** | |
386 | * @} | |
387 | */ | |
388 | ||
389 | #endif /* AVUTIL_MEM_H */ |