/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * particular file as subject to the "Classpath" exception as provided

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

package java.awt.image;

import java.awt.Transparency;

import java.awt.color.ColorSpace;

import java.math.BigInteger;

/**

 * The <code>IndexColorModel</code> class is a <code>ColorModel</code>

 * class that works with pixel values consisting of a

 * single sample that is an index into a fixed colormap in the default

 * sRGB color space.  The colormap specifies red, green, blue, and

 * optional alpha components corresponding to each index.  All components

 * are represented in the colormap as 8-bit unsigned integral values.

 * Some constructors allow the caller to specify "holes" in the colormap

 * by indicating which colormap entries are valid and which represent

 * unusable colors via the bits set in a <code>BigInteger</code> object.

 * This color model is similar to an X11 PseudoColor visual.

 * <p>

 * Some constructors provide a means to specify an alpha component

 * for each pixel in the colormap, while others either provide no

 * such means or, in some cases, a flag to indicate whether the

 * colormap data contains alpha values.  If no alpha is supplied to

 * the constructor, an opaque alpha component (alpha = 1.0) is

 * assumed for each entry.

 * An optional transparent pixel value can be supplied that indicates a

 * pixel to be made completely transparent, regardless of any alpha

 * component supplied or assumed for that pixel value.

 * Note that the color components in the colormap of an

 * <code>IndexColorModel</code> objects are never pre-multiplied with

 * the alpha components.

 * <p>

 * <a name="transparency">

 * The transparency of an <code>IndexColorModel</code> object is

 * determined by examining the alpha components of the colors in the

 * colormap and choosing the most specific value after considering

 * the optional alpha values and any transparent index specified.

 * The transparency value is <code>Transparency.OPAQUE</code>

 * only if all valid colors in

 * the colormap are opaque and there is no valid transparent pixel.

 * If all valid colors

 * in the colormap are either completely opaque (alpha = 1.0) or

 * completely transparent (alpha = 0.0), which typically occurs when

 * a valid transparent pixel is specified,

 * the value is <code>Transparency.BITMASK</code>.

 * Otherwise, the value is <code>Transparency.TRANSLUCENT</code>, indicating

 * that some valid color has an alpha component that is

 * neither completely transparent nor completely opaque

 * (0.0 < alpha < 1.0).

 * </a>

 *

 * <p>

 * If an <code>IndexColorModel</code> object has

 * a transparency value of <code>Transparency.OPAQUE</code>,

 * then the <code>hasAlpha</code>

 * and <code>getNumComponents</code> methods

 * (both inherited from <code>ColorModel</code>)

 * return false and 3, respectively.

 * For any other transparency value,

 * <code>hasAlpha</code> returns true

 * and <code>getNumComponents</code> returns 4.

 *

 * <p>

 * <a name="index_values">

 * The values used to index into the colormap are taken from the least

 * significant <em>n</em> bits of pixel representations where

 * <em>n</em> is based on the pixel size specified in the constructor.

 * For pixel sizes smaller than 8 bits, <em>n</em> is rounded up to a

 * power of two (3 becomes 4 and 5,6,7 become 8).

 * For pixel sizes between 8 and 16 bits, <em>n</em> is equal to the

 * pixel size.

 * Pixel sizes larger than 16 bits are not supported by this class.

 * Higher order bits beyond <em>n</em> are ignored in pixel representations.

 * Index values greater than or equal to the map size, but less than

 * 2<sup><em>n</em></sup>, are undefined and return 0 for all color and

 * alpha components.

 * <p>

 * For those methods that use a primitive array pixel representation of

 * type <code>transferType</code>, the array length is always one.

 * The transfer types supported are <code>DataBuffer.TYPE_BYTE</code> and

 * <code>DataBuffer.TYPE_USHORT</code>.  A single int pixel

 * representation is valid for all objects of this class, since it is

 * always possible to represent pixel values used with this class in a

 * single int.  Therefore, methods that use this representation do

 * not throw an <code>IllegalArgumentException</code> due to an invalid

 * pixel value.

 * <p>

 * Many of the methods in this class are final.  The reason for

 * this is that the underlying native graphics code makes assumptions

 * about the layout and operation of this class and those assumptions

 * are reflected in the implementations of the methods here that are

 * marked final.  You can subclass this class for other reasons, but

 * you cannot override or modify the behaviour of those methods.

 *

 * @see ColorModel

 * @see ColorSpace

 * @see DataBuffer

 *

 */

