/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package flash.util;

import java.io.OutputStream;
import java.io.IOException;

/**
 * A variety of utilities for dealing with the image formats that are
 * part of the SWF spec.
 *
 * @author Roger Gonzalez
 */
public class SwfImageUtils
{
    private static class JPEGIterator
    {
        private byte[] jpeg = null;
        private int offset = 0;
        private int length = 0;
        private int nextOffset = -1;
        private boolean valid = false;
        private byte code;

        public JPEGIterator( byte[] jpeg )
        {
            this.jpeg = jpeg;
            reset();
        }

        public boolean valid()
        {
            return this.valid;
        }

        public byte code()
        {
            return this.code;
        }

        public int length()
        {
            return this.length;
        }

        public int size()
        {
            if ( !valid )
                return -1;

            if ( nextOffset == -1 )
                return jpeg.length - offset;
            else
                return nextOffset - offset;
        }


        public int offset()
        {
            return this.offset;
        }

        public boolean reset()
        {
            valid = ((jpeg.length >= 4)
                  && (jpeg[0] == (byte)0xff)
                  && (jpeg[1] == (byte)0xd8)
                  && (jpeg[jpeg.length-2] == (byte)0xff)
                  && (jpeg[jpeg.length-1] == (byte)0xd9));
            offset = 0;
            nextOffset = offsetOfNextBlock();
            code = jpeg[1];
            length = 0;
            return valid;
        }

        public int offsetOfNextBlock()
        {
            int i = offset + 2 + length;

            while (i < jpeg.length)
            {
                if ((code == (byte)0xda) && (jpeg[i] != (byte) 0xff))
                    ++i;
                else if (i+1 >= jpeg.length)
                    return -1;
                else if ( jpeg[i+1] == (byte) 0xff ) // padding
                    ++i;
                else if ((code == (byte)0xda) && (jpeg[i+1] == (byte) 0x00))
                    i += 2;
                else
                    break;
            }

            return i;
        }

        public boolean next()
        {
            if (!valid)
                return false;

            // entry state assumes that we are on the
            // start of a valid record, i.e. that
            // offset points at 0xff and that offset+1
            // is a code.  if the current record has
            // a length, it is assumed to be set.

            offset = nextOffset;
            if ((offset >= jpeg.length) || (offset == -1))
            {
                valid = false;
                offset = jpeg.length;
                return false;
            }

            code = jpeg[offset+1];

            if ((code == (byte) 0x00) || (code == (byte) 0x01)
                || ((code >= (byte)0xd0) && (code <= (byte)0xd9)))
            {
                length = 0;
            }
            else if (offset + 3 >= jpeg.length)
                valid = false;
            else
            {
                length = ((jpeg[offset+2]&0xff)<<8)
                       +  (jpeg[offset+3]&0xff);
            }
            nextOffset = offsetOfNextBlock();
            return valid;
        }
    }

    public static class JPEG
    {
        public byte[] table;
        public byte[] data;

        private int width;
        private int height;

        public JPEG( byte[] table, byte[] data )
        {
            this.table = table;
            this.data = data;

            validate();
        }

        public JPEG( byte[] jpeg, boolean doSplit )
        {
            if (doSplit)
                split( jpeg );
            else
                data = jpeg;

            validate();
        }

        public int getWidth()
        {
            return width;
        }

        public int getHeight()
        {
            return height;
        }

        static public boolean markerIsSOF( byte code )
        {
            return ((code >= (byte)0xc0)
                    && (code <= (byte)0xcf)
                    && (code != (byte)0xc4)
                    && (code != (byte)0xcc));
        }

        public boolean validate()
        {
            if (table != null)
            {
                // Confirm that there are only db and c4 markers...

                JPEGIterator it = new JPEGIterator( table );

                if ( !it.valid() )  // constructor does an SOI/EOI check...
                    return false;
                it.next();

                while (it.valid() && (it.code() != (byte)0xd9))
                {
                    if ((it.code() != (byte)0xc4) && (it.code() != (byte)0xdb))
                        return false;
                    it.next();
                }

                if (it.offset() != table.length-2)
                    return false;
            }

            if (data == null)
                return false;

            JPEGIterator it = new JPEGIterator( data );

            if ( !it.valid() )
                return false;

            boolean foundSOS = false;
            boolean foundSOF = false;

            while (it.valid())
            {
                if (it.code() == (byte)0xda)
                    foundSOS = true;

                if (!foundSOF && markerIsSOF(it.code()))
                {
                    foundSOF = true;
                    height = (((data[it.offset()+5]&0xff)<<8)
                              |(data[it.offset()+6]&0xff));

                    width = (((data[it.offset()+7]&0xff)<<8)
                             |(data[it.offset()+8]&0xff));

                    if ((width == 0) || (height == 0))
                        return false;
                }
                it.next();
            }
            return ( foundSOS && foundSOF && (it.offset() == data.length));
        }

