/*
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */


#define __VPX_MEM_C__

#include "vpx_mem.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef CONFIG_MEM_MANAGER
# if defined(VXWORKS)
#  define CONFIG_MEM_MANAGER  1 //include heap manager functionality,
//default: enabled on vxworks
# else
#  define CONFIG_MEM_MANAGER  0 //include heap manager functionality
# endif
#endif

#ifndef CONFIG_MEM_TRACKER
# define CONFIG_MEM_TRACKER     1 //include xvpx_* calls in the lib
#endif

#ifndef CONFIG_MEM_CHECKS
# define CONFIG_MEM_CHECKS      0 //include some basic safety checks in
//vpx_memcpy, _memset, and _memmove
#endif

#ifndef USE_GLOBAL_FUNCTION_POINTERS
# define USE_GLOBAL_FUNCTION_POINTERS   0  //use function pointers instead of compiled functions.
#endif

#if CONFIG_MEM_TRACKER
# include "vpx_mem_tracker.h"
# if VPX_MEM_TRACKER_VERSION_CHIEF != 2 || VPX_MEM_TRACKER_VERSION_MAJOR != 5
#  error "vpx_mem requires memory tracker version 2.5 to track memory usage"
# endif
#endif

#define ADDRESS_STORAGE_SIZE      sizeof(size_t)

#ifndef DEFAULT_ALIGNMENT
# if defined(VXWORKS)
#  define DEFAULT_ALIGNMENT        32        //default addr alignment to use in
//calls to vpx_* functions other
//than vpx_memalign
# else
#  define DEFAULT_ALIGNMENT        1
# endif
#endif

#if DEFAULT_ALIGNMENT < 1
# error "DEFAULT_ALIGNMENT must be >= 1!"
#endif

#if CONFIG_MEM_TRACKER
# define TRY_BOUNDS_CHECK         1         //when set to 1 pads each allocation,
//integrity can be checked using
//vpx_memory_tracker_check_integrity
//or on free by defining
//TRY_BOUNDS_CHECK_ON_FREE
static unsigned long g_alloc_count = 0;

#else
# define TRY_BOUNDS_CHECK         0
#endif

#if TRY_BOUNDS_CHECK
# define TRY_BOUNDS_CHECK_ON_FREE 0          //checks mem integrity on every
//free, very expensive
# define BOUNDS_CHECK_VALUE       0xdeadbeef //value stored before/after ea.
//mem addr for bounds checking
# define BOUNDS_CHECK_PAD_SIZE    32         //size of the padding before and
//after ea allocation to be filled
//with BOUNDS_CHECK_VALUE.
//this should be a multiple of 4
#else
# define BOUNDS_CHECK_VALUE       0
# define BOUNDS_CHECK_PAD_SIZE    0
#endif

#if CONFIG_MEM_MANAGER
# include "heapmm.h"
# include "hmm_intrnl.h"

# define SHIFT_HMM_ADDR_ALIGN_UNIT 5
# define TOTAL_MEMORY_TO_ALLOCATE  20971520 // 20 * 1024 * 1024

# define MM_DYNAMIC_MEMORY 1
# if MM_DYNAMIC_MEMORY
static unsigned char *g_p_mng_memory_raw = NULL;
static unsigned char *g_p_mng_memory     = NULL;
# else
static unsigned char g_p_mng_memory[TOTAL_MEMORY_TO_ALLOCATE];
# endif

static size_t g_mm_memory_size = TOTAL_MEMORY_TO_ALLOCATE;

static hmm_descriptor hmm_d;
static int g_mng_memory_allocated = 0;

static int vpx_mm_create_heap_memory();
static void *vpx_mm_realloc(void *memblk, size_t size);
#endif //CONFIG_MEM_MANAGER

#if USE_GLOBAL_FUNCTION_POINTERS