public class IndexColorModel extends ColorModel {

    private int rgb[];

    private int map_size;

    private int pixel_mask;

    private int transparent_index = -1;

    private boolean allgrayopaque;

    private BigInteger validBits;

    private static int[] opaqueBits = {8, 8, 8};

    private static int[] alphaBits = {8, 8, 8, 8};

    static private native void initIDs();

    static {

        ColorModel.loadLibraries();

        initIDs();

    }

    /**

     * Constructs an <code>IndexColorModel</code> from the specified

     * arrays of red, green, and blue components.  Pixels described

     * by this color model all have alpha components of 255

     * unnormalized (1.0 normalized), which means they

     * are fully opaque.  All of the arrays specifying the color

     * components must have at least the specified number of entries.

     * The <code>ColorSpace</code> is the default sRGB space.

     * Since there is no alpha information in any of the arguments

     * to this constructor, the transparency value is always

     * <code>Transparency.OPAQUE</code>.

     * The transfer type is the smallest of <code>DataBuffer.TYPE_BYTE</code>

     * or <code>DataBuffer.TYPE_USHORT</code> that can hold a single pixel.

     * @param bits      the number of bits each pixel occupies

     * @param size      the size of the color component arrays

     * @param r         the array of red color components

     * @param g         the array of green color components

     * @param b         the array of blue color components

     * @throws IllegalArgumentException if <code>bits</code> is less

     *         than 1 or greater than 16

     * @throws IllegalArgumentException if <code>size</code> is less

     *         than 1

     */

    public IndexColorModel(int bits, int size,

                           byte r[], byte g[], byte b[]) {

        super(bits, opaqueBits,

              ColorSpace.getInstance(ColorSpace.CS_sRGB),

              false, false, OPAQUE,

              ColorModel.getDefaultTransferType(bits));

        if (bits < 1 || bits > 16) {

            throw new IllegalArgumentException("Number of bits must be between"

                                               +" 1 and 16.");

        }

        setRGBs(size, r, g, b, null);

        calculatePixelMask();

    }

    /**

     * Constructs an <code>IndexColorModel</code> from the given arrays

     * of red, green, and blue components.  Pixels described by this color

     * model all have alpha components of 255 unnormalized

     * (1.0 normalized), which means they are fully opaque, except

     * for the indicated pixel to be made transparent.  All of the arrays

     * specifying the color components must have at least the specified

     * number of entries.

     * The <code>ColorSpace</code> is the default sRGB space.

     * The transparency value may be <code>Transparency.OPAQUE</code> or

     * <code>Transparency.BITMASK</code> depending on the arguments, as

     * specified in the <a href="#transparency">class description</a> above.

     * The transfer type is the smallest of <code>DataBuffer.TYPE_BYTE</code>

     * or <code>DataBuffer.TYPE_USHORT</code> that can hold a

     * single pixel.

     * @param bits      the number of bits each pixel occupies

     * @param size      the size of the color component arrays

     * @param r         the array of red color components

     * @param g         the array of green color components

     * @param b         the array of blue color components

     * @param trans     the index of the transparent pixel

     * @throws IllegalArgumentException if <code>bits</code> is less than

     *          1 or greater than 16

     * @throws IllegalArgumentException if <code>size</code> is less than

     *          1

     */

    public IndexColorModel(int bits, int size,

                           byte r[], byte g[], byte b[], int trans) {

        super(bits, opaqueBits,

              ColorSpace.getInstance(ColorSpace.CS_sRGB),

              false, false, OPAQUE,

              ColorModel.getDefaultTransferType(bits));

        if (bits < 1 || bits > 16) {

            throw new IllegalArgumentException("Number of bits must be between"

                                               +" 1 and 16.");

        }

        setRGBs(size, r, g, b, null);

        setTransparentPixel(trans);

        calculatePixelMask();

    }

