/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Interface function implementation

*

*/

/*!

 * \internal

 * \file

 * \brief Interface function implementation

 */

#ifndef M3G_CORE_INCLUDE

#   error included by m3g_core.c; do not compile separately.

#endif

#include "m3g_array.h"

#include "m3g_gl.h"

#if defined(M3G_DEBUG_OUT_OF_MEMORY)

#   include <stdlib.h> /* for getenv() and atoi() */

#endif

/*----------------------------------------------------------------------

 * Private data structure(s)

 *--------------------------------------------------------------------*/

#define MAX_LOCKHEAP_SIZE 100

typedef struct StartGuardRec HeapBlock;

/*!

 * \internal

 * \brief "Interface" structure

 *

 * Holds global state for an M3G instance

 */

struct M3GInterfaceImpl

{

    /*!

     * \internal

     * \brief Interface function pointers

     *

     * Each interface can have a separate set of functions for memory

     * allocation.

     */

    struct {

        /*@shared@*/ m3gMallocFunc        *malloc;

        /*@shared@*/ m3gFreeFunc          *free;

        /*@shared@*/ m3gObjectAllocator   *objAlloc;

        /*@shared@*/ m3gObjectResolver    *objResolve;

        /*@shared@*/ m3gObjectDeallocator *objFree;

        /*@shared@*/ m3gErrorHandler      *error;

        /*@shared@*/ m3gBeginRenderFunc   *getFrameBuffer;

        /*@shared@*/ m3gEndRenderFunc     *releaseFrameBuffer;

        /*@shared@*/ m3gReleaseTargetFunc *releaseTarget;

    } func;

    /*Object *objects;*/

    /*! \internal \brief Latest error code for this interface */

    M3Genum error;

    /*! \internal \brief Associated user context data */

    void *userContext;

#   if defined(M3G_DEBUG)

    /*! \internal \brief Number of memory lock requests in effect */

    M3Gint lockCount;

    struct {

        const char *file;

        int line;

    } lockHeap[MAX_LOCKHEAP_SIZE];

#   endif

#   if !defined(M3G_NGL_CONTEXT_API)

    /*! \internal \brief Number of GL activation requests */

    M3Gint glRefCount;

#   endif

    /*! \internal \brief Number of objects registered for this interface */

    M3Gint objCount;

    /*! \internal \brief "Shutdown" flag for when we need to wait for

     *  objects to be deleted */

    M3Gbool shutdown;

    /* Temporary buffer */

    void *tempBuffer;

    M3Gsizei tempSize;

    M3Gbool tempLocked;

    /* Transformation cache */

    TCache *tcache;

#   if !defined(M3G_NGL_TEXTURE_API)

    PointerArray deadGLObjects;

#   endif

#   if defined(M3G_ENABLE_PROFILING)

    /*!

     * \internal

     * \brief Statistics counters

     */

    M3Gint statistics[M3G_STAT_MAX];

    M3Gint lastPeak;

    M3Gint profileInterval;

#   endif /*M3G_ENABLE_PROFILING*/

    /* Memory allocation debug counters */

#   if defined(M3G_DEBUG)

    M3Gint mallocCount;

    M3Gint objAllocCount;

#   endif

#   if defined(M3G_DEBUG_OUT_OF_MEMORY)

    M3Gsize mallocBytes, mallocLimit;

    M3Gsize objAllocBytes, objAllocLimit;

    M3Gint mallocFailureCounter, mallocFailRate;

    M3Gint objAllocFailureCounter, objAllocFailRate;

#   endif

#   if defined(M3G_DEBUG_HEAP_TRACKING)

    HeapBlock *blockList;

#   endif

    M3Gint maxTextureDimension;

    M3Gint maxViewportWidth;

    M3Gint maxViewportHeight;

    M3Gint maxViewportDim;

    M3Gbool supportAntialiasing;

    M3Gbool colorMaskWorkaround;

    M3Gbool twoSidedLightingWorkaround;

};

#if defined(M3G_DEBUG)

typedef struct StartGuardRec

{

#   if defined(M3G_DEBUG_HEAP_TRACKING)

    const char *allocFile;

    int allocLine : 31;

    int isObject  : 1;

    HeapBlock *next, *prev;

#   endif

    M3Guint endOffset;

    M3Guint magic;

} StartGuard;