struct GLOBAL_FUNC_POINTERS
{
    g_malloc_func g_malloc;
    g_calloc_func g_calloc;
    g_realloc_func g_realloc;
    g_free_func g_free;
    g_memcpy_func g_memcpy;
    g_memset_func g_memset;
    g_memmove_func g_memmove;
};
struct GLOBAL_FUNC_POINTERS *g_func = 0;

# define VPX_MALLOC_L  g_func->g_malloc
# define VPX_REALLOC_L g_func->g_realloc
# define VPX_FREE_L    g_func->g_free
# define VPX_MEMCPY_L  g_func->g_memcpy
# define VPX_MEMSET_L  g_func->g_memset
# define VPX_MEMMOVE_L g_func->g_memmove

#else
# define VPX_MALLOC_L  malloc
# define VPX_REALLOC_L realloc
# define VPX_FREE_L    free
# define VPX_MEMCPY_L  memcpy
# define VPX_MEMSET_L  memset
# define VPX_MEMMOVE_L memmove
#endif // USE_GLOBAL_FUNCTION_POINTERS

/* Should probably use a vpx_mem logger function. */
#define __REMOVE_PRINTFS
#ifdef __REMOVE_PRINTFS
#define _P(x)
#else
#define _P(x) x
#endif

/*returns an addr aligned to the byte boundary specified by align*/
#define align_addr(addr,align) \
    (void*)(((size_t)(addr) + ((align) - 1)) & (size_t)-(align))

unsigned int vpx_mem_get_version()
{
    unsigned int ver = ((unsigned int)(unsigned char)VPX_MEM_VERSION_CHIEF << 24 |
                        (unsigned int)(unsigned char)VPX_MEM_VERSION_MAJOR << 16 |
                        (unsigned int)(unsigned char)VPX_MEM_VERSION_MINOR << 8  |
                        (unsigned int)(unsigned char)VPX_MEM_VERSION_PATCH);
    return ver;
}

int vpx_mem_set_heap_size(size_t size)
{
    int ret = -1;

#if CONFIG_MEM_MANAGER
#if MM_DYNAMIC_MEMORY

    if (!g_mng_memory_allocated && size)
    {
        g_mm_memory_size = size;
        ret = 0;
    }
    else
        ret = -3;

#else
    ret = -2;
#endif
#else
    (void)size;
#endif

    return ret;
}

void *vpx_memalign(size_t align, size_t size)
{
    void *addr,
         * x = NULL;

#if CONFIG_MEM_MANAGER
    int number_aau;

    if (vpx_mm_create_heap_memory() < 0)
    {
        _P(printf("[vpx][mm] ERROR vpx_memalign() Couldn't create memory for Heap.\n");)
    }

    number_aau = ((size + align - 1 + ADDRESS_STORAGE_SIZE) >>
                  SHIFT_HMM_ADDR_ALIGN_UNIT) + 1;

    addr = hmm_alloc(&hmm_d, number_aau);
#else
    addr = VPX_MALLOC_L(size + align - 1 + ADDRESS_STORAGE_SIZE);
#endif //CONFIG_MEM_MANAGER

    if (addr)
    {
        x = align_addr((unsigned char *)addr + ADDRESS_STORAGE_SIZE, (int)align);
        /* save the actual malloc address */
        ((size_t *)x)[-1] = (size_t)addr;
    }

    return x;
}

void *vpx_malloc(size_t size)
{
    return vpx_memalign(DEFAULT_ALIGNMENT, size);
}

void *vpx_calloc(size_t num, size_t size)
{
    void *x;

    x = vpx_memalign(DEFAULT_ALIGNMENT, num * size);

    if (x)
        VPX_MEMSET_L(x, 0, num * size);

    return x;
}

