/*

 * 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

 * published by the Free Software Foundation.  Oracle designates this

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

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.awt.image;

import java.awt.color.ColorSpace;

import java.awt.Transparency;

/**

 * The {@code DirectColorModel} class is a {@code ColorModel}

 * class that works with pixel values that represent RGB

 * color and alpha information as separate samples and that pack all

 * samples for a single pixel into a single int, short, or byte quantity.

 * This class can be used only with ColorSpaces of type ColorSpace.TYPE_RGB.

 * In addition, for each component of the ColorSpace, the minimum

 * normalized component value obtained via the {@code getMinValue()}

 * method of ColorSpace must be 0.0, and the maximum value obtained via

 * the {@code getMaxValue()} method must be 1.0 (these min/max

 * values are typical for RGB spaces).

 * There must be three color samples in the pixel values and there can

 * be a single alpha sample.  For those methods that use a primitive array

 * pixel representation of type {@code transferType}, the array

 * length is always one.  The transfer

 * types supported are DataBuffer.TYPE_BYTE,

 * DataBuffer.TYPE_USHORT, and DataBuffer.TYPE_INT.

 * Color and alpha samples are stored in the single

 * element of the array in bits indicated by bit masks.  Each bit mask

 * must be contiguous and masks must not overlap.  The same masks apply to

 * the single int pixel representation used by other methods.  The

 * correspondence of masks and color/alpha samples is as follows:

 * <ul>

 * <li> Masks are identified by indices running from 0 through 2

 * if no alpha is present, or 3 if an alpha is present.

 * <li> The first three indices refer to color samples;

 * index 0 corresponds to red, index 1 to green, and index 2 to blue.

 * <li> Index 3 corresponds to the alpha sample, if present.

 * </ul>

 * <p>

 * The translation from pixel values to color/alpha components for

 * display or processing purposes is a one-to-one correspondence of

 * samples to components.  A {@code DirectColorModel} is

 * typically used with image data which uses masks to define packed

 * samples.  For example, a {@code DirectColorModel} can be used in

 * conjunction with a {@code SinglePixelPackedSampleModel} to

 * construct a {@link BufferedImage}.  Normally the masks used by the

 * {@link SampleModel} and the {@code ColorModel} would be the

 * same.  However, if they are different, the color interpretation

 * of pixel data will be done according to the masks of the

 * {@code ColorModel}.

 * <p>

 * 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 which use this

 * representation will not throw an {@code IllegalArgumentException}

 * due to an invalid pixel value.

 * <p>

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

 * The default RGB ColorModel specified by the

 * {@link ColorModel#getRGBdefault() getRGBdefault} method is a

 * {@code DirectColorModel} with the following parameters:

 * <pre>

 * Number of bits:        32

 * Red mask:              0x00ff0000

 * Green mask:            0x0000ff00

 * Blue mask:             0x000000ff

 * Alpha mask:            0xff000000

 * Color space:           sRGB

 * isAlphaPremultiplied:  False

 * Transparency:          Transparency.TRANSLUCENT

 * transferType:          DataBuffer.TYPE_INT

 * </pre>

 * <p>

 * Many of the methods in this class are final. This is because 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 behavior of those methods.

 *

 * @see ColorModel

 * @see ColorSpace

 * @see SinglePixelPackedSampleModel

 * @see BufferedImage

 * @see ColorModel#getRGBdefault

 *

 */

public class DirectColorModel extends PackedColorModel {

    private int red_mask;

    private int green_mask;

    private int blue_mask;

    private int alpha_mask;

    private int red_offset;

    private int green_offset;

    private int blue_offset;

    private int alpha_offset;

    private int red_scale;

    private int green_scale;

    private int blue_scale;

    private int alpha_scale;

    private boolean is_LinearRGB;

    private int lRGBprecision;

    private byte[] tosRGB8LUT;

    private byte[] fromsRGB8LUT8;