typedef struct

{

    M3Guint magic;

} EndGuard;

/* Magic number used to tag memory blocks */

#define MEMORY_MAGIC 0xAE352001u

/* Macros for computing the instrumentated and "user" sizes and

 * pointers of memory blocks */

/*@notfunction@*/

#   define INSTRUMENTATED_SIZE(bytes)                           \

        ((M3Guint) (sizeof(StartGuard) + sizeof(EndGuard)       \

            + M3G_ALIGN_TO(bytes, sizeof(M3Guint))))

/*@notfunction@*/

#   define PAYLOAD_BLOCK(physicalPtr) \

        (((M3Gubyte*)physicalPtr) + sizeof(StartGuard))

/*@notfunction@*/

#   define PHYSICAL_BLOCK(payloadPtr) \

        (((M3Gubyte*)payloadPtr) - sizeof(StartGuard))

/*@notfunction@*/

#   define PAYLOAD_SIZE(blockPtr)      \

        (((const StartGuard *)PHYSICAL_BLOCK(blockPtr))->endOffset      \

         - sizeof(StartGuard))

#else /* !M3G_DEBUG */

/*@notfunction@*/

#   define INSTRUMENTATED_SIZE(bytes)   ((M3Guint)(bytes))

/*@notfunction@*/

#   define PAYLOAD_BLOCK(ptr)           (ptr)

/*@notfunction@*/

#   define PHYSICAL_BLOCK(ptr)          (ptr)

/*@notfunction@*/

#   define PAYLOAD_SIZE(blockPtr)      0

#endif /* M3G_DEBUG */

/*----------------------------------------------------------------------

 * Static data for managing NGL contexts

 *--------------------------------------------------------------------*/

#if defined(M3G_NGL_CONTEXT_API)

static M3Gint m3gs_glRefCount = 0;

#if defined(M3G_BUILD_ISA)

#   define M3G_SYSTEM_ALLOC     os_block_alloc

#   define M3G_SYSTEM_DEALLOC   os_block_dealloc

#else

#   define M3G_SYSTEM_ALLOC     malloc

#   define M3G_SYSTEM_DEALLOC   free

#endif

static void *m3gs_nglMem;

static void *m3gs_nglTexMgr;

#endif

#if defined(M3G_NGL_TEXTURE_API)

M3Gubyte *m3gs_nglTexUnit[M3G_NUM_TEXTURE_UNITS];

#endif

/*----------------------------------------------------------------------

 * Private functions

 *--------------------------------------------------------------------*/

/*@access M3GMemObject@*/

static /*@dependent@*/ void *defaultResolver(M3GMemObject handle)

{

    return (void *)handle;

}

/*--------------------------------------------------------------------*/

#if defined(M3G_DEBUG)

static void validateBlock(/*@reldef@*//*@temp@*//*@null@*/ const void *ptr) 

{

    if (ptr != NULL && M3G_IS_ALIGNED(ptr)) {

        const StartGuard *start = (const StartGuard *) PHYSICAL_BLOCK(ptr);

        if (start->magic == MEMORY_MAGIC) {

            const EndGuard *end = (const EndGuard *)

                (((M3Gubyte *)start) + start->endOffset);

            if (end->magic == MEMORY_MAGIC) {

                return; /* all clear */

            }

        }

        M3G_LOG1(M3G_LOG_FATAL_ERRORS,

                 "Corrupted memory block 0x%08X!\n", (unsigned) ptr);

        M3G_ASSERT(M3G_FALSE);

    }

    else {

        M3G_LOG1(M3G_LOG_FATAL_ERRORS,

                 "Invalid pointer to 0x%08X!\n", (unsigned) ptr);

        M3G_ASSERT(M3G_FALSE);

    }

}

#if defined(M3G_DEBUG_HEAP_TRACKING)

static void instrumentateBlock(/*@reldef@*//*@temp@*/ void *ptr,

                               M3Gsize bytes,

                               const char *file,

                               int line)

#else

static void instrumentateBlock(/*@reldef@*//*@temp@*/ void *ptr, M3Gsize bytes)

