/*

  * 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 <stdlib.h>

 #include <string.h>

 #if HAVE_MALLOC_H

 #include <malloc.h>
 #endif
 

 #include "avutil.h"

 #include "mem.h"
 

 /* here we can use OS-dependent allocation functions */

 #undef free
 #undef malloc
 #undef realloc
 

 #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 */
 

 #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 possible 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 - 1)&(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

     ptr = memalign(ALIGN,size);

     /* 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, 0x2a, size);
 #endif

     return ptr;
 }
 

 void *av_realloc(void *ptr, size_t size)

 {

 #if CONFIG_MEMALIGN_HACK

     int diff;
 #endif

     /* let's disallow possible 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];

     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 && size)
         av_free(ptr);
     return r;
 }
 

 void av_free(void *ptr)
 {

 #if CONFIG_MEMALIGN_HACK

     if (ptr)

         free((char*)ptr - ((char*)ptr)[-1]);

 #elif HAVE_ALIGNED_MALLOC
     _aligned_free(ptr);

 #else

     free(ptr);

 #endif

 }
 

 void av_freep(void *arg)
 {
     void **ptr= (void**)arg;
     av_free(*ptr);
     *ptr = NULL;
 }
 

 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){

         int len = strlen(s) + 1;
         ptr = av_malloc(len);
         if (ptr)
             memcpy(ptr, s, len);

     }

     return ptr;
 }
 

 /* add one element to a dynamic array */
 void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
 {
     /* see similar ffmpeg.c:grow_array() */
     int nb, nb_alloc;
     intptr_t *tab;
 
     nb = *nb_ptr;
     tab = *(intptr_t**)tab_ptr;
     if ((nb & (nb - 1)) == 0) {
         if (nb == 0)
             nb_alloc = 1;
         else
             nb_alloc = nb * 2;
         tab = av_realloc(tab, nb_alloc * sizeof(intptr_t));
         *(intptr_t**)tab_ptr = tab;
     }
     tab[nb++] = (intptr_t)elem;
     *nb_ptr = nb;
 }