1 /*

     2  * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.

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

     4  *

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

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

     7  * published by the Free Software Foundation.  Oracle designates this

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

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

    10  *

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

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

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

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

    15  * accompanied this code).

    16  *

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

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

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

    20  *

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

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

    23  * questions.

    24  */

    25 

    26 package java.awt.image;

    27 

    28 import java.awt.color.ColorSpace;

    29 import java.awt.color.ICC_ColorSpace;

    30 import java.util.Arrays;

    31 

    32 /**

    33  * A {@code ColorModel} class that works with pixel values that

    34  * represent color and alpha information as separate samples and that

    35  * store each sample in a separate data element.  This class can be

    36  * used with an arbitrary {@code ColorSpace}.  The number of

    37  * color samples in the pixel values must be same as the number of

    38  * color components in the {@code ColorSpace}. There may be a

    39  * single alpha sample.

    40  * <p>

    41  * For those methods that use

    42  * a primitive array pixel representation of type {@code transferType},

    43  * the array length is the same as the number of color and alpha samples.

    44  * Color samples are stored first in the array followed by the alpha

    45  * sample, if present.  The order of the color samples is specified

    46  * by the {@code ColorSpace}.  Typically, this order reflects the

    47  * name of the color space type. For example, for {@code TYPE_RGB},

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

    49  * <p>

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

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

    52  * samples to components.

    53  * Depending on the transfer type used to create an instance of

    54  * {@code ComponentColorModel}, the pixel sample values

    55  * represented by that instance may be signed or unsigned and may

    56  * be of integral type or float or double (see below for details).

    57  * The translation from sample values to normalized color/alpha components

    58  * must follow certain rules.  For float and double samples, the translation

    59  * is an identity, i.e. normalized component values are equal to the

    60  * corresponding sample values.  For integral samples, the translation

    61  * should be only a simple scale and offset, where the scale and offset

    62  * constants may be different for each component.  The result of

    63  * applying the scale and offset constants is a set of color/alpha

    64  * component values, which are guaranteed to fall within a certain

    65  * range.  Typically, the range for a color component will be the range

    66  * defined by the {@code getMinValue} and {@code getMaxValue}

    67  * methods of the {@code ColorSpace} class.  The range for an

    68  * alpha component should be 0.0 to 1.0.

    69  * <p>

    70  * Instances of {@code ComponentColorModel} created with transfer types

    71  * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},

    72  * and {@code DataBuffer.TYPE_INT} have pixel sample values which

    73  * are treated as unsigned integral values.

    74  * The number of bits in a color or alpha sample of a pixel value might not

    75  * be the same as the number of bits for the corresponding color or alpha

    76  * sample passed to the

    77  * {@code ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)}

    78  * constructor.  In

    79  * that case, this class assumes that the least significant n bits of a sample

    80  * value hold the component value, where n is the number of significant bits

    81  * for the component passed to the constructor.  It also assumes that

    82  * any higher-order bits in a sample value are zero.  Thus, sample values

    83  * range from 0 to 2<sup>n</sup> - 1.  This class maps these sample values

    84  * to normalized color component values such that 0 maps to the value

    85  * obtained from the {@code ColorSpace's getMinValue}

    86  * method for each component and 2<sup>n</sup> - 1 maps to the value

    87  * obtained from {@code getMaxValue}.  To create a

    88  * {@code ComponentColorModel} with a different color sample mapping

    89  * requires subclassing this class and overriding the

    90  * {@code getNormalizedComponents(Object, float[], int)} method.

    91  * The mapping for an alpha sample always maps 0 to 0.0 and

    92  * 2<sup>n</sup> - 1 to 1.0.

    93  * <p>

    94  * For instances with unsigned sample values,

    95  * the unnormalized color/alpha component representation is only

    96  * supported if two conditions hold.  First, sample value 0 must

    97  * map to normalized component value 0.0 and sample value 2<sup>n</sup> - 1

    98  * to 1.0.  Second the min/max range of all color components of the

    99  * {@code ColorSpace} must be 0.0 to 1.0.  In this case, the

   100  * component representation is the n least

   101  * significant bits of the corresponding sample.  Thus each component is

   102  * an unsigned integral value between 0 and 2<sup>n</sup> - 1, where

   103  * n is the number of significant bits for a particular component.

   104  * If these conditions are not met, any method taking an unnormalized

   105  * component argument will throw an {@code IllegalArgumentException}.

   106  * <p>

   107  * Instances of {@code ComponentColorModel} created with transfer types

   108  * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT}, and

   109  * {@code DataBuffer.TYPE_DOUBLE} have pixel sample values which

   110  * are treated as signed short, float, or double values.

   111  * Such instances do not support the unnormalized color/alpha component

   112  * representation, so any methods taking such a representation as an argument

   113  * will throw an {@code IllegalArgumentException} when called on one

   114  * of these instances.  The normalized component values of instances

   115  * of this class have a range which depends on the transfer

   116  * type as follows: for float samples, the full range of the float data

   117  * type; for double samples, the full range of the float data type

   118  * (resulting from casting double to float); for short samples,

   119  * from approximately -maxVal to +maxVal, where maxVal is the per

   120  * component maximum value for the {@code ColorSpace}

   121  * (-32767 maps to -maxVal, 0 maps to 0.0, and 32767 maps

   122  * to +maxVal).  A subclass may override the scaling for short sample

   123  * values to normalized component values by overriding the

   124  * {@code getNormalizedComponents(Object, float[], int)} method.

   125  * For float and double samples, the normalized component values are

   126  * taken to be equal to the corresponding sample values, and subclasses

   127  * should not attempt to add any non-identity scaling for these transfer

   128  * types.

   129  * <p>

   130  * Instances of {@code ComponentColorModel} created with transfer types

   131  * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT}, and

   132  * {@code DataBuffer.TYPE_DOUBLE}

   133  * use all the bits of all sample values.  Thus all color/alpha components

   134  * have 16 bits when using {@code DataBuffer.TYPE_SHORT}, 32 bits when

   135  * using {@code DataBuffer.TYPE_FLOAT}, and 64 bits when using

   136  * {@code DataBuffer.TYPE_DOUBLE}.  When the

   137  * {@code ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)}

   138  * form of constructor is used with one of these transfer types, the

   139  * bits array argument is ignored.

   140  * <p>

   141  * It is possible to have color/alpha sample values

   142  * which cannot be reasonably interpreted as component values for rendering.

   143  * This can happen when {@code ComponentColorModel} is subclassed to

   144  * override the mapping of unsigned sample values to normalized color

   145  * component values or when signed sample values outside a certain range

   146  * are used.  (As an example, specifying an alpha component as a signed

   147  * short value outside the range 0 to 32767, normalized range 0.0 to 1.0, can

   148  * lead to unexpected results.) It is the

   149  * responsibility of applications to appropriately scale pixel data before

   150  * rendering such that color components fall within the normalized range

   151  * of the {@code ColorSpace} (obtained using the {@code getMinValue}

   152  * and {@code getMaxValue} methods of the {@code ColorSpace} class)

   153  * and the alpha component is between 0.0 and 1.0.  If color or alpha

   154  * component values fall outside these ranges, rendering results are

   155  * indeterminate.

   156  * <p>

   157  * Methods that use a single int pixel representation throw

   158  * an {@code IllegalArgumentException}, unless the number of components

   159  * for the {@code ComponentColorModel} is one and the component

   160  * value is unsigned -- in other words,  a single color component using

   161  * a transfer type of {@code DataBuffer.TYPE_BYTE},

   162  * {@code DataBuffer.TYPE_USHORT}, or {@code DataBuffer.TYPE_INT}

   163  * and no alpha.

   164  * <p>

   165  * A {@code ComponentColorModel} can be used in conjunction with a

   166  * {@code ComponentSampleModel}, a {@code BandedSampleModel},

   167  * or a {@code PixelInterleavedSampleModel} to construct a

   168  * {@code BufferedImage}.

   169  *

   170  * @see ColorModel

   171  * @see ColorSpace

   172  * @see ComponentSampleModel

   173  * @see BandedSampleModel

   174  * @see PixelInterleavedSampleModel

   175  * @see BufferedImage

   176  *

   177  */

   178 public class ComponentColorModel extends ColorModel {

   179 

   180     /**

   181      * {@code signed}  is {@code true} for {@code short},

   182      * {@code float}, and {@code double} transfer types; it

   183      * is {@code false} for {@code byte}, {@code ushort},

   184      * and {@code int} transfer types.

   185      */

   186     private boolean signed; // true for transfer types short, float, double

   187                             // false for byte, ushort, int

   188     private boolean is_sRGB_stdScale;

   189     private boolean is_LinearRGB_stdScale;

   190     private boolean is_LinearGray_stdScale;

   191     private boolean is_ICCGray_stdScale;

   192     private byte[] tosRGB8LUT;

   193     private byte[] fromsRGB8LUT8;

   194     private short[] fromsRGB8LUT16;

   195     private byte[] fromLinearGray16ToOtherGray8LUT;

   196     private short[] fromLinearGray16ToOtherGray16LUT;

   197     private boolean needScaleInit;

   198     private boolean noUnnorm;

   199     private boolean nonStdScale;

   200     private float[] min;

   201     private float[] diffMinMax;

   202     private float[] compOffset;

   203     private float[] compScale;

   204     private volatile int hashCode;

   205 

   206     /**

   207      * Constructs a {@code ComponentColorModel} from the specified

   208      * parameters. Color components will be in the specified

   209      * {@code ColorSpace}.  The supported transfer types are

   210      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},

   211      * {@code DataBuffer.TYPE_INT},

   212      * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},

   213      * and {@code DataBuffer.TYPE_DOUBLE}.

   214      * If not null, the {@code bits} array specifies the

   215      * number of significant bits per color and alpha component and its

   216      * length should be at least the number of components in the

   217      * {@code ColorSpace} if there is no alpha

   218      * information in the pixel values, or one more than this number if

   219      * there is alpha information.  When the {@code transferType} is

   220      * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},

   221      * or {@code DataBuffer.TYPE_DOUBLE} the {@code bits} array

   222      * argument is ignored.  {@code hasAlpha} indicates whether alpha

   223      * information is present.  If {@code hasAlpha} is true, then

   224      * the boolean {@code isAlphaPremultiplied}

   225      * specifies how to interpret color and alpha samples in pixel values.

   226      * If the boolean is true, color samples are assumed to have been

   227      * multiplied by the alpha sample. The {@code transparency}

   228      * specifies what alpha values can be represented by this color model.

   229      * The acceptable {@code transparency} values are

   230      * {@code OPAQUE}, {@code BITMASK} or {@code TRANSLUCENT}.

   231      * The {@code transferType} is the type of primitive array used

   232      * to represent pixel values.

   233      *

   234      * @param colorSpace       The {@code ColorSpace} associated

   235      *                         with this color model.

   236      * @param bits             The number of significant bits per component.

   237      *                         May be null, in which case all bits of all

   238      *                         component samples will be significant.

   239      *                         Ignored if transferType is one of

   240      *                         {@code DataBuffer.TYPE_SHORT},

   241      *                         {@code DataBuffer.TYPE_FLOAT}, or

   242      *                         {@code DataBuffer.TYPE_DOUBLE},

   243      *                         in which case all bits of all component

   244      *                         samples will be significant.

   245      * @param hasAlpha         If true, this color model supports alpha.

   246      * @param isAlphaPremultiplied If true, alpha is premultiplied.

   247      * @param transparency     Specifies what alpha values can be represented

   248      *                         by this color model.

   249      * @param transferType     Specifies the type of primitive array used to

   250      *                         represent pixel values.

   251      *

   252      * @throws IllegalArgumentException If the {@code bits} array

   253      *         argument is not null, its length is less than the number of

   254      *         color and alpha components, and transferType is one of

   255      *         {@code DataBuffer.TYPE_BYTE},

   256      *         {@code DataBuffer.TYPE_USHORT}, or

   257      *         {@code DataBuffer.TYPE_INT}.

   258      * @throws IllegalArgumentException If transferType is not one of

   259      *         {@code DataBuffer.TYPE_BYTE},

   260      *         {@code DataBuffer.TYPE_USHORT},

   261      *         {@code DataBuffer.TYPE_INT},

   262      *         {@code DataBuffer.TYPE_SHORT},

   263      *         {@code DataBuffer.TYPE_FLOAT}, or

   264      *         {@code DataBuffer.TYPE_DOUBLE}.

   265      *

   266      * @see ColorSpace

   267      * @see java.awt.Transparency

   268      */

   269     public ComponentColorModel (ColorSpace colorSpace,

   270                                 int[] bits,

   271                                 boolean hasAlpha,

   272                                 boolean isAlphaPremultiplied,

   273                                 int transparency,

   274                                 int transferType) {

   275         super (bitsHelper(transferType, colorSpace, hasAlpha),

   276                bitsArrayHelper(bits, transferType, colorSpace, hasAlpha),

   277                colorSpace, hasAlpha, isAlphaPremultiplied, transparency,

   278                transferType);

   279         switch(transferType) {

   280             case DataBuffer.TYPE_BYTE:

   281             case DataBuffer.TYPE_USHORT:

   282             case DataBuffer.TYPE_INT:

   283                 signed = false;

   284                 needScaleInit = true;

   285                 break;

   286             case DataBuffer.TYPE_SHORT:

   287                 signed = true;

   288                 needScaleInit = true;

   289                 break;

   290             case DataBuffer.TYPE_FLOAT:

   291             case DataBuffer.TYPE_DOUBLE:

   292                 signed = true;

   293                 needScaleInit = false;

   294                 noUnnorm = true;

   295                 nonStdScale = false;

   296                 break;

   297             default:

   298                 throw new IllegalArgumentException("This constructor is not "+

   299                          "compatible with transferType " + transferType);

   300         }

   301         setupLUTs();

   302     }

   303 

   304     /**

   305      * Constructs a {@code ComponentColorModel} from the specified

   306      * parameters. Color components will be in the specified

   307      * {@code ColorSpace}.  The supported transfer types are

   308      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},

   309      * {@code DataBuffer.TYPE_INT},

   310      * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},

   311      * and {@code DataBuffer.TYPE_DOUBLE}.  The number of significant

   312      * bits per color and alpha component will be 8, 16, 32, 16, 32,  or 64,

   313      * respectively.  The number of color components will be the

   314      * number of components in the {@code ColorSpace}.  There will be

   315      * an alpha component if {@code hasAlpha} is {@code true}.

   316      * If {@code hasAlpha} is true, then

   317      * the boolean {@code isAlphaPremultiplied}

   318      * specifies how to interpret color and alpha samples in pixel values.

   319      * If the boolean is true, color samples are assumed to have been

   320      * multiplied by the alpha sample. The {@code transparency}

   321      * specifies what alpha values can be represented by this color model.

   322      * The acceptable {@code transparency} values are

   323      * {@code OPAQUE}, {@code BITMASK} or {@code TRANSLUCENT}.

   324      * The {@code transferType} is the type of primitive array used

   325      * to represent pixel values.

   326      *

   327      * @param colorSpace       The {@code ColorSpace} associated

   328      *                         with this color model.

   329      * @param hasAlpha         If true, this color model supports alpha.

   330      * @param isAlphaPremultiplied If true, alpha is premultiplied.

   331      * @param transparency     Specifies what alpha values can be represented

   332      *                         by this color model.

   333      * @param transferType     Specifies the type of primitive array used to

   334      *                         represent pixel values.

   335      *

   336      * @throws IllegalArgumentException If transferType is not one of

   337      *         {@code DataBuffer.TYPE_BYTE},

   338      *         {@code DataBuffer.TYPE_USHORT},

   339      *         {@code DataBuffer.TYPE_INT},

   340      *         {@code DataBuffer.TYPE_SHORT},

   341      *         {@code DataBuffer.TYPE_FLOAT}, or

   342      *         {@code DataBuffer.TYPE_DOUBLE}.

   343      *

   344      * @see ColorSpace

   345      * @see java.awt.Transparency

   346      * @since 1.4

   347      */

   348     public ComponentColorModel (ColorSpace colorSpace,

   349                                 boolean hasAlpha,

   350                                 boolean isAlphaPremultiplied,

   351                                 int transparency,

   352                                 int transferType) {

   353         this(colorSpace, null, hasAlpha, isAlphaPremultiplied,

   354              transparency, transferType);

   355     }

   356 

   357     private static int bitsHelper(int transferType,

   358                                   ColorSpace colorSpace,

   359                                   boolean hasAlpha) {

   360         int numBits = DataBuffer.getDataTypeSize(transferType);

   361         int numComponents = colorSpace.getNumComponents();

   362         if (hasAlpha) {

   363             ++numComponents;

   364         }

   365         return numBits * numComponents;

   366     }

   367 

   368     private static int[] bitsArrayHelper(int[] origBits,

   369                                          int transferType,

   370                                          ColorSpace colorSpace,

   371                                          boolean hasAlpha) {

   372         switch(transferType) {

   373             case DataBuffer.TYPE_BYTE:

   374             case DataBuffer.TYPE_USHORT:

   375             case DataBuffer.TYPE_INT:

   376                 if (origBits != null) {

   377                     return origBits;

   378                 }

   379                 break;

   380             default:

   381                 break;

   382         }

   383         int numBits = DataBuffer.getDataTypeSize(transferType);

   384         int numComponents = colorSpace.getNumComponents();

   385         if (hasAlpha) {

   386             ++numComponents;

   387         }

   388         int[] bits = new int[numComponents];

   389         for (int i = 0; i < numComponents; i++) {

   390             bits[i] = numBits;

   391         }

   392         return bits;

   393     }

   394 

   395     private void setupLUTs() {

   396         // REMIND: there is potential to accelerate sRGB, LinearRGB,

   397         // LinearGray, ICCGray, and non-ICC Gray spaces with non-standard

   398         // scaling, if that becomes important

   399         //

   400         // NOTE: The is_xxx_stdScale and nonStdScale booleans are provisionally

   401         // set here when this method is called at construction time.  These

   402         // variables may be set again when initScale is called later.

   403         // When setupLUTs returns, nonStdScale is true if (the transferType

   404         // is not float or double) AND (some minimum ColorSpace component

   405         // value is not 0.0 OR some maximum ColorSpace component value

   406         // is not 1.0).  This is correct for the calls to

   407         // getNormalizedComponents(Object, float[], int) from initScale().

   408         // initScale() may change the value nonStdScale based on the

   409         // return value of getNormalizedComponents() - this will only

   410         // happen if getNormalizedComponents() has been overridden by a

   411         // subclass to make the mapping of min/max pixel sample values

   412         // something different from min/max color component values.

   413         if (is_sRGB) {

   414             is_sRGB_stdScale = true;

   415             nonStdScale = false;

   416         } else if (ColorModel.isLinearRGBspace(colorSpace)) {

   417             // Note that the built-in Linear RGB space has a normalized

   418             // range of 0.0 - 1.0 for each coordinate.  Usage of these

   419             // LUTs makes that assumption.

   420             is_LinearRGB_stdScale = true;

   421             nonStdScale = false;

   422             if (transferType == DataBuffer.TYPE_BYTE) {

   423                 tosRGB8LUT = ColorModel.getLinearRGB8TosRGB8LUT();

   424                 fromsRGB8LUT8 = ColorModel.getsRGB8ToLinearRGB8LUT();

   425             } else {

   426                 tosRGB8LUT = ColorModel.getLinearRGB16TosRGB8LUT();

   427                 fromsRGB8LUT16 = ColorModel.getsRGB8ToLinearRGB16LUT();

   428             }

   429         } else if ((colorSpaceType == ColorSpace.TYPE_GRAY) &&

   430                    (colorSpace instanceof ICC_ColorSpace) &&

   431                    (colorSpace.getMinValue(0) == 0.0f) &&

   432                    (colorSpace.getMaxValue(0) == 1.0f)) {

   433             // Note that a normalized range of 0.0 - 1.0 for the gray

   434             // component is required, because usage of these LUTs makes

   435             // that assumption.

   436             ICC_ColorSpace ics = (ICC_ColorSpace) colorSpace;

   437             is_ICCGray_stdScale = true;

   438             nonStdScale = false;

   439             fromsRGB8LUT16 = ColorModel.getsRGB8ToLinearRGB16LUT();

   440             if (ColorModel.isLinearGRAYspace(ics)) {

   441                 is_LinearGray_stdScale = true;

   442                 if (transferType == DataBuffer.TYPE_BYTE) {

   443                     tosRGB8LUT = ColorModel.getGray8TosRGB8LUT(ics);

   444                 } else {

   445                     tosRGB8LUT = ColorModel.getGray16TosRGB8LUT(ics);

   446                 }

   447             } else {

   448                 if (transferType == DataBuffer.TYPE_BYTE) {

   449                     tosRGB8LUT = ColorModel.getGray8TosRGB8LUT(ics);

   450                     fromLinearGray16ToOtherGray8LUT =

   451                         ColorModel.getLinearGray16ToOtherGray8LUT(ics);

   452                 } else {

   453                     tosRGB8LUT = ColorModel.getGray16TosRGB8LUT(ics);

   454                     fromLinearGray16ToOtherGray16LUT =

   455                         ColorModel.getLinearGray16ToOtherGray16LUT(ics);

   456                 }

   457             }

   458         } else if (needScaleInit) {

   459             // if transferType is byte, ushort, int, or short and we

   460             // don't already know the ColorSpace has minVlaue == 0.0f and

   461             // maxValue == 1.0f for all components, we need to check that

   462             // now and setup the min[] and diffMinMax[] arrays if necessary.

   463             nonStdScale = false;

   464             for (int i = 0; i < numColorComponents; i++) {

   465                 if ((colorSpace.getMinValue(i) != 0.0f) ||

   466                     (colorSpace.getMaxValue(i) != 1.0f)) {

   467                     nonStdScale = true;

   468                     break;

   469                 }

   470             }

   471             if (nonStdScale) {

   472                 min = new float[numColorComponents];

   473                 diffMinMax = new float[numColorComponents];

   474                 for (int i = 0; i < numColorComponents; i++) {

   475                     min[i] = colorSpace.getMinValue(i);

   476                     diffMinMax[i] = colorSpace.getMaxValue(i) - min[i];

   477                 }

   478             }

   479         }

   480     }

   481 

   482     private void initScale() {

   483         // This method is called the first time any method which uses

   484         // pixel sample value to color component value scaling information

   485         // is called if the transferType supports non-standard scaling

   486         // as defined above (byte, ushort, int, and short), unless the

   487         // method is getNormalizedComponents(Object, float[], int) (that

   488         // method must be overridden to use non-standard scaling).  This

   489         // method also sets up the noUnnorm boolean variable for these

   490         // transferTypes.  After this method is called, the nonStdScale

   491         // variable will be true if getNormalizedComponents() maps a

   492         // sample value of 0 to anything other than 0.0f OR maps a

   493         // sample value of 2^^n - 1 (2^^15 - 1 for short transferType)

   494         // to anything other than 1.0f.  Note that this can be independent

   495         // of the colorSpace min/max component values, if the

   496         // getNormalizedComponents() method has been overridden for some

   497         // reason, e.g. to provide greater dynamic range in the sample

   498         // values than in the color component values.  Unfortunately,

   499         // this method can't be called at construction time, since a

   500         // subclass may still have uninitialized state that would cause

   501         // getNormalizedComponents() to return an incorrect result.

   502         needScaleInit = false; // only needs to called once

   503         if (nonStdScale || signed) {

   504             // The unnormalized form is only supported for unsigned

   505             // transferTypes and when the ColorSpace min/max values

   506             // are 0.0/1.0.  When this method is called nonStdScale is

   507             // true if the latter condition does not hold.  In addition,

   508             // the unnormalized form requires that the full range of

   509             // the pixel sample values map to the full 0.0 - 1.0 range

   510             // of color component values.  That condition is checked

   511             // later in this method.

   512             noUnnorm = true;

   513         } else {

   514             noUnnorm = false;

   515         }

   516         float[] lowVal, highVal;

   517         switch (transferType) {

   518         case DataBuffer.TYPE_BYTE:

   519             {

   520                 byte[] bpixel = new byte[numComponents];

   521                 for (int i = 0; i < numColorComponents; i++) {

   522                     bpixel[i] = 0;

   523                 }

   524                 if (supportsAlpha) {

   525                     bpixel[numColorComponents] =

   526                         (byte) ((1 << nBits[numColorComponents]) - 1);

   527                 }

   528                 lowVal = getNormalizedComponents(bpixel, null, 0);

   529                 for (int i = 0; i < numColorComponents; i++) {

   530                     bpixel[i] = (byte) ((1 << nBits[i]) - 1);

   531                 }

   532                 highVal = getNormalizedComponents(bpixel, null, 0);

   533             }

   534             break;

   535         case DataBuffer.TYPE_USHORT:

   536             {

   537                 short[] uspixel = new short[numComponents];

   538                 for (int i = 0; i < numColorComponents; i++) {

   539                     uspixel[i] = 0;

   540                 }

   541                 if (supportsAlpha) {

   542                     uspixel[numColorComponents] =

   543                         (short) ((1 << nBits[numColorComponents]) - 1);

   544                 }

   545                 lowVal = getNormalizedComponents(uspixel, null, 0);

   546                 for (int i = 0; i < numColorComponents; i++) {

   547                     uspixel[i] = (short) ((1 << nBits[i]) - 1);

   548                 }

   549                 highVal = getNormalizedComponents(uspixel, null, 0);

   550             }

   551             break;

   552         case DataBuffer.TYPE_INT:

   553             {

   554                 int[] ipixel = new int[numComponents];

   555                 for (int i = 0; i < numColorComponents; i++) {

   556                     ipixel[i] = 0;

   557                 }

   558                 if (supportsAlpha) {

   559                     ipixel[numColorComponents] =

   560                         ((1 << nBits[numColorComponents]) - 1);

   561                 }

   562                 lowVal = getNormalizedComponents(ipixel, null, 0);

   563                 for (int i = 0; i < numColorComponents; i++) {

   564                     ipixel[i] = ((1 << nBits[i]) - 1);

   565                 }

   566                 highVal = getNormalizedComponents(ipixel, null, 0);

   567             }

   568             break;

   569         case DataBuffer.TYPE_SHORT:

   570             {

   571                 short[] spixel = new short[numComponents];

   572                 for (int i = 0; i < numColorComponents; i++) {

   573                     spixel[i] = 0;

   574                 }

   575                 if (supportsAlpha) {

   576                     spixel[numColorComponents] = 32767;

   577                 }

   578                 lowVal = getNormalizedComponents(spixel, null, 0);

   579                 for (int i = 0; i < numColorComponents; i++) {

   580                     spixel[i] = 32767;

   581                 }

   582                 highVal = getNormalizedComponents(spixel, null, 0);

   583             }

   584             break;

   585         default:

   586             lowVal = highVal = null;  // to keep the compiler from complaining

   587             break;

   588         }

   589         nonStdScale = false;

   590         for (int i = 0; i < numColorComponents; i++) {

   591             if ((lowVal[i] != 0.0f) || (highVal[i] != 1.0f)) {

   592                 nonStdScale = true;

   593                 break;

   594             }

   595         }

   596         if (nonStdScale) {

   597             noUnnorm = true;

   598             is_sRGB_stdScale = false;

   599             is_LinearRGB_stdScale = false;

   600             is_LinearGray_stdScale = false;

   601             is_ICCGray_stdScale = false;

   602             compOffset = new float[numColorComponents];

   603             compScale = new float[numColorComponents];

   604             for (int i = 0; i < numColorComponents; i++) {

   605                 compOffset[i] = lowVal[i];

   606                 compScale[i] = 1.0f / (highVal[i] - lowVal[i]);

   607             }

   608         }

   609     }

   610 

   611     private int getRGBComponent(int pixel, int idx) {

   612         if (numComponents > 1) {

   613             throw new

   614                 IllegalArgumentException("More than one component per pixel");

   615         }

   616         if (signed) {

   617             throw new

   618                 IllegalArgumentException("Component value is signed");

   619         }

   620         if (needScaleInit) {

   621             initScale();

   622         }

   623         // Since there is only 1 component, there is no alpha

   624 

   625         // Normalize the pixel in order to convert it

   626         Object opixel = null;

   627         switch (transferType) {

   628         case DataBuffer.TYPE_BYTE:

   629             {

   630                 byte[] bpixel = { (byte) pixel };

   631                 opixel = bpixel;

   632             }

   633             break;

   634         case DataBuffer.TYPE_USHORT:

   635             {

   636                 short[] spixel = { (short) pixel };

   637                 opixel = spixel;

   638             }

   639             break;

   640         case DataBuffer.TYPE_INT:

   641             {

   642                 int[] ipixel = { pixel };

   643                 opixel = ipixel;

   644             }

   645             break;

   646         }

   647         float[] norm = getNormalizedComponents(opixel, null, 0);

   648         float[] rgb = colorSpace.toRGB(norm);

   649 

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

   651     }

   652 

   653     /**

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

   655      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion

   656      * is done if necessary.  The pixel value is specified as an int.

   657      * The returned value will be a non pre-multiplied value.

   658      * If the alpha is premultiplied, this method divides

   659      * it out before returning the value (if the alpha value is 0,

   660      * the red value will be 0).

   661      *

   662      * @param pixel The pixel from which you want to get the red color component.

   663      *

   664      * @return The red color component for the specified pixel, as an int.

   665      *

   666      * @throws IllegalArgumentException If there is more than

   667      * one component in this {@code ColorModel}.

   668      * @throws IllegalArgumentException If the component value for this

   669      * {@code ColorModel} is signed

   670      */

   671     public int getRed(int pixel) {

   672         return getRGBComponent(pixel, 0);

   673     }

   674 

   675     /**

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

   677      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion

   678      * is done if necessary.  The pixel value is specified as an int.

   679      * The returned value will be a non

   680      * pre-multiplied value. If the alpha is premultiplied, this method

   681      * divides it out before returning the value (if the alpha value is 0,

   682      * the green value will be 0).

   683      *

   684      * @param pixel The pixel from which you want to get the green color component.

   685      *

   686      * @return The green color component for the specified pixel, as an int.

   687      *

   688      * @throws IllegalArgumentException If there is more than

   689      * one component in this {@code ColorModel}.

   690      * @throws IllegalArgumentException If the component value for this

   691      * {@code ColorModel} is signed

   692      */

   693     public int getGreen(int pixel) {

   694         return getRGBComponent(pixel, 1);

   695     }

   696 

   697     /**

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

   699      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion

   700      * is done if necessary.  The pixel value is specified as an int.

   701      * The returned value will be a non

   702      * pre-multiplied value. If the alpha is premultiplied, this method

   703      * divides it out before returning the value (if the alpha value is 0,

   704      * the blue value will be 0).

   705      *

   706      * @param pixel The pixel from which you want to get the blue color component.

   707      *

   708      * @return The blue color component for the specified pixel, as an int.

   709      *

   710      * @throws IllegalArgumentException If there is more than

   711      * one component in this {@code ColorModel}.

   712      * @throws IllegalArgumentException If the component value for this

   713      * {@code ColorModel} is signed

   714      */

   715     public int getBlue(int pixel) {

   716         return getRGBComponent(pixel, 2);

   717     }

   718 

   719     /**

   720      * Returns the alpha component for the specified pixel, scaled

   721      * from 0 to 255.   The pixel value is specified as an int.

   722      *

   723      * @param pixel The pixel from which you want to get the alpha component.

   724      *

   725      * @return The alpha component for the specified pixel, as an int.

   726      *

   727      * @throws IllegalArgumentException If there is more than

   728      * one component in this {@code ColorModel}.

   729      * @throws IllegalArgumentException If the component value for this

   730      * {@code ColorModel} is signed

   731      */

   732     public int getAlpha(int pixel) {

   733         if (supportsAlpha == false) {

   734             return 255;

   735         }

   736         if (numComponents > 1) {

   737             throw new

   738                 IllegalArgumentException("More than one component per pixel");

   739         }

   740         if (signed) {

   741             throw new

   742                 IllegalArgumentException("Component value is signed");

   743         }

   744 

   745         return (int) ((((float) pixel) / ((1<<nBits[0])-1)) * 255.0f + 0.5f);

   746     }

   747 

   748     /**

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

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

   751      * The returned value will be in a non pre-multiplied format. If

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

   753      * color components (if the alpha value is 0, the color values will be 0).

   754      *

   755      * @param pixel The pixel from which you want to get the color/alpha components.

   756      *

   757      * @return The color/alpha components for the specified pixel, as an int.

   758      *

   759      * @throws IllegalArgumentException If there is more than

   760      * one component in this {@code ColorModel}.

   761      * @throws IllegalArgumentException If the component value for this

   762      * {@code ColorModel} is signed

   763      */

   764     public int getRGB(int pixel) {

   765         if (numComponents > 1) {

   766             throw new

   767                 IllegalArgumentException("More than one component per pixel");

   768         }

   769         if (signed) {

   770             throw new

   771                 IllegalArgumentException("Component value is signed");

   772         }

   773 

   774         return (getAlpha(pixel) << 24)

   775             | (getRed(pixel) << 16)

   776             | (getGreen(pixel) << 8)

   777             | (getBlue(pixel) << 0);

   778     }

   779 

   780     private int extractComponent(Object inData, int idx, int precision) {

   781         // Extract component idx from inData.  The precision argument

   782         // should be either 8 or 16.  If it's 8, this method will return

   783         // an 8-bit value.  If it's 16, this method will return a 16-bit

   784         // value for transferTypes other than TYPE_BYTE.  For TYPE_BYTE,

   785         // an 8-bit value will be returned.

   786 

   787         // This method maps the input value corresponding to a

   788         // normalized ColorSpace component value of 0.0 to 0, and the

   789         // input value corresponding to a normalized ColorSpace

   790         // component value of 1.0 to 2^n - 1 (where n is 8 or 16), so

   791         // it is appropriate only for ColorSpaces with min/max component

   792         // values of 0.0/1.0.  This will be true for sRGB, the built-in

   793         // Linear RGB and Linear Gray spaces, and any other ICC grayscale

   794         // spaces for which we have precomputed LUTs.

   795 

   796         boolean needAlpha = (supportsAlpha && isAlphaPremultiplied);

   797         int alp = 0;

   798         int comp;

   799         int mask = (1 << nBits[idx]) - 1;

   800 

   801         switch (transferType) {

   802             // Note: we do no clamping of the pixel data here - we

   803             // assume that the data is scaled properly

   804             case DataBuffer.TYPE_SHORT: {

   805                 short sdata[] = (short[]) inData;

   806                 float scalefactor = (float) ((1 << precision) - 1);

   807                 if (needAlpha) {

   808                     short s = sdata[numColorComponents];

   809                     if (s != (short) 0) {

   810                         return (int) ((((float) sdata[idx]) /

   811                                        ((float) s)) * scalefactor + 0.5f);

   812                     } else {

   813                         return 0;

   814                     }

   815                 } else {

   816                     return (int) ((sdata[idx] / 32767.0f) * scalefactor + 0.5f);

   817                 }

   818             }

   819             case DataBuffer.TYPE_FLOAT: {

   820                 float fdata[] = (float[]) inData;

   821                 float scalefactor = (float) ((1 << precision) - 1);

   822                 if (needAlpha) {

   823                     float f = fdata[numColorComponents];

   824                     if (f != 0.0f) {

   825                         return (int) (((fdata[idx] / f) * scalefactor) + 0.5f);

   826                     } else {

   827                         return 0;

   828                     }

   829                 } else {

   830                     return (int) (fdata[idx] * scalefactor + 0.5f);

   831                 }

   832             }

   833             case DataBuffer.TYPE_DOUBLE: {

   834                 double ddata[] = (double[]) inData;

   835                 double scalefactor = (double) ((1 << precision) - 1);

   836                 if (needAlpha) {

   837                     double d = ddata[numColorComponents];

   838                     if (d != 0.0) {

   839                         return (int) (((ddata[idx] / d) * scalefactor) + 0.5);

   840                     } else {

   841                         return 0;

   842                     }

   843                 } else {

   844                     return (int) (ddata[idx] * scalefactor + 0.5);

   845                 }

   846             }

   847             case DataBuffer.TYPE_BYTE:

   848                byte bdata[] = (byte[])inData;

   849                comp = bdata[idx] & mask;

   850                precision = 8;

   851                if (needAlpha) {

   852                    alp = bdata[numColorComponents] & mask;

   853                }

   854             break;

   855             case DataBuffer.TYPE_USHORT:

   856                short usdata[] = (short[])inData;

   857                comp = usdata[idx] & mask;

   858                if (needAlpha) {

   859                    alp = usdata[numColorComponents] & mask;

   860                }

   861             break;

   862             case DataBuffer.TYPE_INT:

   863                int idata[] = (int[])inData;

   864                comp = idata[idx];

   865                if (needAlpha) {

   866                    alp = idata[numColorComponents];

   867                }

   868             break;

   869             default:

   870                throw new

   871                    UnsupportedOperationException("This method has not "+

   872                    "been implemented for transferType " + transferType);

   873         }

   874         if (needAlpha) {

   875             if (alp != 0) {

   876                 float scalefactor = (float) ((1 << precision) - 1);

   877                 float fcomp = ((float) comp) / ((float)mask);

   878                 float invalp = ((float) ((1<<nBits[numColorComponents]) - 1)) /

   879                                ((float) alp);

   880                 return (int) (fcomp * invalp * scalefactor + 0.5f);

   881             } else {

   882                 return 0;

   883             }

   884         } else {

   885             if (nBits[idx] != precision) {

   886                 float scalefactor = (float) ((1 << precision) - 1);

   887                 float fcomp = ((float) comp) / ((float)mask);

   888                 return (int) (fcomp * scalefactor + 0.5f);

   889             }

   890             return comp;

   891         }

   892     }

   893 

   894     private int getRGBComponent(Object inData, int idx) {

   895         if (needScaleInit) {

   896             initScale();

   897         }

   898         if (is_sRGB_stdScale) {

   899             return extractComponent(inData, idx, 8);

   900         } else if (is_LinearRGB_stdScale) {

   901             int lutidx = extractComponent(inData, idx, 16);

   902             return tosRGB8LUT[lutidx] & 0xff;

   903         } else if (is_ICCGray_stdScale) {

   904             int lutidx = extractComponent(inData, 0, 16);

   905             return tosRGB8LUT[lutidx] & 0xff;

   906         }

   907 

   908         // Not CS_sRGB, CS_LINEAR_RGB, or any TYPE_GRAY ICC_ColorSpace

   909         float[] norm = getNormalizedComponents(inData, null, 0);

   910         // Note that getNormalizedComponents returns non-premultiplied values

   911         float[] rgb = colorSpace.toRGB(norm);

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

   913     }

   914 

   915     /**

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

   917      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion

   918      * is done if necessary.  The {@code pixel} value is specified by an array

   919      * of data elements of type {@code transferType} passed in as an object

   920      * reference. The returned value will be a non pre-multiplied value. If the

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

   922      * the value (if the alpha value is 0, the red value will be 0). Since

   923      * {@code ComponentColorModel} can be subclassed, subclasses

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

   925      * it then they throw an exception if they use an unsupported

   926      * {@code transferType}.

   927      *

   928      * @param inData The pixel from which you want to get the red color component,

   929      * specified by an array of data elements of type {@code transferType}.

   930      *

   931      * @return The red color component for the specified pixel, as an int.

   932      *

   933      * @throws ClassCastException If {@code inData} is not a primitive array

   934      * of type {@code transferType}.

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

   936      * large enough to hold a pixel value for this

   937      * {@code ColorModel}.

   938      * @throws UnsupportedOperationException If the transfer type of

   939      * this {@code ComponentColorModel}

   940      * is not one of the supported transfer types:

   941      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},

   942      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},

   943      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.

   944      */

   945     public int getRed(Object inData) {

   946         return getRGBComponent(inData, 0);

   947     }

   948 

   949 

   950     /**

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

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

   953      * A color conversion is done if necessary.  The {@code pixel} value

   954      * is specified by an array of data elements of type {@code transferType}

   955      * passed in as an object reference. The returned value is a non pre-multiplied

   956      * value. If the alpha is premultiplied, this method divides it out before

   957      * returning the value (if the alpha value is 0, the green value will be 0).

   958      * Since {@code ComponentColorModel} can be subclassed,

   959      * subclasses inherit the implementation of this method and if they

   960      * don't override it then they throw an exception if they use an

   961      * unsupported {@code transferType}.

   962      *

   963      * @param inData The pixel from which you want to get the green color component,

   964      * specified by an array of data elements of type {@code transferType}.

   965      *

   966      * @return The green color component for the specified pixel, as an int.

   967      *

   968      * @throws ClassCastException If {@code inData} is not a primitive array

   969      * of type {@code transferType}.

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

   971      * large enough to hold a pixel value for this

   972      * {@code ColorModel}.

   973      * @throws UnsupportedOperationException If the transfer type of

   974      * this {@code ComponentColorModel}

   975      * is not one of the supported transfer types:

   976      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},

   977      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},

   978      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.

   979      */

   980     public int getGreen(Object inData) {

   981         return getRGBComponent(inData, 1);

   982     }

   983 

   984 

   985     /**

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

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

   988      * A color conversion is done if necessary.  The {@code pixel} value is

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

   990      * passed in as an object reference. The returned value is a non pre-multiplied

   991      * value. If the alpha is premultiplied, this method divides it out before

   992      * returning the value (if the alpha value is 0, the blue value will be 0).

   993      * Since {@code ComponentColorModel} can be subclassed,

   994      * subclasses inherit the implementation of this method and if they

   995      * don't override it then they throw an exception if they use an

   996      * unsupported {@code transferType}.

   997      *

   998      * @param inData The pixel from which you want to get the blue color component,

   999      * specified by an array of data elements of type {@code transferType}.

  1000      *

  1001      * @return The blue color component for the specified pixel, as an int.

  1002      *

  1003      * @throws ClassCastException If {@code inData} is not a primitive array

  1004      * of type {@code transferType}.

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

  1006      * large enough to hold a pixel value for this

  1007      * {@code ColorModel}.

  1008      * @throws UnsupportedOperationException If the transfer type of

  1009      * this {@code ComponentColorModel}

  1010      * is not one of the supported transfer types:

  1011      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},

  1012      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},

  1013      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.

  1014      */

  1015     public int getBlue(Object inData) {

  1016         return getRGBComponent(inData, 2);

  1017     }

  1018 

  1019     /**

  1020      * Returns the alpha component for the specified pixel, scaled from

  1021      * 0 to 255.  The pixel value is specified by an array of data

  1022      * elements of type {@code transferType} passed in as an

  1023      * object reference.  Since {@code ComponentColorModel} can be

  1024      * subclassed, subclasses inherit the

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

  1026      * they throw an exception if they use an unsupported

  1027      * {@code transferType}.

  1028      *

  1029      * @param inData The pixel from which you want to get the alpha component,

  1030      * specified by an array of data elements of type {@code transferType}.

  1031      *

  1032      * @return The alpha component for the specified pixel, as an int.

  1033      *

  1034      * @throws ClassCastException If {@code inData} is not a primitive array

  1035      * of type {@code transferType}.

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

  1037      * large enough to hold a pixel value for this

  1038      * {@code ColorModel}.

  1039      * @throws UnsupportedOperationException If the transfer type of

  1040      * this {@code ComponentColorModel}

  1041      * is not one of the supported transfer types:

  1042      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},

  1043      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},

  1044      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.

  1045      */

  1046     public int getAlpha(Object inData) {

  1047         if (supportsAlpha == false) {

  1048             return 255;

  1049         }

  1050 

  1051         int alpha = 0;

  1052         int aIdx = numColorComponents;

  1053         int mask = (1 << nBits[aIdx]) - 1;

  1054 

  1055         switch (transferType) {

  1056             case DataBuffer.TYPE_SHORT:

  1057                 short sdata[] = (short[])inData;

  1058                 alpha = (int) ((sdata[aIdx] / 32767.0f) * 255.0f + 0.5f);

  1059                 return alpha;

  1060             case DataBuffer.TYPE_FLOAT:

  1061                 float fdata[] = (float[])inData;

  1062                 alpha = (int) (fdata[aIdx] * 255.0f + 0.5f);

  1063                 return alpha;

  1064             case DataBuffer.TYPE_DOUBLE:

  1065                 double ddata[] = (double[])inData;

  1066                 alpha = (int) (ddata[aIdx] * 255.0 + 0.5);

  1067                 return alpha;

  1068             case DataBuffer.TYPE_BYTE:

  1069                byte bdata[] = (byte[])inData;

  1070                alpha = bdata[aIdx] & mask;

  1071             break;

  1072             case DataBuffer.TYPE_USHORT:

  1073                short usdata[] = (short[])inData;

  1074                alpha = usdata[aIdx] & mask;

  1075             break;

  1076             case DataBuffer.TYPE_INT:

  1077                int idata[] = (int[])inData;

  1078                alpha = idata[aIdx];

  1079             break;

  1080             default:

  1081                throw new

  1082                    UnsupportedOperationException("This method has not "+

  1083                    "been implemented for transferType " + transferType);

  1084         }

  1085 

  1086         if (nBits[aIdx] == 8) {

  1087             return alpha;

  1088         } else {

  1089             return (int)

  1090                 ((((float) alpha) / ((float) ((1 << nBits[aIdx]) - 1))) *

  1091                  255.0f + 0.5f);

  1092         }

  1093     }

  1094 

  1095     /**

  1096      * Returns the color/alpha components for the specified pixel in the

  1097      * default RGB color model format.  A color conversion is done if

  1098      * necessary.  The pixel value is specified by an

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

  1100      * in as an object reference.

  1101      * The returned value is in a non pre-multiplied format. If

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

  1103      * color components (if the alpha value is 0, the color values will be 0).

  1104      * Since {@code ComponentColorModel} can be subclassed,

  1105      * subclasses inherit the implementation of this method and if they

  1106      * don't override it then they throw an exception if they use an

  1107      * unsupported {@code transferType}.

  1108      *

  1109      * @param inData The pixel from which you want to get the color/alpha components,

  1110      * specified by an array of data elements of type {@code transferType}.

  1111      *

  1112      * @return The color/alpha components for the specified pixel, as an int.

  1113      *

  1114      * @throws ClassCastException If {@code inData} is not a primitive array

  1115      * of type {@code transferType}.

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

  1117      * large enough to hold a pixel value for this

  1118      * {@code ColorModel}.

  1119      * @throws UnsupportedOperationException If the transfer type of

  1120      * this {@code ComponentColorModel}

  1121      * is not one of the supported transfer types:

  1122      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},

  1123      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},

  1124      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.

  1125      * @see ColorModel#getRGBdefault

  1126      */

  1127     public int getRGB(Object inData) {

  1128         if (needScaleInit) {

  1129             initScale();

  1130         }

  1131         if (is_sRGB_stdScale || is_LinearRGB_stdScale) {

  1132             return (getAlpha(inData) << 24)

  1133                 | (getRed(inData) << 16)

  1134                 | (getGreen(inData) << 8)