    /**

     * Constructs an <code>IndexColorModel</code> from the given

     * arrays of red, green, blue and alpha components.  All of the

     * arrays specifying the components must have at least the specified

     * number of entries.

     * The <code>ColorSpace</code> is the default sRGB space.

     * The transparency value may be any of <code>Transparency.OPAQUE</code>,

     * <code>Transparency.BITMASK</code>,

     * or <code>Transparency.TRANSLUCENT</code>

     * depending on the arguments, as specified

     * in the <a href="#transparency">class description</a> above.

     * The transfer type is the smallest of <code>DataBuffer.TYPE_BYTE</code>

     * or <code>DataBuffer.TYPE_USHORT</code> that can hold a single pixel.

     * @param bits      the number of bits each pixel occupies

     * @param size      the size of the color component arrays

     * @param r         the array of red color components

     * @param g         the array of green color components

     * @param b         the array of blue color components

     * @param a         the array of alpha value components

     * @throws IllegalArgumentException if <code>bits</code> is less

     *           than 1 or greater than 16

     * @throws IllegalArgumentException if <code>size</code> is less

     *           than 1

     */

    public IndexColorModel(int bits, int size,

                           byte r[], byte g[], byte b[], byte a[]) {

        super (bits, alphaBits,

               ColorSpace.getInstance(ColorSpace.CS_sRGB),

               true, false, TRANSLUCENT,

               ColorModel.getDefaultTransferType(bits));

        if (bits < 1 || bits > 16) {

            throw new IllegalArgumentException("Number of bits must be between"

                                               +" 1 and 16.");

        }

        setRGBs (size, r, g, b, a);

        calculatePixelMask();

    }

    /**

     * Constructs an <code>IndexColorModel</code> from a single

     * array of interleaved red, green, blue and optional alpha

     * components.  The array must have enough values in it to

     * fill all of the needed component arrays of the specified

     * size.  The <code>ColorSpace</code> is the default sRGB space.

     * The transparency value may be any of <code>Transparency.OPAQUE</code>,

     * <code>Transparency.BITMASK</code>,

     * or <code>Transparency.TRANSLUCENT</code>

     * depending on the arguments, as specified

     * in the <a href="#transparency">class description</a> above.

     * The transfer type is the smallest of

     * <code>DataBuffer.TYPE_BYTE</code> or <code>DataBuffer.TYPE_USHORT</code>

     * that can hold a single pixel.

     *

     * @param bits      the number of bits each pixel occupies

     * @param size      the size of the color component arrays

     * @param cmap      the array of color components

     * @param start     the starting offset of the first color component

     * @param hasalpha  indicates whether alpha values are contained in

     *                  the <code>cmap</code> array

     * @throws IllegalArgumentException if <code>bits</code> is less

     *           than 1 or greater than 16

     * @throws IllegalArgumentException if <code>size</code> is less

     *           than 1

     */

    public IndexColorModel(int bits, int size, byte cmap[], int start,

                           boolean hasalpha) {

        this(bits, size, cmap, start, hasalpha, -1);

        if (bits < 1 || bits > 16) {

            throw new IllegalArgumentException("Number of bits must be between"

                                               +" 1 and 16.");

        }

    }

    /**

     * Constructs an <code>IndexColorModel</code> from a single array of

     * interleaved red, green, blue and optional alpha components.  The

     * specified transparent index represents a pixel that is made

     * entirely transparent regardless of any alpha value specified

     * for it.  The array must have enough values in it to fill all

     * of the needed component arrays of the specified size.

     * The <code>ColorSpace</code> is the default sRGB space.

     * The transparency value may be any of <code>Transparency.OPAQUE</code>,

     * <code>Transparency.BITMASK</code>,

     * or <code>Transparency.TRANSLUCENT</code>

     * depending on the arguments, as specified

     * in the <a href="#transparency">class description</a> above.

     * The transfer type is the smallest of

     * <code>DataBuffer.TYPE_BYTE</code> or <code>DataBuffer.TYPE_USHORT</code>

     * that can hold a single pixel.

     * @param bits      the number of bits each pixel occupies

     * @param size      the size of the color component arrays

     * @param cmap      the array of color components

     * @param start     the starting offset of the first color component

     * @param hasalpha  indicates whether alpha values are contained in

     *                  the <code>cmap</code> array

     * @param trans     the index of the fully transparent pixel

     * @throws IllegalArgumentException if <code>bits</code> is less than

     *               1 or greater than 16

     * @throws IllegalArgumentException if <code>size</code> is less than

     *               1

     */

