| 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 */ |