/*

* 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: Native implementation of the Loader class

*

*/

/*!

 * \internal

 * \file

 * \brief Native implementation of the Loader class

 *

*/

#include "m3g_object.h"

#include "m3g_array.h"

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

 * Internal data types

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

/*!

 * \internal

 * \brief Possible global states for the loader

 */

typedef enum {

    /*! \internal \brief Loading not supported yet */

    LOADSTATE_NOT_SUPPORTED = -2,

    /*! \internal \brief Loading has terminated with an error */

    LOADSTATE_ERROR         = -1,

    /*! \internal \brief Loading has not started yet */

    LOADSTATE_INITIAL       =  0,

    /*! \internal \brief The identifier of the file is being read */

    LOADSTATE_IDENTIFIER,

    /*! \internal \brief The header of the section is being read */

    LOADSTATE_SECTION,

    /*! \internal \brief The header field of an object is being read */

    LOADSTATE_OBJECT,

    /*! \internal \brief Loading is finished */

    LOADSTATE_DONE

} LoaderState;

/*!

 * \internal

 * \brief Possible local states for the loader

 */

typedef enum {

    /*! \internal \brief Local state is entered */

    LOADSTATE_ENTER,

    /*! \internal \brief Local state is exited */

    LOADSTATE_EXIT,

    /*! \internal \brief Local state is section checksum */

    LOADSTATE_CHECKSUM

} LoaderLocalState;

/*!

 * \internal

 * \brief Buffered byte stream class

 */

typedef struct

{

    M3Gubyte *allocatedData;

    M3Gubyte *data;

    M3Gsizei capacity, bytesAvailable, totalBytes;

} BufferedStream;

/*!

 * \internal

 * \brief User data for a loaded object

 */

typedef struct

{

    M3GObject object;

    M3Gint numParams;

    M3Gbyte **params;

    M3Gsizei *paramLengths;

    M3Gint *paramId;

} UserData;

/*!

 * \internal

 * \brief Loader instance data

 */

typedef struct M3GLoaderImpl

{

    Object object;

    BufferedStream stream;

    M3Gsizei bytesRequired;

    M3Gsizei sectionBytesRequired;

    PointerArray refArray;

    PointerArray userDataArray;

    /*!

     * \internal

     * \brief The global state the loader is in

     *

     * This is a rather ordinary state machine thing; basically the

     * type of object being loaded, or one of the possible error

     * conditions. In here, it also amounts to a particular coroutine

     * execution context.

     */

    LoaderState state;

    /*!

     * \internal

     * \brief The local state of the loader

     *

     * This is basically the line number within a particular coroutine

     * function.

     */

    M3Gint localState;

    /*!

     * \internal

     * \brief Object being loaded

     */

    M3Gint objectType;

    /*!

     * \internal

     * \brief Loaded object

     */

    M3GObject loadedObject;

    /*!

     * \internal

     * \brief Pointer to the beginning of an object

     */

    M3Gubyte *objectData;

    /*!

     * \internal

     * \brief Pointer to the end of an object

     */

    M3Gubyte *objectDataEnd;

    /*!

     * \internal

     * \brief Pointer to the context data for the current coroutine

     * context

     */

    M3Gubyte *localData;

    /*!

     * \internal

     * \brief Size of the current coroutine data

     *

     * This is grown dynamically as necessary, rather than trying to

     * maintain a single size that fits all coroutines.

     */

    size_t localDataSize;

    /* File information */

    M3Gbool hasReferences;

    M3Gsizei fileSize;

    M3Gsizei contentSize;

    M3Gint triCount;

    M3Gint triConstraint;

    /* Section information */

    M3Gbool compressed;

    M3Gint sectionLength;

    M3Gint sectionNum;

    M3Gint inflatedLength;

    M3Gubyte *sectionData;

    M3Gubyte *allocatedSectionData;

    /* Adler data */

    M3Gint S12[2];

} Loader;

typedef struct {

    const unsigned char *data;

    int read;

    int length;

} compressedData;

/* Type ID used for classifying objects derived from Node */

#define ANY_NODE_CLASS ((M3GClass)(-1))

#include <string.h>

#define m3gCmp(s1, s2, len)  memcmp(s1, s2, len)

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

 * Private constants

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

#define M3G_MIN_OBJECT_SIZE     (1 + 4)

#define M3G_MIN_SECTION_SIZE    (1 + 4 + 4)

#define M3G_CHECKSUM_SIZE       4

#define M3G_ADLER_CONST         65521;

