mm7: lib/libavutil/mem.h comparison

comparison lib/libavutil/mem.h @ 2134:992d2e6f907d

preparation for libavcodec

author	zipi
date	Tue, 31 Dec 2013 14:52:14 +0000
parents
children

comparison

equal deleted inserted replaced

-:e378232bfd36
+:992d2e6f907d
+/*
+* copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
+*
+* This file is part of FFmpeg.
+*
+* FFmpeg 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.
+*
+* FFmpeg 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 FFmpeg; 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 "error.h"
+#include "avutil.h"
+/**
+* @addtogroup lavu_mem
+* @{
+*/
+#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || 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__)
+#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);
+/**
+* Helper function to allocate a block of size * nmemb bytes with
+* using 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 <= 0 || 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_malloc(z)() or av_realloc() or NULL.
+* @param size Size in bytes for 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.
+* @see av_fast_realloc()
+*/
+void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
+/**
+* Allocate or reallocate a block of memory.
+* This function does the same thing as av_realloc, except:
+* - It takes two arguments and checks 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;".
+*/
+void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
+/**
+* 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 nmemb * size bytes with alignment suitable for all
+* memory accesses (including vectors if available on the CPU) and
+* zero all the bytes of the block.
+* The allocation will fail if nmemb * size is greater than or equal
+* to INT_MAX.
+* @param nmemb
+* @param size
+* @return Pointer to the allocated block, NULL if it cannot be allocated.
+*/
+void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
+/**
+* Helper function to allocate a block of size * nmemb bytes with
+* using 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 <= 0 || 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 the buffer p.
+* @param p buffer to be duplicated
+* @return Pointer to a newly allocated buffer containing a
+* copy of p or NULL if the buffer cannot be allocated.
+*/
+void *av_memdup(const void *p, size_t size);
+/**
+* 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);
+/**
+* Add an element to a dynamic array.
+*
+* The array to grow is supposed to be an array of pointers to
+* structures, and the element to add must be a pointer to an already
+* allocated structure.
+*
+* The array is reallocated when its size reaches powers of 2.
+* Therefore, the amortized cost of adding an element is constant.
+*
+* In case of success, the pointer to the array is updated in order to
+* point to the new grown array, and the number pointed to by nb_ptr
+* is incremented.
+* In case of failure, the array is freed, *tab_ptr is set to NULL and
+* *nb_ptr is set to 0.
+*
+* @param tab_ptr pointer to the array to grow
+* @param nb_ptr  pointer to the number of elements in the array
+* @param elem    element to add
+* @see av_dynarray2_add()
+*/
+void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
+/**
+* Add an element of size elem_size to a dynamic array.
+*
+* The array is reallocated when its number of elements reaches powers of 2.
+* Therefore, the amortized cost of adding an element is constant.
+*
+* In case of success, the pointer to the array is updated in order to
+* point to the new grown array, and the number pointed to by nb_ptr
+* is incremented.
+* In case of failure, the array is freed, *tab_ptr is set to NULL and
+* *nb_ptr is set to 0.
+*
+* @param tab_ptr   pointer to the array to grow
+* @param nb_ptr    pointer to the number of elements in the array
+* @param elem_size size in bytes of the elements in the array
+* @param elem_data pointer to the data of the element to add. If NULL, the space of
+*                  the new added element is not filled.
+* @return          pointer to the data of the element to copy in the new allocated space.
+*                  If NULL, the new allocated space is left uninitialized."
+* @see av_dynarray_add()
+*/
+void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
+const uint8_t *elem_data);
+/**
+* Multiply two size_t values checking for overflow.
+* @return  0 if success, AVERROR(EINVAL) if overflow.
+*/
+static inline int av_size_mult(size_t a, size_t b, size_t *r)
+{
+size_t t = a * b;
+/* Hack inspired from glibc: only try the division if nelem and elsize
+* are both greater than sqrt(SIZE_MAX). */
+if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
+return AVERROR(EINVAL);
+*r = t;
+return 0;
+}
+/**
+* Set the maximum size that may me allocated in one block.
+*/
+void av_max_alloc(size_t max);
+/**
+* @brief deliberately overlapping memcpy implementation
+* @param dst destination buffer
+* @param back how many bytes back we start (the initial size of the overlapping window), must be > 0
+* @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);
+/**
+* @}
+*/
+#endif /* AVUTIL_MEM_H */

Mercurial > mm7

comparison lib/libavutil/mem.h @ 2134:992d2e6f907d