void *vpx_realloc(void *memblk, size_t size)
{
    void *addr,
         * new_addr = NULL;
    int align = DEFAULT_ALIGNMENT;

    /*
    The realloc() function changes the size of the object pointed to by
    ptr to the size specified by size, and returns a pointer to the
    possibly moved block. The contents are unchanged up to the lesser
    of the new and old sizes. If ptr is null, realloc() behaves like
    malloc() for the specified size. If size is zero (0) and ptr is
    not a null pointer, the object pointed to is freed.
    */
    if (!memblk)
        new_addr = vpx_malloc(size);
    else if (!size)
        vpx_free(memblk);
    else
    {
        addr   = (void *)(((size_t *)memblk)[-1]);
        memblk = NULL;

#if CONFIG_MEM_MANAGER
        new_addr = vpx_mm_realloc(addr, size + align + ADDRESS_STORAGE_SIZE);
#else
        new_addr = VPX_REALLOC_L(addr, size + align + ADDRESS_STORAGE_SIZE);
#endif

        if (new_addr)
        {
            addr = new_addr;
            new_addr = (void *)(((size_t)
                                 ((unsigned char *)new_addr + ADDRESS_STORAGE_SIZE) + (align - 1)) &
                                (size_t) - align);
            /* save the actual malloc address */
            ((size_t *)new_addr)[-1] = (size_t)addr;
        }
    }

    return new_addr;
}

void vpx_free(void *memblk)
{
    if (memblk)
    {
        void *addr = (void *)(((size_t *)memblk)[-1]);
#if CONFIG_MEM_MANAGER
        hmm_free(&hmm_d, addr);
#else
        VPX_FREE_L(addr);
#endif
    }
}

void *vpx_mem_alloc(int id, size_t size, size_t align)
{
#if defined CHIP_DM642 || defined __uClinux__
    void *mem = (void *)mem_alloc(id, size, align);

    if (!mem)
    {
        _P(fprintf(stderr,
                   "\n"
                   "*********************************************************\n"
                   "WARNING: mem_alloc returned 0 for id=%p size=%u align=%u.\n"
                   "*********************************************************\n",
                   mem, size, align));
        // should no longer need this.  Softier says it's fixed. 2005-01-21 tjf
        //#if defined __uClinux__
        //while(1)usleep(1000000);
        //#endif
    }

#if defined __uClinux__
    else if (mem == (void *)0xFFFFFFFF)
    {
        // out of memory/error
        mem = (void *)0;

        _P(fprintf(stderr,
                   "\n"
                   "******************************************************\n"
                   "ERROR: mem_alloc id=%p size=%u align=%u OUT OF MEMORY.\n"
                   "******************************************************\n",
                   mem, size, align));
    }

#endif  // __uClinux__

    return mem;
#else
    (void)id;
    (void)size;
    (void)align;
    return (void *)0;
#endif
}

void vpx_mem_free(int id, void *mem, size_t size)
{
#if defined CHIP_DM642 || defined __uClinux__

    if (!mem)
    {
        _P(fprintf(stderr,
                   "\n"
                   "**************************************\n"
                   "WARNING: 0 being free'd id=%p size=%u.\n"
                   "**************************************\n",
                   id, size));

        // should no longer need this.  Softier says it's fixed. 2005-01-21 tjf
        //#if defined __uClinux__
        //while(1)usleep(1000000);
        //#endif
    }

    mem_free(id, mem, size);
#else
    (void)id;
    (void)mem;
    (void)size;
#endif
}


#if CONFIG_MEM_TRACKER

void *xvpx_mem_alloc(int id, size_t size, size_t align, char *file, int line)
{
    void *mem = vpx_mem_alloc(id, size, align);

    vpx_memory_tracker_add((size_t)mem, size, file, line, 0);

    return mem;
}

void xvpx_mem_free(int id, void *mem, size_t size, char *file, int line)
{
    if (vpx_memory_tracker_remove((size_t)mem) == -2)
    {
#if REMOVE_PRINTFS
        (void)file;
        (void)line;
#endif
        _P(fprintf(stderr, "[vpx_mem][xvpx_mem_free] addr: %p (id=%p size=%u) "
                   "not found in list; freed from file:%s"
                   " line:%d\n", mem, id, size, file, line));
    }

    vpx_mem_free(id, mem, size);
}

