private int rgb[];

private int map_size;

private int pixel_mask;

private int transparent_index = -1;

private boolean allgrayopaque;

private BigInteger validBits;

private sun.awt.image.BufImgSurfaceData.ICMColorData colorData = null;

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

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

static private native void initIDs();

static {

ColorModel.loadLibraries();

initIDs();

}

/**

public IndexColorModel(int bits, int size,

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

super(bits, opaqueBits,

ColorSpace.getInstance(ColorSpace.CS_sRGB),

false, false, OPAQUE,

ColorModel.getDefaultTransferType(bits));

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

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

+" 1 and 16.");

}

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

calculatePixelMask();

}

/**

public IndexColorModel(int bits, int size,

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

super(bits, opaqueBits,

ColorSpace.getInstance(ColorSpace.CS_sRGB),

false, false, OPAQUE,

ColorModel.getDefaultTransferType(bits));

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

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

+" 1 and 16.");

}

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

setTransparentPixel(trans);

calculatePixelMask();

}

/**

public IndexColorModel(int bits, int size,

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

super (bits, alphaBits,

ColorSpace.getInstance(ColorSpace.CS_sRGB),

true, false, TRANSLUCENT,

ColorModel.getDefaultTransferType(bits));

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

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

+" 1 and 16.");

}

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

calculatePixelMask();

}

/**

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

boolean hasalpha) {

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

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

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

+" 1 and 16.");

}

}

/**

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

boolean hasalpha, int trans) {

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

super(bits, opaqueBits,

ColorSpace.getInstance(ColorSpace.CS_sRGB),

false, false, OPAQUE,

ColorModel.getDefaultTransferType(bits));

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

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

+" 1 and 16.");

}

if (size < 1) {

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

") must be >= 1");

}

map_size = size;

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

int j = start;

int alpha = 0xff;

boolean allgray = true;

int transparency = OPAQUE;

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

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

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

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

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

if (hasalpha) {

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

if (alpha != 0xff) {

if (alpha == 0x00) {

if (transparency == OPAQUE) {

transparency = BITMASK;

}

if (transparent_index < 0) {

transparent_index = i;

}

} else {

transparency = TRANSLUCENT;

}

allgray = false;

}

}

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

}

this.allgrayopaque = allgray;

setTransparency(transparency);

setTransparentPixel(trans);

calculatePixelMask();

}

/**

public IndexColorModel(int bits, int size,

int cmap[], int start,

boolean hasalpha, int trans, int transferType) {

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

super(bits, opaqueBits,

ColorSpace.getInstance(ColorSpace.CS_sRGB),

false, false, OPAQUE,

transferType);

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

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

+" 1 and 16.");

}

if (size < 1) {

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

") must be >= 1");

}

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

(transferType != DataBuffer.TYPE_USHORT)) {

throw new IllegalArgumentException("transferType must be either" +

"DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT");

}

setRGBs(size, cmap, start, hasalpha);

setTransparentPixel(trans);

calculatePixelMask();

}

/**

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

int transferType, BigInteger validBits) {

super (bits, alphaBits,

ColorSpace.getInstance(ColorSpace.CS_sRGB),

true, false, TRANSLUCENT,

transferType);

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

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

+" 1 and 16.");

}

if (size < 1) {

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

") must be >= 1");

}

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

(transferType != DataBuffer.TYPE_USHORT)) {

throw new IllegalArgumentException("transferType must be either" +

"DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT");

}

if (validBits != null) {

// Check to see if it is all valid

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

if (!validBits.testBit(i)) {

this.validBits = validBits;

break;

}

}

}

setRGBs(size, cmap, start, true);

calculatePixelMask();

}

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

if (size < 1) {

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

") must be >= 1");

}

map_size = size;

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

int alpha = 0xff;

int transparency = OPAQUE;

boolean allgray = true;

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

int rc = r[i] & 0xff;

int gc = g[i] & 0xff;

int bc = b[i] & 0xff;

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

if (a != null) {

alpha = a[i] & 0xff;

if (alpha != 0xff) {

if (alpha == 0x00) {

if (transparency == OPAQUE) {

transparency = BITMASK;

}

if (transparent_index < 0) {

transparent_index = i;

}

} else {

transparency = TRANSLUCENT;

}

allgray = false;

}

}

rgb[i] = (alpha << 24) | (rc << 16) | (gc << 8) | bc;

}

this.allgrayopaque = allgray;

setTransparency(transparency);

}

private void setRGBs(int size, int cmap[], int start, boolean hasalpha) {

map_size = size;

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

int j = start;

int transparency = OPAQUE;

boolean allgray = true;

BigInteger validBits = this.validBits;

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

if (validBits != null && !validBits.testBit(i)) {

continue;

}

int cmaprgb = cmap[j];

int r = (cmaprgb >> 16) & 0xff;

int g = (cmaprgb >> 8) & 0xff;

int b = (cmaprgb ) & 0xff;

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

if (hasalpha) {

int alpha = cmaprgb >>> 24;

if (alpha != 0xff) {

if (alpha == 0x00) {

if (transparency == OPAQUE) {

transparency = BITMASK;

}

if (transparent_index < 0) {

transparent_index = i;

}

} else {

transparency = TRANSLUCENT;

}

allgray = false;

}

} else {

cmaprgb |= 0xff000000;

}

rgb[i] = cmaprgb;

}

this.allgrayopaque = allgray;

setTransparency(transparency);

}

private int calcRealMapSize(int bits, int size) {

int newSize = Math.max(1 << bits, size);

return Math.max(newSize, 256);

}

private BigInteger getAllValid() {

int numbytes = (map_size+7)/8;

byte[] valid = new byte[numbytes];

java.util.Arrays.fill(valid, (byte)0xff);

valid[0] = (byte)(0xff >>> (numbytes*8 - map_size));

return new BigInteger(1, valid);

}

/**

public int getTransparency() {

return transparency;

}

/**

public int[] getComponentSize() {

if (nBits == null) {

if (supportsAlpha) {

nBits = new int[4];

nBits[3] = 8;

}

else {

nBits = new int[3];

}

nBits[0] = nBits[1] = nBits[2] = 8;

}

return nBits.clone();

}

/**

final public int getMapSize() {

return map_size;

}

/**

final public int getTransparentPixel() {

return transparent_index;

}

/**

final public void getReds(byte r[]) {

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

r[i] = (byte) (rgb[i] >> 16);

}

}

/**

final public void getGreens(byte g[]) {

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

g[i] = (byte) (rgb[i] >> 8);

}

}

/**

final public void getBlues(byte b[]) {

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

b[i] = (byte) rgb[i];

}

}

/**

final public void getAlphas(byte a[]) {

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

a[i] = (byte) (rgb[i] >> 24);

}

}

/**

final public void getRGBs(int rgb[]) {

System.arraycopy(this.rgb, 0, rgb, 0, map_size);

}

private void setTransparentPixel(int trans) {

if (trans >= 0 && trans < map_size) {

rgb[trans] &= 0x00ffffff;

transparent_index = trans;

allgrayopaque = false;

if (this.transparency == OPAQUE) {

setTransparency(BITMASK);

}

}

}

private void setTransparency(int transparency) {

if (this.transparency != transparency) {

this.transparency = transparency;

if (transparency == OPAQUE) {

supportsAlpha = false;

numComponents = 3;

nBits = opaqueBits;

} else {

supportsAlpha = true;

numComponents = 4;

nBits = alphaBits;

}

}

}

/**

private final void calculatePixelMask() {

// Note that we adjust the mask so that our masking behavior here

// is consistent with that of our native rendering loops.

int maskbits = pixel_bits;

if (maskbits == 3) {

maskbits = 4;

} else if (maskbits > 4 && maskbits < 8) {

maskbits = 8;

}

pixel_mask = (1 << maskbits) - 1;

}

/**

final public int getRed(int pixel) {

return (rgb[pixel & pixel_mask] >> 16) & 0xff;

}

/**

final public int getGreen(int pixel) {

return (rgb[pixel & pixel_mask] >> 8) & 0xff;

}

/**

final public int getBlue(int pixel) {

return rgb[pixel & pixel_mask] & 0xff;

}

/**

final public int getAlpha(int pixel) {

return (rgb[pixel & pixel_mask] >> 24) & 0xff;

}

/**

final public int getRGB(int pixel) {

return rgb[pixel & pixel_mask];

}

private static final int CACHESIZE = 40;

private int lookupcache[] = new int[CACHESIZE];

/**

public synchronized Object getDataElements(int rgb, Object pixel) {

int red = (rgb>>16) & 0xff;

int green = (rgb>>8) & 0xff;

int blue = rgb & 0xff;

int alpha = (rgb>>>24);

int pix = 0;

// Note that pixels are stored at lookupcache[2*i]

// and the rgb that was searched is stored at

// lookupcache[2*i+1]. Also, the pixel is first

// inverted using the unary complement operator

// before storing in the cache so it can never be 0.

for (int i = CACHESIZE - 2; i >= 0; i -= 2) {

if ((pix = lookupcache[i]) == 0) {

break;

}

if (rgb == lookupcache[i+1]) {

return installpixel(pixel, ~pix);

}

}

if (allgrayopaque) {

// IndexColorModel objects are all tagged as

// non-premultiplied so ignore the alpha value

// of the incoming color, convert the

// non-premultiplied color components to a

// grayscale value and search for the closest

// gray value in the palette. Since all colors

// in the palette are gray, we only need compare

// to one of the color components for a match

// using a simple linear distance formula.

int minDist = 256;

int d;

int gray = (int) (red*77 + green*150 + blue*29 + 128)/256;

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

if (this.rgb[i] == 0x0) {

// For allgrayopaque colormaps, entries are 0

// iff they are an invalid color and should be

// ignored during color searches.

continue;

}

d = (this.rgb[i] & 0xff) - gray;

if (d < 0) d = -d;

if (d < minDist) {

pix = i;

if (d == 0) {

break;

}

minDist = d;

}

}

} else if (transparency == OPAQUE) {

// IndexColorModel objects are all tagged as

// non-premultiplied so ignore the alpha value

// of the incoming color and search for closest

// color match independently using a 3 component

// Euclidean distance formula.

// For opaque colormaps, palette entries are 0

// iff they are an invalid color and should be

// ignored during color searches.

// As an optimization, exact color searches are

// likely to be fairly common in opaque colormaps

// so first we will do a quick search for an

// exact match.

int smallestError = Integer.MAX_VALUE;

int lut[] = this.rgb;

int lutrgb;

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

lutrgb = lut[i];

if (lutrgb == rgb && lutrgb != 0) {

pix = i;

smallestError = 0;

break;

}

}

if (smallestError != 0) {

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

lutrgb = lut[i];

if (lutrgb == 0) {

continue;

}

int tmp = ((lutrgb >> 16) & 0xff) - red;

int currentError = tmp*tmp;

if (currentError < smallestError) {

tmp = ((lutrgb >> 8) & 0xff) - green;

currentError += tmp * tmp;

if (currentError < smallestError) {

tmp = (lutrgb & 0xff) - blue;

currentError += tmp * tmp;

if (currentError < smallestError) {

pix = i;

smallestError = currentError;

}

}

}

}

}

} else if (alpha == 0 && transparent_index >= 0) {

// Special case - transparent color maps to the

// specified transparent pixel, if there is one

pix = transparent_index;

} else {

// IndexColorModel objects are all tagged as

// non-premultiplied so use non-premultiplied

// color components in the distance calculations.

// Look for closest match using a 4 component

// Euclidean distance formula.

int smallestError = Integer.MAX_VALUE;

int lut[] = this.rgb;

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

int lutrgb = lut[i];

if (lutrgb == rgb) {

if (validBits != null && !validBits.testBit(i)) {

continue;

}

pix = i;