/*

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

*

*/

package javax.microedition.m3g;

import java.io.*;

import java.io.IOException;

import java.util.Vector;

import java.util.Hashtable;

import javax.microedition.io.*;

import javax.microedition.lcdui.Image;

import javax.microedition.io.Connector;

import javax.microedition.io.HttpConnection;

//#ifdef RD_JAVA_OMJ

import com.nokia.mj.impl.rt.support.Finalizer;

//#endif // RD_JAVA_OMJ

public class Loader

{

    // M3G

    static final byte[] M3G_FILE_IDENTIFIER =

    {

        -85, 74, 83, 82, 49, 56, 52, -69, 13, 10, 26, 10

    };

    // PNG

    static final byte[] PNG_FILE_IDENTIFIER =

    {

        -119, 80, 78, 71, 13, 10, 26, 10

    };

    static final int PNG_IHDR = ((73 << 24) + (72 << 16) + (68 << 8) + 82);

    static final int PNG_tRNS = ((116 << 24) + (82 << 16) + (78 << 8) + 83);

    static final int PNG_IDAT = ((73 << 24) + (68 << 16) + (65 << 8) + 84);

    // JPEG

    static final byte[] JPEG_FILE_IDENTIFIER =

    {

        -1, -40

    };

    static final int JPEG_JFIF = ((74 << 24) + (70 << 16) + (73 << 8) + 70);

    // Bytes before colour info in a frame header 'SOFn':

    // length (2 bytes), precision (1 byte), image height & width (4 bytes)

    static final int JPEG_SOFn_DELTA = 7;

    static final int JPEG_INVALID_COLOUR_FORMAT = -1;

    // File identifier types

    private static final int INVALID_HEADER_TYPE = -1;

    private static final int M3G_TYPE = 0;

    private static final int PNG_TYPE = 1;

    private static final int JPEG_TYPE = 2;

    // Misc.

    private static final int MAX_IDENTIFIER_LENGTH  = M3G_FILE_IDENTIFIER.length;

    // Initial buffer length for the header

    private static final int AVG_HEADER_SEC_LENGTH  = 64;

    // Initial buffer length for the xref section

    private static final int AVG_XREF_SEC_LENGTH    = 128;

    // Instance specific

    int handle;

    private Vector iLoadedObjects = new Vector();

    private Vector iFileHistory = new Vector();

    private String iResourceName = null;

    private String iParentResourceName = null;

    private int iTotalFileSize = 0;

    private int iBytesRead = M3G_FILE_IDENTIFIER.length;

    private byte[] iStreamData = null;

    private int iStreamOffset = 0;

    private Interface iInterface;

//#ifdef RD_JAVA_OMJ

    private Finalizer mFinalizer = new Finalizer()

    {

        public void finalizeImpl()

        {

            doFinalize();

        }

    };

//#endif // RD_JAVA_OMJ

    /**

     * Default ctor

     */

    private Loader()

    {

        iInterface = Interface.getInstance();

    }

    /**

     * Ctor

     * @param aFileHistory File storage

     * @param aParentResourceName Resource name

     */

    private Loader(Vector aFileHistory, String aParentResourceName)

    {

        iParentResourceName = aParentResourceName;

        iFileHistory        = aFileHistory;

        iInterface          = Interface.getInstance();

    }

    public static Object3D[] load(String name) throws IOException

    {

        if (name == null)

        {

            throw new NullPointerException();

        }

        try

        {

            return (new Loader()).loadFromStream(name);

        }

        catch (SecurityException e)

        {

            throw e;

        }

        catch (IOException e)

        {

            throw e;

        }

        catch (Exception e)

        {

            throw new IOException("Load error " + e);

        }

    }

    public static Object3D[] load(byte[] data, int offset) throws IOException

    {

        if (data == null)

        {

            throw new NullPointerException();

        }

        if (offset < 0 || offset >= data.length)

        {

            throw new IndexOutOfBoundsException();

        }

        try

        {

            return (new Loader()).loadFromByteArray(data, offset);

        }

        catch (SecurityException e)

        {

            throw e;

        }

        catch (IOException e)

        {

            throw e;

        }

        catch (Exception e)

        {

            throw new IOException("Load error " + e);

        }

    }

    /**

     * @see javax.microedition.m3g.Loader#load(String)

     */

    private Object3D[] loadFromStream(String aName) throws IOException