void *xvpx_memalign(size_t align, size_t size, char *file, int line)
{
#if TRY_BOUNDS_CHECK
    unsigned char *x_bounds;
#endif

    void *x;

    if (g_alloc_count == 0)
    {
#if TRY_BOUNDS_CHECK
        int i_rv = vpx_memory_tracker_init(BOUNDS_CHECK_PAD_SIZE, BOUNDS_CHECK_VALUE);
#else
        int i_rv = vpx_memory_tracker_init(0, 0);
#endif

        if (i_rv < 0)
        {
            _P(printf("ERROR xvpx_malloc MEM_TRACK_USAGE error vpx_memory_tracker_init().\n");)
        }
    }

#if TRY_BOUNDS_CHECK
    {
        int i;
        unsigned int tempme = BOUNDS_CHECK_VALUE;

        x_bounds = vpx_memalign(align, size + (BOUNDS_CHECK_PAD_SIZE * 2));

        if (x_bounds)
        {
            /*we're aligning the address twice here but to keep things
              consistent we want to have the padding come before the stored
              address so no matter what free function gets called we will
              attempt to free the correct address*/
            x_bounds = (unsigned char *)(((size_t *)x_bounds)[-1]);
            x = align_addr(x_bounds + BOUNDS_CHECK_PAD_SIZE + ADDRESS_STORAGE_SIZE,
                           (int)align);
            /* save the actual malloc address */
            ((size_t *)x)[-1] = (size_t)x_bounds;

            for (i = 0; i < BOUNDS_CHECK_PAD_SIZE; i += sizeof(unsigned int))
            {
                VPX_MEMCPY_L(x_bounds + i, &tempme, sizeof(unsigned int));
                VPX_MEMCPY_L((unsigned char *)x + size + i,
                             &tempme, sizeof(unsigned int));
            }
        }
        else
            x = NULL;
    }
#else
    x = vpx_memalign(align, size);
#endif //TRY_BOUNDS_CHECK

    g_alloc_count++;

    vpx_memory_tracker_add((size_t)x, size, file, line, 1);

    return x;
}

void *xvpx_malloc(size_t size, char *file, int line)
{
    return xvpx_memalign(DEFAULT_ALIGNMENT, size, file, line);
}

void *xvpx_calloc(size_t num, size_t size, char *file, int line)
{
    void *x = xvpx_memalign(DEFAULT_ALIGNMENT, num * size, file, line);

    if (x)
        VPX_MEMSET_L(x, 0, num * size);

    return x;
}

void *xvpx_realloc(void *memblk, size_t size, char *file, int line)
{
    struct mem_block *p = NULL;
    int orig_size = 0,
        orig_line = 0;
    char *orig_file = NULL;

#if TRY_BOUNDS_CHECK
    unsigned char *x_bounds = memblk ?
                              (unsigned char *)(((size_t *)memblk)[-1]) :
                              NULL;
#endif

    void *x;

    if (g_alloc_count == 0)
    {
#if TRY_BOUNDS_CHECK

        if (!vpx_memory_tracker_init(BOUNDS_CHECK_PAD_SIZE, BOUNDS_CHECK_VALUE))
#else
        if (!vpx_memory_tracker_init(0, 0))
#endif
        {
            _P(printf("ERROR xvpx_malloc MEM_TRACK_USAGE error vpx_memory_tracker_init().\n");)
        }
    }

    if (p = vpx_memory_tracker_find((size_t)memblk))
    {
        orig_size = p->size;
        orig_file = p->file;
        orig_line = p->line;
    }

#if TRY_BOUNDS_CHECK_ON_FREE
    vpx_memory_tracker_check_integrity(file, line);
#endif

    //have to do this regardless of success, because
    //the memory that does get realloc'd may change
    //the bounds values of this block
    vpx_memory_tracker_remove((size_t)memblk);

#if TRY_BOUNDS_CHECK
    {
        int i;
        unsigned int tempme = BOUNDS_CHECK_VALUE;

        x_bounds = vpx_realloc(memblk, size + (BOUNDS_CHECK_PAD_SIZE * 2));

        if (x_bounds)
        {
            x_bounds = (unsigned char *)(((size_t *)x_bounds)[-1]);
            x = align_addr(x_bounds + BOUNDS_CHECK_PAD_SIZE + ADDRESS_STORAGE_SIZE,
                           (int)DEFAULT_ALIGNMENT);
            /* save the actual malloc address */
            ((size_t *)x)[-1] = (size_t)x_bounds;

            for (i = 0; i < BOUNDS_CHECK_PAD_SIZE; i += sizeof(unsigned int))
            {
                VPX_MEMCPY_L(x_bounds + i, &tempme, sizeof(unsigned int));
                VPX_MEMCPY_L((unsigned char *)x + size + i,
                             &tempme, sizeof(unsigned int));
            }
        }
        else
            x = NULL;
    }
#else
    x = vpx_realloc(memblk, size);
#endif //TRY_BOUNDS_CHECK

    if (x)
        vpx_memory_tracker_add((size_t)x, size, file, line, 1);
    else
        vpx_memory_tracker_add((size_t)memblk, orig_size, orig_file, orig_line, 1);

    return x;
}

