/*
 * This file was adapted from Jason Marshall's PNGImageProducer.java
 *
 * Copyright (c) 1997, Jason Marshall.  All Rights Reserved
 *
 * The author makes no representations or warranties regarding the suitability,
 * reliability or stability of this code.  This code is provided AS IS.  The
 * author shall not be liable for any damages suffered as a result of using,
 * modifying or redistributing this software or any derivitives thereof.
 * Permission to use, reproduce, modify and/or (re)distribute this software is
 * hereby granted.
 */

package org.ibex.graphics;

import org.ibex.util.*;
import java.io.*;
import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;
import java.util.zip.*;

/** Converts an InputStream carrying a PNG image into an ARGB int[] */
public class PNG {

    public PNG() { }
    
    private static Queue instances = new Queue(10);
    private Picture p;

    public static void load(InputStream is, Picture p) {
        PNG g = (PNG)instances.remove(false);
        if (g == null) g = new PNG();
        try {
            g._load(is, p);
            p.data = g.data;
        } catch (Exception e) {
            if (Log.on) Log.info(PNG.class, e);
            return;
        }
        // FIXME: must reset fields
        // if (instances.size() < 10) instances.append(g);
    }

    // Public Methods ///////////////////////////////////////////////////////////////////////////////

    /** process a PNG as an inputstream; returns null if there is an error
        @param name A string describing the image, to be used when logging errors
    */
    private void _load(InputStream is, Picture pic) throws IOException {
        p = pic;
        if (is instanceof BufferedInputStream) underlyingStream = (BufferedInputStream)is;
        else underlyingStream = new BufferedInputStream(is);
        target_offset = 0;
        inputStream = new DataInputStream(underlyingStream);
        
        // consume the header
        if ((inputStream.read() != 137) || (inputStream.read() != 80) || (inputStream.read() != 78) || (inputStream.read() != 71) ||
            (inputStream.read() != 13) || (inputStream.read() != 10) || (inputStream.read() != 26) || (inputStream.read() != 10)) {
            Log.info(this, "PNG: error: input file is not a PNG file");
            data = p.data = new int[] { };
            p.width = p.height = 0;
            return;
        }
        

        while (!error) {
            if (needChunkInfo) {
                chunkLength = inputStream.readInt();
                chunkType = inputStream.readInt();
                needChunkInfo = false;
            }
            
	    // I rewrote this as an if/else to work around a JODE bug with switch() blocks
	    if (chunkType == CHUNK_bKGD) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_cHRM) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_gAMA) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_hIST) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_pHYs) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_sBIT) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_tEXt) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_zTXt) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_tIME) inputStream.skip(chunkLength);
	    else if (chunkType == CHUNK_IHDR) handleIHDR();
	    else if (chunkType == CHUNK_PLTE) handlePLTE();
	    else if (chunkType == CHUNK_tRNS) handletRNS();
	    else if (chunkType == CHUNK_IDAT) handleIDAT();
	    else if (chunkType == CHUNK_IEND) break;
	    else {
                System.err.println("unrecognized chunk type " + Integer.toHexString(chunkType) + ". skipping");
                inputStream.skip(chunkLength);
            }
            
            int crc = inputStream.readInt();
            needChunkInfo = true;
        }
        p.isLoaded = true;
    }

    // Chunk Handlers ///////////////////////////////////////////////////////////////////////

    /** handle data chunk */
    private void handleIDAT() throws IOException {
        if (p.width == -1 || p.height == -1) throw new IOException("never got image width/height");
        switch (depth) {
        case 1: mask = 0x1; break;
        case 2: mask = 0x3; break;
        case 4: mask = 0xf; break;
        case 8: case 16: mask = 0xff; break;
        default: mask = 0x0; break;
        }
        if (depth < 8) smask = mask << depth;
        else smask = mask << 8;

        int count = p.width * p.height;

        switch (colorType) {
        case 0:
        case 2:
        case 6:
        case 4:
            ipixels = new int[count];
            pixels = ipixels;
            break;
        case 3:
            bpixels = new byte[count];
            pixels = bpixels;
            break;
        default:
            throw new IOException("Image has unknown color type");
        }
        if (interlaceMethod != 0) multipass = true;
        readImageData();
    }

    /** handle header chunk */
    private void handleIHDR() throws IOException {
        if (headerFound) throw new IOException("Extraneous IHDR chunk encountered.");
        if (chunkLength != 13) throw new IOException("IHDR chunk length wrong: " + chunkLength);
        p.width = inputStream.readInt();
        p.height = inputStream.readInt();
        depth = inputStream.read();
        colorType = inputStream.read();
        compressionMethod = inputStream.read();
        filterMethod = inputStream.read();
        interlaceMethod = inputStream.read();
    }

    /** handle pallette chunk */
    private void handlePLTE() throws IOException {
        if (colorType == 3) {
            palette = new byte[chunkLength];
            inputStream.readFully(palette);
        } else {
            // Ignore suggested palette
            inputStream.skip(chunkLength);
        }
    }

    /** handle transparency chunk; modifies palette */
    private void handletRNS() throws IOException {
        int chunkLen = chunkLength;
        if (palette == null) {
            if (Log.on) Log.info(this, "warning: tRNS chunk encountered before pLTE; ignoring alpha channel");
            inputStream.skip(chunkLength);
            return;
        }
        int len = palette.length;
        if (colorType == 3) {
            transparency = true;

            int transLength = len/3;
            byte[] trans = new byte[transLength];
            for (int i = 0; i < transLength; i++) trans[i] = (byte) 0xff;
            inputStream.readFully(trans, 0, chunkLength);

            byte[] newPalette = new byte[len + transLength];
            for (int i = newPalette.length; i > 0;) {
                newPalette[--i] = trans[--transLength];
                newPalette[--i] = palette[--len];
                newPalette[--i] = palette[--len];
                newPalette[--i] = palette[--len];
            }
            palette = newPalette;

        } else {
            inputStream.skip(chunkLength);
        }
    }

    /// Helper functions for IDAT ///////////////////////////////////////////////////////////////////////////////////////////

    /** Read Image data in off of a compression stream */
    private void readImageData() throws IOException {
        InputStream dataStream = new SequenceInputStream(new IDATEnumeration(this));
        DataInputStream dis = new DataInputStream(new BufferedInputStream(new InflaterInputStream(dataStream, new Inflater())));
        int bps, filterOffset;
        switch (colorType) {
          case 0: case 3: bps = depth; break;
          case 2: bps = 3 * depth; break;
          case 4: bps = depth<<1; break;
          case 6: bps = depth<<2; break;
          default: throw new IOException("Unknown color type encountered.");
        }

        filterOffset = (bps + 7) >> 3;

        for (pass = (multipass ? 1 : 0); pass < 8; pass++) {
            int pass = this.pass;
            int rInc = rowInc[pass];
            int cInc = colInc[pass];
            int sCol = startingCol[pass];
            int val = (p.width - sCol + cInc - 1) / cInc;
            int samples = val * filterOffset;
            int rowSize = (val * bps)>>3;
            int sRow = startingRow[pass];
            if (p.height <= sRow || rowSize == 0) continue;
            int sInc = rInc * p.width;
            byte inbuf[] = new byte[rowSize];
            int pix[] = new int[rowSize];
            int upix[] = null;
            int temp[] = new int[rowSize];
            int nextY = sRow;               // next Y value and number of rows to report to sendPixels
            int rows = 0;
            int rowStart = sRow * p.width;

            for (int y = sRow; y < p.height; y += rInc, rowStart += sInc) {
                rows += rInc;
                int rowFilter = dis.read();
                dis.readFully(inbuf);
                if (!filterRow(inbuf, pix, upix, rowFilter, filterOffset)) throw new IOException("Unknown filter type: " + rowFilter);
                insertPixels(pix, rowStart + sCol, samples);
                if (multipass && (pass < 6)) blockFill(rowStart);
                upix = pix;
                pix = temp;
                temp = upix;
            }
            if (!multipass) break;
        }
        while(dis.read() != -1) System.err.println("Leftover data encountered.");

        // 24-bit color is our native format
        if (colorType == 2 || colorType == 6) {
            data = (int[])pixels;
            if (colorType == 2) {
                for(int i=0; i<data.length; i++)
                    data[i] |= 0xFF000000;
            }

        } else if (colorType == 3) {
            byte[] pix = (byte[])pixels;
            data = new int[pix.length];
            for(int i=0; i<pix.length; i++) {
                if (transparency) {
                    data[i] =
                        ((palette[4 * (pix[i] & 0xff) + 3] & 0xff) << 24) |
                        ((palette[4 * (pix[i] & 0xff) + 0] & 0xff) << 16) |
                        ((palette[4 * (pix[i] & 0xff) + 1] & 0xff) << 8) |
                        (palette[4 * (pix[i] & 0xff) + 2] & 0xff);
                } else {
                    data[i] =
                        0xFF000000 |
                        ((palette[3 * (pix[i] & 0xff) + 0] & 0xff) << 16) |
                        ((palette[3 * (pix[i] & 0xff) + 1] & 0xff) << 8) |
                        (palette[3 * (pix[i] & 0xff) + 2] & 0xff);
                }
            }

        } else if (colorType == 0 || colorType == 4) {
            if (depth == 16) depth = 8;
            int[] pix = (int[])pixels;
            data = new int[pix.length];
            for(int i=0; i<pix.length; i ++) {
                if (colorType == 0) {
                    int val = (pix[i] & 0xff) << (8 - depth);
                    data[i] =
                        0xFF000000 | 
                        (val << 16) | 
                        (val << 8) | 
                        val;
                } else {
                    int alpha = (pix[i] & mask) << (8 - depth);
                    int val = ((pix[i] & smask) >> depth) << (8 - depth);
                    data[i] =
                        (alpha << 24) |
                        (val << 16) | 
                        (val << 8) | 
                        val;
                }
            }
        }

    }

    private void insertGreyPixels(int pix[], int offset, int samples) {
        int p = pix[0];
        int ipix[] = ipixels;
        int cInc = colInc[pass];
        int rs = 0;

        if (colorType == 0) {
            switch (depth) {
            case 1:
                for (int j = 0; j < samples; j++, offset += cInc) {
                    if (rs != 0) rs--;
                    else { rs = 7; p = pix[j>>3]; }
                    ipix[offset] = (p>>rs) & 0x1;
                }
                break;
            case 2:
                for (int j = 0; j < samples; j++, offset += cInc) {
                    if (rs != 0) rs -= 2;
                    else { rs = 6; p = pix[j>>2]; }
                    ipix[offset] = (p>>rs) & 0x3;
                }
                break;
            case 4:
                for (int j = 0; j < samples; j++, offset += cInc) {
                    if (rs != 0) rs = 0;
                    else { rs = 4; p = pix[j>>1]; }
                    ipix[offset] = (p>>rs) & 0xf;
                }
                break;
            case 8:
                for (int j = 0; j < samples; offset += cInc) ipix[offset] = (byte) pix[j++];
                break;
            case 16:
                samples = samples<<1;
                for (int j = 0; j < samples; j += 2, offset += cInc) ipix[offset] = pix[j];
                break;
            default: break;
            }
        } else if (colorType == 4) {
            if (depth == 8) {
                for (int j = 0; j < samples; offset += cInc) ipix[offset] = (pix[j++]<<8) | pix[j++];
            } else {
                samples = samples<<1;
                for (int j = 0; j < samples; j += 2, offset += cInc) ipix[offset] = (pix[j]<<8) | pix[j+=2];
            }
        }
    }

    private void insertPalettedPixels(int pix[], int offset, int samples) {
        int rs = 0;
        int p = pix[0];
        byte bpix[] = bpixels;
        int cInc = colInc[pass];

        switch (depth) {
          case 1:
            for (int j = 0; j < samples; j++, offset += cInc) {
                if (rs != 0) rs--;
                else { rs = 7; p = pix[j>>3]; }
                bpix[offset] = (byte) ((p>>rs) & 0x1);
            }
            break;
          case 2:
            for (int j = 0; j < samples; j++, offset += cInc) {
                if (rs != 0) rs -= 2;
                else { rs = 6; p = pix[j>>2]; }
                bpix[offset] = (byte) ((p>>rs) & 0x3);
            }
            break;
          case 4:
            for (int j = 0; j < samples; j++, offset += cInc) {
                if (rs != 0) rs = 0;
                else { rs = 4; p = pix[j>>1]; }
                bpix[offset] = (byte) ((p>>rs) & 0xf);
            }
            break;
          case 8:
            for (int j = 0; j < samples; j++, offset += cInc) bpix[offset] = (byte) pix[j];
            break;
        }
    }

    private void insertPixels(int pix[], int offset, int samples) {
        switch (colorType) {
        case 0:
        case 4:
            insertGreyPixels(pix, offset, samples);
            break;
        case 2: {
            int j = 0;
            int ipix[] = ipixels;
            int cInc = colInc[pass];
            if (depth == 8) {
                for (j = 0; j < samples; offset += cInc)
                    ipix[offset] = (pix[j++]<<16) | (pix[j++]<<8) | pix[j++];
            } else {
                samples = samples<<1;
                for (j = 0; j < samples; j += 2, offset += cInc)
                    ipix[offset] = (pix[j]<<16) | (pix[j+=2]<<8) | pix[j+=2];
            }
            break; }
        case 3:
            insertPalettedPixels(pix, offset, samples);
            break;
        case 6: {
            int j = 0;
            int ipix[] = ipixels;
            int cInc = colInc[pass];
            if (depth == 8) {
                for (j = 0; j < samples; offset += cInc) {
                    ipix[offset] = (pix[j++]<<16) | (pix[j++]<<8) | pix[j++] |
                                    (pix[j++]<<24);
                }
            } else {
                samples = samples<<1;
                for (j = 0; j < samples; j += 2, offset += cInc) {
                    ipix[offset] = (pix[j]<<16) | (pix[j+=2]<<8) | pix[j+=2] |
                                    (pix[j+=2]<<24);
                }
            }
            break; }
          default:
            break;
        }
    }

    private void blockFill(int rowStart) {
        int counter;
        int dw = p.width;
        int pass = this.pass;
        int w = blockWidth[pass];
        int sCol = startingCol[pass];
        int cInc = colInc[pass];
        int wInc = cInc - w;
        int maxW = rowStart + dw - w;
        int len;
        int h = blockHeight[pass];
        int maxH = rowStart + (dw * h);
        int startPos = rowStart + sCol;
        counter = startPos;

        if (colorType == 3) {
            byte bpix[] = bpixels;
            byte pixel;
            len = bpix.length;
            for (; counter <= maxW;) {
                int end = counter + w;
                pixel = bpix[counter++];
                for (; counter < end; counter++) bpix[counter] = pixel;
                counter += wInc;
            }
            maxW += w;
            if (counter < maxW)
                for (pixel = bpix[counter++]; counter < maxW; counter++)
                    bpix[counter] = pixel;
            if (len < maxH) maxH = len;
            for (counter = startPos + dw; counter < maxH; counter += dw)
                System.arraycopy(bpix, startPos, bpix, counter, dw - sCol);
        } else {
            int ipix[] = ipixels;
            int pixel;
            len = ipix.length;
            for (; counter <= maxW;) {
                int end = counter + w;
                pixel = ipix[counter++];
                for (; counter < end; counter++)
                    ipix[counter] = pixel;
                counter += wInc;
            }
            maxW += w;
            if (counter < maxW)
                for (pixel = ipix[counter++]; counter < maxW; counter++)
                    ipix[counter] = pixel;
            if (len < maxH) maxH = len;
            for (counter = startPos + dw; counter < maxH; counter += dw)
                System.arraycopy(ipix, startPos, ipix, counter, dw - sCol);
        }
    }

    private boolean filterRow(byte inbuf[], int pix[], int upix[], int rowFilter, int boff) {
        int rowWidth = pix.length;
        switch (rowFilter) {
        case 0: {
            for (int x = 0; x < rowWidth; x++) pix[x] = 0xff & inbuf[x];
            break; }
        case 1: {
            int x = 0;
            for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
            for ( ; x < rowWidth; x++) pix[x] = 0xff & (inbuf[x] + pix[x - boff]);
            break; }
        case 2: {
            if (upix != null) {
                for (int x = 0; x < rowWidth; x++)
                    pix[x] = 0xff & (upix[x] + inbuf[x]);
            } else {
                for (int x = 0; x < rowWidth; x++)
                    pix[x] = 0xff & inbuf[x];
            }
            break; }
        case 3: {
            if (upix != null) {
                int x = 0;
                for ( ; x < boff; x++) {
                    int rval = upix[x];
                    pix[x] = 0xff & ((rval>>1) + inbuf[x]);
                }
                for ( ; x < rowWidth; x++) {
                    int rval = upix[x] + pix[x - boff];
                    pix[x] = 0xff & ((rval>>1) + inbuf[x]);
                }
            } else {
                int x = 0;
                for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
                for ( ; x < rowWidth; x++) {
                    int rval = pix[x - boff];
                    pix[x] = 0xff & ((rval>>1) + inbuf[x]);
                }
            }
            break; }
        case 4: {
            if (upix != null) {
                int x = 0;
                for ( ; x < boff; x++) pix[x] = 0xff & (upix[x] + inbuf[x]);
                for ( ; x < rowWidth; x++) {
                    int a, b, c, p, pa, pb, pc, rval;
                    a = pix[x - boff];
                    b = upix[x];
                    c = upix[x - boff];
                    p = a + b - c;
                    pa = p > a ? p - a : a - p;
                    pb = p > b ? p - b : b - p;
                    pc = p > c ? p - c : c - p;
                    if ((pa <= pb) && (pa <= pc)) rval = a;
                    else if (pb <= pc) rval = b;
                    else rval = c;
                    pix[x] = 0xff & (rval + inbuf[x]);
                }
            } else {
                int x = 0;
                for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
                for ( ; x < rowWidth; x++) {
                    int rval = pix[x - boff];
                    pix[x] = 0xff & (rval + inbuf[x]);
                }
            }
            break; }
        default: return false;
        }
        return true;
    }

    // Private Data ///////////////////////////////////////////////////////////////////////////////////////
    
    private int target_offset = 0;
    private int sigmask = 0xffff;
    private Object pixels = null;
    private int ipixels[] = null;
    private byte bpixels[] = null;
    private boolean multipass = false;
    private boolean complete = false;
    private boolean error = false;

    int[] data = null;

    private InputStream underlyingStream = null;
    private DataInputStream inputStream = null;
    private Thread controlThread = null;
    private boolean infoAvailable = false;
    private int updateDelay = 750;

    // Image decoding state variables
    private boolean headerFound = false;
    private int compressionMethod = -1;
    private int depth = -1;
    private int colorType = -1;
    private int filterMethod = -1;
    private int interlaceMethod = -1;
    private int pass = 0;
    private byte palette[] = null;
    private int mask = 0x0;
    private int smask = 0x0;
    private boolean transparency = false;

    private int chunkLength = 0;
    private int chunkType = 0;
    private boolean needChunkInfo = true;

    private static final int CHUNK_bKGD = 0x624B4744;   // "bKGD"
    private static final int CHUNK_cHRM = 0x6348524D;   // "cHRM"
    private static final int CHUNK_gAMA = 0x67414D41;   // "gAMA"
    private static final int CHUNK_hIST = 0x68495354;   // "hIST"
    private static final int CHUNK_IDAT = 0x49444154;   // "IDAT"
    private static final int CHUNK_IEND = 0x49454E44;   // "IEND"
    private static final int CHUNK_IHDR = 0x49484452;   // "IHDR"
    private static final int CHUNK_PLTE = 0x504C5445;   // "PLTE"
    private static final int CHUNK_pHYs = 0x70485973;   // "pHYs"
    private static final int CHUNK_sBIT = 0x73424954;   // "sBIT"
    private static final int CHUNK_tEXt = 0x74455874;   // "tEXt"
    private static final int CHUNK_tIME = 0x74494D45;   // "tIME"
    private static final int CHUNK_tRNS = 0x74524E53;   // "tIME"
    private static final int CHUNK_zTXt = 0x7A545874;   // "zTXt"

    private static final int startingRow[]  =  { 0, 0, 0, 4, 0, 2, 0, 1 };
    private static final int startingCol[]  =  { 0, 0, 4, 0, 2, 0, 1, 0 };
    private static final int rowInc[]       =  { 1, 8, 8, 8, 4, 4, 2, 2 };
    private static final int colInc[]       =  { 1, 8, 8, 4, 4, 2, 2, 1 };
    private static final int blockHeight[]  =  { 1, 8, 8, 4, 4, 2, 2, 1 };
    private static final int blockWidth[]   =  { 1, 8, 4, 4, 2, 2, 1, 1 };

    // Helper Classes ////////////////////////////////////////////////////////////////////

    private static class MeteredInputStream extends FilterInputStream {
        int bytesLeft;
        int marked;
        
        public MeteredInputStream(InputStream in, int size) {
            super(in);
            bytesLeft = size;
        }
        
        public final int read() throws IOException {
            if (bytesLeft > 0) {
                int val = in.read();
                if (val != -1) bytesLeft--;
                return val;
            }
            return -1;
        }
        
        public final int read(byte b[]) throws IOException {
            return read(b, 0, b.length);
        }
        
        public final int read(byte b[], int off, int len) throws IOException {
            if (bytesLeft > 0) {
                len = (len > bytesLeft ? bytesLeft : len);
                int read = in.read(b, off, len);
                if (read > 0) bytesLeft -= read;
                return read;
            }
            return -1;
        }
        
        public final long skip(long n) throws IOException {
            n = (n > bytesLeft ? bytesLeft : n);
            long skipped = in.skip(n);
            if (skipped > 0) bytesLeft -= skipped;
            return skipped;
        }
        
        public final int available() throws IOException {
            int n = in.available();
            return (n > bytesLeft ? bytesLeft : n);
        }
        
        public final void close() throws IOException { /* Eat this */ }

        public final void mark(int readlimit) {
            marked = bytesLeft;
            in.mark(readlimit);
        }
        
        public final void reset() throws IOException {
            in.reset();
            bytesLeft = marked;
        }
        
        public final boolean markSupported() { return in.markSupported(); }
    }

    /** Support class, used to eat the IDAT headers dividing up the deflated stream */
    private static class IDATEnumeration implements Enumeration {
        InputStream underlyingStream;
        PNG owner;
        boolean firstStream = true;
        
        public IDATEnumeration(PNG owner) {
            this.owner = owner;
            this.underlyingStream = owner.underlyingStream;
        }
        
        public Object nextElement() {
            firstStream = false;
            return new MeteredInputStream(underlyingStream, owner.chunkLength);
        }
        
        public boolean hasMoreElements() {
            DataInputStream dis = new DataInputStream(underlyingStream);
            if (!firstStream) {
                try {
                    int crc = dis.readInt();
                    owner.needChunkInfo = false;
                    owner.chunkLength = dis.readInt();
                    owner.chunkType = dis.readInt();
                } catch (IOException ioe) {
                    return false;
                }
            }
            if (owner.chunkType == PNG.CHUNK_IDAT) return true;
            return false;
        }
    }

}