        private void split( byte[] jpeg ) throws IllegalStateException
        {
            JPEGIterator it = new JPEGIterator( jpeg );
            int tablesize = 4;

            while (it.valid())
            {
                if ((it.code() == (byte)0xdb) || (it.code() == (byte)0xc4))
                    tablesize += it.length() + 2;
                it.next();
            }

            table = new byte[tablesize];
            int tableoffset = 0;
            table[tableoffset++] = (byte) 0xff;
            table[tableoffset++] = (byte) 0xd8;

            int datasize = 4 + (jpeg.length - tablesize);
            int dataoffset = 0;
            data = new byte[datasize];

            it.reset();
            while (it.valid())
            {
                if ((it.code() == (byte)0xdb) || (it.code() == (byte)0xc4))
                {
                    java.lang.System.arraycopy( jpeg,
                                                it.offset(),
                                                table,
                                                tableoffset,
                                                it.size() );
                    tableoffset += it.size();
                }
                else
                {
                    java.lang.System.arraycopy( jpeg,
                                                it.offset(),
                                                data,
                                                dataoffset,
                                                it.size() );
                    dataoffset += it.size();
                }
                it.next();
            }
            table[tableoffset++] = (byte) 0xff;
            table[tableoffset++] = (byte) 0xd9;

            if ( (tableoffset < table.length) || (dataoffset < data.length) )
                throw new IllegalStateException( "JPEG data is corrupt!" );
        }

        public void write( OutputStream out ) throws IOException
        {
            // Simple case: non-split JPEG
            if (table == null)
            {
                out.write( data );
                return;
            }

            // Harder case... emit the tables just before the SOS marker.
            int i = 0;
            while (i < data.length)
            {
                if ( data[i] != (byte) 0xff )
                {
                    ++i;
                    continue;
                }
                if (i + 1 >= data.length)
                    return;


                byte marker = data[i+1];

                if (marker == (byte) 0xff)
                {
                    ++i;
                    continue;
                }

                if ((marker == (byte) 0x00)
                    || (marker == (byte) 0x01)
                    || ((marker >= (byte) 0xd0) && (marker <= (byte) 0xd9 )))
                {
                    i += 2;
                    continue;
                }
                if (marker == (byte) 0xda)    // Start of Scan, aka SOS
                {
                    out.write( data, 0, i );
                    out.write( table, 2, table.length - 4 );
                    out.write( data, i, data.length - i );
                    return;
                }
                else
                {
                    if (i + 3 >= data.length)
                        return;

                    int length =  ((data[i+2]&0xff)<<8) + (data[i+3]&0xff);
                    i += length;
                }
            }
        }

    }

