/*

 * 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"

//#define USE_MEM_STATS

#ifdef USE_MEM_STATS

#include <malloc.h>

static int mem_cur, mem_max;

static int block_cur, block_max;

#endif

#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 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);

#ifdef USE_MEM_STATS

    printf("malloc(%ld) -> %p\n", size, ptr);

    if (ptr) {

        mem_cur += malloc_usable_size(ptr);

        if (mem_cur > mem_max) {

            mem_max = mem_cur;

            printf("mem_max=%d\n", mem_max);

        }

        if (++block_cur > block_max) {

            block_max = block_cur;

            printf("block_max=%d\n", block_max);

        }

    }

#endif

#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

#ifdef USE_MEM_STATS

    if (ptr) {

        mem_cur -= malloc_usable_size(ptr);

        block_cur--;

    }

    printf("realloc(%p, %ld)\n", ptr, size);

    ptr = realloc(ptr, size + !size);

    if (ptr) {

        mem_cur += malloc_usable_size(ptr);

        if (mem_cur > mem_max) {

            mem_max = mem_cur;

            printf("mem_max=%d\n", mem_max);

        }

        if (++block_cur > block_max) {

            block_max = block_cur;

            printf("block_max=%d\n", block_max);

        }

    }

    return ptr;

#else

    return realloc(ptr, size + !size);

#endif

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

}

int av_reallocp(void *ptr, size_t size)

{

    void **ptrptr = ptr;

    void *ret;

    if (!size) {

        av_freep(ptr);

        return 0;

    }

    ret = av_realloc(*ptrptr, size);

    if (!ret) {

        av_freep(ptr);

        return AVERROR(ENOMEM);

    }

    *ptrptr = ret;

    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 **ptrptr = ptr;

    *ptrptr = av_realloc_f(*ptrptr, nmemb, size);

    if (!*ptrptr && 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

#ifdef USE_MEM_STATS

    if (ptr) {

        printf("free(%p)\n", ptr);

        mem_cur -= malloc_usable_size(ptr);

        block_cur--;

    }

#endif

    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;

}

#ifdef USE_FULL

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_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 = *(void ***)tab_ptr;

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

        tab[*nb_ptr] = elem;

        *(void ***)tab_ptr = tab;

    }, {

        return AVERROR(ENOMEM);

    });

    return 0;

}

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

{

    void **tab = *(void ***)tab_ptr;

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

        tab[*nb_ptr] = elem;

        *(void ***)tab_ptr = 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;

    AV_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(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;

}

#endif

static inline int ff_fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)

{

    void **p = ptr;

    if (min_size < *size)

        return 0;

    min_size = FFMAX(17 * min_size / 16 + 32, min_size);

    av_free(*p);

    *p = zero_realloc ? av_mallocz(min_size) : av_malloc(min_size);

    if (!*p)

        min_size = 0;

    *size = min_size;

    return 1;

}

void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)

{

    ff_fast_malloc(ptr, size, min_size, 0);

}

void *av_malloc_array(size_t nmemb, size_t size)

{

    if (!size || nmemb >= INT_MAX / size)

        return NULL;

    return av_malloc(nmemb * size);

}

void *av_mallocz_array(size_t nmemb, size_t size)

{

    if (!size || nmemb >= INT_MAX / size)

        return NULL;

    return av_mallocz(nmemb * size);

}