    public IndexColorModel(int bits, int size, byte cmap[], int start,

                           boolean hasalpha, int trans) {

        // REMIND: This assumes the ordering: RGB[A]

        super(bits, opaqueBits,

              ColorSpace.getInstance(ColorSpace.CS_sRGB),

              false, false, OPAQUE,

              ColorModel.getDefaultTransferType(bits));

        if (bits < 1 || bits > 16) {

            throw new IllegalArgumentException("Number of bits must be between"

                                               +" 1 and 16.");

        }

        if (size < 1) {

            throw new IllegalArgumentException("Map size ("+size+

                                               ") must be >= 1");

        }

        map_size = size;

        rgb = new int[calcRealMapSize(bits, size)];

        int j = start;

        int alpha = 0xff;

        boolean allgray = true;

        int transparency = OPAQUE;

        for (int i = 0; i < size; i++) {

            int r = cmap[j++] & 0xff;

            int g = cmap[j++] & 0xff;

            int b = cmap[j++] & 0xff;

            allgray = allgray && (r == g) && (g == b);

            if (hasalpha) {

                alpha = cmap[j++] & 0xff;

                if (alpha != 0xff) {

                    if (alpha == 0x00) {

                        if (transparency == OPAQUE) {

                            transparency = BITMASK;

                        }

                        if (transparent_index < 0) {

                            transparent_index = i;

                        }

                    } else {

                        transparency = TRANSLUCENT;

                    }

                    allgray = false;

                }

            }

            rgb[i] = (alpha << 24) | (r << 16) | (g << 8) | b;

        }

        this.allgrayopaque = allgray;

        setTransparency(transparency);

        setTransparentPixel(trans);

        calculatePixelMask();

    }

    /**

     * Constructs an <code>IndexColorModel</code> from an array of

     * ints where each int is comprised of red, green, blue, and

     * optional alpha components in the default RGB color model format.

     * The specified transparent index represents a pixel that is made

     * entirely transparent regardless of any alpha value specified

     * for it.  The array must have enough values in it to fill all

     * of the needed component arrays of the specified size.

     * The <code>ColorSpace</code> is the default sRGB space.

     * The transparency value may be any of <code>Transparency.OPAQUE</code>,

     * <code>Transparency.BITMASK</code>,

     * or <code>Transparency.TRANSLUCENT</code>

     * depending on the arguments, as specified

     * in the <a href="#transparency">class description</a> above.

     * @param bits      the number of bits each pixel occupies

     * @param size      the size of the color component arrays

     * @param cmap      the array of color components

     * @param start     the starting offset of the first color component

     * @param hasalpha  indicates whether alpha values are contained in

     *                  the <code>cmap</code> array

     * @param trans     the index of the fully transparent pixel

     * @param transferType the data type of the array used to represent

     *           pixel values.  The data type must be either

     *           <code>DataBuffer.TYPE_BYTE</code> or

     *           <code>DataBuffer.TYPE_USHORT</code>.

     * @throws IllegalArgumentException if <code>bits</code> is less

     *           than 1 or greater than 16

     * @throws IllegalArgumentException if <code>size</code> is less

     *           than 1

     * @throws IllegalArgumentException if <code>transferType</code> is not

     *           one of <code>DataBuffer.TYPE_BYTE</code> or

     *           <code>DataBuffer.TYPE_USHORT</code>

     */

    public IndexColorModel(int bits, int size,

                           int cmap[], int start,

                           boolean hasalpha, int trans, int transferType) {

        // REMIND: This assumes the ordering: RGB[A]

        super(bits, opaqueBits,

              ColorSpace.getInstance(ColorSpace.CS_sRGB),

              false, false, OPAQUE,

              transferType);

        if (bits < 1 || bits > 16) {

            throw new IllegalArgumentException("Number of bits must be between"

                                               +" 1 and 16.");

        }

        if (size < 1) {

            throw new IllegalArgumentException("Map size ("+size+

                                               ") must be >= 1");

        }

        if ((transferType != DataBuffer.TYPE_BYTE) &&

            (transferType != DataBuffer.TYPE_USHORT)) {

            throw new IllegalArgumentException("transferType must be either" +

                "DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT");

        }

        setRGBs(size, cmap, start, hasalpha);

        setTransparentPixel(trans);

        calculatePixelMask();

    }