static const M3Gubyte M3G_FILE_IDENTIFIER[] = {

    0xAB, 0x4A, 0x53, 0x52, 0x31, 0x38, 0x34, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A

};

static const M3Gubyte PNG_FILE_IDENTIFIER[] = {

    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a

};

static void m3gCleanupLoader(M3GLoader loader);

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

 * Platform-specific "inflate" decompression code

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

/*!

 * \internal

 * \brief Decompresses a block of data into an output buffer

 *

 * \param srcLength number of bytes in the input (compressed) buffer

 * \param src       pointer to the input buffer

 * \param dstLength number of bytes allocated in the output buffer

 * \param dst       pointer to the output buffer

 * \return the number of bytes written to \c dst

 */

static M3Gsizei m3gInflateBlock(M3Gsizei srcLength, const M3Gubyte *src,

                                M3Gsizei dstLength, M3Gubyte *dst);

/* Include the platform-dependent implementation */

#if !defined(M3G_TARGET_GENERIC)

#   include "m3g_loader_inflate.inl"

#endif

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

 * Private functions

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

/*!

 * \internal

 * \brief Destructor

 */

static void m3gDestroyLoader(Object *obj)

{

    Loader* loader = (Loader *) obj;

    M3G_VALIDATE_OBJECT(loader);

    {

        Interface *m3g = M3G_INTERFACE(loader);

        M3Gint n, i;

        m3gCleanupLoader(loader);

        m3gDestroyArray(&loader->refArray, m3g);

        n = m3gArraySize(&loader->userDataArray);

        for (i = 0; i < n; ++i)

        {

            UserData *data = (UserData *)m3gGetArrayElement(&loader->userDataArray, i);

            m3gFree(m3g, data->params);

            m3gFree(m3g, data->paramLengths);

            m3gFree(m3g, data->paramId);

            m3gFree(m3g, data);

        }

        m3gDestroyArray(&loader->userDataArray, m3g);

        m3gFree(m3g, loader->stream.allocatedData);

        m3gFree(m3g, loader->allocatedSectionData);

    }

    m3gDestroyObject(obj);

}

/*!

 * \internal

 * \brief Stores new data in the stream buffer of this loader

 */

static M3Gbool m3gBufferData( M3GInterface m3g,

                           BufferedStream *stream,

                           M3Gsizei bytes,

                           const M3Gubyte *data)