    {

        if (aName == null)

        {

            throw new NullPointerException();

        }

        if (inFileHistory(aName))

        {

            throw new IOException("Reference loop detected.");

        }

        iResourceName = aName;

        iFileHistory.addElement(aName);

        PeekInputStream stream = new PeekInputStream(

            getInputStream(aName), MAX_IDENTIFIER_LENGTH);

        // png, jpeg or m3g

        int type = getIdentifierType(stream);

        stream.rewind();

        iStreamData = null;

        iStreamOffset = 0;

        Object3D[] objects;

        try

        {

            objects = doLoad(stream, type);

        }

        finally

        {

            try

            {

                stream.close();

                stream = null;

            }

            catch (Exception e) {}

        }

        // Finally, remove file from history

        iFileHistory.removeElement(aName);

        return objects;

    }

    /**

     * @see javax.microedition.m3g.Loader#load(byte[], int)

     */

    private Object3D[] loadFromByteArray(byte[] aData, int aOffset) throws IOException

    {

        if (aData == null)

        {

            throw new NullPointerException("Resource byte array is null.");

        }

        int type = getIdentifierType(aData, aOffset);

        ByteArrayInputStream stream =

            new ByteArrayInputStream(aData, aOffset, aData.length - aOffset);

        iStreamData = aData;

        iStreamOffset = aOffset;

        iResourceName = "ByteArray";

        Object3D[] objects;

        try

        {

            objects = doLoad(stream, type);

        }

        finally

        {

            try

            {

                stream.close();

                stream = null;

            }

            catch (Exception e) {}

        }

        return objects;

    }

    /**

     * Dispatcher

     * @param aStream Source stream

     * @param aType Resource type

     */

    private Object3D[] doLoad(InputStream aStream, int aType) throws IOException

    {

        if (aType == M3G_TYPE)

        {

            return loadM3G(aStream);

        }

        else if (aType == PNG_TYPE)

        {

            return loadPNG(aStream);

        }

        else if (aType == JPEG_TYPE)

        {

            return loadJPEG(aStream);

        }

        throw new IOException("File not recognized.");

    }

    /**

     * PNG resource loader

     * @param aStream Resource stream

     * @return An array of newly created Object3D instances

     */

    private Object3D[] loadPNG(InputStream aStream) throws IOException

    {

        int format = Image2D.RGB;

        DataInputStream in = new DataInputStream(aStream);

        // Scan chuncs that have effect on Image2D format

        in.skip(PNG_FILE_IDENTIFIER.length);

        try

        {

            while (true)

            {

                int length = in.readInt();

                int type = in.readInt();

                // IHDR

                if (type == PNG_IHDR)

                {

                    in.skip(9);

                    int colourType = in.readUnsignedByte();

                    length -= 10;

                    switch (colourType)

                    {

                    case 0:

                        format = Image2D.LUMINANCE;

                        break;

                    case 2:

                        format = Image2D.RGB;

                        break;

                    case 3:

                        format = Image2D.RGB;

                        break;

                    case 4:

                        format = Image2D.LUMINANCE_ALPHA;

                        break;

                    case 6:

                        format = Image2D.RGBA;

                        break;

                    }

                }

                // tRNS

                if (type == PNG_tRNS)

                {

                    switch (format)

                    {

                    case Image2D.LUMINANCE:

                        format = Image2D.LUMINANCE_ALPHA;

                        break;

                    case Image2D.RGB:

                        format = Image2D.RGBA;

                        break;

                    }

                }

                // IDAT

                if (type == PNG_IDAT)

                {

                    break;

                }

                in.skip(length + 4);

            }

        }

        // EOF

        catch (Exception e)

        {

        }

        // Close the data stream

        try

        {

            in.close();

            in = null;

        }

        catch (Exception e) {}

        return buildImage2D(format);

    }

    /**

     * JPEG (with the same detailed definitions about the JPEG image format as defined in the

     * JSR 118 MIDP 2.1 specification for LCDUI) MUST be supported by compliant

     * implementations as a 2D bitmap image format for the Image2D class using the

     * javax.microedition.m3g.Loader class, and for M3G content files referencing bitmap images.

     * For colour JPEG images, the pixel format of the returned Image2D object MUST be

     * Image2D.RGB and for monochrome JPEG images, the pixel format MUST be

     * Image2D.LUMINANCE.

     *

     * JPEG marker: A two-byte code in which the first byte is 0xFF and the second

     * byte is a value between 1 and 0xFE.

     *

     * A JFIF file uses APP0 (0xe0) marker segments and constrains certain parameters in the frame.

     *

     * A frame header:

     * - 0xff, 'SOFn'

     * - length (2 bytes, Hi-Lo)

     * - data precision (1 byte)

     * - image height (2 bytes, Hi-Lo)

     * - image width (2 bytes, Hi-Lo)

     * - number of components (1 byte): 1 = grey scaled, 3 = color YCbCr or YIQ, 4 = color CMYK)

     *

     * @param aStream Resource stream

     * @return An array of newly created Object3D instances

     */

