mem.h 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188
  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. * @file
  22. * memory handling functions
  23. */
  24. #ifndef AVUTIL_MEM_H
  25. #define AVUTIL_MEM_H
  26. #include "attributes.h"
  27. #include "error.h"
  28. #include "avutil.h"
  29. /**
  30. * @addtogroup lavu_mem
  31. * @{
  32. */
  33. #if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C)
  34. #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
  35. #define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v
  36. #elif defined(__TI_COMPILER_VERSION__)
  37. #define DECLARE_ALIGNED(n,t,v) \
  38. AV_PRAGMA(DATA_ALIGN(v,n)) \
  39. t __attribute__((aligned(n))) v
  40. #define DECLARE_ASM_CONST(n,t,v) \
  41. AV_PRAGMA(DATA_ALIGN(v,n)) \
  42. static const t __attribute__((aligned(n))) v
  43. #elif defined(__GNUC__)
  44. #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
  45. #define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v
  46. #elif defined(_MSC_VER)
  47. #define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v
  48. #define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v
  49. #else
  50. #define DECLARE_ALIGNED(n,t,v) t v
  51. #define DECLARE_ASM_CONST(n,t,v) static const t v
  52. #endif
  53. #if AV_GCC_VERSION_AT_LEAST(3,1)
  54. #define av_malloc_attrib __attribute__((__malloc__))
  55. #else
  56. #define av_malloc_attrib
  57. #endif
  58. #if AV_GCC_VERSION_AT_LEAST(4,3)
  59. #define av_alloc_size(n) __attribute__((alloc_size(n)))
  60. #else
  61. #define av_alloc_size(n)
  62. #endif
  63. /**
  64. * Allocate a block of size bytes with alignment suitable for all
  65. * memory accesses (including vectors if available on the CPU).
  66. * @param size Size in bytes for the memory block to be allocated.
  67. * @return Pointer to the allocated block, NULL if the block cannot
  68. * be allocated.
  69. * @see av_mallocz()
  70. */
  71. void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
  72. /**
  73. * Allocate or reallocate a block of memory.
  74. * If ptr is NULL and size > 0, allocate a new block. If
  75. * size is zero, free the memory block pointed to by ptr.
  76. * @param ptr Pointer to a memory block already allocated with
  77. * av_malloc(z)() or av_realloc() or NULL.
  78. * @param size Size in bytes for the memory block to be allocated or
  79. * reallocated.
  80. * @return Pointer to a newly reallocated block or NULL if the block
  81. * cannot be reallocated or the function is used to free the memory block.
  82. * @see av_fast_realloc()
  83. */
  84. void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
  85. /**
  86. * Allocate or reallocate a block of memory.
  87. * This function does the same thing as av_realloc, except:
  88. * - It takes two arguments and checks the result of the multiplication for
  89. * integer overflow.
  90. * - It frees the input block in case of failure, thus avoiding the memory
  91. * leak with the classic "buf = realloc(buf); if (!buf) return -1;".
  92. */
  93. void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
  94. /**
  95. * Free a memory block which has been allocated with av_malloc(z)() or
  96. * av_realloc().
  97. * @param ptr Pointer to the memory block which should be freed.
  98. * @note ptr = NULL is explicitly allowed.
  99. * @note It is recommended that you use av_freep() instead.
  100. * @see av_freep()
  101. */
  102. void av_free(void *ptr);
  103. /**
  104. * Allocate a block of size bytes with alignment suitable for all
  105. * memory accesses (including vectors if available on the CPU) and
  106. * zero all the bytes of the block.
  107. * @param size Size in bytes for the memory block to be allocated.
  108. * @return Pointer to the allocated block, NULL if it cannot be allocated.
  109. * @see av_malloc()
  110. */
  111. void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
  112. /**
  113. * Allocate a block of nmemb * size bytes with alignment suitable for all
  114. * memory accesses (including vectors if available on the CPU) and
  115. * zero all the bytes of the block.
  116. * The allocation will fail if nmemb * size is greater than or equal
  117. * to INT_MAX.
  118. * @param nmemb
  119. * @param size
  120. * @return Pointer to the allocated block, NULL if it cannot be allocated.
  121. */
  122. void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
  123. /**
  124. * Duplicate the string s.
  125. * @param s string to be duplicated
  126. * @return Pointer to a newly allocated string containing a
  127. * copy of s or NULL if the string cannot be allocated.
  128. */
  129. char *av_strdup(const char *s) av_malloc_attrib;
  130. /**
  131. * Free a memory block which has been allocated with av_malloc(z)() or
  132. * av_realloc() and set the pointer pointing to it to NULL.
  133. * @param ptr Pointer to the pointer to the memory block which should
  134. * be freed.
  135. * @see av_free()
  136. */
  137. void av_freep(void *ptr);
  138. /**
  139. * Add an element to a dynamic array.
  140. *
  141. * @param tab_ptr Pointer to the array.
  142. * @param nb_ptr Pointer to the number of elements in the array.
  143. * @param elem Element to be added.
  144. */
  145. void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
  146. /**
  147. * Multiply two size_t values checking for overflow.
  148. * @return 0 if success, AVERROR(EINVAL) if overflow.
  149. */
  150. static inline int av_size_mult(size_t a, size_t b, size_t *r)
  151. {
  152. size_t t = a * b;
  153. /* Hack inspired from glibc: only try the division if nelem and elsize
  154. * are both greater than sqrt(SIZE_MAX). */
  155. if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
  156. return AVERROR(EINVAL);
  157. *r = t;
  158. return 0;
  159. }
  160. /**
  161. * Set the maximum size that may me allocated in one block.
  162. */
  163. void av_max_alloc(size_t max);
  164. /**
  165. * @}
  166. */
  167. #endif /* AVUTIL_MEM_H */