mirror of
https://git.ffmpeg.org/ffmpeg.git
synced 2024-12-26 09:12:33 +00:00
f637046d31
Clang normally disguises as GCC (defining __GNUC__), and thus get all the normal GCC specific attributes. Clang can also work as a drop-in replacement for MSVC, and in these cases, it doesn't define __GNUC__, but defines _MSC_VER instead. Even in these setups, it still supports the GCC style attributes, thus use them, especially where there isn't any MSVC specific version, or where the MSVC specific version doesn't work on clang (for DECLARE_ASM_CONST). Signed-off-by: Martin Storsjö <martin@martin.st>
276 lines
10 KiB
C
276 lines
10 KiB
C
/*
|
|
* copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
|
|
*
|
|
* This file is part of Libav.
|
|
*
|
|
* Libav is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* Libav is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with Libav; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* memory handling functions
|
|
*/
|
|
|
|
#ifndef AVUTIL_MEM_H
|
|
#define AVUTIL_MEM_H
|
|
|
|
#include <limits.h>
|
|
#include <stdint.h>
|
|
|
|
#include "attributes.h"
|
|
#include "avutil.h"
|
|
|
|
/**
|
|
* @addtogroup lavu_mem
|
|
* @{
|
|
*/
|
|
|
|
|
|
#if defined(__ICC) && __ICC < 1200 || defined(__SUNPRO_C)
|
|
#define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
|
|
#define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v
|
|
#elif defined(__TI_COMPILER_VERSION__)
|
|
#define DECLARE_ALIGNED(n,t,v) \
|
|
AV_PRAGMA(DATA_ALIGN(v,n)) \
|
|
t __attribute__((aligned(n))) v
|
|
#define DECLARE_ASM_CONST(n,t,v) \
|
|
AV_PRAGMA(DATA_ALIGN(v,n)) \
|
|
static const t __attribute__((aligned(n))) v
|
|
#elif defined(__GNUC__) || defined(__clang__)
|
|
#define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
|
|
#define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v
|
|
#elif defined(_MSC_VER)
|
|
#define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v
|
|
#define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v
|
|
#else
|
|
#define DECLARE_ALIGNED(n,t,v) t v
|
|
#define DECLARE_ASM_CONST(n,t,v) static const t v
|
|
#endif
|
|
|
|
#if AV_GCC_VERSION_AT_LEAST(3,1)
|
|
#define av_malloc_attrib __attribute__((__malloc__))
|
|
#else
|
|
#define av_malloc_attrib
|
|
#endif
|
|
|
|
#if AV_GCC_VERSION_AT_LEAST(4,3)
|
|
#define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))
|
|
#else
|
|
#define av_alloc_size(...)
|
|
#endif
|
|
|
|
/**
|
|
* Allocate a block of size bytes with alignment suitable for all
|
|
* memory accesses (including vectors if available on the CPU).
|
|
* @param size Size in bytes for the memory block to be allocated.
|
|
* @return Pointer to the allocated block, NULL if the block cannot
|
|
* be allocated.
|
|
* @see av_mallocz()
|
|
*/
|
|
void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
|
|
|
|
/**
|
|
* Allocate a block of size * nmemb bytes with av_malloc().
|
|
* @param nmemb Number of elements
|
|
* @param size Size of the single element
|
|
* @return Pointer to the allocated block, NULL if the block cannot
|
|
* be allocated.
|
|
* @see av_malloc()
|
|
*/
|
|
av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size)
|
|
{
|
|
if (!size || nmemb >= INT_MAX / size)
|
|
return NULL;
|
|
return av_malloc(nmemb * size);
|
|
}
|
|
|
|
/**
|
|
* Allocate or reallocate 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.
|
|
* @param ptr Pointer to a memory block already allocated with
|
|
* av_realloc() or NULL.
|
|
* @param size Size in bytes of the memory block to be allocated or
|
|
* reallocated.
|
|
* @return 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 Pointers originating from the av_malloc() family of functions must
|
|
* not be passed to av_realloc(). The former can be implemented using
|
|
* memalign() (or other functions), and there is no guarantee that
|
|
* pointers from such functions can be passed to realloc() at all.
|
|
* The situation is undefined according to POSIX and may crash with
|
|
* some libc implementations.
|
|
* @see av_fast_realloc()
|
|
*/
|
|
void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
|
|
|
|
/**
|
|
* Allocate or reallocate 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.
|
|
* @param ptr Pointer to a pointer to a memory block already allocated
|
|
* with av_realloc(), or pointer to a pointer to NULL.
|
|
* The pointer is updated on success, or freed on failure.
|
|
* @param size Size in bytes for the memory block to be allocated or
|
|
* reallocated
|
|
* @return Zero on success, an AVERROR error code on failure.
|
|
* @warning Pointers originating from the av_malloc() family of functions must
|
|
* not be passed to av_reallocp(). The former can be implemented using
|
|
* memalign() (or other functions), and there is no guarantee that
|
|
* pointers from such functions can be passed to realloc() at all.
|
|
* The situation is undefined according to POSIX and may crash with
|
|
* some libc implementations.
|
|
*/
|
|
int av_reallocp(void *ptr, size_t size);
|
|
|
|
/**
|
|
* Allocate or reallocate 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.
|
|
* @param ptr Pointer to a memory block already allocated with
|
|
* av_realloc() or NULL.
|
|
* @param nmemb Number of elements
|
|
* @param size Size of the single element
|
|
* @return 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 Pointers originating from the av_malloc() family of functions must
|
|
* not be passed to av_realloc(). The former can be implemented using
|
|
* memalign() (or other functions), and there is no guarantee that
|
|
* pointers from such functions can be passed to realloc() at all.
|
|
* The situation is undefined according to POSIX and may crash with
|
|
* some libc implementations.
|
|
*/
|
|
av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
|
|
|
|
/**
|
|
* Allocate or reallocate 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.
|
|
* @param ptr Pointer to a pointer to a memory block already allocated
|
|
* with av_realloc(), or pointer to a pointer to NULL.
|
|
* The pointer is updated on success, or freed on failure.
|
|
* @param nmemb Number of elements
|
|
* @param size Size of the single element
|
|
* @return Zero on success, an AVERROR error code on failure.
|
|
* @warning Pointers originating from the av_malloc() family of functions must
|
|
* not be passed to av_realloc(). The former can be implemented using
|
|
* memalign() (or other functions), and there is no guarantee that
|
|
* pointers from such functions can be passed to realloc() at all.
|
|
* The situation is undefined according to POSIX and may crash with
|
|
* some libc implementations.
|
|
*/
|
|
av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
|
|
|
|
/**
|
|
* Free a memory block which has been allocated with av_malloc(z)() or
|
|
* av_realloc().
|
|
* @param ptr Pointer to the memory block which should be freed.
|
|
* @note ptr = NULL is explicitly allowed.
|
|
* @note It is recommended that you use av_freep() instead.
|
|
* @see av_freep()
|
|
*/
|
|
void av_free(void *ptr);
|
|
|
|
/**
|
|
* Allocate a block of size bytes with alignment suitable for all
|
|
* memory accesses (including vectors if available on the CPU) and
|
|
* zero all the bytes of the block.
|
|
* @param size Size in bytes for the memory block to be allocated.
|
|
* @return Pointer to the allocated block, NULL if it cannot be allocated.
|
|
* @see av_malloc()
|
|
*/
|
|
void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
|
|
|
|
/**
|
|
* Allocate a block of size * nmemb bytes with av_mallocz().
|
|
* @param nmemb Number of elements
|
|
* @param size Size of the single element
|
|
* @return Pointer to the allocated block, NULL if the block cannot
|
|
* be allocated.
|
|
* @see av_mallocz()
|
|
* @see av_malloc_array()
|
|
*/
|
|
av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size)
|
|
{
|
|
if (!size || nmemb >= INT_MAX / size)
|
|
return NULL;
|
|
return av_mallocz(nmemb * size);
|
|
}
|
|
|
|
/**
|
|
* Duplicate the string s.
|
|
* @param s string to be duplicated
|
|
* @return Pointer to a newly-allocated string containing a
|
|
* copy of s or NULL if the string cannot be allocated.
|
|
*/
|
|
char *av_strdup(const char *s) av_malloc_attrib;
|
|
|
|
/**
|
|
* Duplicate a substring of the string s.
|
|
* @param s string to be duplicated
|
|
* @param len the maximum length of the resulting string (not counting the
|
|
* terminating byte).
|
|
* @return Pointer to a newly-allocated string containing a
|
|
* copy of s or NULL if the string cannot be allocated.
|
|
*/
|
|
char *av_strndup(const char *s, size_t len) av_malloc_attrib;
|
|
|
|
/**
|
|
* Free a memory block which has been allocated with av_malloc(z)() or
|
|
* av_realloc() and set the pointer pointing to it to NULL.
|
|
* @param ptr Pointer to the pointer to the memory block which should
|
|
* be freed.
|
|
* @see av_free()
|
|
*/
|
|
void av_freep(void *ptr);
|
|
|
|
/**
|
|
* deliberately overlapping memcpy implementation
|
|
* @param dst destination buffer
|
|
* @param back how many bytes back we start (the initial size of the overlapping window)
|
|
* @param cnt number of bytes to copy, must be >= 0
|
|
*
|
|
* cnt > back is valid, this will copy the bytes we just copied,
|
|
* thus creating a repeating pattern with a period length of back.
|
|
*/
|
|
void av_memcpy_backptr(uint8_t *dst, int back, int cnt);
|
|
|
|
/**
|
|
* Reallocate the given block if it is not large enough, otherwise do nothing.
|
|
*
|
|
* @see av_realloc
|
|
*/
|
|
void *av_fast_realloc(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.
|
|
*
|
|
* @param ptr pointer to pointer to already allocated buffer, overwritten with pointer to new buffer
|
|
* @param size size of the buffer *ptr points to
|
|
* @param min_size minimum size of *ptr buffer after returning, *ptr will be NULL and
|
|
* *size 0 if an error occurred.
|
|
*/
|
|
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#endif /* AVUTIL_MEM_H */
|