void xvpx_free(void *p_address, char *file, int line)
{
#if TRY_BOUNDS_CHECK
    unsigned char *p_bounds_address = (unsigned char *)p_address;
    //p_bounds_address -= BOUNDS_CHECK_PAD_SIZE;
#endif

#if !TRY_BOUNDS_CHECK_ON_FREE
    (void)file;
    (void)line;
#endif

    if (p_address)
    {
#if TRY_BOUNDS_CHECK_ON_FREE
        vpx_memory_tracker_check_integrity(file, line);
#endif

        //if the addr isn't found in the list, assume it was allocated via
        //vpx_ calls not xvpx_, therefore it does not contain any padding
        if (vpx_memory_tracker_remove((size_t)p_address) == -2)
        {
            p_bounds_address = p_address;
            _P(fprintf(stderr, "[vpx_mem][xvpx_free] addr: %p not found in"
                       " list; freed from file:%s"
                       " line:%d\n", p_address, file, line));
        }
        else
            --g_alloc_count;

#if TRY_BOUNDS_CHECK
        vpx_free(p_bounds_address);
#else
        vpx_free(p_address);
#endif

        if (!g_alloc_count)
            vpx_memory_tracker_destroy();
    }
}

#endif /*CONFIG_MEM_TRACKER*/

#if CONFIG_MEM_CHECKS
#if defined(VXWORKS)
#include <task_lib.h> //for task_delay()
/* This function is only used to get a stack trace of the player
object so we can se where we are having a problem. */
static int get_my_tt(int task)
{
    tt(task);

    return 0;
}

static void vx_sleep(int msec)
{
    int ticks_to_sleep = 0;

    if (msec)
    {
        int msec_per_tick = 1000 / sys_clk_rate_get();

        if (msec < msec_per_tick)
            ticks_to_sleep++;
        else
            ticks_to_sleep = msec / msec_per_tick;
    }

    task_delay(ticks_to_sleep);
}
#endif
#endif

void *vpx_memcpy(void *dest, const void *source, size_t length)
{
#if CONFIG_MEM_CHECKS

    if (((int)dest < 0x4000) || ((int)source < 0x4000))
    {
        _P(printf("WARNING: vpx_memcpy dest:0x%x source:0x%x len:%d\n", (int)dest, (int)source, length);)

#if defined(VXWORKS)
        sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0);

        vx_sleep(10000);
#endif
    }

#endif

    return VPX_MEMCPY_L(dest, source, length);
}

void *vpx_memset(void *dest, int val, size_t length)
{
#if CONFIG_MEM_CHECKS

    if ((int)dest < 0x4000)
    {
        _P(printf("WARNING: vpx_memset dest:0x%x val:%d len:%d\n", (int)dest, val, length);)

#if defined(VXWORKS)
        sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0);

        vx_sleep(10000);
#endif
    }