    private short[] fromsRGB8LUT16;

    /**

     * Constructs a {@code DirectColorModel} from the specified masks

     * that indicate which bits in an {@code int} pixel representation

     * contain the red, green and blue color samples.  As pixel values do not

     * contain alpha information, all pixels are treated as opaque, which

     * means that alpha = 1.0.  All of the bits

     * in each mask must be contiguous and fit in the specified number

     * of least significant bits of an {@code int} pixel representation.

     *  The {@code ColorSpace} is the default sRGB space. The

     * transparency value is Transparency.OPAQUE.  The transfer type

     * is the smallest of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,

     * or DataBuffer.TYPE_INT that can hold a single pixel.

     * @param bits the number of bits in the pixel values; for example,

     *         the sum of the number of bits in the masks.

     * @param rmask specifies a mask indicating which bits in an

     *         integer pixel contain the red component

     * @param gmask specifies a mask indicating which bits in an

     *         integer pixel contain the green component

     * @param bmask specifies a mask indicating which bits in an

     *         integer pixel contain the blue component

     *

     */

    public DirectColorModel(int bits,

                            int rmask, int gmask, int bmask) {

        this(bits, rmask, gmask, bmask, 0);

    }

    /**

     * Constructs a {@code DirectColorModel} from the specified masks

     * that indicate which bits in an {@code int} pixel representation

     * contain the red, green and blue color samples and the alpha sample,

     * if present.  If {@code amask} is 0, pixel values do not contain

     * alpha information and all pixels are treated as opaque, which means

     * that alpha = 1.0.  All of the bits in each mask must

     * be contiguous and fit in the specified number of least significant bits

     * of an {@code int} pixel representation.  Alpha, if present, is not

     * premultiplied.  The {@code ColorSpace} is the default sRGB space.

     * The transparency value is Transparency.OPAQUE if no alpha is

     * present, or Transparency.TRANSLUCENT otherwise.  The transfer type

     * is the smallest of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,

     * or DataBuffer.TYPE_INT that can hold a single pixel.

     * @param bits the number of bits in the pixel values; for example,

     *         the sum of the number of bits in the masks.

     * @param rmask specifies a mask indicating which bits in an

     *         integer pixel contain the red component

     * @param gmask specifies a mask indicating which bits in an

     *         integer pixel contain the green component

     * @param bmask specifies a mask indicating which bits in an

     *         integer pixel contain the blue component

     * @param amask specifies a mask indicating which bits in an

     *         integer pixel contain the alpha component

     */

    public DirectColorModel(int bits, int rmask, int gmask,

                            int bmask, int amask) {

        super (ColorSpace.getInstance(ColorSpace.CS_sRGB),

               bits, rmask, gmask, bmask, amask, false,

               amask == 0 ? Transparency.OPAQUE : Transparency.TRANSLUCENT,

               ColorModel.getDefaultTransferType(bits));

        setFields();

    }

