#endif
#include "avutil.h"
+#include "common.h"
#include "intreadwrite.h"
#include "mem.h"
void *av_malloc(size_t size)
{
void *ptr = NULL;
-#if CONFIG_MEMALIGN_HACK
- long diff;
-#endif
- /* let's disallow possible ambiguous cases */
+ /* let's disallow possibly ambiguous cases */
if (size > (INT_MAX - 32) || !size)
return NULL;
-#if CONFIG_MEMALIGN_HACK
- ptr = malloc(size + 32);
- if (!ptr)
- return ptr;
- diff = ((-(long)ptr - 1) & 31) + 1;
- ptr = (char *)ptr + diff;
- ((char *)ptr)[-1] = diff;
-#elif HAVE_POSIX_MEMALIGN
+#if HAVE_POSIX_MEMALIGN
if (posix_memalign(&ptr, 32, size))
ptr = NULL;
#elif HAVE_ALIGNED_MALLOC
void *av_realloc(void *ptr, size_t size)
{
-#if CONFIG_MEMALIGN_HACK
- int diff;
-#endif
-
- /* let's disallow possible ambiguous cases */
+ /* let's disallow possibly ambiguous cases */
if (size > (INT_MAX - 16))
return NULL;
-#if CONFIG_MEMALIGN_HACK
- //FIXME this isn't aligned correctly, though it probably isn't needed
- if (!ptr)
- return av_malloc(size);
- diff = ((char *)ptr)[-1];
- return (char *)realloc((char *)ptr - diff, size + diff) + diff;
-#elif HAVE_ALIGNED_MALLOC
+#if HAVE_ALIGNED_MALLOC
return _aligned_realloc(ptr, size, 32);
#else
return realloc(ptr, size);
#endif
}
+int av_reallocp(void *ptr, size_t size)
+{
+ void *val;
+
+ if (!size) {
+ av_freep(ptr);
+ return 0;
+ }
+
+ memcpy(&val, ptr, sizeof(val));
+ val = av_realloc(val, size);
+
+ if (!val) {
+ av_freep(ptr);
+ return AVERROR(ENOMEM);
+ }
+
+ memcpy(ptr, &val, sizeof(val));
+ return 0;
+}
+
+void *av_realloc_array(void *ptr, size_t nmemb, size_t size)
+{
+ if (!size || nmemb >= INT_MAX / size)
+ return NULL;
+ return av_realloc(ptr, nmemb * size);
+}
+
+int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
+{
+ void *val;
+
+ if (!size || nmemb >= INT_MAX / size)
+ return AVERROR(ENOMEM);
+ if (!nmemb) {
+ av_freep(ptr);
+ return 0;
+ }
+
+ memcpy(&val, ptr, sizeof(val));
+ val = av_realloc(val, nmemb * size);
+ if (!val) {
+ av_freep(ptr);
+ return AVERROR(ENOMEM);
+ }
+
+ memcpy(ptr, &val, sizeof(val));
+ return 0;
+}
+
void av_free(void *ptr)
{
-#if CONFIG_MEMALIGN_HACK
- if (ptr)
- free((char *)ptr - ((char *)ptr)[-1]);
-#elif HAVE_ALIGNED_MALLOC
+#if HAVE_ALIGNED_MALLOC
_aligned_free(ptr);
#else
free(ptr);
void av_freep(void *arg)
{
- void **ptr = (void **)arg;
- av_free(*ptr);
- *ptr = NULL;
+ void *val;
+
+ memcpy(&val, arg, sizeof(val));
+ memcpy(arg, &(void *){ NULL }, sizeof(val));
+ av_free(val);
}
void *av_mallocz(size_t size)
char *ptr = NULL;
if (s) {
int len = strlen(s) + 1;
- ptr = av_malloc(len);
+ ptr = av_realloc(NULL, len);
if (ptr)
memcpy(ptr, s, len);
}
return ptr;
}
+char *av_strndup(const char *s, size_t len)
+{
+ char *ret = NULL, *end;
+
+ if (!s)
+ return NULL;
+
+ end = memchr(s, 0, len);
+ if (end)
+ len = end - s;
+
+ ret = av_realloc(NULL, len + 1);
+ if (!ret)
+ return NULL;
+
+ memcpy(ret, s, len);
+ ret[len] = 0;
+ return ret;
+}
+
static void fill16(uint8_t *dst, int len)
{
uint32_t v = AV_RN16(dst - 2);
*dst = *src;
}
}
+
+void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
+{
+ if (min_size < *size)
+ return ptr;
+
+ min_size = FFMAX(17 * min_size / 16 + 32, min_size);
+
+ ptr = av_realloc(ptr, min_size);
+ /* we could set this to the unmodified min_size but this is safer
+ * if the user lost the ptr and uses NULL now
+ */
+ if (!ptr)
+ min_size = 0;
+
+ *size = min_size;
+
+ return ptr;
+}
+
+void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
+{
+ void **p = ptr;
+ if (min_size < *size)
+ return;
+ min_size = FFMAX(17 * min_size / 16 + 32, min_size);
+ av_free(*p);
+ *p = av_malloc(min_size);
+ if (!*p)
+ min_size = 0;
+ *size = min_size;
+}