/*
 *  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 Igor V. Stolyarov
 * @version $Revision$
 */

package java.awt.image;

import java.awt.color.ColorSpace;

import org.apache.harmony.awt.gl.color.LUTColorConverter;
import org.apache.harmony.awt.internal.nls.Messages;

/**
 * The Class ComponentColorModel represents a color model that is defined in
 * terms of its components.
 * 
 * @since Android 1.0
 */
public class ComponentColorModel extends ColorModel {

    /**
     * The signed.
     */
    private boolean signed; // Pixel samples are signed.

    // Samples with TransferType DataBuffer.TYPE_BYTE,
    // DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT -
    // unsigned. Samples with others TransferType -
    // signed.

    /**
     * The integral.
     */
    private boolean integral; // Pixel samples are integral.

    // Samples with TransferType DataBuffer.TYPE_BYTE,
    // DataBuffer.TYPE_USHORT, DataBuffer.Short and
    // DataBuffer.TYPE_INT - integral.

    /**
     * The scale factors.
     */
    private float scaleFactors[]; // Array of factors for reduction components

    // values into the form scaled from 0 to 255

    /**
     * The donot support unnormalized.
     */
    private boolean donotSupportUnnormalized; // This Color Model don't support

    // unnormolized form

    /**
     * The need alpha divide.
     */
    private boolean needAlphaDivide; // hasAlpha && isAlphaPremultiplied

    /**
     * The calc value.
     */
    private boolean calcValue; // Value was culculated

    /**
     * The need scale.
     */
    private boolean needScale; // Normalized value need to scale

    /**
     * The min vals.
     */
    private float minVals[]; // Array of Min normalized values

    /**
     * The ranges.
     */
    private float ranges[]; // Array of range normalized values

    /**
     * The alpha lut.
     */
    private byte alphaLUT[]; // Lookup table for scale alpha value

    /**
     * The color lu ts.
     */
    private byte colorLUTs[][]; // Lookup tables for scale color values

    /**
     * The from_ linea r_ rg b_ lut.
     */
    private byte from_LINEAR_RGB_LUT[]; // Lookup table for conversion from

    // Linear RGB Color Space into sRGB

    /**
     * The to_ linea r_8 rg b_ lut.
     */
    private byte to_LINEAR_8RGB_LUT[]; // Lookup table for conversion from

    // sRGB Color Space into Linear RGB
    // 8 bit

    /**
     * The to_ linea r_16 rg b_ lut.
     */
    private short to_LINEAR_16RGB_LUT[]; // Lookup table for conversion from

    // sRGB Color Space into Linear RGB
    // 16 bit

    /**
     * The LINEA r_ rg b_ length.
     */
    private int LINEAR_RGB_Length; // Linear RGB bit length

    /**
     * The factor.
     */
    private float fFactor; // Scale factor

    /**
     * The is_s rgb.
     */
    private boolean is_sRGB; // ColorModel has sRGB ColorSpace

    /**
     * The is_ linea r_ rgb.
     */
    private boolean is_LINEAR_RGB; // Color Model has Linear RGB Color

    // Space

    /**
     * Instantiates a new component color model.
     * 
     * @param colorSpace
     *            the color space.
     * @param bits
     *            the array of component masks.
     * @param hasAlpha
     *            whether the color model has alpha.
     * @param isAlphaPremultiplied
     *            whether the alpha is pre-multiplied.
     * @param transparency
     *            the transparency strategy, @see java.awt.Transparency.
     * @param transferType
     *            the transfer type (primitive java type to use for the
     *            components).
     */
    public ComponentColorModel(ColorSpace colorSpace, int bits[], boolean hasAlpha,
            boolean isAlphaPremultiplied, int transparency, int transferType) {
        super(createPixelBits(colorSpace, hasAlpha, transferType), validateBits(bits, colorSpace,
                hasAlpha, transferType), colorSpace, hasAlpha, isAlphaPremultiplied, transparency,
                transferType);

        needScale = false;
        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
            case DataBuffer.TYPE_USHORT:
            case DataBuffer.TYPE_INT:
                signed = false;
                integral = true;
                donotSupportUnnormalized = false;
                scaleFactors = new float[numComponents];
                for (int i = 0; i < numColorComponents; i++) {
                    scaleFactors[i] = 1.0f / maxValues[i];
                    if (cs.getMinValue(i) != 0.0f || cs.getMaxValue(i) != 1.0f) {
                        donotSupportUnnormalized = true;
                    }
                }
                if (hasAlpha) {
                    maxValues[numColorComponents] = (1 << bits[numColorComponents]) - 1;
                    scaleFactors[numColorComponents] = 1.0f / maxValues[numColorComponents];
                }
                break;
            case DataBuffer.TYPE_SHORT:
                signed = true;
                integral = true;
                donotSupportUnnormalized = true;
                scaleFactors = new float[numComponents];
                for (int i = 0; i < numComponents; i++) {
                    maxValues[i] = Short.MAX_VALUE;
                    scaleFactors[i] = 1.0f / maxValues[i];
                    if (cs.getMinValue(i) != 0.0f || cs.getMaxValue(i) != 1.0f) {
                        needScale = true;
                    }
                }
                if (needScale) {
                    minVals = new float[numColorComponents];
                    ranges = new float[numColorComponents];
                    for (int i = 0; i < numColorComponents; i++) {
                        minVals[i] = cs.getMinValue(i);
                        ranges[i] = cs.getMaxValue(i) - minVals[i];
                    }
                }
                break;
            case DataBuffer.TYPE_FLOAT:
            case DataBuffer.TYPE_DOUBLE:
                signed = true;
                integral = false;
                donotSupportUnnormalized = true;
                break;
            default:
                // awt.215=transferType is not one of DataBuffer.TYPE_BYTE,
                // DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT,
                // DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT, or
                // DataBuffer.TYPE_DOUBLE
                throw new IllegalArgumentException(Messages.getString("awt.215")); //$NON-NLS-1$
        }

