summaryrefslogtreecommitdiff
path: root/libavutil/mem.h (plain)
blob: 527cd03191a90927780291ada6394a9414a6750f
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 * @ingroup lavu_mem
24 * Memory handling functions
25 */
26
27#ifndef AVUTIL_MEM_H
28#define AVUTIL_MEM_H
29
30#include <limits.h>
31#include <stdint.h>
32
33#include "attributes.h"
34#include "error.h"
35#include "avutil.h"
36
37/**
38 * @addtogroup lavu_mem
39 * Utilities for manipulating memory.
40 *
41 * FFmpeg has several applications of memory that are not required of a typical
42 * program. For example, the computing-heavy components like video decoding and
43 * encoding can be sped up significantly through the use of aligned memory.
44 *
45 * However, for each of FFmpeg's applications of memory, there might not be a
46 * recognized or standardized API for that specific use. Memory alignment, for
47 * instance, varies wildly depending on operating systems, architectures, and
48 * compilers. Hence, this component of @ref libavutil is created to make
49 * dealing with memory consistently possible on all platforms.
50 *
51 * @{
52 *
53 * @defgroup lavu_mem_macros Alignment Macros
54 * Helper macros for declaring aligned variables.
55 * @{
56 */
57
58/**
59 * @def DECLARE_ALIGNED(n,t,v)
60 * Declare a variable that is aligned in memory.
61 *
62 * @code{.c}
63 * DECLARE_ALIGNED(16, uint16_t, aligned_int) = 42;
64 * DECLARE_ALIGNED(32, uint8_t, aligned_array)[128];
65 *
66 * // The default-alignment equivalent would be
67 * uint16_t aligned_int = 42;
68 * uint8_t aligned_array[128];
69 * @endcode
70 *
71 * @param n Minimum alignment in bytes
72 * @param t Type of the variable (or array element)
73 * @param v Name of the variable
74 */
75
76/**
77 * @def DECLARE_ASM_CONST(n,t,v)
78 * Declare a static constant aligned variable appropriate for use in inline
79 * assembly code.
80 *
81 * @code{.c}
82 * DECLARE_ASM_CONST(16, uint64_t, pw_08) = UINT64_C(0x0008000800080008);
83 * @endcode
84 *
85 * @param n Minimum alignment in bytes
86 * @param t Type of the variable (or array element)
87 * @param v Name of the variable
88 */
89
90#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C)
91 #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
92 #define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v
93#elif defined(__TI_COMPILER_VERSION__)
94 #define DECLARE_ALIGNED(n,t,v) \
95 AV_PRAGMA(DATA_ALIGN(v,n)) \
96 t __attribute__((aligned(n))) v
97 #define DECLARE_ASM_CONST(n,t,v) \
98 AV_PRAGMA(DATA_ALIGN(v,n)) \
99 static const t __attribute__((aligned(n))) v
100#elif defined(__DJGPP__)
101 #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (FFMIN(n, 16)))) v
102 #define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v
103#elif defined(__GNUC__) || defined(__clang__)
104 #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
105 #define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v
106#elif defined(_MSC_VER)
107 #define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v
108 #define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v
109#else
110 #define DECLARE_ALIGNED(n,t,v) t v
111 #define DECLARE_ASM_CONST(n,t,v) static const t v
112#endif
113
114/**
115 * @}
116 */
117
118/**
119 * @defgroup lavu_mem_attrs Function Attributes
120 * Function attributes applicable to memory handling functions.
121 *
122 * These function attributes can help compilers emit more useful warnings, or
123 * generate better code.
124 * @{
125 */
126
127/**
128 * @def av_malloc_attrib
129 * Function attribute denoting a malloc-like function.
130 *
131 * @see <a href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-g_t_0040code_007bmalloc_007d-function-attribute-3251">Function attribute `malloc` in GCC's documentation</a>
132 */
133
134#if AV_GCC_VERSION_AT_LEAST(3,1)
135 #define av_malloc_attrib __attribute__((__malloc__))
136#else
137 #define av_malloc_attrib
138#endif
139
140/**
141 * @def av_alloc_size(...)
142 * Function attribute used on a function that allocates memory, whose size is
143 * given by the specified parameter(s).
144 *
145 * @code{.c}
146 * void *av_malloc(size_t size) av_alloc_size(1);
147 * void *av_calloc(size_t nmemb, size_t size) av_alloc_size(1, 2);
148 * @endcode
149 *
150 * @param ... One or two parameter indexes, separated by a comma
151 *
152 * @see <a href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-g_t_0040code_007balloc_005fsize_007d-function-attribute-3220">Function attribute `alloc_size` in GCC's documentation</a>
153 */
154
155#if AV_GCC_VERSION_AT_LEAST(4,3)
156 #define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))
157#else
158 #define av_alloc_size(...)
159#endif
160
161/**
162 * @}
163 */
164
165/**
166 * @defgroup lavu_mem_funcs Heap Management
167 * Functions responsible for allocating, freeing, and copying memory.
168 *
169 * All memory allocation functions have a built-in upper limit of `INT_MAX`
170 * bytes. This may be changed with av_max_alloc(), although exercise extreme
171 * caution when doing so.
172 *
173 * @{
174 */
175
176/**
177 * Allocate a memory block with alignment suitable for all memory accesses
178 * (including vectors if available on the CPU).
179 *
180 * @param size Size in bytes for the memory block to be allocated
181 * @return Pointer to the allocated block, or `NULL` if the block cannot
182 * be allocated
183 * @see av_mallocz()
184 */
185void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
186
187/**
188 * Allocate a memory block with alignment suitable for all memory accesses
189 * (including vectors if available on the CPU) and zero all the bytes of the
190 * block.
191 *
192 * @param size Size in bytes for the memory block to be allocated
193 * @return Pointer to the allocated block, or `NULL` if it cannot be allocated
194 * @see av_malloc()
195 */
196void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
197
198/**
199 * Allocate a memory block for an array with av_malloc().
200 *
201 * The allocated memory will have size `size * nmemb` bytes.
202 *
203 * @param nmemb Number of element
204 * @param size Size of a single element
205 * @return Pointer to the allocated block, or `NULL` if the block cannot
206 * be allocated
207 * @see av_malloc()
208 */
209av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size)
210{
211 if (!size || nmemb >= INT_MAX / size)
212 return NULL;
213 return av_malloc(nmemb * size);
214}
215
216/**
217 * Allocate a memory block for an array with av_mallocz().
218 *
219 * The allocated memory will have size `size * nmemb` bytes.
220 *
221 * @param nmemb Number of elements
222 * @param size Size of the single element
223 * @return Pointer to the allocated block, or `NULL` if the block cannot
224 * be allocated
225 *
226 * @see av_mallocz()
227 * @see av_malloc_array()
228 */
229av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size)
230{
231 if (!size || nmemb >= INT_MAX / size)
232 return NULL;
233 return av_mallocz(nmemb * size);
234}
235
236/**
237 * Non-inlined equivalent of av_mallocz_array().
238 *
239 * Created for symmetry with the calloc() C function.
240 */
241void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
242
243/**
244 * Allocate, reallocate, or free a block of memory.
245 *
246 * If `ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is
247 * zero, free the memory block pointed to by `ptr`. Otherwise, expand or
248 * shrink that block of memory according to `size`.
249 *
250 * @param ptr Pointer to a memory block already allocated with
251 * av_realloc() or `NULL`
252 * @param size Size in bytes of the memory block to be allocated or
253 * reallocated
254 *
255 * @return Pointer to a newly-reallocated block or `NULL` if the block
256 * cannot be reallocated or the function is used to free the memory block
257 *
258 * @warning Unlike av_malloc(), the returned pointer is not guaranteed to be
259 * correctly aligned.
260 * @see av_fast_realloc()
261 * @see av_reallocp()
262 */
263void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
264
265/**
266 * Allocate, reallocate, or free a block of memory through a pointer to a
267 * pointer.
268 *
269 * If `*ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is
270 * zero, free the memory block pointed to by `*ptr`. Otherwise, expand or
271 * shrink that block of memory according to `size`.
272 *
273 * @param[in,out] ptr Pointer to a pointer to a memory block already allocated
274 * with av_realloc(), or a pointer to `NULL`. The pointer
275 * is updated on success, or freed on failure.
276 * @param[in] size Size in bytes for the memory block to be allocated or
277 * reallocated
278 *
279 * @return Zero on success, an AVERROR error code on failure
280 *
281 * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
282 * correctly aligned.
283 */
284av_warn_unused_result
285int av_reallocp(void *ptr, size_t size);
286
287/**
288 * Allocate, reallocate, or free a block of memory.
289 *
290 * This function does the same thing as av_realloc(), except:
291 * - It takes two size arguments and allocates `nelem * elsize` bytes,
292 * after checking the result of the multiplication for integer overflow.
293 * - It frees the input block in case of failure, thus avoiding the memory
294 * leak with the classic
295 * @code{.c}
296 * buf = realloc(buf);
297 * if (!buf)
298 * return -1;
299 * @endcode
300 * pattern.
301 */
302void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
303
304/**
305 * Allocate, reallocate, or free an array.
306 *
307 * If `ptr` is `NULL` and `nmemb` > 0, allocate a new block. If
308 * `nmemb` is zero, free the memory block pointed to by `ptr`.
309 *
310 * @param ptr Pointer to a memory block already allocated with
311 * av_realloc() or `NULL`
312 * @param nmemb Number of elements in the array
313 * @param size Size of the single element of the array
314 *
315 * @return Pointer to a newly-reallocated block or NULL if the block
316 * cannot be reallocated or the function is used to free the memory block
317 *
318 * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
319 * correctly aligned.
320 * @see av_reallocp_array()
321 */
322av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
323
324/**
325 * Allocate, reallocate, or free an array through a pointer to a pointer.
326 *
327 * If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block. If `nmemb` is
328 * zero, free the memory block pointed to by `*ptr`.
329 *
330 * @param[in,out] ptr Pointer to a pointer to a memory block already
331 * allocated with av_realloc(), or a pointer to `NULL`.
332 * The pointer is updated on success, or freed on failure.
333 * @param[in] nmemb Number of elements
334 * @param[in] size Size of the single element
335 *
336 * @return Zero on success, an AVERROR error code on failure
337 *
338 * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
339 * correctly aligned.
340 */
341av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
342
343/**
344 * Reallocate the given buffer if it is not large enough, otherwise do nothing.
345 *
346 * If the given buffer is `NULL`, then a new uninitialized buffer is allocated.
347 *
348 * If the given buffer is not large enough, and reallocation fails, `NULL` is
349 * returned and `*size` is set to 0, but the original buffer is not changed or
350 * freed.
351 *
352 * A typical use pattern follows:
353 *
354 * @code{.c}
355 * uint8_t *buf = ...;
356 * uint8_t *new_buf = av_fast_realloc(buf, &current_size, size_needed);
357 * if (!new_buf) {
358 * // Allocation failed; clean up original buffer
359 * av_freep(&buf);
360 * return AVERROR(ENOMEM);
361 * }
362 * @endcode
363 *
364 * @param[in,out] ptr Already allocated buffer, or `NULL`
365 * @param[in,out] size Pointer to current size of buffer `ptr`. `*size` is
366 * changed to `min_size` in case of success or 0 in
367 * case of failure
368 * @param[in] min_size New size of buffer `ptr`
369 * @return `ptr` if the buffer is large enough, a pointer to newly reallocated
370 * buffer if the buffer was not large enough, or `NULL` in case of
371 * error
372 * @see av_realloc()
373 * @see av_fast_malloc()
374 */
375void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size);
376
377/**
378 * Allocate a buffer, reusing the given one if large enough.
379 *
380 * Contrary to av_fast_realloc(), the current buffer contents might not be
381 * preserved and on error the old buffer is freed, thus no special handling to
382 * avoid memleaks is necessary.
383 *
384 * `*ptr` is allowed to be `NULL`, in which case allocation always happens if
385 * `size_needed` is greater than 0.
386 *
387 * @code{.c}
388 * uint8_t *buf = ...;
389 * av_fast_malloc(&buf, &current_size, size_needed);
390 * if (!buf) {
391 * // Allocation failed; buf already freed
392 * return AVERROR(ENOMEM);
393 * }
394 * @endcode
395 *
396 * @param[in,out] ptr Pointer to pointer to an already allocated buffer.
397 * `*ptr` will be overwritten with pointer to new
398 * buffer on success or `NULL` on failure
399 * @param[in,out] size Pointer to current size of buffer `*ptr`. `*size` is
400 * changed to `min_size` in case of success or 0 in
401 * case of failure
402 * @param[in] min_size New size of buffer `*ptr`
403 * @see av_realloc()
404 * @see av_fast_mallocz()
405 */
406void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
407
408/**
409 * Allocate and clear a buffer, reusing the given one if large enough.
410 *
411 * Like av_fast_malloc(), but all newly allocated space is initially cleared.
412 * Reused buffer is not cleared.
413 *
414 * `*ptr` is allowed to be `NULL`, in which case allocation always happens if
415 * `size_needed` is greater than 0.
416 *
417 * @param[in,out] ptr Pointer to pointer to an already allocated buffer.
418 * `*ptr` will be overwritten with pointer to new
419 * buffer on success or `NULL` on failure
420 * @param[in,out] size Pointer to current size of buffer `*ptr`. `*size` is
421 * changed to `min_size` in case of success or 0 in
422 * case of failure
423 * @param[in] min_size New size of buffer `*ptr`
424 * @see av_fast_malloc()
425 */
426void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size);
427
428/**
429 * Free a memory block which has been allocated with a function of av_malloc()
430 * or av_realloc() family.
431 *
432 * @param ptr Pointer to the memory block which should be freed.
433 *
434 * @note `ptr = NULL` is explicitly allowed.
435 * @note It is recommended that you use av_freep() instead, to prevent leaving
436 * behind dangling pointers.
437 * @see av_freep()
438 */
439void av_free(void *ptr);
440
441/**
442 * Free a memory block which has been allocated with a function of av_malloc()
443 * or av_realloc() family, and set the pointer pointing to it to `NULL`.
444 *
445 * @code{.c}
446 * uint8_t *buf = av_malloc(16);
447 * av_free(buf);
448 * // buf now contains a dangling pointer to freed memory, and accidental
449 * // dereference of buf will result in a use-after-free, which may be a
450 * // security risk.
451 *
452 * uint8_t *buf = av_malloc(16);
453 * av_freep(&buf);
454 * // buf is now NULL, and accidental dereference will only result in a
455 * // NULL-pointer dereference.
456 * @endcode
457 *
458 * @param ptr Pointer to the pointer to the memory block which should be freed
459 * @note `*ptr = NULL` is safe and leads to no action.
460 * @see av_free()
461 */
462void av_freep(void *ptr);
463
464/**
465 * Duplicate a string.
466 *
467 * @param s String to be duplicated
468 * @return Pointer to a newly-allocated string containing a
469 * copy of `s` or `NULL` if the string cannot be allocated
470 * @see av_strndup()
471 */
472char *av_strdup(const char *s) av_malloc_attrib;
473
474/**
475 * Duplicate a substring of a string.
476 *
477 * @param s String to be duplicated
478 * @param len Maximum length of the resulting string (not counting the
479 * terminating byte)
480 * @return Pointer to a newly-allocated string containing a
481 * substring of `s` or `NULL` if the string cannot be allocated
482 */
483char *av_strndup(const char *s, size_t len) av_malloc_attrib;
484
485/**
486 * Duplicate a buffer with av_malloc().
487 *
488 * @param p Buffer to be duplicated
489 * @param size Size in bytes of the buffer copied
490 * @return Pointer to a newly allocated buffer containing a
491 * copy of `p` or `NULL` if the buffer cannot be allocated
492 */
493void *av_memdup(const void *p, size_t size);
494
495/**
496 * Overlapping memcpy() implementation.
497 *
498 * @param dst Destination buffer
499 * @param back Number of bytes back to start copying (i.e. the initial size of
500 * the overlapping window); must be > 0
501 * @param cnt Number of bytes to copy; must be >= 0
502 *
503 * @note `cnt > back` is valid, this will copy the bytes we just copied,
504 * thus creating a repeating pattern with a period length of `back`.
505 */
506void av_memcpy_backptr(uint8_t *dst, int back, int cnt);
507
508/**
509 * @}
510 */
511
512/**
513 * @defgroup lavu_mem_dynarray Dynamic Array
514 *
515 * Utilities to make an array grow when needed.
516 *
517 * Sometimes, the programmer would want to have an array that can grow when
518 * needed. The libavutil dynamic array utilities fill that need.
519 *
520 * libavutil supports two systems of appending elements onto a dynamically
521 * allocated array, the first one storing the pointer to the value in the
522 * array, and the second storing the value directly. In both systems, the
523 * caller is responsible for maintaining a variable containing the length of
524 * the array, as well as freeing of the array after use.
525 *
526 * The first system stores pointers to values in a block of dynamically
527 * allocated memory. Since only pointers are stored, the function does not need
528 * to know the size of the type. Both av_dynarray_add() and
529 * av_dynarray_add_nofree() implement this system.
530 *
531 * @code
532 * type **array = NULL; //< an array of pointers to values
533 * int nb = 0; //< a variable to keep track of the length of the array
534 *
535 * type to_be_added = ...;
536 * type to_be_added2 = ...;
537 *
538 * av_dynarray_add(&array, &nb, &to_be_added);
539 * if (nb == 0)
540 * return AVERROR(ENOMEM);
541 *
542 * av_dynarray_add(&array, &nb, &to_be_added2);
543 * if (nb == 0)
544 * return AVERROR(ENOMEM);
545 *
546 * // Now:
547 * // nb == 2
548 * // &to_be_added == array[0]
549 * // &to_be_added2 == array[1]
550 *
551 * av_freep(&array);
552 * @endcode
553 *
554 * The second system stores the value directly in a block of memory. As a
555 * result, the function has to know the size of the type. av_dynarray2_add()
556 * implements this mechanism.
557 *
558 * @code
559 * type *array = NULL; //< an array of values
560 * int nb = 0; //< a variable to keep track of the length of the array
561 *
562 * type to_be_added = ...;
563 * type to_be_added2 = ...;
564 *
565 * type *addr = av_dynarray2_add((void **)&array, &nb, sizeof(*array), NULL);
566 * if (!addr)
567 * return AVERROR(ENOMEM);
568 * memcpy(addr, &to_be_added, sizeof(to_be_added));
569 *
570 * // Shortcut of the above.
571 * type *addr = av_dynarray2_add((void **)&array, &nb, sizeof(*array),
572 * (const void *)&to_be_added2);
573 * if (!addr)
574 * return AVERROR(ENOMEM);
575 *
576 * // Now:
577 * // nb == 2
578 * // to_be_added == array[0]
579 * // to_be_added2 == array[1]
580 *
581 * av_freep(&array);
582 * @endcode
583 *
584 * @{
585 */
586
587/**
588 * Add the pointer to an element to a dynamic array.
589 *
590 * The array to grow is supposed to be an array of pointers to
591 * structures, and the element to add must be a pointer to an already
592 * allocated structure.
593 *
594 * The array is reallocated when its size reaches powers of 2.
595 * Therefore, the amortized cost of adding an element is constant.
596 *
597 * In case of success, the pointer to the array is updated in order to
598 * point to the new grown array, and the number pointed to by `nb_ptr`
599 * is incremented.
600 * In case of failure, the array is freed, `*tab_ptr` is set to `NULL` and
601 * `*nb_ptr` is set to 0.
602 *
603 * @param[in,out] tab_ptr Pointer to the array to grow
604 * @param[in,out] nb_ptr Pointer to the number of elements in the array
605 * @param[in] elem Element to add
606 * @see av_dynarray_add_nofree(), av_dynarray2_add()
607 */
608void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
609
610/**
611 * Add an element to a dynamic array.
612 *
613 * Function has the same functionality as av_dynarray_add(),
614 * but it doesn't free memory on fails. It returns error code
615 * instead and leave current buffer untouched.
616 *
617 * @return >=0 on success, negative otherwise
618 * @see av_dynarray_add(), av_dynarray2_add()
619 */
620av_warn_unused_result
621int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem);
622
623/**
624 * Add an element of size `elem_size` to a dynamic array.
625 *
626 * The array is reallocated when its number of elements reaches powers of 2.
627 * Therefore, the amortized cost of adding an element is constant.
628 *
629 * In case of success, the pointer to the array is updated in order to
630 * point to the new grown array, and the number pointed to by `nb_ptr`
631 * is incremented.
632 * In case of failure, the array is freed, `*tab_ptr` is set to `NULL` and
633 * `*nb_ptr` is set to 0.
634 *
635 * @param[in,out] tab_ptr Pointer to the array to grow
636 * @param[in,out] nb_ptr Pointer to the number of elements in the array
637 * @param[in] elem_size Size in bytes of an element in the array
638 * @param[in] elem_data Pointer to the data of the element to add. If
639 * `NULL`, the space of the newly added element is
640 * allocated but left uninitialized.
641 *
642 * @return Pointer to the data of the element to copy in the newly allocated
643 * space
644 * @see av_dynarray_add(), av_dynarray_add_nofree()
645 */
646void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
647 const uint8_t *elem_data);
648
649/**
650 * @}
651 */
652
653/**
654 * @defgroup lavu_mem_misc Miscellaneous Functions
655 *
656 * Other functions related to memory allocation.
657 *
658 * @{
659 */
660
661/**
662 * Multiply two `size_t` values checking for overflow.
663 *
664 * @param[in] a,b Operands of multiplication
665 * @param[out] r Pointer to the result of the operation
666 * @return 0 on success, AVERROR(EINVAL) on overflow
667 */
668static inline int av_size_mult(size_t a, size_t b, size_t *r)
669{
670 size_t t = a * b;
671 /* Hack inspired from glibc: don't try the division if nelem and elsize
672 * are both less than sqrt(SIZE_MAX). */
673 if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
674 return AVERROR(EINVAL);
675 *r = t;
676 return 0;
677}
678
679/**
680 * Set the maximum size that may be allocated in one block.
681 *
682 * The value specified with this function is effective for all libavutil's @ref
683 * lavu_mem_funcs "heap management functions."
684 *
685 * By default, the max value is defined as `INT_MAX`.
686 *
687 * @param max Value to be set as the new maximum size
688 *
689 * @warning Exercise extreme caution when using this function. Don't touch
690 * this if you do not understand the full consequence of doing so.
691 */
692void av_max_alloc(size_t max);
693
694/**
695 * @}
696 * @}
697 */
698
699#endif /* AVUTIL_MEM_H */
700
generated by cgit at 2024-05-17 15:55:42 (GMT)