    // You don't care about this.  Move along.
    public static void jpegDebugSegments( byte[] data )
    {
        JPEGIterator it = new JPEGIterator( data );

        while (it.valid())
        {
            System.out.print( "offset " + it.offset() + ": " );

            System.out.print( Integer.toHexString(it.code() & 0xff) + " (");

            switch( it.code() )
            {
                case (byte)0xc0: System.out.print( "SOF0"); break;
                case (byte)0xc1: System.out.print( "SOF1"); break;
                case (byte)0xc2: System.out.print( "SOF2"); break;
                case (byte)0xc3: System.out.print( "SOF3"); break;
                case (byte)0xc4: System.out.print( "DHT"); break;
                case (byte)0xc5: System.out.print( "SOF5"); break;
                case (byte)0xc6: System.out.print( "SOF6"); break;
                case (byte)0xc7: System.out.print( "SOF7"); break;
                case (byte)0xc8: System.out.print( "JPGext"); break;
                case (byte)0xc9: System.out.print( "SOF9"); break;
                case (byte)0xca: System.out.print( "SOF10"); break;
                case (byte)0xcb: System.out.print( "SOF11"); break;
                case (byte)0xcc: System.out.print( "DAC"); break;
                case (byte)0xcd: System.out.print( "SOF13"); break;
                case (byte)0xce: System.out.print( "SOF14"); break;
                case (byte)0xcf: System.out.print( "SOF15"); break;

                case (byte)0xd0: System.out.print( "RST0"); break;
                case (byte)0xd1: System.out.print( "RST1"); break;
                case (byte)0xd2: System.out.print( "RST2"); break;
                case (byte)0xd3: System.out.print( "RST3"); break;
                case (byte)0xd4: System.out.print( "RST4"); break;
                case (byte)0xd5: System.out.print( "RST5"); break;
                case (byte)0xd6: System.out.print( "RST6"); break;
                case (byte)0xd7: System.out.print( "RST7"); break;

                case (byte)0xd8: System.out.print( "SOI"); break;
                case (byte)0xd9: System.out.print( "EOI"); break;

                case (byte)0xda: System.out.print( "SOS"); break;
                case (byte)0xdb: System.out.print( "DQT"); break;
                case (byte)0xdc: System.out.print( "DNL"); break;
                case (byte)0xdd: System.out.print( "DRI"); break;
                case (byte)0xde: System.out.print( "DHP"); break;
                case (byte)0xdf: System.out.print( "EXP"); break;

                case (byte)0xe0: System.out.print( "APP0"); break;
                case (byte)0xe1: System.out.print( "APP1"); break;
                case (byte)0xe2: System.out.print( "APP2"); break;
                case (byte)0xe3: System.out.print( "APP3"); break;
                case (byte)0xe4: System.out.print( "APP4"); break;
                case (byte)0xe5: System.out.print( "APP5"); break;
                case (byte)0xe6: System.out.print( "APP6"); break;
                case (byte)0xe7: System.out.print( "APP7"); break;
                case (byte)0xe8: System.out.print( "APP8"); break;
                case (byte)0xe9: System.out.print( "APP9"); break;
                case (byte)0xea: System.out.print( "APP10"); break;
                case (byte)0xeb: System.out.print( "APP11"); break;
                case (byte)0xec: System.out.print( "APP12"); break;
                case (byte)0xed: System.out.print( "APP13"); break;
                case (byte)0xee: System.out.print( "APP14"); break;
                case (byte)0xef: System.out.print( "APP15"); break;

                case (byte)0xf0: System.out.print( "JPG0"); break;
                case (byte)0xf1: System.out.print( "JPG1"); break;
                case (byte)0xf2: System.out.print( "JPG2"); break;
                case (byte)0xf3: System.out.print( "JPG3"); break;
                case (byte)0xf4: System.out.print( "JPG4"); break;
                case (byte)0xf5: System.out.print( "JPG5"); break;
                case (byte)0xf6: System.out.print( "JPG6"); break;
                case (byte)0xf7: System.out.print( "JPG7"); break;
                case (byte)0xf8: System.out.print( "JPG8"); break;
                case (byte)0xf9: System.out.print( "JPG9"); break;
                case (byte)0xfa: System.out.print( "JPG10"); break;
                case (byte)0xfb: System.out.print( "JPG11"); break;
                case (byte)0xfc: System.out.print( "JPG12"); break;
                case (byte)0xfd: System.out.print( "JPG13"); break;
                case (byte)0xfe: System.out.print( "COM"); break;

                case (byte)0x00: System.out.print( "00?"); break;
                case (byte)0x01: System.out.print( "TEM"); break;
                    default: System.out.print("???"); break;
            }
            System.out.print( ") ");

            if ((it.code() == (byte) 0x00)
                || (it.code() == (byte) 0x01)
                || ((it.code() >= (byte) 0xd0) && (it.code() <= (byte) 0xd9 )))
                System.out.print( "len=0");
            else
                System.out.print( "len=" + it.length() );

            System.out.print( " size=" + it.size() );

            int i = it.offset();

            if ( it.code() == (byte)0xfe)
            {
                byte[] comment = new byte[it.length() + 1];
                for ( int c = 0; c < it.length(); ++c )
                    comment[c] = data[i+2+c];

                System.out.print( " COMMENT='" + comment + "'");
            }

            if ( it.code() == (byte)0xe0)
            {
                if (( data[i+4] == 'J')
                    && (data[i+5] == 'F')
                    && (data[i+6] == 'I')
                    && (data[i+7] == 'F')
                    && (data[i+8] == 0))
                    System.out.print(" JFIF");
            }

            if ( (it.code() == (byte)0xc0)
                 || (it.code() == (byte)0xc1)
                 || (it.code() == (byte)0xc2)
                 || (it.code() == (byte)0xc3)
                 || (it.code() == (byte)0xc5)
                 || (it.code() == (byte)0xc6)
                 || (it.code() == (byte)0xc7)
                 || (it.code() == (byte)0xc8)
                 || (it.code() == (byte)0xc9)
                 || (it.code() == (byte)0xca)
                 || (it.code() == (byte)0xcb)
                 || (it.code() == (byte)0xcd)
                 || (it.code() == (byte)0xce)
                 || (it.code() == (byte)0xcf))
            {
                System.out.print( " precision = " + data[i+4]);
                int y = ((data[i+5]&0xff)<<8) | (data[i+6]&0xff);
                int x = ((data[i+7]&0xff)<<8) | (data[i+8]&0xff);
                System.out.print( " dimensions = " + x + "," + y );
            }


            System.out.println(".");
            it.next();
        }
    }
}