    /**

     * Constructs a {@code DirectColorModel} from the specified

     * parameters.  Color components are in the specified

     * {@code ColorSpace}, which must be of type ColorSpace.TYPE_RGB

     * and have minimum normalized component values which are all 0.0

     * and maximum values which are all 1.0.

     * The masks specify which bits in an {@code int} pixel

     * representation contain the red, green and blue color samples and

     * the alpha sample, if present.  If {@code amask} is 0, pixel

     * values do not contain alpha information and all pixels are treated

     * as opaque, which means that alpha = 1.0.  All of the

     * bits in each mask must be contiguous and fit in the specified number

     * of least significant bits of an {@code int} pixel

     * representation.  If there is alpha, the {@code boolean}

     * {@code isAlphaPremultiplied} specifies how to interpret

     * color and alpha samples in pixel values.  If the {@code boolean}

     * is {@code true}, color samples are assumed to have been

     * multiplied by the alpha sample.  The transparency value is

     * Transparency.OPAQUE, if no alpha is present, or

     * Transparency.TRANSLUCENT otherwise.  The transfer type

     * is the type of primitive array used to represent pixel values and

     * must be one of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, or

     * DataBuffer.TYPE_INT.

     * @param space the specified {@code ColorSpace}

     * @param bits the number of bits in the pixel values; for example,

     *         the sum of the number of bits in the masks.

     * @param rmask specifies a mask indicating which bits in an

     *         integer pixel contain the red component

     * @param gmask specifies a mask indicating which bits in an

     *         integer pixel contain the green component

     * @param bmask specifies a mask indicating which bits in an

     *         integer pixel contain the blue component

     * @param amask specifies a mask indicating which bits in an

     *         integer pixel contain the alpha component

     * @param isAlphaPremultiplied {@code true} if color samples are

     *        premultiplied by the alpha sample; {@code false} otherwise

     * @param transferType the type of array used to represent pixel values

     * @throws IllegalArgumentException if {@code space} is not a

     *         TYPE_RGB space or if the min/max normalized component

     *         values are not 0.0/1.0.

     */

    public DirectColorModel(ColorSpace space, int bits, int rmask,

                            int gmask, int bmask, int amask,

                            boolean isAlphaPremultiplied,

                            int transferType) {

        super (space, bits, rmask, gmask, bmask, amask,

               isAlphaPremultiplied,

               amask == 0 ? Transparency.OPAQUE : Transparency.TRANSLUCENT,

               transferType);

        if (ColorModel.isLinearRGBspace(colorSpace)) {

            is_LinearRGB = true;

            if (maxBits <= 8) {

                lRGBprecision = 8;

                tosRGB8LUT = ColorModel.getLinearRGB8TosRGB8LUT();

                fromsRGB8LUT8 = ColorModel.getsRGB8ToLinearRGB8LUT();

            } else {

                lRGBprecision = 16;

                tosRGB8LUT = ColorModel.getLinearRGB16TosRGB8LUT();

                fromsRGB8LUT16 = ColorModel.getsRGB8ToLinearRGB16LUT();

            }

        } else if (!is_sRGB) {

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

                // super constructor checks that space is TYPE_RGB

                // check here that min/max are all 0.0/1.0

                if ((space.getMinValue(i) != 0.0f) ||

                    (space.getMaxValue(i) != 1.0f)) {

                    throw new IllegalArgumentException(

                        "Illegal min/max RGB component value");

                }

            }

        }