{

    M3Gsizei used;

    /* Allocate initial buffer */

    if (stream->allocatedData == NULL) {

        stream->capacity = bytes + 512;

        stream->allocatedData = m3gAllocZ(m3g, stream->capacity);

        if (!stream->allocatedData) {

            return M3G_FALSE;

        }

        stream->data = stream->allocatedData;

        stream->bytesAvailable = 0;

        stream->totalBytes = 0;

    }

    /* First skip used bytes */

    used = stream->data - stream->allocatedData;

    if (used > 0) {

        m3gMove(stream->allocatedData, stream->data, stream->bytesAvailable);

        stream->data = stream->allocatedData;

    }

    /* Check if new data fits in current buffer */

    if ((stream->capacity - stream->bytesAvailable) < bytes) {

        M3Gubyte *newData;

        stream->capacity = stream->capacity + bytes + 512;

        newData = m3gAllocZ(m3g, stream->capacity);

        if (!newData) {

            m3gFree(m3g, stream->allocatedData);

            stream->allocatedData = NULL;

            return M3G_FALSE;

        }

        m3gCopy(newData, stream->data, stream->bytesAvailable);

        m3gFree(m3g, stream->allocatedData);

        stream->allocatedData = newData;

        stream->data = stream->allocatedData;

    }

    m3gCopy(stream->data + stream->bytesAvailable, data, bytes);

    stream->bytesAvailable += bytes;

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Resets buffered data

 */

static void m3gResetBufferedData(BufferedStream *stream)

{

    stream->bytesAvailable = 0;

    stream->data = stream->allocatedData;

    stream->totalBytes = 0;

}

/*!

 * \internal

 * \brief Gets buffered data pointer

 */

static M3Gubyte *m3gGetBufferedDataPtr(BufferedStream *stream, M3Gint length)

{

    if (stream->bytesAvailable >= length) {

        return stream->data;

    }

    else {

        return NULL;

    }

}

/*!

 * \internal

 * \brief Advances buffered data pointer

 */

static void m3gAdvanceBufferedData(BufferedStream *stream, M3Gint length)

{

    stream->data += length;

    stream->bytesAvailable -= length;

    stream->totalBytes += length;

}

/*!

 * \internal

 * \brief Verify a boolean

 */

static M3Gbool m3gVerifyBool(M3Gubyte *data)

{

    return (*data == 0 || *data == 1);

}

/*!

 * \internal

 * \brief Loads ARGB color from data array

 */

static M3Guint m3gLoadARGB(M3Gubyte *data)

{

    M3Guint v = data[3];

    v <<= 8;

    v |=  data[0];

    v <<= 8;

    v |=  data[1];

    v <<= 8;

    v |=  data[2];

    return v;

}

/*!

 * \internal

 * \brief Loads RGB color from data array

 */

static M3Guint m3gLoadRGB(M3Gubyte *data)

{

    M3Guint v = data[0];

    v <<= 8;

    v |=  data[1];

    v <<= 8;

    v |=  data[2];

    return v;

}

/*!

 * \internal

 * \brief Loads short from data array

 */

static M3Gshort m3gLoadShort(M3Gubyte *data)

{

    M3Gshort v = data[1];

    v <<= 8;

    v |=  data[0];

    return v;

}

/*!

 * \internal

 * \brief Loads integer from data array

 */

static M3Gint m3gLoadInt(M3Gubyte *data)

{

    M3Gint v = data[3];

    v <<= 8;

    v |=  data[2];

    v <<= 8;

    v |=  data[1];

    v <<= 8;

    v |=  data[0];

    return v;

}

/*!

 * \internal

 * \brief Loads integer from data array

 */

static M3Gbool m3gLoadFloat(M3Gubyte *data, M3Gfloat *res)

{

    M3Guint v = data[3];

    v <<= 8;

    v |=  data[2];

    v <<= 8;

    v |=  data[1];

    v <<= 8;

    v |=  data[0];

    *res = (*(M3Gfloat*)&(v));

    if ((v & 0x7f800000) ==  0x7f800000 ||

        v == 0x80000000 || // negative zero

        ((v & 0x007FFFFF ) != 0 && ( v & 0x7F800000 ) == 0))

        return M3G_FALSE;

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Loads 4 * 4 matrix from data array

 */

static M3Gbool m3gLoadMatrix(Matrix *m, M3Gubyte *data)

{

    M3Gint i;

    M3Gfloat array[16];

    for (i = 0; i < 16; i++) {

        if (!m3gLoadFloat(data + 4 * i, &array[i]))

            return M3G_FALSE;

    }

    m3gSetMatrixRows(m, array);

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Inflates a section

 */

static M3Gubyte *m3gInflateSection(Loader *loader,

                                   M3Gubyte *compressed,

                                   M3Gint cLength, M3Gint iLength)

{

    M3Gubyte *inflated = m3gAllocZ(M3G_INTERFACE(loader), iLength);

    if (inflated && !m3gInflateBlock(cLength, compressed, iLength, inflated)) {

        m3gFree(M3G_INTERFACE(loader), inflated);

        return NULL;

    }

    return inflated;

}

/*!

 * \internal

 * \brief Loads file identifier

 */

static LoaderState m3gLoadIdentifier(Loader *loader)

{

    M3Gubyte *data = m3gGetBufferedDataPtr(&loader->stream, loader->bytesRequired);

    if (loader->localState == LOADSTATE_ENTER) {

        if (m3gCmp(data, PNG_FILE_IDENTIFIER, sizeof(PNG_FILE_IDENTIFIER)) == 0) {

            m3gAdvanceBufferedData(&loader->stream, loader->bytesRequired);

            return LOADSTATE_NOT_SUPPORTED;

        }

        else {

            loader->localState = LOADSTATE_EXIT;

            loader->bytesRequired = sizeof(M3G_FILE_IDENTIFIER);

            return LOADSTATE_IDENTIFIER;

        }

    }

    else {

        if (m3gCmp(data, M3G_FILE_IDENTIFIER, sizeof(M3G_FILE_IDENTIFIER)) == 0) {

            m3gAdvanceBufferedData(&loader->stream, loader->bytesRequired);

            loader->localState = LOADSTATE_ENTER;

            loader->bytesRequired = M3G_MIN_SECTION_SIZE;

            return LOADSTATE_SECTION;

        }

        loader->bytesRequired = 0;

        return LOADSTATE_ERROR;

    }

}

/*!

 * \internal

 * \brief Adler helper functions

 */

static void m3gInitAdler(M3Gint *S12)

{

    S12[0] = 1; S12[1] = 0;