    /**

     * Constructs an <code>IndexColorModel</code> from an

     * <code>int</code> array where each <code>int</code> is

     * comprised of red, green, blue, and alpha

     * components in the default RGB color model format.

     * The array must have enough values in it to fill all

     * of the needed component arrays of the specified size.

     * The <code>ColorSpace</code> is the default sRGB space.

     * The transparency value may be any of <code>Transparency.OPAQUE</code>,

     * <code>Transparency.BITMASK</code>,

     * or <code>Transparency.TRANSLUCENT</code>

     * depending on the arguments, as specified

     * in the <a href="#transparency">class description</a> above.

     * The transfer type must be one of <code>DataBuffer.TYPE_BYTE</code>

     * <code>DataBuffer.TYPE_USHORT</code>.

     * The <code>BigInteger</code> object specifies the valid/invalid pixels

     * in the <code>cmap</code> array.  A pixel is valid if the

     * <code>BigInteger</code> value at that index is set, and is invalid

     * if the <code>BigInteger</code> bit  at that index is not set.

     * @param bits the number of bits each pixel occupies

     * @param size the size of the color component array

     * @param cmap the array of color components

     * @param start the starting offset of the first color component

     * @param transferType the specified data type

     * @param validBits a <code>BigInteger</code> object.  If a bit is

     *    set in the BigInteger, the pixel at that index is valid.

     *    If a bit is not set, the pixel at that index

     *    is considered invalid.  If null, all pixels are valid.

     *    Only bits from 0 to the map size are considered.

     * @throws IllegalArgumentException if <code>bits</code> is less

     *           than 1 or greater than 16

     * @throws IllegalArgumentException if <code>size</code> is less

     *           than 1

     * @throws IllegalArgumentException if <code>transferType</code> is not

     *           one of <code>DataBuffer.TYPE_BYTE</code> or

     *           <code>DataBuffer.TYPE_USHORT</code>

     *

     * @since 1.3

     */

    public IndexColorModel(int bits, int size, int cmap[], int start,

                           int transferType, BigInteger validBits) {

        super (bits, alphaBits,

               ColorSpace.getInstance(ColorSpace.CS_sRGB),

               true, false, TRANSLUCENT,

               transferType);

        if (bits < 1 || bits > 16) {

            throw new IllegalArgumentException("Number of bits must be between"

                                               +" 1 and 16.");

        }

        if (size < 1) {

            throw new IllegalArgumentException("Map size ("+size+

                                               ") must be >= 1");

        }

        if ((transferType != DataBuffer.TYPE_BYTE) &&

            (transferType != DataBuffer.TYPE_USHORT)) {

            throw new IllegalArgumentException("transferType must be either" +

                "DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT");

        }

        if (validBits != null) {

            // Check to see if it is all valid

            for (int i=0; i < size; i++) {

                if (!validBits.testBit(i)) {

                    this.validBits = validBits;

                    break;

                }

            }

        }

        setRGBs(size, cmap, start, true);

        calculatePixelMask();

    }

    private void setRGBs(int size, byte r[], byte g[], byte b[], byte a[]) {

        if (size < 1) {

            throw new IllegalArgumentException("Map size ("+size+

                                               ") must be >= 1");

        }

        map_size = size;

        rgb = new int[calcRealMapSize(pixel_bits, size)];

        int alpha = 0xff;

        int transparency = OPAQUE;

        boolean allgray = true;

        for (int i = 0; i < size; i++) {

            int rc = r[i] & 0xff;

            int gc = g[i] & 0xff;

            int bc = b[i] & 0xff;

            allgray = allgray && (rc == gc) && (gc == bc);

            if (a != null) {

                alpha = a[i] & 0xff;

                if (alpha != 0xff) {

                    if (alpha == 0x00) {

                        if (transparency == OPAQUE) {

                            transparency = BITMASK;

                        }

                        if (transparent_index < 0) {

                            transparent_index = i;