|
void * | av_malloc (size_t size) av_malloc_attrib av_alloc_size(1) |
|
void * | av_mallocz (size_t size) av_malloc_attrib av_alloc_size(1) |
|
| av_alloc_size (1, 2) static inline void *av_malloc_array(size_t nmemb |
|
return | av_malloc (nmemb *size) |
|
return | av_mallocz (nmemb *size) |
|
void * | av_calloc (size_t nmemb, size_t size) av_malloc_attrib |
|
void * | av_realloc (void *ptr, size_t size) av_alloc_size(2) |
|
av_warn_unused_result int | av_reallocp (void *ptr, size_t size) |
|
void * | av_realloc_f (void *ptr, size_t nelem, size_t elsize) |
|
| av_alloc_size (2, 3) void *av_realloc_array(void *ptr |
|
void * | av_fast_realloc (void *ptr, unsigned int *size, size_t min_size) |
|
void | av_fast_malloc (void *ptr, unsigned int *size, size_t min_size) |
|
void | av_fast_mallocz (void *ptr, unsigned int *size, size_t min_size) |
|
void | av_free (void *ptr) |
|
void | av_freep (void *ptr) |
|
char * | av_strdup (const char *s) av_malloc_attrib |
|
char * | av_strndup (const char *s, size_t len) av_malloc_attrib |
|
void * | av_memdup (const void *p, size_t size) |
|
void | av_memcpy_backptr (uint8_t *dst, int back, int cnt) |
|
Functions responsible for allocating, freeing, and copying memory.
All memory allocation functions have a built-in upper limit of INT_MAX
bytes. This may be changed with av_max_alloc(), although exercise extreme caution when doing so.
◆ av_alloc_size() [1/2]
Allocate a memory block for an array with av_malloc().
The allocated memory will have size size * nmemb
bytes.
- Parameters
-
nmemb | Number of element |
size | Size of a single element |
- Returns
- Pointer to the allocated block, or
NULL
if the block cannot be allocated
- See also
- av_malloc()
Allocate a memory block for an array with av_mallocz().
The allocated memory will have size size * nmemb
bytes.
- Parameters
-
nmemb | Number of elements |
size | Size of the single element |
- Returns
- Pointer to the allocated block, or
NULL
if the block cannot be allocated
- See also
- av_mallocz()
-
av_malloc_array()
◆ av_alloc_size() [2/2]
Allocate, reallocate, or free an array.
If ptr
is NULL
and nmemb
> 0, allocate a new block. If nmemb
is zero, free the memory block pointed to by ptr
.
- Parameters
-
ptr | Pointer to a memory block already allocated with av_realloc() or NULL |
nmemb | Number of elements in the array |
size | Size of the single element of the array |
- Returns
- Pointer to a newly-reallocated block or NULL if the block cannot be reallocated or the function is used to free the memory block
- Warning
- Unlike av_malloc(), the allocated memory is not guaranteed to be correctly aligned.
- See also
- av_reallocp_array()
Allocate, reallocate, or free an array through a pointer to a pointer.
If *ptr
is NULL
and nmemb
> 0, allocate a new block. If nmemb
is zero, free the memory block pointed to by *ptr
.
- Parameters
-
[in,out] | ptr | Pointer to a pointer to a memory block already allocated with av_realloc(), or a pointer to NULL . The pointer is updated on success, or freed on failure. |
[in] | nmemb | Number of elements |
[in] | size | Size of the single element |
- Returns
- Zero on success, an AVERROR error code on failure
- Warning
- Unlike av_malloc(), the allocated memory is not guaranteed to be correctly aligned.
◆ av_calloc()
void* av_calloc |
( |
size_t |
nmemb, |
|
|
size_t |
size |
|
) |
| |
Non-inlined equivalent of av_mallocz_array().
Created for symmetry with the calloc() C function.
◆ 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.
Contrary to av_fast_realloc(), the current buffer contents might not be preserved and on error the old buffer is freed, thus no special handling to avoid memleaks is necessary.
*ptr
is allowed to be NULL
, in which case allocation always happens if size_needed
is greater than 0.
uint8_t *buf = ...;
if (!buf) {
}
- Parameters
-
[in,out] | ptr | Pointer to pointer to an already allocated buffer. *ptr will be overwritten with pointer to new buffer on success or NULL on failure |
[in,out] | size | Pointer to current size of buffer *ptr . *size is changed to min_size in case of success or 0 in case of failure |
[in] | min_size | New size of buffer *ptr |
- See also
- av_realloc()
-
av_fast_mallocz()
◆ 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.
Like av_fast_malloc(), but all newly allocated space is initially cleared. Reused buffer is not cleared.
*ptr
is allowed to be NULL
, in which case allocation always happens if size_needed
is greater than 0.
- Parameters
-
[in,out] | ptr | Pointer to pointer to an already allocated buffer. *ptr will be overwritten with pointer to new buffer on success or NULL on failure |
[in,out] | size | Pointer to current size of buffer *ptr . *size is changed to min_size in case of success or 0 in case of failure |
[in] | min_size | New size of buffer *ptr |
- See also
- av_fast_malloc()
◆ 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.
If the given buffer is NULL
, then a new uninitialized buffer is allocated.
If the given buffer is not large enough, and reallocation fails, NULL
is returned and *size
is set to 0, but the original buffer is not changed or freed.
A typical use pattern follows:
uint8_t *buf = ...;
if (!new_buf) {
}
- Parameters
-
[in,out] | ptr | Already allocated buffer, or NULL |
[in,out] | size | Pointer to current size of buffer ptr . *size is changed to min_size in case of success or 0 in case of failure |
[in] | min_size | New size of buffer ptr |
- Returns
ptr
if the buffer is large enough, a pointer to newly reallocated buffer if the buffer was not large enough, or NULL
in case of error
- See also
- av_realloc()
-
av_fast_malloc()
◆ 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.
- Parameters
-
ptr | Pointer to the memory block which should be freed. |
- Note
ptr = NULL
is explicitly allowed.
-
It is recommended that you use av_freep() instead, to prevent leaving behind dangling pointers.
- See also
- av_freep()
◆ av_freep()
void av_freep |
( |
void * |
ptr | ) |
|
Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family, and set the pointer pointing to it to NULL
.
- Parameters
-
ptr | Pointer to the pointer to the memory block which should be freed |
- Note
*ptr = NULL
is safe and leads to no action.
- See also
- av_free()
◆ av_malloc() [1/2]
void* av_malloc |
( |
size_t |
size | ) |
|
Allocate a memory block with alignment suitable for all memory accesses (including vectors if available on the CPU).
- Parameters
-
size | Size in bytes for the memory block to be allocated |
- Returns
- Pointer to the allocated block, or
NULL
if the block cannot be allocated
- See also
- av_mallocz()
◆ av_malloc() [2/2]
return av_malloc |
( |
nmemb * |
size | ) |
|
◆ av_mallocz() [1/2]
void* av_mallocz |
( |
size_t |
size | ) |
|
Allocate a memory block with alignment suitable for all memory accesses (including vectors if available on the CPU) and zero all the bytes of the block.
- Parameters
-
size | Size in bytes for the memory block to be allocated |
- Returns
- Pointer to the allocated block, or
NULL
if it cannot be allocated
- See also
- av_malloc()
◆ av_mallocz() [2/2]
return av_mallocz |
( |
nmemb * |
size | ) |
|
◆ av_memcpy_backptr()
void av_memcpy_backptr |
( |
uint8_t * |
dst, |
|
|
int |
back, |
|
|
int |
cnt |
|
) |
| |
Overlapping memcpy() implementation.
- Parameters
-
dst | Destination buffer |
back | Number of bytes back to start copying (i.e. the initial size of the overlapping window); must be > 0 |
cnt | Number of bytes to copy; must be >= 0 |
- Note
cnt > back
is valid, this will copy the bytes we just copied, thus creating a repeating pattern with a period length of back
.
◆ av_memdup()
void* av_memdup |
( |
const void * |
p, |
|
|
size_t |
size |
|
) |
| |
Duplicate a buffer with av_malloc().
- Parameters
-
p | Buffer to be duplicated |
size | Size in bytes of the buffer copied |
- Returns
- Pointer to a newly allocated buffer containing a copy of
p
or NULL
if the buffer cannot be allocated
◆ av_realloc()
void* av_realloc |
( |
void * |
ptr, |
|
|
size_t |
size |
|
) |
| |
Allocate, reallocate, or free a block of memory.
If ptr
is NULL
and size
> 0, allocate a new block. If size
is zero, free the memory block pointed to by ptr
. Otherwise, expand or shrink that block of memory according to size
.
- Parameters
-
ptr | Pointer to a memory block already allocated with av_realloc() or NULL |
size | Size in bytes of the memory block to be allocated or reallocated |
- Returns
- Pointer to a newly-reallocated block or
NULL
if the block cannot be reallocated or the function is used to free the memory block
- Warning
- Unlike av_malloc(), the returned pointer is not guaranteed to be correctly aligned.
- See also
- av_fast_realloc()
-
av_reallocp()
◆ av_realloc_f()
void* av_realloc_f |
( |
void * |
ptr, |
|
|
size_t |
nelem, |
|
|
size_t |
elsize |
|
) |
| |
Allocate, reallocate, or free a block of memory.
This function does the same thing as av_realloc(), except:
- It takes two size arguments and allocates
nelem * elsize
bytes, after checking the result of the multiplication for integer overflow.
- It frees the input block in case of failure, thus avoiding the memory leak with the classic
buf = realloc(buf);
if (!buf)
return -1;
pattern.
◆ av_reallocp()
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
If *ptr
is NULL
and size
> 0, allocate a new block. If size
is zero, free the memory block pointed to by *ptr
. Otherwise, expand or shrink that block of memory according to size
.
- Parameters
-
[in,out] | ptr | Pointer to a pointer to a memory block already allocated with av_realloc(), or a pointer to NULL . The pointer is updated on success, or freed on failure. |
[in] | size | Size in bytes for the memory block to be allocated or reallocated |
- Returns
- Zero on success, an AVERROR error code on failure
- Warning
- Unlike av_malloc(), the allocated memory is not guaranteed to be correctly aligned.
◆ av_strdup()
char* av_strdup |
( |
const char * |
s | ) |
|
Duplicate a string.
- Parameters
-
- Returns
- Pointer to a newly-allocated string containing a copy of
s
or NULL
if the string cannot be allocated
- See also
- av_strndup()
◆ av_strndup()
char* av_strndup |
( |
const char * |
s, |
|
|
size_t |
len |
|
) |
| |
Duplicate a substring of a string.
- Parameters
-
s | String to be duplicated |
len | Maximum length of the resulting string (not counting the terminating byte) |
- Returns
- Pointer to a newly-allocated string containing a substring of
s
or NULL
if the string cannot be allocated
◆ nmemb
◆ size
Initial value:{
return NULL
size_t size
Definition: mem.h:207
size_t nmemb
Definition: mem.h:319