#endif

    return VPX_MEMSET_L(dest, val, length);
}

void *vpx_memmove(void *dest, const void *src, size_t count)
{
#if CONFIG_MEM_CHECKS

    if (((int)dest < 0x4000) || ((int)src < 0x4000))
    {
        _P(printf("WARNING: vpx_memmove dest:0x%x src:0x%x count:%d\n", (int)dest, (int)src, count);)

#if defined(VXWORKS)
        sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0);

        vx_sleep(10000);
#endif
    }

#endif

    return VPX_MEMMOVE_L(dest, src, count);
}

#if CONFIG_MEM_MANAGER

static int vpx_mm_create_heap_memory()
{
    int i_rv = 0;

    if (!g_mng_memory_allocated)
    {
#if MM_DYNAMIC_MEMORY
        g_p_mng_memory_raw =
            (unsigned char *)malloc(g_mm_memory_size + HMM_ADDR_ALIGN_UNIT);

        if (g_p_mng_memory_raw)
        {
            g_p_mng_memory = (unsigned char *)((((unsigned int)g_p_mng_memory_raw) +
                                                HMM_ADDR_ALIGN_UNIT - 1) &
                                               -(int)HMM_ADDR_ALIGN_UNIT);

            _P(printf("[vpx][mm] total memory size:%d g_p_mng_memory_raw:0x%x g_p_mng_memory:0x%x\n"
                      , g_mm_memory_size + HMM_ADDR_ALIGN_UNIT
                      , (unsigned int)g_p_mng_memory_raw
                      , (unsigned int)g_p_mng_memory);)
        }
        else
        {
            _P(printf("[vpx][mm] Couldn't allocate memory:%d for vpx memory manager.\n"
                      , g_mm_memory_size);)

            i_rv = -1;
        }

        if (g_p_mng_memory)
#endif
        {
            int chunk_size = 0;

            g_mng_memory_allocated = 1;

            hmm_init(&hmm_d);

            chunk_size = g_mm_memory_size >> SHIFT_HMM_ADDR_ALIGN_UNIT;

            chunk_size -= DUMMY_END_BLOCK_BAUS;

            _P(printf("[vpx][mm] memory size:%d for vpx memory manager. g_p_mng_memory:0x%x  chunk_size:%d\n"
                      , g_mm_memory_size
                      , (unsigned int)g_p_mng_memory
                      , chunk_size);)

            hmm_new_chunk(&hmm_d, (void *)g_p_mng_memory, chunk_size);
        }

#if MM_DYNAMIC_MEMORY
        else
        {
            _P(printf("[vpx][mm] Couldn't allocate memory:%d for vpx memory manager.\n"
                      , g_mm_memory_size);)

            i_rv = -1;
        }

#endif
    }

    return i_rv;
}

static void *vpx_mm_realloc(void *memblk, size_t size)
{
    void *p_ret = NULL;

    if (vpx_mm_create_heap_memory() < 0)
    {
        _P(printf("[vpx][mm] ERROR vpx_mm_realloc() Couldn't create memory for Heap.\n");)
    }
    else
    {
        int i_rv = 0;
        int old_num_aaus;
        int new_num_aaus;

        old_num_aaus = hmm_true_size(memblk);
        new_num_aaus = (size >> SHIFT_HMM_ADDR_ALIGN_UNIT) + 1;

        if (old_num_aaus == new_num_aaus)
        {
            p_ret = memblk;
        }
        else
        {
            i_rv = hmm_resize(&hmm_d, memblk, new_num_aaus);

            if (i_rv == 0)
            {
                p_ret = memblk;
            }
            else
            {
                /* Error. Try to malloc and then copy data. */
                void *p_from_malloc;

                new_num_aaus = (size >> SHIFT_HMM_ADDR_ALIGN_UNIT) + 1;
                p_from_malloc  = hmm_alloc(&hmm_d, new_num_aaus);

                if (p_from_malloc)
                {
                    vpx_memcpy(p_from_malloc, memblk, size);
                    hmm_free(&hmm_d, memblk);

                    p_ret = p_from_malloc;
                }
            }
        }
    }

    return p_ret;
}
#endif //CONFIG_MEM_MANAGER