#endif

{

    M3Guint offset = M3G_ALIGN_TO(bytes, M3G_ALIGNMENT) + sizeof(StartGuard);

    StartGuard *start;

    EndGuard *end;

    M3G_ASSERT_PTR(ptr);

    M3G_ASSERT_ALIGNMENT(offset);

    /* Insert start and end guard blocks for holding debugging data as

     * well as guarding against (short) over- and underruns */

    start = (StartGuard *) PHYSICAL_BLOCK(ptr);

    end   = (EndGuard *) (((M3Gubyte *)start) + offset);

    start->endOffset = offset;

    start->magic = MEMORY_MAGIC;

    end->magic = MEMORY_MAGIC;

#   if defined(M3G_DEBUG_HEAP_TRACKING)

    start->isObject = 0;

#   endif

    /* Fill with garbage that will show up on the debugger if used

     * before initialized */

    {

        M3Guint *p = (M3Guint *) ptr;

        M3Guint count = bytes >> 2;

        while (count--) {

            *p++ = 0xBAADF00Du;

        }

    }

#   if defined(M3G_DEBUG_HEAP_TRACKING)

    /* Register allocation location */

    start->allocFile = file;

    start->allocLine = line;

#   endif

    validateBlock(ptr);

}

static void destroyBlock(/*@reldef@*//*@temp@*//*@null@*/ void *ptr)

{

    if (ptr != NULL) {

        validateBlock(ptr);

        {

            /* Fill with garbage that will show up on the debugger if

             * used after deallocation */

            StartGuard *start = (StartGuard *) PHYSICAL_BLOCK(ptr);

            M3Guint *p = (M3Guint *) start;

            M3Guint count = (start->endOffset + sizeof(EndGuard)) >> 2;

            while (count--) {

                *p++ = 0xDEADBEEFu;

            }

        }

    }

}

#if defined(M3G_DEBUG_HEAP_TRACKING)

static void insertBlock(void *ptr, HeapBlock **blockListHead)

{

    HeapBlock *head  = *blockListHead;

    HeapBlock *block = (HeapBlock *) PHYSICAL_BLOCK(ptr);

    M3G_ASSERT_PTR(block);

    *blockListHead = block;

    block->prev = NULL;

    block->next = head;

    if (head != NULL) {

        head->prev = block;

    }

}

#endif

#if defined(M3G_DEBUG_HEAP_TRACKING)

static void removeBlock(void *ptr, HeapBlock **blockListHead)

{

    if (ptr != NULL) {

        HeapBlock *head  = *blockListHead;

        HeapBlock *block = (HeapBlock *) PHYSICAL_BLOCK(ptr);

        validateBlock(ptr);

        M3G_ASSERT_PTR(head);

        M3G_ASSERT_PTR(block);

        if (block->prev) {

            block->prev->next = block->next;

        }

        if (block->next) {

            block->next->prev = block->prev;

        }

        if (block == head) {

            *blockListHead = block->next;

        }

        block->next = NULL;

        block->prev = NULL;

    }

}

#endif

#if defined(M3G_DEBUG_HEAP_TRACKING) && defined(M3G_LOGLEVEL)

static void dumpBlocks(const HeapBlock *head) 

{

    while (head) {

        M3G_LOG4(M3G_LOG_FATAL_ERRORS,

                 "0x%08X: %s:%d, %d bytes\n",

                 (unsigned) PAYLOAD_BLOCK(head),

                 head->allocFile,

                 head->allocLine,

                 (M3Gsizei) PAYLOAD_SIZE(PAYLOAD_BLOCK(head)));

        head = head->next;

    }

}

#endif

#undef MEMORY_MAGIC

#else /* !M3G_DEBUG */

#   define instrumentateBlock(ptr, bytes)

#   define validateBlock(ptr)

#   define destroyBlock(ptr)

#endif /* M3G_DEBUG */

/*--------------------------------------------------------------------*/

/*----------------------------------------------------------------------

 * Internal functions

 *--------------------------------------------------------------------*/

#if defined(M3G_DEBUG)

