/*

  * default memory allocator for libavutil

  * Copyright (c) 2002 Fabrice Bellard

  *

  * 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

  * default memory allocator for libavutil

  */

 #define _XOPEN_SOURCE 600
 

 #include "config.h"

 #include <limits.h>

 #include <stdint.h>

 #include <stdlib.h>

 #include <string.h>

 #if HAVE_MALLOC_H

 #include <malloc.h>
 #endif
 

 #include "avassert.h"

 #include "avutil.h"

 #include "common.h"

 #include "dynarray.h"

 #include "intreadwrite.h"

 #include "mem.h"
 

 #ifdef MALLOC_PREFIX
 
 #define malloc         AV_JOIN(MALLOC_PREFIX, malloc)
 #define memalign       AV_JOIN(MALLOC_PREFIX, memalign)
 #define posix_memalign AV_JOIN(MALLOC_PREFIX, posix_memalign)
 #define realloc        AV_JOIN(MALLOC_PREFIX, realloc)
 #define free           AV_JOIN(MALLOC_PREFIX, free)
 
 void *malloc(size_t size);
 void *memalign(size_t align, size_t size);
 int   posix_memalign(void **ptr, size_t align, size_t size);
 void *realloc(void *ptr, size_t size);
 void  free(void *ptr);
 
 #endif /* MALLOC_PREFIX */
 

 #include "mem_internal.h"
 

 #define ALIGN (HAVE_AVX ? 32 : 16)
 

 /* NOTE: if you want to override these functions with your own
  * implementations (not recommended) you have to link libav* as
  * dynamic libraries and remove -Wl,-Bsymbolic from the linker flags.
  * Note that this will cost performance. */

 static size_t max_alloc_size= INT_MAX;
 
 void av_max_alloc(size_t max){
     max_alloc_size = max;
 }

 void *av_malloc(size_t size)

 {

     void *ptr = NULL;

 #if CONFIG_MEMALIGN_HACK

     long diff;

 #endif

     /* let's disallow possibly ambiguous cases */

     if (size > (max_alloc_size - 32))

         return NULL;

 #if CONFIG_MEMALIGN_HACK

     ptr = malloc(size + ALIGN);

     if (!ptr)

         return ptr;

     diff              = ((~(long)ptr)&(ALIGN - 1)) + 1;

     ptr               = (char *)ptr + diff;
     ((char *)ptr)[-1] = diff;

 #elif HAVE_POSIX_MEMALIGN

     if (size) //OS X on SDK 10.6 has a broken posix_memalign implementation

     if (posix_memalign(&ptr, ALIGN, size))

         ptr = NULL;

 #elif HAVE_ALIGNED_MALLOC

     ptr = _aligned_malloc(size, ALIGN);

 #elif HAVE_MEMALIGN

 #ifndef __DJGPP__

     ptr = memalign(ALIGN, size);

 #else
     ptr = memalign(size, ALIGN);
 #endif

     /* Why 64?

      * Indeed, we should align it:
      *   on  4 for 386
      *   on 16 for 486
      *   on 32 for 586, PPro - K6-III
      *   on 64 for K7 (maybe for P3 too).
      * Because L1 and L2 caches are aligned on those values.
      * But I don't want to code such logic here!

      */

     /* Why 32?
      * For AVX ASM. SSE / NEON needs only 16.
      * Why not larger? Because I did not see a difference in benchmarks ...

      */

     /* benchmarks with P3
      * memalign(64) + 1          3071, 3051, 3032
      * memalign(64) + 2          3051, 3032, 3041
      * memalign(64) + 4          2911, 2896, 2915
      * memalign(64) + 8          2545, 2554, 2550
      * memalign(64) + 16         2543, 2572, 2563
      * memalign(64) + 32         2546, 2545, 2571
      * memalign(64) + 64         2570, 2533, 2558
      *
      * BTW, malloc seems to do 8-byte alignment by default here.

      */

 #else
     ptr = malloc(size);
 #endif

     if(!ptr && !size) {
         size = 1;

         ptr= av_malloc(1);

     }
 #if CONFIG_MEMORY_POISONING
     if (ptr)

         memset(ptr, FF_MEMORY_POISON, size);

 #endif

     return ptr;
 }
 

 void *av_realloc(void *ptr, size_t size)

 {

 #if CONFIG_MEMALIGN_HACK

     int diff;
 #endif

     /* let's disallow possibly ambiguous cases */

     if (size > (max_alloc_size - 32))

         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];

     av_assert0(diff>0 && diff<=ALIGN);

     ptr = realloc((char *)ptr - diff, size + diff);
     if (ptr)
         ptr = (char *)ptr + diff;

     return ptr;

 #elif HAVE_ALIGNED_MALLOC

     return _aligned_realloc(ptr, size + !size, ALIGN);

 #else

     return realloc(ptr, size + !size);

 #endif

 }
 

 void *av_realloc_f(void *ptr, size_t nelem, size_t elsize)
 {
     size_t size;
     void *r;
 
     if (av_size_mult(elsize, nelem, &size)) {
         av_free(ptr);
         return NULL;
     }
     r = av_realloc(ptr, size);

     if (!r)

         av_free(ptr);
     return r;
 }
 

 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;
 
     memcpy(&val, ptr, sizeof(val));

     val = av_realloc_f(val, nmemb, size);
     memcpy(ptr, &val, sizeof(val));
     if (!val && nmemb && size)

         return AVERROR(ENOMEM);

     return 0;
 }
 

 void av_free(void *ptr)
 {

 #if CONFIG_MEMALIGN_HACK

     if (ptr) {
         int v= ((char *)ptr)[-1];
         av_assert0(v>0 && v<=ALIGN);
         free((char *)ptr - v);
     }

 #elif HAVE_ALIGNED_MALLOC
     _aligned_free(ptr);

 #else

     free(ptr);

 #endif

 }
 

 void av_freep(void *arg)
 {

     void *val;
 
     memcpy(&val, arg, sizeof(val));
     memcpy(arg, &(void *){ NULL }, sizeof(val));
     av_free(val);

 }
 

 void *av_mallocz(size_t size)

 {

     void *ptr = av_malloc(size);

     if (ptr)
         memset(ptr, 0, size);
     return ptr;
 }
 

 void *av_calloc(size_t nmemb, size_t size)
 {
     if (size <= 0 || nmemb >= INT_MAX / size)
         return NULL;
     return av_mallocz(nmemb * size);
 }
 

 char *av_strdup(const char *s)
 {

     char *ptr = NULL;
     if (s) {

         size_t len = strlen(s) + 1;

         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;
 }
 

 void *av_memdup(const void *p, size_t size)
 {
     void *ptr = NULL;
     if (p) {
         ptr = av_malloc(size);
         if (ptr)
             memcpy(ptr, p, size);
     }
     return ptr;
 }
 

 int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
 {

     void **tab;
     memcpy(&tab, tab_ptr, sizeof(tab));

     FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, {

         tab[*nb_ptr] = elem;

         memcpy(tab_ptr, &tab, sizeof(tab));

     }, {
         return AVERROR(ENOMEM);
     });
     return 0;
 }
 

 void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
 {

     void **tab;
     memcpy(&tab, tab_ptr, sizeof(tab));

     FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, {

         tab[*nb_ptr] = elem;

         memcpy(tab_ptr, &tab, sizeof(tab));

     }, {
         *nb_ptr = 0;
         av_freep(tab_ptr);
     });

 }

 void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
                        const uint8_t *elem_data)
 {

     uint8_t *tab_elem_data = NULL;
 

     FF_DYNARRAY_ADD(INT_MAX, elem_size, *tab_ptr, *nb_ptr, {

         tab_elem_data = (uint8_t *)*tab_ptr + (*nb_ptr) * elem_size;
         if (elem_data)
             memcpy(tab_elem_data, elem_data, elem_size);
         else if (CONFIG_MEMORY_POISONING)
             memset(tab_elem_data, FF_MEMORY_POISON, elem_size);
     }, {
         av_freep(tab_ptr);
         *nb_ptr = 0;
     });

     return tab_elem_data;
 }
 

 static void fill16(uint8_t *dst, int len)
 {
     uint32_t v = AV_RN16(dst - 2);
 
     v |= v << 16;
 
     while (len >= 4) {
         AV_WN32(dst, v);
         dst += 4;
         len -= 4;
     }
 
     while (len--) {
         *dst = dst[-2];
         dst++;
     }
 }
 
 static void fill24(uint8_t *dst, int len)
 {
 #if HAVE_BIGENDIAN
     uint32_t v = AV_RB24(dst - 3);
     uint32_t a = v << 8  | v >> 16;
     uint32_t b = v << 16 | v >> 8;
     uint32_t c = v << 24 | v;
 #else
     uint32_t v = AV_RL24(dst - 3);
     uint32_t a = v       | v << 24;
     uint32_t b = v >> 8  | v << 16;
     uint32_t c = v >> 16 | v << 8;
 #endif
 
     while (len >= 12) {
         AV_WN32(dst,     a);
         AV_WN32(dst + 4, b);
         AV_WN32(dst + 8, c);
         dst += 12;
         len -= 12;
     }
 
     if (len >= 4) {
         AV_WN32(dst, a);
         dst += 4;
         len -= 4;
     }
 
     if (len >= 4) {
         AV_WN32(dst, b);
         dst += 4;
         len -= 4;
     }
 
     while (len--) {
         *dst = dst[-3];
         dst++;
     }
 }
 
 static void fill32(uint8_t *dst, int len)
 {
     uint32_t v = AV_RN32(dst - 4);
 
     while (len >= 4) {
         AV_WN32(dst, v);
         dst += 4;
         len -= 4;
     }
 
     while (len--) {
         *dst = dst[-4];
         dst++;
     }
 }
 

 void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
 {
     const uint8_t *src = &dst[-back];

     if (!back)
         return;
 

     if (back == 1) {
         memset(dst, *src, cnt);

     } else if (back == 2) {
         fill16(dst, cnt);
     } else if (back == 3) {
         fill24(dst, cnt);
     } else if (back == 4) {
         fill32(dst, cnt);

     } else {

         if (cnt >= 16) {

             int blocklen = back;
             while (cnt > blocklen) {
                 memcpy(dst, src, blocklen);
                 dst       += blocklen;
                 cnt       -= blocklen;
                 blocklen <<= 1;
             }
             memcpy(dst, src, cnt);

             return;
         }
         if (cnt >= 8) {
             AV_COPY32U(dst,     src);
             AV_COPY32U(dst + 4, src + 4);
             src += 8;
             dst += 8;
             cnt -= 8;
         }
         if (cnt >= 4) {
             AV_COPY32U(dst, src);
             src += 4;
             dst += 4;
             cnt -= 4;
         }
         if (cnt >= 2) {
             AV_COPY16U(dst, src);
             src += 2;
             dst += 2;
             cnt -= 2;

         }

         if (cnt)
             *dst = *src;

     }
 }

 void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
 {
     if (min_size < *size)
         return ptr;
 

     min_size = FFMAX(min_size + 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)
 {
     ff_fast_malloc(ptr, size, min_size, 0);
 }
 

 void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
 {
     ff_fast_malloc(ptr, size, min_size, 1);
 }