mem.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244
  1. /*
  2. * default memory allocator for libavutil
  3. * Copyright (c) 2002 Fabrice Bellard
  4. *
  5. * This file is part of FFmpeg.
  6. *
  7. * FFmpeg is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU Lesser General Public
  9. * License as published by the Free Software Foundation; either
  10. * version 2.1 of the License, or (at your option) any later version.
  11. *
  12. * FFmpeg is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15. * Lesser General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU Lesser General Public
  18. * License along with FFmpeg; if not, write to the Free Software
  19. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20. */
  21. /**
  22. * @file
  23. * default memory allocator for libavutil
  24. */
  25. #define _XOPEN_SOURCE 600
  26. #include "config.h"
  27. #include <limits.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #if HAVE_MALLOC_H
  31. #include <malloc.h>
  32. #endif
  33. #include "avutil.h"
  34. #include "mem.h"
  35. /* here we can use OS-dependent allocation functions */
  36. #undef free
  37. #undef malloc
  38. #undef realloc
  39. #ifdef MALLOC_PREFIX
  40. #define malloc AV_JOIN(MALLOC_PREFIX, malloc)
  41. #define memalign AV_JOIN(MALLOC_PREFIX, memalign)
  42. #define posix_memalign AV_JOIN(MALLOC_PREFIX, posix_memalign)
  43. #define realloc AV_JOIN(MALLOC_PREFIX, realloc)
  44. #define free AV_JOIN(MALLOC_PREFIX, free)
  45. void *malloc(size_t size);
  46. void *memalign(size_t align, size_t size);
  47. int posix_memalign(void **ptr, size_t align, size_t size);
  48. void *realloc(void *ptr, size_t size);
  49. void free(void *ptr);
  50. #endif /* MALLOC_PREFIX */
  51. #define ALIGN (HAVE_AVX ? 32 : 16)
  52. /* NOTE: if you want to override these functions with your own
  53. * implementations (not recommended) you have to link libav* as
  54. * dynamic libraries and remove -Wl,-Bsymbolic from the linker flags.
  55. * Note that this will cost performance. */
  56. static size_t max_alloc_size= INT_MAX;
  57. void av_max_alloc(size_t max){
  58. max_alloc_size = max;
  59. }
  60. void *av_malloc(size_t size)
  61. {
  62. void *ptr = NULL;
  63. #if CONFIG_MEMALIGN_HACK
  64. long diff;
  65. #endif
  66. /* let's disallow possible ambiguous cases */
  67. if (size > (max_alloc_size-32))
  68. return NULL;
  69. #if CONFIG_MEMALIGN_HACK
  70. ptr = malloc(size+ALIGN);
  71. if(!ptr)
  72. return ptr;
  73. diff= ((-(long)ptr - 1)&(ALIGN-1)) + 1;
  74. ptr = (char*)ptr + diff;
  75. ((char*)ptr)[-1]= diff;
  76. #elif HAVE_POSIX_MEMALIGN
  77. if (size) //OS X on SDK 10.6 has a broken posix_memalign implementation
  78. if (posix_memalign(&ptr,ALIGN,size))
  79. ptr = NULL;
  80. #elif HAVE_ALIGNED_MALLOC
  81. ptr = _aligned_malloc(size, ALIGN);
  82. #elif HAVE_MEMALIGN
  83. ptr = memalign(ALIGN,size);
  84. /* Why 64?
  85. Indeed, we should align it:
  86. on 4 for 386
  87. on 16 for 486
  88. on 32 for 586, PPro - K6-III
  89. on 64 for K7 (maybe for P3 too).
  90. Because L1 and L2 caches are aligned on those values.
  91. But I don't want to code such logic here!
  92. */
  93. /* Why 32?
  94. For AVX ASM. SSE / NEON needs only 16.
  95. Why not larger? Because I did not see a difference in benchmarks ...
  96. */
  97. /* benchmarks with P3
  98. memalign(64)+1 3071,3051,3032
  99. memalign(64)+2 3051,3032,3041
  100. memalign(64)+4 2911,2896,2915
  101. memalign(64)+8 2545,2554,2550
  102. memalign(64)+16 2543,2572,2563
  103. memalign(64)+32 2546,2545,2571
  104. memalign(64)+64 2570,2533,2558
  105. BTW, malloc seems to do 8-byte alignment by default here.
  106. */
  107. #else
  108. ptr = malloc(size);
  109. #endif
  110. if(!ptr && !size) {
  111. size = 1;
  112. ptr= av_malloc(1);
  113. }
  114. #if CONFIG_MEMORY_POISONING
  115. if (ptr)
  116. memset(ptr, 0x2a, size);
  117. #endif
  118. return ptr;
  119. }
  120. void *av_realloc(void *ptr, size_t size)
  121. {
  122. #if CONFIG_MEMALIGN_HACK
  123. int diff;
  124. #endif
  125. /* let's disallow possible ambiguous cases */
  126. if (size > (max_alloc_size-32))
  127. return NULL;
  128. #if CONFIG_MEMALIGN_HACK
  129. //FIXME this isn't aligned correctly, though it probably isn't needed
  130. if(!ptr) return av_malloc(size);
  131. diff= ((char*)ptr)[-1];
  132. ptr= realloc((char*)ptr - diff, size + diff);
  133. if(ptr) ptr = (char*)ptr + diff;
  134. return ptr;
  135. #elif HAVE_ALIGNED_MALLOC
  136. return _aligned_realloc(ptr, size + !size, ALIGN);
  137. #else
  138. return realloc(ptr, size + !size);
  139. #endif
  140. }
  141. void *av_realloc_f(void *ptr, size_t nelem, size_t elsize)
  142. {
  143. size_t size;
  144. void *r;
  145. if (av_size_mult(elsize, nelem, &size)) {
  146. av_free(ptr);
  147. return NULL;
  148. }
  149. r = av_realloc(ptr, size);
  150. if (!r && size)
  151. av_free(ptr);
  152. return r;
  153. }
  154. void av_free(void *ptr)
  155. {
  156. #if CONFIG_MEMALIGN_HACK
  157. if (ptr)
  158. free((char*)ptr - ((char*)ptr)[-1]);
  159. #elif HAVE_ALIGNED_MALLOC
  160. _aligned_free(ptr);
  161. #else
  162. free(ptr);
  163. #endif
  164. }
  165. void av_freep(void *arg)
  166. {
  167. void **ptr= (void**)arg;
  168. av_free(*ptr);
  169. *ptr = NULL;
  170. }
  171. void *av_mallocz(size_t size)
  172. {
  173. void *ptr = av_malloc(size);
  174. if (ptr)
  175. memset(ptr, 0, size);
  176. return ptr;
  177. }
  178. void *av_calloc(size_t nmemb, size_t size)
  179. {
  180. if (size <= 0 || nmemb >= INT_MAX / size)
  181. return NULL;
  182. return av_mallocz(nmemb * size);
  183. }
  184. char *av_strdup(const char *s)
  185. {
  186. char *ptr= NULL;
  187. if(s){
  188. int len = strlen(s) + 1;
  189. ptr = av_malloc(len);
  190. if (ptr)
  191. memcpy(ptr, s, len);
  192. }
  193. return ptr;
  194. }
  195. /* add one element to a dynamic array */
  196. void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
  197. {
  198. /* see similar ffmpeg.c:grow_array() */
  199. int nb, nb_alloc;
  200. intptr_t *tab;
  201. nb = *nb_ptr;
  202. tab = *(intptr_t**)tab_ptr;
  203. if ((nb & (nb - 1)) == 0) {
  204. if (nb == 0)
  205. nb_alloc = 1;
  206. else
  207. nb_alloc = nb * 2;
  208. tab = av_realloc(tab, nb_alloc * sizeof(intptr_t));
  209. *(intptr_t**)tab_ptr = tab;
  210. }
  211. tab[nb++] = (intptr_t)elem;
  212. *nb_ptr = nb;
  213. }