        needAlphaDivide = hasAlpha && isAlphaPremultiplied;
        initLUTs();
    }

    /**
     * Instantiates a new component color model.
     * 
     * @param colorSpace
     *            the color space.
     * @param hasAlpha
     *            whether the color model has alpha.
     * @param isAlphaPremultiplied
     *            whether the alpha is pre-multiplied.
     * @param transparency
     *            the transparency strategy, @see java.awt.Transparency.
     * @param transferType
     *            the transfer type (primitive java type to use for the
     *            components).
     */
    public ComponentColorModel(ColorSpace colorSpace, boolean hasAlpha,
            boolean isAlphaPremultiplied, int transparency, int transferType) {

        this(colorSpace, createPixelBitsArray(colorSpace, hasAlpha, transferType), hasAlpha,
                isAlphaPremultiplied, transparency, transferType);
    }

    /**
     * Validate bits.
     * 
     * @param bits
     *            the bits.
     * @param colorSpace
     *            the color space.
     * @param hasAlpha
     *            the has alpha.
     * @param transferType
     *            the transfer type.
     * @return the int[].
     */
    private static int[] validateBits(int bits[], ColorSpace colorSpace, boolean hasAlpha,
            int transferType) {
        if (bits != null) {
            return bits;
        }

        int numComponents = colorSpace.getNumComponents();
        if (hasAlpha) {
            numComponents++;
        }
        bits = new int[numComponents];

        int componentLength = DataBuffer.getDataTypeSize(transferType);

        for (int i = 0; i < numComponents; i++) {
            bits[i] = componentLength;
        }

        return bits;
    }

    /**
     * Creates the pixel bits.
     * 
     * @param colorSpace
     *            the color space.
     * @param hasAlpha
     *            the has alpha.
     * @param transferType
     *            the transfer type.
     * @return the int.
     */
    private static int createPixelBits(ColorSpace colorSpace, boolean hasAlpha, int transferType) {
        int numComponents = colorSpace.getNumComponents();
        if (hasAlpha) {
            numComponents++;
        }
        int componentLength = DataBuffer.getDataTypeSize(transferType);
        return numComponents * componentLength;
    }

    /**
     * Creates the pixel bits array.
     * 
     * @param colorSpace
     *            the color space.
     * @param hasAlpha
     *            the has alpha.
     * @param transferType
     *            the transfer type.
     * @return the int[].
     */
    private static int[] createPixelBitsArray(ColorSpace colorSpace, boolean hasAlpha,
            int transferType) {

        int numComponents = colorSpace.getNumComponents();
        if (hasAlpha) {
            numComponents++;
        }

        int bits[] = new int[numComponents];
        for (int i = 0; i < numComponents; i++) {
            bits[i] = DataBuffer.getDataTypeSize(transferType);
        }
        return bits;
    }

    @Override
    public Object getDataElements(int components[], int offset, Object obj) {
        if (donotSupportUnnormalized) {
            // awt.213=This ComponentColorModel does not support the
            // unnormalized form
            throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
        }

        if (offset + numComponents > components.length) {
            // awt.216=The components array is not large enough to hold all the
            // color and alpha components
            throw new IllegalArgumentException(Messages.getString("awt.216")); //$NON-NLS-1$
        }

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
                byte ba[];
                if (obj == null) {
                    ba = new byte[numComponents];
                } else {
                    ba = (byte[])obj;
                }
                for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
                    ba[i] = (byte)components[idx];
                }
                return ba;
            case DataBuffer.TYPE_USHORT:
                short sa[];
                if (obj == null) {
                    sa = new short[numComponents];
                } else {
                    sa = (short[])obj;
                }
                for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
                    sa[i] = (short)components[idx];
                }
                return sa;
            case DataBuffer.TYPE_INT:
                int ia[];
                if (obj == null) {
                    ia = new int[numComponents];
                } else {
                    ia = (int[])obj;
                }
                for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
                    ia[i] = components[idx];
                }
                return ia;
            default:
                // awt.217=The transfer type of this ComponentColorModel is not
                // one
                // of the following transfer types: DataBuffer.TYPE_BYTE,
                // DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT
                throw new UnsupportedOperationException(Messages.getString("awt.217")); //$NON-NLS-1$
        }
    }

    @Override
    public Object getDataElements(float normComponents[], int normOffset, Object obj) {
        if (needScale) {
            for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
                normComponents[idx] = (normComponents[idx] - minVals[i]) / ranges[i];
            }
        }

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
                byte ba[];
                if (obj == null) {
                    ba = new byte[numComponents];
                } else {
                    ba = (byte[])obj;
                }

                if (needAlphaDivide) {
                    float alpha = normComponents[normOffset + numColorComponents];
                    for (int i = 0, idx = normOffset; i < numColorComponents; i++, idx++) {
                        ba[i] = (byte)(normComponents[idx] * alpha * maxValues[i] + 0.5f);
                    }
                    ba[numColorComponents] = (byte)(normComponents[normOffset + numColorComponents]
                            * maxValues[numColorComponents] + 0.5f);
                } else {
                    for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                        ba[idx] = (byte)(normComponents[idx] * maxValues[i] + 0.5f);
                    }
                }
                return ba;

            case DataBuffer.TYPE_USHORT:
                short usa[];
                if (obj == null) {
                    usa = new short[numComponents];
                } else {
                    usa = (short[])obj;
                }

                if (needAlphaDivide) {
                    float alpha = normComponents[normOffset + numColorComponents];
                    for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
                        usa[i] = (short)(normComponents[idx] * alpha * maxValues[i] + 0.5f);
                    }
                    usa[numColorComponents] = (short)(alpha * maxValues[numColorComponents] + 0.5f);
                } else {
                    for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                        usa[i] = (short)(normComponents[idx] * maxValues[i] + 0.5f);
                    }
                }
                return usa;

            case DataBuffer.TYPE_INT:
                int ia[];
                if (obj == null) {
                    ia = new int[numComponents];
                } else {
                    ia = (int[])obj;
                }

                if (needAlphaDivide) {
                    float alpha = normComponents[normOffset + numColorComponents];
                    for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
                        ia[i] = (int)(normComponents[idx] * alpha * maxValues[i] + 0.5f);
                    }
                    ia[numColorComponents] = (int)(alpha * maxValues[numColorComponents] + 0.5f);
                } else {
                    for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                        ia[i] = (int)(normComponents[idx] * maxValues[i] + 0.5f);
                    }
                }
                return ia;

            case DataBuffer.TYPE_SHORT:
                short sa[];
                if (obj == null) {
                    sa = new short[numComponents];
                } else {
                    sa = (short[])obj;
                }

                if (needAlphaDivide) {
                    float alpha = normComponents[normOffset + numColorComponents];
                    for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
                        sa[i] = (short)(normComponents[idx] * alpha * maxValues[i] + 0.5f);
                    }
                    sa[numColorComponents] = (short)(alpha * maxValues[numColorComponents] + 0.5f);
                } else {
                    for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                        sa[i] = (short)(normComponents[idx] * maxValues[i] + 0.5f);
                    }
                }
                return sa;

            case DataBuffer.TYPE_FLOAT:
                float fa[];
                if (obj == null) {
                    fa = new float[numComponents];
                } else {
                    fa = (float[])obj;
                }

                if (needAlphaDivide) {
                    float alpha = normComponents[normOffset + numColorComponents];
                    for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
                        fa[i] = normComponents[idx] * alpha;
                    }
                    fa[numColorComponents] = alpha;
                } else {
                    for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                        fa[i] = normComponents[idx];
                    }
                }
                return fa;

            case DataBuffer.TYPE_DOUBLE:
                double da[];
                if (obj == null) {
                    da = new double[numComponents];
                } else {
                    da = (double[])obj;
                }

                if (needAlphaDivide) {
                    double alpha = normComponents[normOffset + numColorComponents];
                    for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
                        da[i] = normComponents[idx] * alpha;
                    }
                    da[numColorComponents] = alpha;
                } else {
                    for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                        da[i] = normComponents[idx];
                    }
                }
                return da;

            default:
                // awt.213=This ComponentColorModel does not support the
                // unnormalized form
                throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
        }
    }

    @Override
    public Object getDataElements(int rgb, Object pixel) {
        float normComp[];
        float comp[];

        int red = (rgb >> 16) & 0xff;
        int green = (rgb >> 8) & 0xff;
        int blue = rgb & 0xff;
        int alpha = (rgb >> 24) & 0xff;

        comp = new float[3];
        if (is_sRGB || is_LINEAR_RGB) {
            if (is_LINEAR_RGB) {
                if (LINEAR_RGB_Length == 8) {
                    red = to_LINEAR_8RGB_LUT[red] & 0xff;
                    green = to_LINEAR_8RGB_LUT[green] & 0xff;
                    blue = to_LINEAR_8RGB_LUT[blue] & 0xff;
                } else {
                    red = to_LINEAR_16RGB_LUT[red] & 0xffff;
                    green = to_LINEAR_16RGB_LUT[green] & 0xffff;
                    blue = to_LINEAR_16RGB_LUT[blue] & 0xffff;
                }
            }
            comp[0] = red / fFactor;
            comp[1] = green / fFactor;
            comp[2] = blue / fFactor;
            if (!hasAlpha) {
                normComp = comp;
            } else {
                float normAlpha = alpha / 255.0f;
                normComp = new float[numComponents];
                for (int i = 0; i < numColorComponents; i++) {
                    normComp[i] = comp[i];
                }
                normComp[numColorComponents] = normAlpha;
            }
        } else {
            comp[0] = red / fFactor;
            comp[1] = green / fFactor;
            comp[2] = blue / fFactor;
            float[] defComp = cs.fromRGB(comp);
            if (!hasAlpha) {
                normComp = defComp;
            } else {
                float normAlpha = alpha / 255.0f;
                normComp = new float[numComponents];
                for (int i = 0; i < numColorComponents; i++) {
                    normComp[i] = defComp[i];
                }
                normComp[numColorComponents] = normAlpha;
            }
        }
        if (hasAlpha && isAlphaPremultiplied) {
            normComp[0] *= normComp[numColorComponents];
            normComp[1] *= normComp[numColorComponents];
            normComp[2] *= normComp[numColorComponents];
        }

        return getDataElements(normComp, 0, pixel);
    }

    @Override
    public WritableRaster getAlphaRaster(WritableRaster raster) {
        if (!hasAlpha) {
            return null;
        }

        int x = raster.getMinX();
        int y = raster.getMinY();
        int bandList[] = new int[1];
        bandList[0] = raster.getNumBands() - 1;

        return raster.createWritableChild(x, y, raster.getWidth(), raster.getHeight(), x, y,
                bandList);
    }

    @Override
    public ColorModel coerceData(WritableRaster raster, boolean isAlphaPremultiplied) {
        if (!hasAlpha || this.isAlphaPremultiplied == isAlphaPremultiplied) {
            return this;
        }

        int minX = raster.getMinX();
        int minY = raster.getMinY();
        int w = raster.getWidth();
        int h = raster.getHeight();

        if (isAlphaPremultiplied) {
            switch (transferType) {
                case DataBuffer.TYPE_BYTE:
                case DataBuffer.TYPE_USHORT:
                case DataBuffer.TYPE_INT:
                    float alphaFactor = maxValues[numColorComponents];
                    int iComponents[] = null;
                    int iTransparentComponents[] = new int[numComponents];
                    for (int i = 0; i < h; i++, minY++) {
                        for (int j = 0, x = minX; j < w; j++, x++) {
                            iComponents = raster.getPixel(x, minY, iComponents);
                            if (iComponents[numColorComponents] == 0) {
                                raster.setPixel(x, minY, iTransparentComponents);
                            } else {
                                float alpha = iComponents[numColorComponents] / alphaFactor;
                                for (int n = 0; n < numColorComponents; n++) {
                                    iComponents[n] = (int)(alpha * iComponents[n] + 0.5f);
                                }
                                raster.setPixel(x, minY, iComponents);
                            }
                        }

                    }
                    break;

                case DataBuffer.TYPE_SHORT:
                    float sAlphaFactor = maxValues[numColorComponents];
                    short sComponents[] = null;
                    short sTransparentComponents[] = new short[numComponents];
                    for (int i = 0; i < h; i++, minY++) {
                        for (int j = 0, x = minX; j < w; j++, x++) {
                            sComponents = (short[])raster.getDataElements(x, minY, sComponents);
                            if (sComponents[numColorComponents] == 0) {
                                raster.setDataElements(x, minY, sTransparentComponents);
                            } else {
                                float alpha = sComponents[numColorComponents] / sAlphaFactor;
                                for (int n = 0; n < numColorComponents; n++) {
                                    sComponents[n] = (byte)(alpha * sComponents[n] + 0.5f);
                                }
                                raster.setDataElements(x, minY, sComponents);
                            }
                        }

                    }
                    break;

                case DataBuffer.TYPE_FLOAT:
                    float fComponents[] = null;
                    float fTransparentComponents[] = new float[numComponents];
                    for (int i = 0; i < h; i++, minY++) {
                        for (int j = 0, x = minX; j < w; j++, x++) {
                            fComponents = raster.getPixel(x, minY, fComponents);
                            if (fComponents[numColorComponents] == 0.0f) {
                                raster.setDataElements(x, minY, fTransparentComponents);
                            } else {
                                float alpha = fComponents[numColorComponents];
                                for (int n = 0; n < numColorComponents; n++) {
                                    fComponents[n] = fComponents[n] * alpha;
                                }
                                raster.setPixel(x, minY, fComponents);
                            }
                        }

                    }
                    break;

                case DataBuffer.TYPE_DOUBLE:
                    double dComponents[] = null;
                    double dTransparentComponents[] = new double[numComponents];
                    for (int i = 0; i < h; i++, minY++) {
                        for (int j = 0, x = minX; j < w; j++, x++) {
                            dComponents = raster.getPixel(x, minY, dComponents);
                            if (dComponents[numColorComponents] == 0.0) {
                                raster.setPixel(x, minY, dTransparentComponents);
                            } else {
                                double alpha = dComponents[numColorComponents];
                                for (int n = 0; n < numColorComponents; n++) {
                                    dComponents[n] = dComponents[n] * alpha;
                                }
                                raster.setPixel(x, minY, dComponents);
                            }
                        }

                    }
                    break;

                default:
                    // awt.219=This transferType is not supported by this color
                    // model
                    throw new UnsupportedOperationException(Messages.getString("awt.219")); //$NON-NLS-1$
            }
        } else {
            switch (transferType) {
                case DataBuffer.TYPE_BYTE:
                case DataBuffer.TYPE_USHORT:
                case DataBuffer.TYPE_INT:
                    float alphaFactor = maxValues[numColorComponents];
                    int iComponents[] = null;
                    int iTransparentComponents[] = new int[numComponents];
                    for (int i = 0; i < h; i++, minY++) {
                        for (int j = 0, x = minX; j < w; j++, x++) {
                            iComponents = raster.getPixel(x, minY, iComponents);
                            if (iComponents[numColorComponents] == 0) {
                                raster.setPixel(x, minY, iTransparentComponents);
                            } else {
                                float alpha = iComponents[numColorComponents] / alphaFactor;
                                for (int n = 0; n < numColorComponents; n++) {
                                    iComponents[n] = (int)(iComponents[n] / alpha + 0.5f);
                                }
                                raster.setPixel(x, minY, iComponents);
                            }
                        }

                    }
                    break;

                case DataBuffer.TYPE_SHORT:
                    float sAlphaFactor = maxValues[numColorComponents];
                    short sComponents[] = null;
                    short sTransparentComponents[] = new short[numComponents];
                    for (int i = 0; i < h; i++, minY++) {
                        for (int j = 0, x = minX; j < w; j++, x++) {
                            sComponents = (short[])raster.getDataElements(x, minY, sComponents);
                            if (sComponents[numColorComponents] == 0) {
                                raster.setDataElements(x, minY, sTransparentComponents);
                            } else {
                                float alpha = sComponents[numColorComponents] / sAlphaFactor;
                                for (int n = 0; n < numColorComponents; n++) {
                                    sComponents[n] = (byte)(sComponents[n] / alpha + 0.5f);
                                }
                                raster.setDataElements(x, minY, sComponents);
                            }
                        }

                    }
                    break;

                case DataBuffer.TYPE_FLOAT:
                    float fComponents[] = null;
                    float fTransparentComponents[] = new float[numComponents];
                    for (int i = 0; i < h; i++, minY++) {
                        for (int j = 0, x = minX; j < w; j++, x++) {
                            fComponents = raster.getPixel(x, minY, fComponents);
                            if (fComponents[numColorComponents] == 0.0f) {
                                raster.setDataElements(x, minY, fTransparentComponents);
                            } else {
                                float alpha = fComponents[numColorComponents];
                                for (int n = 0; n < numColorComponents; n++) {
                                    fComponents[n] = fComponents[n] / alpha;
                                }
                                raster.setPixel(x, minY, fComponents);
                            }
                        }

                    }
                    break;

                case DataBuffer.TYPE_DOUBLE:
                    double dComponents[] = null;
                    double dTransparentComponents[] = new double[numComponents];
                    for (int i = 0; i < h; i++, minY++) {
                        for (int j = 0, x = minX; j < w; j++, x++) {
                            dComponents = raster.getPixel(x, minY, dComponents);
                            if (dComponents[numColorComponents] == 0.0) {
                                raster.setPixel(x, minY, dTransparentComponents);
                            } else {
                                double alpha = dComponents[numColorComponents];
                                for (int n = 0; n < numColorComponents; n++) {
                                    dComponents[n] = dComponents[n] / alpha;
                                }
                                raster.setPixel(x, minY, dComponents);
                            }
                        }

                    }
                    break;
                default:
                    // awt.219=This transferType is not supported by this color
                    // model
                    throw new UnsupportedOperationException(Messages.getString("awt.219")); //$NON-NLS-1$
            }
        }

        if (!signed) {
            return new ComponentColorModel(cs, bits, hasAlpha, isAlphaPremultiplied, transparency,
                    transferType);
        }

        return new ComponentColorModel(cs, null, hasAlpha, isAlphaPremultiplied, transparency,
                transferType);
    }

    @Override
    public int[] getComponents(Object pixel, int[] components, int offset) {
        if (donotSupportUnnormalized) {
            // awt.213=This ComponentColorModel does not support the
            // unnormalized form
            throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
        }

        if (components == null) {
            components = new int[offset + numComponents];
        } else if (offset + numComponents > components.length) {
            // awt.218=The components array is not large enough to hold all the
            // color and alpha components
            throw new IllegalArgumentException(Messages.getString("awt.218")); //$NON-NLS-1$
        }

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
                byte ba[] = (byte[])pixel;

                for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
                    components[idx] = ba[i] & 0xff;
                }
                return components;

            case DataBuffer.TYPE_USHORT:
                short sa[] = (short[])pixel;
                for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
                    components[idx] = sa[i] & 0xffff;
                }
                return components;

            case DataBuffer.TYPE_INT:
                int ia[] = (int[])pixel;
                for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
                    components[idx] = ia[i];
                }
                return components;

            default:
                // awt.217=The transfer type of this ComponentColorModel is not
                // one
                // of the following transfer types: DataBuffer.TYPE_BYTE,
                // DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT
                throw new UnsupportedOperationException(Messages.getString("awt.217")); //$NON-NLS-1$
        }

    }

    @Override
    public float[] getNormalizedComponents(Object pixel, float normComponents[], int normOffset) {

        if (normComponents == null) {
            normComponents = new float[numComponents + normOffset];
        }

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
                byte ba[] = (byte[])pixel;
                for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                    normComponents[idx] = (ba[i] & 0xff) * scaleFactors[i];
                }
                break;

            case DataBuffer.TYPE_USHORT:
                short usa[] = (short[])pixel;
                for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                    normComponents[idx] = (usa[i] & 0xffff) * scaleFactors[i];
                }
                break;

            case DataBuffer.TYPE_INT:
                int ia[] = (int[])pixel;
                for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                    normComponents[idx] = ia[i] * scaleFactors[i];
                }
                break;

            case DataBuffer.TYPE_SHORT:
                short sa[] = (short[])pixel;
                for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                    normComponents[idx] = sa[i] * scaleFactors[i];
                }
                break;

            case DataBuffer.TYPE_FLOAT:
                float fa[] = (float[])pixel;
                for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                    normComponents[idx] = fa[i];
                }
                break;

            case DataBuffer.TYPE_DOUBLE:
                double da[] = (double[])pixel;
                for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
                    normComponents[idx] = (float)da[i];
                }
                break;

            default:
                // awt.21A=This ComponentColorModel does not support this
                // transferType
                throw new IllegalArgumentException(Messages.getString("awt.21A")); //$NON-NLS-1$
        }

        if (needAlphaDivide) {
            float alpha = normComponents[normOffset + numColorComponents];
            for (int i = 0, idx = normOffset; i < numColorComponents; i++, idx++) {
                normComponents[idx] /= alpha;
            }
        }

        if (needScale) {
            for (int i = 0, idx = normOffset; i < numColorComponents; i++, idx++) {
                normComponents[idx] = minVals[i] + ranges[i] * normComponents[idx];
            }
        }
        return normComponents;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof ComponentColorModel)) {
            return false;
        }
        return super.equals(obj);
    }

    @Override
    public int getRed(Object inData) {
        return getRGBComponent(inData, 0);
    }

    @Override
    public int getRGB(Object inData) {
        int alpha = getAlpha(inData);
        if (cs.getType() == ColorSpace.TYPE_GRAY) {
            int gray = getRed(inData);
            return (alpha << 24 | gray << 16 | gray << 8 | gray);
        }
        return (alpha << 24 | getRed(inData) << 16 | getGreen(inData) << 8 | getBlue(inData));
    }

    @Override
    public int getGreen(Object inData) {
        return getRGBComponent(inData, 1);
    }

    @Override
    public int getBlue(Object inData) {
        return getRGBComponent(inData, 2);
    }

    @Override
    public int getAlpha(Object inData) {
        if (!hasAlpha) {
            return 255;
        }
        int alpha = 0;

        switch (transferType) {
            case DataBuffer.TYPE_BYTE: {
                byte ba[] = (byte[])inData;
                alpha = ba[numColorComponents] & 0xff;
                if (bits[numColorComponents] != 8) {
                    return alphaLUT[alpha] & 0xff;
                }
                return alpha;
            }
            case DataBuffer.TYPE_USHORT: {
                short usa[] = (short[])inData;
                alpha = usa[numColorComponents] & 0xffff;
                if (bits[numColorComponents] != 8) {
                    return alphaLUT[alpha] & 0xff;
                }
                return alpha;
            }
            case DataBuffer.TYPE_INT: {
                int ia[] = (int[])inData;
                alpha = ia[numColorComponents];
                if (bits[numColorComponents] != 8) {
                    return alphaLUT[alpha] & 0xff;
                }
                return alpha;
            }
            case DataBuffer.TYPE_SHORT: {
                short sa[] = (short[])inData;
                alpha = sa[numColorComponents];
                if (bits[numColorComponents] != 8) {
                    return alphaLUT[alpha] & 0xff;
                }
                return alpha;
            }
            case DataBuffer.TYPE_FLOAT: {
                float fa[] = (float[])inData;
                return (int)(fa[numColorComponents] * 255.0f + 0.5f);
            }
            case DataBuffer.TYPE_DOUBLE: {
                double da[] = (double[])inData;
                return (int)(da[numColorComponents] * 255.0 + 0.5);
            }
            default: {
                // awt.214=This Color Model doesn't support this transferType
                throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
            }
        }
    }

    @Override
    public WritableRaster createCompatibleWritableRaster(int w, int h) {
        SampleModel sm = createCompatibleSampleModel(w, h);
        DataBuffer db = sm.createDataBuffer();
        return Raster.createWritableRaster(sm, db, null);
    }

    @Override
    public boolean isCompatibleSampleModel(SampleModel sm) {
        if (!(sm instanceof ComponentSampleModel)) {
            return false;
        }
        if (numComponents != sm.getNumBands()) {
            return false;
        }
        if (transferType != sm.getTransferType()) {
            return false;
        }
        return true;
    }

    @Override
    public SampleModel createCompatibleSampleModel(int w, int h) {
        int bandOffsets[] = new int[numComponents];
        for (int i = 0; i < numComponents; i++) {
            bandOffsets[i] = i;
        }

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
            case DataBuffer.TYPE_USHORT:
                return new PixelInterleavedSampleModel(transferType, w, h, numComponents, w
                        * numComponents, bandOffsets);

            default:
                return new ComponentSampleModel(transferType, w, h, numComponents, w
                        * numComponents, bandOffsets);
        }
    }

    @Override
    public boolean isCompatibleRaster(Raster raster) {
        SampleModel sm = raster.getSampleModel();
        if (!(sm instanceof ComponentSampleModel)) {
            return false;
        }

        if (sm.getNumBands() != numComponents) {
            return false;
        }
        if (raster.getTransferType() != transferType) {
            return false;
        }

        int sampleSizes[] = sm.getSampleSize();
        for (int i = 0; i < numComponents; i++) {
            if (bits[i] != sampleSizes[i]) {
                return false;
            }
        }
        return true;
    }

    @Override
    public float[] getNormalizedComponents(int components[], int offset, float normComponents[],
            int normOffset) {
        if (donotSupportUnnormalized) {
            // awt.213=This ComponentColorModel does not support the
            // unnormalized form
            throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
        }

        return super.getNormalizedComponents(components, offset, normComponents, normOffset);
    }

    @Override
    public int getDataElement(int[] components, int offset) {
        if (numComponents > 1) {
            // awt.212=There is more than one component in this ColorModel
            throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
        }
        if (donotSupportUnnormalized) {
            // awt.213=This ComponentColorModel does not support the
            // unnormalized form
            throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
        }
        return components[offset];
    }

    @Override
    public int[] getUnnormalizedComponents(float[] normComponents, int normOffset,
            int[] components, int offset) {

        if (donotSupportUnnormalized) {
            // awt.213=This ComponentColorModel does not support the
            // unnormalized form
            throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
        }

        if (normComponents.length - normOffset < numComponents) {
            // awt.21B=The length of normComponents minus normOffset is less
            // than numComponents
            throw new IllegalArgumentException(Messages.getString("awt.21B")); //$NON-NLS-1$
        }

        return super.getUnnormalizedComponents(normComponents, normOffset, components, offset);
    }

    @Override
    public int getDataElement(float normComponents[], int normOffset) {
        if (numComponents > 1) {
            // awt.212=There is more than one component in this ColorModel
            throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
        }
        if (signed) {
            // awt.210=The component value for this ColorModel is signed
            throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
        }

        Object pixel = getDataElements(normComponents, normOffset, null);

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
                byte ba[] = (byte[])pixel;
                return ba[0] & 0xff;
            case DataBuffer.TYPE_USHORT:
                short sa[] = (short[])pixel;
                return sa[0] & 0xffff;
            case DataBuffer.TYPE_INT:
                int ia[] = (int[])pixel;
                return ia[0];
            default:
                // awt.211=Pixel values for this ColorModel are not conveniently
                // representable as a single int
                throw new IllegalArgumentException(Messages.getString("awt.211")); //$NON-NLS-1$
        }
    }

    @Override
    public int[] getComponents(int pixel, int components[], int offset) {
        if (numComponents > 1) {
            // awt.212=There is more than one component in this ColorModel
            throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
        }
        if (donotSupportUnnormalized) {
            // awt.213=This ComponentColorModel does not support the
            // unnormalized form
            throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
        }

        if (components == null) {
            components = new int[offset + 1];
        }

        components[offset] = pixel & maxValues[0];
        return components;
    }

    @Override
    public int getRed(int pixel) {
        float rgb[] = toRGB(pixel);
        return (int)(rgb[0] * 255.0f + 0.5f);
    }

    @Override
    public int getRGB(int pixel) {
        return (getAlpha(pixel) << 24) | (getRed(pixel) << 16) | (getGreen(pixel) << 8)
                | getBlue(pixel);
    }

    @Override
    public int getGreen(int pixel) {
        float rgb[] = toRGB(pixel);
        return (int)(rgb[1] * 255.0f + 0.5f);
    }

    @Override
    public int getBlue(int pixel) {
        float rgb[] = toRGB(pixel);
        return (int)(rgb[2] * 255.0f + 0.5f);
    }

    @Override
    public int getAlpha(int pixel) {

        // This method throw IllegalArgumentException according to
        // Java API Spacification
        if (signed) {
            // awt.210=The component value for this ColorModel is signed
            throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
        }

        if (numComponents > 1) {
            // awt.212=There is more than one component in this ColorModel
            throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
        }

        return 255;
    }

    /**
     * Initialization of Lookup tables.
     */
    private void initLUTs() {
        is_sRGB = cs.isCS_sRGB();
        is_LINEAR_RGB = (cs == LUTColorConverter.LINEAR_RGB_CS);

        if (hasAlpha && bits[numColorComponents] != 8 && integral) {
            alphaLUT = new byte[maxValues[numColorComponents] + 1];
            for (int i = 0; i <= maxValues[numColorComponents]; i++) {
                alphaLUT[i] = (byte)(scaleFactors[numColorComponents] * i + 0.5f);
            }
        }

        if (is_LINEAR_RGB) {
            if (maxBitLength > 8) {
                LINEAR_RGB_Length = 16;
                from_LINEAR_RGB_LUT = LUTColorConverter.getFrom16lRGBtosRGB_LUT();
                to_LINEAR_16RGB_LUT = LUTColorConverter.getFromsRGBto16lRGB_LUT();
            } else {
                LINEAR_RGB_Length = 8;
                from_LINEAR_RGB_LUT = LUTColorConverter.getFrom8lRGBtosRGB_LUT();
                to_LINEAR_8RGB_LUT = LUTColorConverter.getFromsRGBto8lRGB_LUT();
            }
            fFactor = ((1 << LINEAR_RGB_Length) - 1);
        } else {
            fFactor = 255.0f;
        }

        if (!isAlphaPremultiplied && integral) {
            colorLUTs = new byte[3][];

            if (is_sRGB) {
                for (int i = 0; i < numColorComponents; i++) {
                    if (bits[i] != 8) {
                        for (int j = 0; j < i; j++) {
                            if (bits[i] == bits[j]) {
                                colorLUTs[i] = colorLUTs[j];
                                break;
                            }
                        }
                        colorLUTs[i] = new byte[maxValues[i] + 1];
                        for (int j = 0; j <= maxValues[0]; j++) {
                            colorLUTs[i][j] = (byte)(scaleFactors[i] * j + 0.5f);
                        }
                    }
                }
            }

            if (is_LINEAR_RGB) {

                for (int i = 0; i < numColorComponents; i++) {
                    if (bits[i] != LINEAR_RGB_Length) {
                        for (int j = 0; j < i; j++) {
                            if (bits[i] == bits[j]) {
                                colorLUTs[i] = colorLUTs[j];
                                break;
                            }
                        }
                        colorLUTs[i] = new byte[maxValues[i] + 1];
                        for (int j = 0; j <= maxValues[0]; j++) {
                            int idx;
                            if (LINEAR_RGB_Length == 8) {
                                idx = (int)(scaleFactors[i] * j + 0.5f);
                            } else {
                                idx = (int)(scaleFactors[i] * j * 257.0f + 0.5f);
                            }
                            colorLUTs[i][j] = from_LINEAR_RGB_LUT[idx];
                        }
                    }
                }
            }

        }
    }

    /**
     * To rgb.
     * 
     * @param pixel
     *            the integer representation of the pixel.
     * @return the array of normalized sRGB components.
     */
    private float[] toRGB(int pixel) {

        // This method throw IllegalArgumentException according to
        // Java API Spacification
        if (signed) {
            // awt.210=The component value for this ColorModel is signed
            throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
        }

        if (numComponents > 1) {
            // awt.212=There is more than one component in this ColorModel
            throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
        }

        Object obj = null;

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
                byte ba[] = new byte[1];
                ba[0] = (byte)pixel;
                obj = ba;
                break;

            case DataBuffer.TYPE_USHORT:
                short sa[] = new short[1];
                sa[0] = (short)pixel;
                obj = sa;
                break;

            case DataBuffer.TYPE_INT:
                int ia[] = new int[1];
                ia[0] = pixel;
                obj = ia;
                break;

        }

        return cs.toRGB(getNormalizedComponents(obj, null, 0));
    }

    /**
     * Gets the RGB component.
     * 
     * @param pixel
     *            the pixel.
     * @param idx
     *            the index of component.
     * @return the RGB value from 0 to 255 pixel's component.
     */
    private int getRGBComponent(Object pixel, int idx) {
        if (is_sRGB) {
            int comp = getDefComponent(pixel, idx);
            if (calcValue || bits[idx] == 8) {
                return comp;
            }
            return colorLUTs[idx][comp] & 0xff;
        } else if (is_LINEAR_RGB) {
            int comp = getDefComponent(pixel, idx);
            if (calcValue || bits[idx] == LINEAR_RGB_Length) {
                return from_LINEAR_RGB_LUT[comp] & 0xff;
            }
            return colorLUTs[idx][comp] & 0xff;
        }

        float normComp[] = getNormalizedComponents(pixel, null, 0);
        float rgbComp[] = cs.toRGB(normComp);
        return (int)(rgbComp[idx] * 255.0f + 0.5f);
    }

    /**
     * Gets the def component.
     * 
     * @param pixel
     *            the pixel.
     * @param idx
     *            the index of component.
     * @return the tentative value of the pixel component.
     */
    private int getDefComponent(Object pixel, int idx) {
        int comp = 0;
        calcValue = false;

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
                byte ba[] = (byte[])pixel;
                comp = ba[idx] & 0xff;
                if (needAlphaDivide) {
                    int alpha = ba[numColorComponents] & 0xff;
                    if (alpha == 0) {
                        comp = 0;
                    } else {
                        float normAlpha = scaleFactors[numColorComponents] * alpha;
                        comp = (int)(comp * fFactor / normAlpha + 0.5f);
                    }
                    calcValue = true;
                }
                return comp;

            case DataBuffer.TYPE_USHORT:
                short usa[] = (short[])pixel;
                comp = usa[idx] & 0xffff;
                if (needAlphaDivide) {
                    int alpha = usa[numColorComponents] & 0xffff;
                    if (alpha == 0) {
                        comp = 0;
                    } else {
                        float normAlpha = scaleFactors[numColorComponents] * alpha;
                        comp = (int)(comp * fFactor / normAlpha + 0.5f);
                    }
                    calcValue = true;
                }
                return comp;

            case DataBuffer.TYPE_INT:
                int ia[] = (int[])pixel;
                comp = ia[idx];
                if (needAlphaDivide) {
                    int alpha = ia[numColorComponents];
                    if (alpha == 0) {
                        comp = 0;
                    } else {
                        float normAlpha = scaleFactors[numColorComponents] * alpha;
                        comp = (int)(comp * fFactor / normAlpha + 0.5f);
                    }
                    calcValue = true;
                }
                return comp;

            case DataBuffer.TYPE_SHORT:
                short sa[] = (short[])pixel;
                comp = sa[idx];
                if (needAlphaDivide) {
                    int alpha = sa[numColorComponents];
                    if (alpha == 0) {
                        comp = 0;
                    } else {
                        float normAlpha = scaleFactors[numColorComponents] * alpha;
                        comp = (int)(comp * fFactor / normAlpha + 0.5f);
                    }
                    calcValue = true;
                }
                return comp;

            case DataBuffer.TYPE_FLOAT:
                float fa[] = (float[])pixel;
                if (needAlphaDivide) {
                    float alpha = fa[numColorComponents];
                    if (fa[numColorComponents] == 0.0f) {
                        comp = 0;
                    } else {
                        comp = (int)(fa[idx] * fFactor / alpha + 0.5f);
                    }
                } else {
                    comp = (int)(fa[idx] * fFactor + 0.5f);
                }
                calcValue = true;
                return comp;

            case DataBuffer.TYPE_DOUBLE:
                double da[] = (double[])pixel;
                if (needAlphaDivide) {
                    if (da[numColorComponents] == 0.0) {
                        comp = 0;
                    } else {
                        comp = (int)(da[idx] * fFactor / da[numColorComponents] + 0.5);
                    }
                } else {
                    comp = (int)(da[idx] * fFactor + 0.5);
                }
                calcValue = true;
                return comp;

            default:
                // awt.214=This Color Model doesn't support this transferType
                throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
        }
    }

}