awt/org/apache/harmony/awt/gl/image/JpegDecoder.java

/*
*  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.
*/
/**
 * @author Oleg V. Khaschansky
 * @version $Revision$
 */
package org.apache.harmony.awt.gl.image;

import java.awt.image.*;
import java.awt.color.ColorSpace;
import java.awt.*;
import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;

import org.apache.harmony.awt.internal.nls.Messages;

public class JpegDecoder extends ImageDecoder {
    // Only 2 output colorspaces expected. Others are converted into
    // these ones.
    // 1. Grayscale
    public static final int JCS_GRAYSCALE = 1;
    // 2. RGB
    public static final int JCS_RGB = 2;

    // Flags for the consumer, progressive JPEG
    private static final int hintflagsProgressive =
            ImageConsumer.SINGLEFRAME | // JPEG is a static image
            ImageConsumer.TOPDOWNLEFTRIGHT | // This order is only one possible
            ImageConsumer.COMPLETESCANLINES; // Don't deliver incomplete scanlines
    // Flags for the consumer, singlepass JPEG
    private static final int hintflagsSingle =
            ImageConsumer.SINGLEPASS |
            hintflagsProgressive;

    // Buffer for the stream
    private static final int BUFFER_SIZE = 1024;
    private byte buffer[] = new byte[BUFFER_SIZE];

    // 3 possible color models only
    private static ColorModel cmRGB;
    private static ColorModel cmGray;

    // initializes proper field IDs
    private static native void initIDs();

    // Pointer to native structure which store decoding state
    // between subsequent decoding/IO-suspension cycles
    private long hNativeDecoder = 0; // NULL initially

    private boolean headerDone = false;

    // Next 4 members are filled by the native method (decompress).
    // We can simply check if imageWidth is still negative to find
    // out if they are already filled.
    private int imageWidth = -1;
    private int imageHeight = -1;
    private boolean progressive = false;
    private int jpegColorSpace = 0;

    // Stores number of bytes consumed by the native decoder
    private int bytesConsumed = 0;
    // Stores current scanline returned by the decoder
    private int currScanline = 0;

    private ColorModel cm = null;

    static {
        System.loadLibrary("jpegdecoder"); //$NON-NLS-1$

        cmGray = new ComponentColorModel(
                ColorSpace.getInstance(ColorSpace.CS_GRAY),
                false, false,
                Transparency.OPAQUE, DataBuffer.TYPE_BYTE
        );

        // Create RGB color model
        cmRGB = new DirectColorModel(24, 0xFF0000, 0xFF00, 0xFF);

        initIDs();
    }

    public JpegDecoder(DecodingImageSource src, InputStream is) {
        super(src, is);
    }

    /*
    public JpegDecoder(InputStream iStream, ImageConsumer iConsumer) {
    inputStream = iStream;
    consumer = iConsumer;
    }
    */

    /**
     * @return - not NULL if call is successful
     */
    private native Object decode(
            byte[] input,
            int bytesInBuffer,
            long hDecoder);

    private static native void releaseNativeDecoder(long hDecoder);

    @Override
    public void decodeImage() throws IOException {
        try {
            int bytesRead = 0, dataLength = 0;
            boolean eosReached = false;
            int needBytes, offset, bytesInBuffer = 0;
            byte byteOut[] = null;
            int intOut[] = null;
            // Read from the input stream
            for (;;) {
                needBytes = BUFFER_SIZE - bytesInBuffer;
                offset = bytesInBuffer;

                bytesRead = inputStream.read(buffer, offset, needBytes);

                if (bytesRead < 0) {
                    bytesRead = 0;//break;
                    eosReached = true;
                } // Don't break, maybe something left in buffer

                // Keep track on how much bytes left in buffer
                bytesInBuffer += bytesRead;

                // Here we pass overall number of bytes left in the java buffer
                // (bytesInBuffer) since jpeg decoder has its own buffer and consumes
                // as many bytes as it can. If there are any unconsumed bytes
                // it didn't add them to its buffer...
                Object arr = decode(
                        buffer,
                        bytesInBuffer,
                        hNativeDecoder);

                // Keep track on how much bytes left in buffer
                bytesInBuffer -= bytesConsumed;

                if (!headerDone && imageWidth != -1) {
                    returnHeader();
                    headerDone = true;
                }

                if (bytesConsumed < 0) {
                    break; // Error exit
                }

                if (arr instanceof byte[]) {
                    byteOut = (byte[]) arr;
                    dataLength = byteOut.length;
                    returnData(byteOut, currScanline);
                } else if (arr instanceof int[]) {
                    intOut = (int[]) arr;
                    dataLength = intOut.length;
                    returnData(intOut, currScanline);
                } else {
                    dataLength = 0;
                }

                if (hNativeDecoder == 0) {
                    break;
                }

                if (dataLength == 0 && eosReached) {
                    releaseNativeDecoder(hNativeDecoder);
                    break; // Probably image is truncated
                }
            }
            imageComplete(ImageConsumer.STATICIMAGEDONE);
        } catch (IOException e) {
            throw e;
        } finally {
            closeStream();
        }
    }

    public void returnHeader() {
        setDimensions(imageWidth, imageHeight);

        switch (jpegColorSpace) {
            case JCS_GRAYSCALE: cm = cmGray; break;
            case JCS_RGB: cm = cmRGB; break;
            default: 
                // awt.3D=Unknown colorspace
                throw new IllegalArgumentException(Messages.getString("awt.3D")); //$NON-NLS-1$
        }
        setColorModel(cm);

        setHints(progressive ? hintflagsProgressive : hintflagsSingle);

        setProperties(new Hashtable<Object, Object>()); // Empty
    }

    // Send the data to the consumer
    public void returnData(int data[], int currScanLine) {
        // Send 1 or more scanlines to the consumer.
        int numScanlines = data.length / imageWidth;
        if (numScanlines > 0) {
            setPixels(
                    0, currScanLine - numScanlines,
                    imageWidth, numScanlines,
                    cm, data, 0, imageWidth
            );
        }
    }

    public void returnData(byte data[], int currScanLine) {
        int numScanlines = data.length / imageWidth;
        if (numScanlines > 0) {
            setPixels(
                    0, currScanLine - numScanlines,
                    imageWidth, numScanlines,
                    cm, data, 0, imageWidth
            );
        }
    }
}