    private Object3D[] loadJPEG(InputStream aStream) throws IOException

    {

        int format = JPEG_INVALID_COLOUR_FORMAT;

        DataInputStream in = new DataInputStream(aStream);

        // Skip file identifier

        in.skip(JPEG_FILE_IDENTIFIER.length);

        try

        {

            int marker;

            do

            {

                // Find marker

                while (in.readUnsignedByte() != 0xff);

                do

                {

                    marker = in.readUnsignedByte();

                }

                while (marker == 0xff);

                // Parse marker

                switch (marker)

                {

                    // 'SOFn' (Start Of Frame n)

                case 0xC0:

                case 0xC1:

                case 0xC2:

                case 0xC3:

                case 0xC5:

                case 0xC6:

                case 0xC7:

                case 0xC9:

                case 0xCA:

                case 0xCB:

                case 0xCD:

                case 0xCE:

                case 0xCF:

                    // Skip length(2), precicion(1), width(2), height(2)

                    in.skip(JPEG_SOFn_DELTA);

                    switch (in.readUnsignedByte())

                    {

                    case 1:

                        format = Image2D.LUMINANCE;

                        break;

                    case 3:

                        format = Image2D.RGB;

                        break;

                    default:

                        throw new IOException("Unknown JPG format.");

                    }

                    break;

                    // APP0 (0xe0) marker segments and constrains certain parameters in the frame.

                case 0xe0:

                    int length = in.readUnsignedShort();

                    if (JPEG_JFIF != in.readInt())

                    {

                        throw new IOException("Not a valid JPG file.");

                    }

                    in.skip(length - 4 - 2);

                    break;

                default:

                    // Skip variable data

                    in.skip(in.readUnsignedShort() - 2);

                    break;

                }

            }

            while (format == JPEG_INVALID_COLOUR_FORMAT);

        }

        catch (Exception e) {}

        // Close the data stream

        try

        {

            in.close();

            in = null;

        }

        catch (Exception e) {}

        return buildImage2D(format);

    }

    /**

     * Image2D builder

     * @param aColourFormat Colour format

     * @return An array of newly created Object3D instances

     */

    private Object3D[] buildImage2D(int aColourFormat) throws IOException

    {

        InputStream stream;

        if (iStreamData == null)

        {

            stream = getInputStream(iResourceName);

        }

        else

        {

            stream = (InputStream) new ByteArrayInputStream(

                         iStreamData, iStreamOffset, iStreamData.length - iStreamOffset);

        }

        // Create an image object

        Image2D i2d;

        try

        {

            i2d = new Image2D(aColourFormat, Image.createImage(stream));

        }

        finally

        {

            try

            {

                stream.close();

            }

            catch (Exception e) {}

        }

        return new Object3D[] { i2d };

    }

    /**

     * M3G resource loader

     * @param aStream Resource stream

     * @return An array of newly created Object3D instances

     */

    private Object3D[] loadM3G(InputStream aStream) throws IOException

    {

        aStream.skip(M3G_FILE_IDENTIFIER.length);

        if (aStream instanceof PeekInputStream)

            ((PeekInputStream)aStream).increasePeekBuffer(AVG_HEADER_SEC_LENGTH);

        // Read header

        int compressionScheme = readByte(aStream);

        int totalSectionLength = readUInt32(aStream);

        if (aStream instanceof PeekInputStream && totalSectionLength > AVG_HEADER_SEC_LENGTH)

            ((PeekInputStream)aStream).increasePeekBuffer(totalSectionLength - AVG_HEADER_SEC_LENGTH);

        int uncompressedLength = readUInt32(aStream);

        int objectType = readByte(aStream);

        int length    = readUInt32(aStream);

        byte vMajor = (byte) readByte(aStream);

        byte vMinor = (byte) readByte(aStream);

        boolean externalLinks = readBoolean(aStream);

        iTotalFileSize = readUInt32(aStream);

        int approximateContentSize = readUInt32(aStream);

        String authoringField = readString(aStream);

        int checksum = readUInt32(aStream);

        /* Create and register a new native Loader */

        handle = _ctor(Interface.getHandle());

        Interface.register(this);

        if (externalLinks)