/*!

 * \internal

 * \brief Locks all memory allocation for an interface

 *

 * This is used to ensure that memory compacting does not affect the

 * addresses of our "memory objects" while they're in use. A count of

 * locks is maintained; the same interface may be locked several

 * times, and each lock must be separately released with a call to

 * m3gUnlockMemory.

 *

 * Memory is also automatically locked while a handle is mapped to a

 * pointer; see m3gMapObject.

 *

 */

static void m3gDebugLockMemory(Interface *m3g, const char *file, int line)

{

    M3G_ASSERT(m3gInRange(m3g->lockCount, 0, 0x7FFFFFFE));

    M3G_ASSERT(m3g->lockCount < MAX_LOCKHEAP_SIZE);

    m3g->lockHeap[m3g->lockCount].file = file;

    m3g->lockHeap[m3g->lockCount].line = line;

    m3g->lockCount++;

    m3gIncStat(m3g, M3G_STAT_MEMORY_LOCKS, 1);

}

/*!

 * \internal

 * \brief Releases a memory allocation lock on an interface

 */

static void m3gUnlockMemory(Interface *m3g)

{

    M3G_ASSERT(m3g->lockCount > 0);

    m3g->lockHeap[m3g->lockCount].file = "";

    m3g->lockHeap[m3g->lockCount].line = 0;

    m3g->lockCount--;

}

/*!

 * \internal

 * \brief Checks whether memory is currently locked (debug only)

 */

static M3Gbool m3gMemoryLocked(Interface *m3g)

{

    M3G_ASSERT(m3g->lockCount >= 0);

    if (m3g->lockCount > 0) {

#       if defined(M3G_LOGLEVEL)

        int i;

        M3G_LOG1(M3G_LOG_FATAL_ERRORS,

                 "%d memory lock(s) in effect:\n", m3g->lockCount);

        for (i = m3g->lockCount - 1; i >= 0; --i) {

            M3G_LOG2(M3G_LOG_FATAL_ERRORS, "%s, line %d\n",

                     m3g->lockHeap[i].file, m3g->lockHeap[i].line);

        }

#       endif

        return M3G_TRUE;

    }

    return M3G_FALSE;

}

#endif

/*!

 * \internal

 * \brief Allocates a block of memory from a regular C-style heap

 *

 */

#if defined(M3G_DEBUG)

static void *m3gDebugAlloc(

    Interface *m3g, M3Gsize bytes, const char *file, int line)

#else

static void *m3gAlloc(Interface *m3g, M3Gsize bytes)

#endif    

{

    void *ptr;

    M3G_VALIDATE_INTERFACE(m3g);

    M3G_ASSERT_NO_LOCK(m3g);

    /* Simulate memory allocation failures if enabled */

#   if defined(M3G_DEBUG_OUT_OF_MEMORY)

    if (m3g->mallocFailRate > 0 &&

            m3g->mallocFailureCounter++ >= m3g->mallocFailRate) {

        m3g->mallocFailureCounter = 0;

        goto AllocFailed;

    }

    if (m3g->mallocLimit > 0 &&

            m3g->mallocBytes + bytes > m3g->mallocLimit) {

        goto AllocFailed;

    }

#   endif

    /* First just try to allocate more memory; if that fails, garbage

     * collect and try again before returning with an error */

    ptr = (*m3g->func.malloc)(INSTRUMENTATED_SIZE(bytes));

    if (ptr == NULL) {

        M3G_LOG(M3G_LOG_WARNINGS|M3G_LOG_MEMORY_ALL,

                "Warning: heap alloc failed\n");

        m3gGarbageCollectAll(m3g);

        ptr = (*m3g->func.malloc)(INSTRUMENTATED_SIZE(bytes));

    }

    if (ptr == NULL) {

        goto AllocFailed;

    }

    /* Succesfully allocated some, so update statistics */

#   if defined(M3G_DEBUG)

    m3g->mallocCount++;

#   endif

#   if defined(M3G_DEBUG_OUT_OF_MEMORY)

    m3g->mallocBytes += bytes;

#   endif

    /* Add instrumentation to the block */

    M3G_ASSERT_ALIGNMENT(ptr);

    ptr = PAYLOAD_BLOCK(ptr);

#   if defined(M3G_DEBUG_HEAP_TRACKING)

    insertBlock(ptr, &m3g->blockList);