#if USE_GLOBAL_FUNCTION_POINTERS
# if CONFIG_MEM_TRACKER
extern int vpx_memory_tracker_set_functions(g_malloc_func g_malloc_l
        , g_calloc_func g_calloc_l
        , g_realloc_func g_realloc_l
        , g_free_func g_free_l
        , g_memcpy_func g_memcpy_l
        , g_memset_func g_memset_l
        , g_memmove_func g_memmove_l);
# endif
#endif
int vpx_mem_set_functions(g_malloc_func g_malloc_l
                          , g_calloc_func g_calloc_l
                          , g_realloc_func g_realloc_l
                          , g_free_func g_free_l
                          , g_memcpy_func g_memcpy_l
                          , g_memset_func g_memset_l
                          , g_memmove_func g_memmove_l)
{
#if USE_GLOBAL_FUNCTION_POINTERS

    /* If use global functions is turned on then the
    application must set the global functions before
    it does anything else or vpx_mem will have
    unpredictable results. */
    if (!g_func)
    {
        g_func = (struct GLOBAL_FUNC_POINTERS *)g_malloc_l(sizeof(struct GLOBAL_FUNC_POINTERS));

        if (!g_func)
        {
            return -1;
        }
    }

#if CONFIG_MEM_TRACKER
    {
        int rv = 0;
        rv = vpx_memory_tracker_set_functions(g_malloc_l
                                              , g_calloc_l
                                              , g_realloc_l
                                              , g_free_l
                                              , g_memcpy_l
                                              , g_memset_l
                                              , g_memmove_l);

        if (rv < 0)
        {
            return rv;
        }
    }
#endif

    if (g_malloc_l)
        g_func->g_malloc = g_malloc_l;
    else
        g_func->g_malloc = 0;

    if (g_calloc_l)
        g_func->g_calloc = g_calloc_l;
    else
        g_func->g_calloc = 0;

    if (g_realloc_l)
        g_func->g_realloc = g_realloc_l;
    else
        g_func->g_realloc = 0;

    if (g_free_l)
        g_func->g_free = g_free_l;
    else
        g_func->g_free = 0;

    if (g_memcpy_l)
        g_func->g_memcpy = g_memcpy_l;
    else
        g_func->g_memcpy = 0;

    if (g_memset_l)
        g_func->g_memset = g_memset_l;
    else
        g_func->g_memset = 0;

    if (g_memmove_l)
        g_func->g_memmove = g_memmove_l;
    else
        g_func->g_memmove = 0;

    return 0;
#else
    (void)g_malloc_l;
    (void)g_calloc_l;
    (void)g_realloc_l;
    (void)g_free_l;
    (void)g_memcpy_l;
    (void)g_memset_l;
    (void)g_memmove_l;
    return -1;
#endif
}

int vpx_mem_unset_functions()
{
#if USE_GLOBAL_FUNCTION_POINTERS

    if (g_func)
    {
        g_free_func temp_free;

        temp_free = g_func->g_free;

        temp_free(g_func);
        g_func = 0;
    }

#endif
    return 0;
}

#ifdef _INTEL_LINUX
void *_intel_fast_memcpy(void *dest, const void *src, size_t count)
{

    //memcpy(dest, src, count);
    char *dst8 = (char *)dest;
    char *src8 = (char *)src;

    while (count--)
    {
        *dst8++ = *src8++;
    }

    return dest;
}

void *_intel_fast_memset(void *dest, int c, size_t count)
{
    memset(dest, c, count);
    return dest;
}

void *_VEC_memzero(void *dest, int c, size_t count)
{
    memset(dest, 0, count);
    return dest;
}

#endif //_ICC