        setFields();

    }

    /**

     * Returns the mask indicating which bits in an {@code int} pixel

     * representation contain the red color component.

     * @return the mask, which indicates which bits of the {@code int}

     *         pixel representation contain the red color sample.

     */

    public final int getRedMask() {

        return maskArray[0];

    }

    /**

     * Returns the mask indicating which bits in an {@code int} pixel

     * representation contain the green color component.

     * @return the mask, which indicates which bits of the {@code int}

     *         pixel representation contain the green color sample.

     */

    public final int getGreenMask() {

        return maskArray[1];

    }

    /**

     * Returns the mask indicating which bits in an {@code int} pixel

     * representation contain the blue color component.

     * @return the mask, which indicates which bits of the {@code int}

     *         pixel representation contain the blue color sample.

     */

    public final int getBlueMask() {

        return maskArray[2];

    }

    /**

     * Returns the mask indicating which bits in an {@code int} pixel

     * representation contain the alpha component.

     * @return the mask, which indicates which bits of the {@code int}

     *         pixel representation contain the alpha sample.

     */

    public final int getAlphaMask() {

        if (supportsAlpha) {

            return maskArray[3];

        } else {

            return 0;

        }

    }

    /*

     * Given an int pixel in this ColorModel's ColorSpace, converts

     * it to the default sRGB ColorSpace and returns the R, G, and B

     * components as float values between 0.0 and 1.0.

     */

    private float[] getDefaultRGBComponents(int pixel) {

        // Note that getNormalizedComponents returns non-premultiplied values

        return colorSpace.toRGB(norm);

    }

    private int getsRGBComponentFromsRGB(int pixel, int idx) {

        int c = ((pixel & maskArray[idx]) >>> maskOffsets[idx]);

        if (isAlphaPremultiplied) {

            int a = ((pixel & maskArray[3]) >>> maskOffsets[3]);

            c = (a == 0) ? 0 :

                         (int) (((c * scaleFactors[idx]) * 255.0f /

                                 (a * scaleFactors[3])) + 0.5f);

        } else if (scaleFactors[idx] != 1.0f) {

            c = (int) ((c * scaleFactors[idx]) + 0.5f);

        }

        return c;

    }

    private int getsRGBComponentFromLinearRGB(int pixel, int idx) {

        int c = ((pixel & maskArray[idx]) >>> maskOffsets[idx]);

        if (isAlphaPremultiplied) {

            float factor = (float) ((1 << lRGBprecision) - 1);

            int a = ((pixel & maskArray[3]) >>> maskOffsets[3]);

            c = (a == 0) ? 0 :

                         (int) (((c * scaleFactors[idx]) * factor /

                                 (a * scaleFactors[3])) + 0.5f);

        } else if (nBits[idx] != lRGBprecision) {

            if (lRGBprecision == 16) {

                c = (int) ((c * scaleFactors[idx] * 257.0f) + 0.5f);

            } else {

                c = (int) ((c * scaleFactors[idx]) + 0.5f);

            }

        }

        // now range of c is 0-255 or 0-65535, depending on lRGBprecision

        return tosRGB8LUT[c] & 0xff;

    }

    /**

     * Returns the red color component for the specified pixel, scaled

     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.  A

     * color conversion is done if necessary.  The pixel value is specified

     * as an {@code int}.

     * The returned value is a non pre-multiplied value.  Thus, if the

     * alpha is premultiplied, this method divides it out before returning

     * the value.  If the alpha value is 0, for example, the red value

     * is 0.

     * @param pixel the specified pixel

     * @return the red color component for the specified pixel, from

     *         0 to 255 in the sRGB {@code ColorSpace}.

     */

    public final int getRed(int pixel) {

        if (is_sRGB) {

            return getsRGBComponentFromsRGB(pixel, 0);

        } else if (is_LinearRGB) {

            return getsRGBComponentFromLinearRGB(pixel, 0);

        }

        return (int) (rgb[0] * 255.0f + 0.5f);

    }

    /**

     * Returns the green color component for the specified pixel, scaled

     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.  A

     * color conversion is done if necessary.  The pixel value is specified

     * as an {@code int}.

     * The returned value is a non pre-multiplied value.  Thus, if the

     * alpha is premultiplied, this method divides it out before returning

     * the value.  If the alpha value is 0, for example, the green value

     * is 0.

     * @param pixel the specified pixel

     * @return the green color component for the specified pixel, from

     *         0 to 255 in the sRGB {@code ColorSpace}.

     */

    public final int getGreen(int pixel) {

        if (is_sRGB) {

            return getsRGBComponentFromsRGB(pixel, 1);

        } else if (is_LinearRGB) {

            return getsRGBComponentFromLinearRGB(pixel, 1);

        }

        return (int) (rgb[1] * 255.0f + 0.5f);

    }

    /**

     * Returns the blue color component for the specified pixel, scaled

     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.  A

     * color conversion is done if necessary.  The pixel value is specified

     * as an {@code int}.

     * The returned value is a non pre-multiplied value.  Thus, if the

     * alpha is premultiplied, this method divides it out before returning

     * the value.  If the alpha value is 0, for example, the blue value

     * is 0.

     * @param pixel the specified pixel

     * @return the blue color component for the specified pixel, from

     *         0 to 255 in the sRGB {@code ColorSpace}.

     */

    public final int getBlue(int pixel) {

        if (is_sRGB) {

            return getsRGBComponentFromsRGB(pixel, 2);

        } else if (is_LinearRGB) {

            return getsRGBComponentFromLinearRGB(pixel, 2);

        }

        return (int) (rgb[2] * 255.0f + 0.5f);

    }

    /**

     * Returns the alpha component for the specified pixel, scaled

     * from 0 to 255.  The pixel value is specified as an {@code int}.

     * @param pixel the specified pixel

     * @return the value of the alpha component of {@code pixel}

     *         from 0 to 255.

     */

    public final int getAlpha(int pixel) {

        if (!supportsAlpha) return 255;

        int a = ((pixel & maskArray[3]) >>> maskOffsets[3]);

        if (scaleFactors[3] != 1.0f) {

            a = (int)(a * scaleFactors[3] + 0.5f);

        }

        return a;

    }

    /**

     * Returns the color/alpha components of the pixel in the default

     * RGB color model format.  A color conversion is done if necessary.

     * The pixel value is specified as an {@code int}.

     * The returned value is in a non pre-multiplied format.  Thus, if

     * the alpha is premultiplied, this method divides it out of the

     * color components.  If the alpha value is 0, for example, the color

     * values are each 0.

     * @param pixel the specified pixel

     * @return the RGB value of the color/alpha components of the specified

     *         pixel.

     * @see ColorModel#getRGBdefault

     */

    public final int getRGB(int pixel) {

        if (is_sRGB || is_LinearRGB) {

            return (getAlpha(pixel) << 24)

                | (getRed(pixel) << 16)

                | (getGreen(pixel) << 8)

                | (getBlue(pixel) << 0);

        }

        return (getAlpha(pixel) << 24)

            | (((int) (rgb[0] * 255.0f + 0.5f)) << 16)

            | (((int) (rgb[1] * 255.0f + 0.5f)) << 8)

            | (((int) (rgb[2] * 255.0f + 0.5f)) << 0);

    }

    /**

     * Returns the red color component for the specified pixel, scaled

     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.  A

     * color conversion is done if necessary.  The pixel value is specified

     * by an array of data elements of type {@code transferType} passed

     * in as an object reference.

     * The returned value is a non pre-multiplied value.  Thus, if the

     * alpha is premultiplied, this method divides it out before returning

     * the value.  If the alpha value is 0, for example, the red value

     * is 0.

     * If {@code inData} is not a primitive array of type

     * {@code transferType}, a {@code ClassCastException} is

     * thrown.  An {@code ArrayIndexOutOfBoundsException} is

     * thrown if {@code inData} is not large enough to hold a

     * pixel value for this {@code ColorModel}.  Since

     * {@code DirectColorModel} can be subclassed, subclasses inherit

     * the implementation of this method and if they don't override it

     * then they throw an exception if they use an unsupported

     * {@code transferType}.

     * An {@code UnsupportedOperationException} is thrown if this

     * {@code transferType} is not supported by this

     * {@code ColorModel}.

     * @param inData the array containing the pixel value

     * @return the value of the red component of the specified pixel.

     * @throws ArrayIndexOutOfBoundsException if {@code inData} is not

     *         large enough to hold a pixel value for this color model

     * @throws ClassCastException if {@code inData} is not a

     *         primitive array of type {@code transferType}

     * @throws UnsupportedOperationException if this {@code transferType}

     *         is not supported by this color model

     */

    public int getRed(Object inData) {

        int pixel=0;

        switch (transferType) {

            case DataBuffer.TYPE_BYTE:

               pixel = bdata[0] & 0xff;

            break;

            case DataBuffer.TYPE_USHORT:

               pixel = sdata[0] & 0xffff;

            break;

            case DataBuffer.TYPE_INT:

               pixel = idata[0];

            break;

            default: