1 /*

     2  * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>

     3  *

     4  * This file is part of Libav.

     5  *

     6  * Libav 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  * Libav 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 Libav; 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 

    31 #include "attributes.h"

    32 #include "avutil.h"

    33 

    34 /**

    35  * @addtogroup lavu_mem

    36  * @{

    37  */

    38 

    39 

    40 #if defined(__ICC) && __ICC < 1200 || defined(__SUNPRO_C)

    41     #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v

    42     #define DECLARE_ASM_CONST(n,t,v)    const t __attribute__ ((aligned (n))) v

    43 #elif defined(__TI_COMPILER_VERSION__)

    44     #define DECLARE_ALIGNED(n,t,v)                      \

    45         AV_PRAGMA(DATA_ALIGN(v,n))                      \

    46         t __attribute__((aligned(n))) v

    47     #define DECLARE_ASM_CONST(n,t,v)                    \

    48         AV_PRAGMA(DATA_ALIGN(v,n))                      \

    49         static const t __attribute__((aligned(n))) v

    50 #elif defined(__GNUC__)

    51     #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v

    52     #define DECLARE_ASM_CONST(n,t,v)    static const t av_used __attribute__ ((aligned (n))) v

    53 #elif defined(_MSC_VER)

    54     #define DECLARE_ALIGNED(n,t,v)      __declspec(align(n)) t v

    55     #define DECLARE_ASM_CONST(n,t,v)    __declspec(align(n)) static const t v

    56 #else

    57     #define DECLARE_ALIGNED(n,t,v)      t v

    58     #define DECLARE_ASM_CONST(n,t,v)    static const t v

    59 #endif

    60 

    61 #if AV_GCC_VERSION_AT_LEAST(3,1)

    62     #define av_malloc_attrib __attribute__((__malloc__))

    63 #else

    64     #define av_malloc_attrib

    65 #endif

    66 

    67 #if AV_GCC_VERSION_AT_LEAST(4,3)

    68     #define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))

    69 #else

    70     #define av_alloc_size(...)

    71 #endif

    72 

    73 /**

    74  * Allocate a block of size bytes with alignment suitable for all

    75  * memory accesses (including vectors if available on the CPU).

    76  * @param size Size in bytes for the memory block to be allocated.

    77  * @return Pointer to the allocated block, NULL if the block cannot

    78  * be allocated.

    79  * @see av_mallocz()

    80  */

    81 void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);

    82 

    83 /**

    84  * Helper function to allocate a block of size * nmemb bytes with

    85  * using av_malloc()

    86  * @param nmemb Number of elements

    87  * @param size Size of the single element

    88  * @return Pointer to the allocated block, NULL if the block cannot

    89  * be allocated.

    90  * @see av_malloc()

    91  */

    92 av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size)

    93 {

    94     if (size <= 0 || nmemb >= INT_MAX / size)

    95         return NULL;

    96     return av_malloc(nmemb * size);

    97 }

    98 

    99 /**

   100  * Allocate or reallocate a block of memory.

   101  * If ptr is NULL and size > 0, allocate a new block. If

   102  * size is zero, free the memory block pointed to by ptr.

   103  * @param ptr Pointer to a memory block already allocated with

   104  * av_malloc(z)() or av_realloc() or NULL.

   105  * @param size Size in bytes for the memory block to be allocated or

   106  * reallocated.

   107  * @return Pointer to a newly reallocated block or NULL if the block

   108  * cannot be reallocated or the function is used to free the memory block.

   109  * @see av_fast_realloc()

   110  */

   111 void *av_realloc(void *ptr, size_t size) av_alloc_size(2);

   112 

   113 /**

   114  * Free a memory block which has been allocated with av_malloc(z)() or

   115  * av_realloc().

   116  * @param ptr Pointer to the memory block which should be freed.

   117  * @note ptr = NULL is explicitly allowed.

   118  * @note It is recommended that you use av_freep() instead.

   119  * @see av_freep()

   120  */

   121 void av_free(void *ptr);

   122 

   123 /**

   124  * Allocate a block of size bytes with alignment suitable for all

   125  * memory accesses (including vectors if available on the CPU) and

   126  * zero all the bytes of the block.

   127  * @param size Size in bytes for the memory block to be allocated.

   128  * @return Pointer to the allocated block, NULL if it cannot be allocated.

   129  * @see av_malloc()

   130  */

   131 void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);

   132 

   133 /**

   134  * Helper function to allocate a block of size * nmemb bytes with

   135  * using av_mallocz()

   136  * @param nmemb Number of elements

   137  * @param size Size of the single element

   138  * @return Pointer to the allocated block, NULL if the block cannot

   139  * be allocated.

   140  * @see av_mallocz()

   141  * @see av_malloc_array()

   142  */

   143 av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size)

   144 {

   145     if (size <= 0 || nmemb >= INT_MAX / size)

   146         return NULL;

   147     return av_mallocz(nmemb * size);

   148 }

   149 

   150 /**

   151  * Duplicate the string s.

   152  * @param s string to be duplicated

   153  * @return Pointer to a newly allocated string containing a

   154  * copy of s or NULL if the string cannot be allocated.

   155  */

   156 char *av_strdup(const char *s) av_malloc_attrib;

   157 

   158 /**

   159  * Free a memory block which has been allocated with av_malloc(z)() or

   160  * av_realloc() and set the pointer pointing to it to NULL.

   161  * @param ptr Pointer to the pointer to the memory block which should

   162  * be freed.

   163  * @see av_free()

   164  */

   165 void av_freep(void *ptr);

   166 

   167 /**

   168  * @}

   169  */

   170 

   171 #endif /* AVUTIL_MEM_H */