/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Igor V. Stolyarov
*/
package com.google.code.appengine.awt.image;
import org.apache.harmony.awt.gl.color.LUTColorConverter;
import org.apache.harmony.awt.internal.nls.Messages;
import com.google.code.appengine.awt.color.ColorSpace;
import com.google.code.appengine.awt.image.ColorModel;
import com.google.code.appengine.awt.image.ComponentColorModel;
import com.google.code.appengine.awt.image.ComponentSampleModel;
import com.google.code.appengine.awt.image.DataBuffer;
import com.google.code.appengine.awt.image.PixelInterleavedSampleModel;
import com.google.code.appengine.awt.image.Raster;
import com.google.code.appengine.awt.image.SampleModel;
import com.google.code.appengine.awt.image.WritableRaster;
public class ComponentColorModel extends ColorModel {
private boolean signed; // Pixel samples are signed.
// Samples with TransferType DataBuffer.TYPE_BYTE,
// DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT -
// unsigned. Samples with others TransferType -
// signed.
private boolean integral; // Pixel samples are integral.
// Samples with TransferType DataBuffer.TYPE_BYTE,
// DataBuffer.TYPE_USHORT, DataBuffer.Short and
// DataBuffer.TYPE_INT - integral.
private float scaleFactors[]; // Array of factors for reduction components
// values into the form scaled from 0 to 255
private boolean donotSupportUnnormalized; // This Color Model don't support
// unnormolized form
private boolean needAlphaDivide; // hasAlpha && isAlphaPremultiplied
private boolean calcValue; // Value was culculated
private boolean needScale; // Normalized value need to scale
private float minVals[]; // Array of Min normalized values
private float ranges[]; // Array of range normalized values
private byte alphaLUT[]; // Lookup table for scale alpha value
private byte colorLUTs[][]; // Lookup tables for scale color values
private byte from_LINEAR_RGB_LUT[]; // Lookup table for conversion from
// Linear RGB Color Space into sRGB
private byte to_LINEAR_8RGB_LUT[]; // Lookup table for conversion from
// sRGB Color Space into Linear RGB
// 8 bit
private short to_LINEAR_16RGB_LUT[]; // Lookup table for conversion from
// sRGB Color Space into Linear RGB
// 16 bit
private int LINEAR_RGB_Length; // Linear RGB bit length
private float fFactor; // Scale factor
private boolean is_sRGB; // ColorModel has sRGB ColorSpace
private boolean is_LINEAR_RGB; // Color Model has Linear RGB Color
// Space
public ComponentColorModel(ColorSpace colorSpace, int bits[],
boolean hasAlpha, boolean isAlphaPremultiplied, int transparency,
int transferType) {
super(createPixelBits(colorSpace, hasAlpha, transferType),
validateBits(bits, colorSpace, hasAlpha, transferType),
colorSpace, hasAlpha, isAlphaPremultiplied, transparency,
transferType);
needScale = false;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
case DataBuffer.TYPE_USHORT:
case DataBuffer.TYPE_INT:
signed = false;
integral = true;
donotSupportUnnormalized = false;
scaleFactors = new float[numComponents];
for (int i = 0; i < numColorComponents; i++) {
scaleFactors[i] = 1.0f / maxValues[i];
if (cs.getMinValue(i) != 0.0f || cs.getMaxValue(i) != 1.0f) {
donotSupportUnnormalized = true;
}
}
if (hasAlpha) {
maxValues[numColorComponents] =
(1 << bits[numColorComponents]) - 1;
scaleFactors[numColorComponents] =
1.0f / maxValues[numColorComponents];
}
break;
case DataBuffer.TYPE_SHORT:
signed = true;
integral = true;
donotSupportUnnormalized = true;
scaleFactors = new float[numComponents];
for (int i = 0; i < numComponents; i++) {
maxValues[i] = Short.MAX_VALUE;
scaleFactors[i] = 1.0f / maxValues[i];
if (cs.getMinValue(i) != 0.0f || cs.getMaxValue(i) != 1.0f) {
needScale = true;
}
}
if (needScale) {
minVals = new float[numColorComponents];
ranges = new float[numColorComponents];
for (int i = 0; i < numColorComponents; i++) {
minVals[i] = cs.getMinValue(i);
ranges[i] = cs.getMaxValue(i) - minVals[i];
}
}
break;
case DataBuffer.TYPE_FLOAT:
case DataBuffer.TYPE_DOUBLE:
signed = true;
integral = false;
donotSupportUnnormalized = true;
break;
default:
// awt.215=transferType is not one of DataBuffer.TYPE_BYTE,
// DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT,
// DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT, or
// DataBuffer.TYPE_DOUBLE
throw new IllegalArgumentException(Messages.getString("awt.215")); //$NON-NLS-1$
}
needAlphaDivide = hasAlpha && isAlphaPremultiplied;
initLUTs();
}
public ComponentColorModel(ColorSpace colorSpace, boolean hasAlpha,
boolean isAlphaPremultiplied, int transparency, int transferType) {
this(colorSpace,
createPixelBitsArray(colorSpace, hasAlpha, transferType),
hasAlpha,
isAlphaPremultiplied,
transparency,
transferType);
}
private static int[] validateBits(int bits[], ColorSpace colorSpace,
boolean hasAlpha, int transferType) {
if (bits != null) {
return bits;
}
int numComponents = colorSpace.getNumComponents();
if (hasAlpha) {
numComponents++;
}
bits = new int[numComponents];
int componentLength = DataBuffer.getDataTypeSize(transferType);
for (int i = 0; i < numComponents; i++) {
bits[i] = componentLength;
}
return bits;
}
private static int createPixelBits(ColorSpace colorSpace, boolean hasAlpha,
int transferType) {
int numComponents = colorSpace.getNumComponents();
if (hasAlpha) {
numComponents++;
}
int componentLength = DataBuffer.getDataTypeSize(transferType);
return numComponents * componentLength;
}
private static int[] createPixelBitsArray(ColorSpace colorSpace,
boolean hasAlpha, int transferType) {
int numComponents = colorSpace.getNumComponents();
if (hasAlpha) {
numComponents++;
}
int bits[] = new int[numComponents];
for(int i = 0; i < numComponents; i++){
bits[i] = DataBuffer.getDataTypeSize(transferType);
}
return bits;
}
@Override
public Object getDataElements(int components[], int offset, Object obj) {
if (donotSupportUnnormalized) {
// awt.213=This ComponentColorModel does not support the unnormalized form
throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
}
if (offset + numComponents > components.length) {
// awt.216=The components array is not large enough to hold all the color and alpha components
throw new IllegalArgumentException(Messages.getString("awt.216")); //$NON-NLS-1$
}
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte ba[];
if (obj == null) {
ba = new byte[numComponents];
} else {
ba = (byte[]) obj;
}
for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
ba[i] = (byte) components[idx];
}
return ba;
case DataBuffer.TYPE_USHORT:
short sa[];
if (obj == null) {
sa = new short[numComponents];
} else {
sa = (short[]) obj;
}
for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
sa[i] = (short) components[idx];
}
return sa;
case DataBuffer.TYPE_INT:
int ia[];
if (obj == null) {
ia = new int[numComponents];
} else {
ia = (int[]) obj;
}
for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
ia[i] = components[idx];
}
return ia;
default:
// awt.217=The transfer type of this ComponentColorModel is not one
// of the following transfer types: DataBuffer.TYPE_BYTE,
// DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT
throw new UnsupportedOperationException(Messages
.getString("awt.217")); //$NON-NLS-1$
}
}
@Override
public Object getDataElements(float normComponents[], int normOffset,
Object obj) {
if (needScale) {
for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
normComponents[idx] =
(normComponents[idx] - minVals[i]) / ranges[i];
}
}
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte ba[];
if (obj == null) {
ba = new byte[numComponents];
} else {
ba = (byte[]) obj;
}
if (needAlphaDivide) {
float alpha = normComponents[normOffset + numColorComponents];
for (int i = 0, idx = normOffset; i < numColorComponents;
i++, idx++) {
ba[i] = (byte) (normComponents[idx] * alpha *
maxValues[i] + 0.5f);
}
ba[numColorComponents] =
(byte) (normComponents[normOffset + numColorComponents] *
maxValues[numColorComponents] + 0.5f);
} else {
for (int i = 0, idx = normOffset; i < numComponents;
i++, idx++) {
ba[idx] =
(byte) (normComponents[idx] * maxValues[i] + 0.5f);
}
}
return ba;
case DataBuffer.TYPE_USHORT:
short usa[];
if (obj == null) {
usa = new short[numComponents];
} else {
usa = (short[]) obj;
}
if (needAlphaDivide) {
float alpha = normComponents[normOffset + numColorComponents];
for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
usa[i] = (short) (normComponents[idx] * alpha *
maxValues[i] + 0.5f);
}
usa[numColorComponents] = (short) (alpha *
maxValues[numColorComponents] + 0.5f);
} else {
for (int i = 0, idx = normOffset; i < numComponents;
i++, idx++) {
usa[i] = (short) (normComponents[idx] *
maxValues[i] + 0.5f);
}
}
return usa;
case DataBuffer.TYPE_INT:
int ia[];
if (obj == null) {
ia = new int[numComponents];
} else {
ia = (int[]) obj;
}
if (needAlphaDivide) {
float alpha = normComponents[normOffset + numColorComponents];
for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
ia[i] = (int) (normComponents[idx] * alpha *
maxValues[i] + 0.5f);
}
ia[numColorComponents] = (int) (alpha *
maxValues[numColorComponents] + 0.5f);
} else {
for (int i = 0, idx = normOffset; i < numComponents;
i++, idx++) {
ia[i] = (int) (normComponents[idx] * maxValues[i] + 0.5f);
}
}
return ia;
case DataBuffer.TYPE_SHORT:
short sa[];
if (obj == null) {
sa = new short[numComponents];
} else {
sa = (short[]) obj;
}
if (needAlphaDivide) {
float alpha = normComponents[normOffset + numColorComponents];
for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
sa[i] = (short) (normComponents[idx] * alpha *
maxValues[i] + 0.5f);
}
sa[numColorComponents] = (short) (alpha *
maxValues[numColorComponents] + 0.5f);
} else {
for (int i = 0, idx = normOffset; i < numComponents;
i++, idx++) {
sa[i] = (short) (normComponents[idx] *
maxValues[i] + 0.5f);
}
}
return sa;
case DataBuffer.TYPE_FLOAT:
float fa[];
if (obj == null) {
fa = new float[numComponents];
} else {
fa = (float[]) obj;
}
if (needAlphaDivide) {
float alpha = normComponents[normOffset + numColorComponents];
for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
fa[i] = normComponents[idx] * alpha;
}
fa[numColorComponents] = alpha;
} else {
for (int i = 0, idx = normOffset; i < numComponents;
i++, idx++) {
fa[i] = normComponents[idx];
}
}
return fa;
case DataBuffer.TYPE_DOUBLE:
double da[];
if (obj == null) {
da = new double[numComponents];
} else {
da = (double[]) obj;
}
if (needAlphaDivide) {
double alpha = normComponents[normOffset + numColorComponents];
for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
da[i] = normComponents[idx] * alpha;
}
da[numColorComponents] = alpha;
} else {
for (int i = 0, idx = normOffset; i < numComponents;
i++, idx++) {
da[i] = normComponents[idx];
}
}
return da;
default:
// awt.213=This ComponentColorModel does not support the unnormalized form
throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
}
}
@Override
public Object getDataElements(int rgb, Object pixel) {
float normComp[];
float comp[];
int red = (rgb >> 16) & 0xff;
int green = (rgb >> 8) & 0xff;
int blue = rgb & 0xff;
int alpha = (rgb >> 24) & 0xff;
comp = new float[3];
if (is_sRGB || is_LINEAR_RGB) {
if (is_LINEAR_RGB) {
if (LINEAR_RGB_Length == 8) {
red = to_LINEAR_8RGB_LUT[red] & 0xff;
green = to_LINEAR_8RGB_LUT[green] & 0xff;
blue = to_LINEAR_8RGB_LUT[blue] & 0xff;
} else {
red = to_LINEAR_16RGB_LUT[red] & 0xffff;
green = to_LINEAR_16RGB_LUT[green] & 0xffff;
blue = to_LINEAR_16RGB_LUT[blue] & 0xffff;
}
}
comp[0] = red / fFactor;
comp[1] = green / fFactor;
comp[2] = blue / fFactor;
if (!hasAlpha) {
normComp = comp;
} else {
float normAlpha = alpha / 255.0f;
normComp = new float[numComponents];
for (int i = 0; i < numColorComponents; i++) {
normComp[i] = comp[i];
}
normComp[numColorComponents] = normAlpha;
}
} else {
comp[0] = red / fFactor;
comp[1] = green / fFactor;
comp[2] = blue / fFactor;
float[] defComp = cs.fromRGB(comp);
if (!hasAlpha) {
normComp = defComp;
} else {
float normAlpha = alpha / 255.0f;
normComp = new float[numComponents];
for (int i = 0; i < numColorComponents; i++) {
normComp[i] = defComp[i];
}
normComp[numColorComponents] = normAlpha;
}
}
if(hasAlpha && isAlphaPremultiplied){
normComp[0] *= normComp[numColorComponents];
normComp[1] *= normComp[numColorComponents];
normComp[2] *= normComp[numColorComponents];
}
return getDataElements(normComp, 0, pixel);
}
@Override
public WritableRaster getAlphaRaster(WritableRaster raster) {
if(!hasAlpha) {
return null;
}
int x = raster.getMinX();
int y = raster.getMinY();
int bandList[] = new int[1];
bandList[0] = raster.getNumBands() - 1;
return raster.createWritableChild(x, y, raster.getWidth(),
raster.getHeight(), x, y, bandList);
}
@Override
public ColorModel coerceData(WritableRaster raster,
boolean isAlphaPremultiplied) {
if (!hasAlpha || this.isAlphaPremultiplied == isAlphaPremultiplied) {
return this;
}
int minX = raster.getMinX();
int minY = raster.getMinY();
int w = raster.getWidth();
int h = raster.getHeight();
if (isAlphaPremultiplied) {
switch (transferType) {
case DataBuffer.TYPE_BYTE:
case DataBuffer.TYPE_USHORT:
case DataBuffer.TYPE_INT:
float alphaFactor = maxValues[numColorComponents];
int iComponents[] = null;
int iTransparentComponents[] = new int[numComponents];
for (int i = 0; i < h; i++, minY++) {
for (int j = 0, x = minX; j < w; j++, x++) {
iComponents = raster.getPixel(x, minY,
iComponents);
if (iComponents[numColorComponents] == 0) {
raster.setPixel(x, minY, iTransparentComponents);
} else {
float alpha =
iComponents[numColorComponents] /
alphaFactor;
for (int n = 0; n < numColorComponents; n++) {
iComponents[n] =
(int) (alpha * iComponents[n] + 0.5f);
}
raster.setPixel(x, minY, iComponents);
}
}
}
break;
case DataBuffer.TYPE_SHORT:
float sAlphaFactor = maxValues[numColorComponents];
short sComponents[] = null;
short sTransparentComponents[] = new short[numComponents];
for (int i = 0; i < h; i++, minY++) {
for (int j = 0, x = minX; j < w; j++, x++) {
sComponents = (short[]) raster.getDataElements(x, minY,
sComponents);
if (sComponents[numColorComponents] == 0) {
raster.setDataElements(x, minY,
sTransparentComponents);
} else {
float alpha =
sComponents[numColorComponents] /
sAlphaFactor;
for (int n = 0; n < numColorComponents; n++) {
sComponents[n] =
(byte) (alpha * sComponents[n] + 0.5f);
}
raster.setDataElements(x, minY, sComponents);
}
}
}
break;
case DataBuffer.TYPE_FLOAT:
float fComponents[] = null;
float fTransparentComponents[] = new float[numComponents];
for (int i = 0; i < h; i++, minY++) {
for (int j = 0, x = minX; j < w; j++, x++) {
fComponents = raster.getPixel(x, minY, fComponents);
if (fComponents[numColorComponents] == 0.0f) {
raster.setDataElements(x, minY,
fTransparentComponents);
} else {
float alpha = fComponents[numColorComponents];
for (int n = 0; n < numColorComponents; n++) {
fComponents[n] = fComponents[n] * alpha;
}
raster.setPixel(x, minY, fComponents);
}
}
}
break;
case DataBuffer.TYPE_DOUBLE:
double dComponents[] = null;
double dTransparentComponents[] = new double[numComponents];
for (int i = 0; i < h; i++, minY++) {
for (int j = 0, x = minX; j < w; j++, x++) {
dComponents = raster.getPixel(x, minY, dComponents);
if (dComponents[numColorComponents] == 0.0) {
raster.setPixel(x, minY, dTransparentComponents);
} else {
double alpha = dComponents[numColorComponents];
for (int n = 0; n < numColorComponents; n++) {
dComponents[n] = dComponents[n] * alpha;
}
raster.setPixel(x, minY, dComponents);
}
}
}
break;
default:
// awt.219=This transferType is not supported by this color model
throw new UnsupportedOperationException(Messages.getString("awt.219")); //$NON-NLS-1$
}
} else {
switch (transferType) {
case DataBuffer.TYPE_BYTE:
case DataBuffer.TYPE_USHORT:
case DataBuffer.TYPE_INT:
float alphaFactor = maxValues[numColorComponents];
int iComponents[] = null;
int iTransparentComponents[] = new int[numComponents];
for (int i = 0; i < h; i++, minY++) {
for (int j = 0, x = minX; j < w; j++, x++) {
iComponents = raster.getPixel(x, minY,
iComponents);
if (iComponents[numColorComponents] == 0) {
raster.setPixel(x, minY, iTransparentComponents);
} else {
float alpha =
iComponents[numColorComponents] /
alphaFactor;
for (int n = 0; n < numColorComponents; n++) {
iComponents[n] =
(int) (iComponents[n] /
alpha + 0.5f);
}
raster.setPixel(x, minY, iComponents);
}
}
}
break;
case DataBuffer.TYPE_SHORT:
float sAlphaFactor = maxValues[numColorComponents];
short sComponents[] = null;
short sTransparentComponents[] = new short[numComponents];
for (int i = 0; i < h; i++, minY++) {
for (int j = 0, x = minX; j < w; j++, x++) {
sComponents = (short[]) raster.getDataElements(x, minY,
sComponents);
if (sComponents[numColorComponents] == 0) {
raster.setDataElements(x, minY,
sTransparentComponents);
} else {
float alpha =
sComponents[numColorComponents] /
sAlphaFactor;
for (int n = 0; n < numColorComponents; n++) {
sComponents[n] =
(byte) (sComponents[n] /
alpha + 0.5f);
}
raster.setDataElements(x, minY, sComponents);
}
}
}
break;
case DataBuffer.TYPE_FLOAT:
float fComponents[] = null;
float fTransparentComponents[] = new float[numComponents];
for (int i = 0; i < h; i++, minY++) {
for (int j = 0, x = minX; j < w; j++, x++) {
fComponents = raster.getPixel(x, minY, fComponents);
if (fComponents[numColorComponents] == 0.0f) {
raster.setDataElements(x, minY,
fTransparentComponents);
} else {
float alpha = fComponents[numColorComponents];
for (int n = 0; n < numColorComponents; n++) {
fComponents[n] = fComponents[n] / alpha;
}
raster.setPixel(x, minY, fComponents);
}
}
}
break;
case DataBuffer.TYPE_DOUBLE:
double dComponents[] = null;
double dTransparentComponents[] = new double[numComponents];
for (int i = 0; i < h; i++, minY++) {
for (int j = 0, x = minX; j < w; j++, x++) {
dComponents = raster.getPixel(x, minY, dComponents);
if (dComponents[numColorComponents] == 0.0) {
raster.setPixel(x, minY, dTransparentComponents);
} else {
double alpha = dComponents[numColorComponents];
for (int n = 0; n < numColorComponents; n++) {
dComponents[n] = dComponents[n] / alpha;
}
raster.setPixel(x, minY, dComponents);
}
}
}
break;
default:
// awt.219=This transferType is not supported by this color model
throw new UnsupportedOperationException(Messages.getString("awt.219")); //$NON-NLS-1$
}
}
if (!signed) {
return new ComponentColorModel(cs, bits, hasAlpha,
isAlphaPremultiplied, transparency, transferType);
}
return new ComponentColorModel(cs, null, hasAlpha,
isAlphaPremultiplied, transparency, transferType);
}
@Override
public int[] getComponents(Object pixel, int[] components, int offset) {
if (donotSupportUnnormalized) {
// awt.213=This ComponentColorModel does not support the unnormalized form
throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
}
if (components == null) {
components = new int[offset + numComponents];
} else if (offset + numComponents > components.length) {
// awt.218=The components array is not large enough to hold all the color and alpha components
throw new IllegalArgumentException(Messages.getString("awt.218")); //$NON-NLS-1$
}
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte ba[] = (byte[]) pixel;
for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
components[idx] = ba[i] & 0xff;
}
return components;
case DataBuffer.TYPE_USHORT:
short sa[] = (short[]) pixel;
for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
components[idx] = sa[i] & 0xffff;
}
return components;
case DataBuffer.TYPE_INT:
int ia[] = (int[]) pixel;
for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
components[idx] = ia[i];
}
return components;
default:
// awt.217=The transfer type of this ComponentColorModel is not one
// of the following transfer types: DataBuffer.TYPE_BYTE,
// DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT
throw new UnsupportedOperationException(Messages
.getString("awt.217")); //$NON-NLS-1$
}
}
@Override
public float[] getNormalizedComponents(Object pixel,
float normComponents[], int normOffset) {
if (normComponents == null) {
normComponents = new float[numComponents + normOffset];
}
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte ba[] = (byte[]) pixel;
for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
normComponents[idx] = (ba[i] & 0xff) * scaleFactors[i];
}
break;
case DataBuffer.TYPE_USHORT:
short usa[] = (short[]) pixel;
for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
normComponents[idx] = (usa[i] & 0xffff)
* scaleFactors[i];
}
break;
case DataBuffer.TYPE_INT:
int ia[] = (int[]) pixel;
for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
normComponents[idx] = ia[i] * scaleFactors[i];
}
break;
case DataBuffer.TYPE_SHORT:
short sa[] = (short[]) pixel;
for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
normComponents[idx] = sa[i] * scaleFactors[i];
}
break;
case DataBuffer.TYPE_FLOAT:
float fa[] = (float[]) pixel;
for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
normComponents[idx] = fa[i];
}
break;
case DataBuffer.TYPE_DOUBLE:
double da[] = (double[]) pixel;
for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
normComponents[idx] = (float) da[i];
}
break;
default:
// awt.21A=This ComponentColorModel does not support this transferType
throw new IllegalArgumentException(Messages.getString("awt.21A")); //$NON-NLS-1$
}
if (needAlphaDivide) {
float alpha = normComponents[normOffset + numColorComponents];
for (int i = 0, idx = normOffset; i < numColorComponents;
i++, idx++) {
normComponents[idx] /= alpha;
}
}
if (needScale) {
for (int i = 0, idx = normOffset; i < numColorComponents;
i++, idx++) {
normComponents[idx] = minVals[i] +
ranges[i] * normComponents[idx];
}
}
return normComponents;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof ComponentColorModel)) {
return false;
}
return super.equals(obj);
}
@Override
public int getRed(Object inData) {
return getRGBComponent(inData, 0);
}
@Override
public int getRGB(Object inData) {
int alpha = getAlpha(inData);
if (cs.getType() == ColorSpace.TYPE_GRAY) {
int gray = getRed(inData);
return (alpha << 24 | gray << 16 | gray << 8 | gray);
}
return (alpha << 24 | getRed(inData) << 16 | getGreen(inData) << 8 |
getBlue(inData));
}
@Override
public int getGreen(Object inData) {
return getRGBComponent(inData, 1);
}
@Override
public int getBlue(Object inData) {
return getRGBComponent(inData, 2);
}
@Override
public int getAlpha(Object inData) {
if (!hasAlpha) {
return 255;
}
int alpha = 0;
switch (transferType) {
case DataBuffer.TYPE_BYTE: {
byte ba[] = (byte[]) inData;
alpha = ba[numColorComponents] & 0xff;
if (bits[numColorComponents] != 8) {
return alphaLUT[alpha] & 0xff;
}
return alpha;
}
case DataBuffer.TYPE_USHORT: {
short usa[] = (short[]) inData;
alpha = usa[numColorComponents] & 0xffff;
if (bits[numColorComponents] != 8) {
return alphaLUT[alpha] & 0xff;
}
return alpha;
}
case DataBuffer.TYPE_INT: {
int ia[] = (int[]) inData;
alpha = ia[numColorComponents];
if (bits[numColorComponents] != 8) {
return alphaLUT[alpha] & 0xff;
}
return alpha;
}
case DataBuffer.TYPE_SHORT: {
short sa[] = (short[]) inData;
alpha = sa[numColorComponents];
if (bits[numColorComponents] != 8) {
return alphaLUT[alpha] & 0xff;
}
return alpha;
}
case DataBuffer.TYPE_FLOAT: {
float fa[] = (float[]) inData;
return (int) (fa[numColorComponents] * 255.0f + 0.5f);
}
case DataBuffer.TYPE_DOUBLE: {
double da[] = (double[]) inData;
return (int) (da[numColorComponents] * 255.0 + 0.5);
}
default: {
// awt.214=This Color Model doesn't support this transferType
throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
}
}
}
@Override
public WritableRaster createCompatibleWritableRaster(int w, int h) {
SampleModel sm = createCompatibleSampleModel(w, h);
DataBuffer db = sm.createDataBuffer();
return Raster.createWritableRaster(sm, db, null);
}
@Override
public boolean isCompatibleSampleModel(SampleModel sm) {
if (!(sm instanceof ComponentSampleModel)) {
return false;
}
if (numComponents != sm.getNumBands()) {
return false;
}
if (transferType != sm.getTransferType()) {
return false;
}
return true;
}
@Override
public SampleModel createCompatibleSampleModel(int w, int h) {
int bandOffsets[] = new int[numComponents];
for (int i = 0; i < numComponents; i++) {
bandOffsets[i] = i;
}
switch (transferType) {
case DataBuffer.TYPE_BYTE:
case DataBuffer.TYPE_USHORT:
return new PixelInterleavedSampleModel(transferType, w, h,
numComponents, w * numComponents, bandOffsets);
default:
return new ComponentSampleModel(transferType, w, h, numComponents,
w * numComponents, bandOffsets);
}
}
@Override
public boolean isCompatibleRaster(Raster raster) {
SampleModel sm = raster.getSampleModel();
if (!(sm instanceof ComponentSampleModel)) {
return false;
}
if (sm.getNumBands() != numComponents) {
return false;
}
if (raster.getTransferType() != transferType) {
return false;
}
int sampleSizes[] = sm.getSampleSize();
for (int i = 0; i < numComponents; i++) {
if (bits[i] != sampleSizes[i]) {
return false;
}
}
return true;
}
@Override
public float[] getNormalizedComponents(int components[], int offset,
float normComponents[], int normOffset) {
if (donotSupportUnnormalized) {
// awt.213=This ComponentColorModel does not support the unnormalized form
throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
}
return super.getNormalizedComponents(components, offset,
normComponents, normOffset);
}
@Override
public int getDataElement(int[] components, int offset) {
if (numComponents > 1) {
// awt.212=There is more than one component in this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
}
if (donotSupportUnnormalized) {
// awt.213=This ComponentColorModel does not support the unnormalized form
throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
}
return components[offset];
}
@Override
public int[] getUnnormalizedComponents(float[] normComponents,
int normOffset, int[] components, int offset) {
if (donotSupportUnnormalized) {
// awt.213=This ComponentColorModel does not support the unnormalized form
throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
}
if (normComponents.length - normOffset < numComponents) {
// awt.21B=The length of normComponents minus normOffset is less than numComponents
throw new IllegalArgumentException(Messages.getString("awt.21B")); //$NON-NLS-1$
}
return super.getUnnormalizedComponents(normComponents, normOffset,
components, offset);
}
@Override
public int getDataElement(float normComponents[], int normOffset) {
if (numComponents > 1) {
// awt.212=There is more than one component in this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
}
if (signed) {
// awt.210=The component value for this ColorModel is signed
throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
}
Object pixel = getDataElements(normComponents, normOffset, null);
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte ba[] = (byte[]) pixel;
return ba[0] & 0xff;
case DataBuffer.TYPE_USHORT:
short sa[] = (short[]) pixel;
return sa[0] & 0xffff;
case DataBuffer.TYPE_INT:
int ia[] = (int[]) pixel;
return ia[0];
default:
// awt.211=Pixel values for this ColorModel are not conveniently
// representable as a single int
throw new IllegalArgumentException(Messages.getString("awt.211")); //$NON-NLS-1$
}
}
@Override
public int[] getComponents(int pixel, int components[], int offset) {
if (numComponents > 1) {
// awt.212=There is more than one component in this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
}
if (donotSupportUnnormalized) {
// awt.213=This ComponentColorModel does not support the unnormalized form
throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
}
if (components == null) {
components = new int[offset + 1];
}
components[offset] = pixel & maxValues[0];
return components;
}
@Override
public int getRed(int pixel) {
float rgb[] = toRGB(pixel);
return (int) (rgb[0] * 255.0f + 0.5f);
}
@Override
public int getRGB(int pixel) {
return (getAlpha(pixel) << 24) | (getRed(pixel) << 16) |
(getGreen(pixel) << 8) | getBlue(pixel);
}
@Override
public int getGreen(int pixel) {
float rgb[] = toRGB(pixel);
return (int) (rgb[1] * 255.0f + 0.5f);
}
@Override
public int getBlue(int pixel) {
float rgb[] = toRGB(pixel);
return (int) (rgb[2] * 255.0f + 0.5f);
}
@Override
public int getAlpha(int pixel) {
// This method throw IllegalArgumentException according to
// Java API Specification
if (signed) {
// awt.210=The component value for this ColorModel is signed
throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
}
if (numComponents > 1) {
// awt.212=There is more than one component in this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
}
return 255;
}
/**
* Initialization of Lookup tables
*/
private void initLUTs() {
is_sRGB = cs.isCS_sRGB();
is_LINEAR_RGB = (cs == LUTColorConverter.LINEAR_RGB_CS);
if (hasAlpha && bits[numColorComponents] != 8 && integral) {
alphaLUT = new byte[maxValues[numColorComponents] + 1];
for (int i = 0; i <= maxValues[numColorComponents]; i++) {
alphaLUT[i] = (byte) (scaleFactors[numColorComponents] * i +
0.5f);
}
}
if (is_LINEAR_RGB) {
if (maxBitLength > 8) {
LINEAR_RGB_Length = 16;
from_LINEAR_RGB_LUT =
LUTColorConverter.getFrom16lRGBtosRGB_LUT();
to_LINEAR_16RGB_LUT =
LUTColorConverter.getFromsRGBto16lRGB_LUT();
} else {
LINEAR_RGB_Length = 8;
from_LINEAR_RGB_LUT =
LUTColorConverter.getFrom8lRGBtosRGB_LUT();
to_LINEAR_8RGB_LUT =
LUTColorConverter.getFromsRGBto8lRGB_LUT();
}
fFactor = ((1 << LINEAR_RGB_Length) - 1);
} else {
fFactor = 255.0f;
}
if (!isAlphaPremultiplied && integral) {
colorLUTs = new byte[3][];
if (is_sRGB) {
for (int i = 0; i < numColorComponents; i++) {
if (bits[i] != 8) {
for (int j = 0; j < i; j++) {
if (bits[i] == bits[j]) {
colorLUTs[i] = colorLUTs[j];
break;
}
}
colorLUTs[i] = new byte[maxValues[i] + 1];
for (int j = 0; j <= maxValues[0]; j++) {
colorLUTs[i][j] =
(byte) (scaleFactors[i] * j + 0.5f);
}
}
}
}
if (is_LINEAR_RGB) {
for (int i = 0; i < numColorComponents; i++) {
if (bits[i] != LINEAR_RGB_Length) {
for (int j = 0; j < i; j++) {
if (bits[i] == bits[j]) {
colorLUTs[i] = colorLUTs[j];
break;
}
}
colorLUTs[i] = new byte[maxValues[i] + 1];
for (int j = 0; j <= maxValues[0]; j++) {
int idx;
if (LINEAR_RGB_Length == 8) {
idx = (int) (scaleFactors[i] * j + 0.5f);
} else {
idx = (int) (scaleFactors[i] * j * 257.0f +
0.5f);
}
colorLUTs[i][j] = from_LINEAR_RGB_LUT[idx];
}
}
}
}
}
}
/**
* @param pixel - int representation of pixel
* @return - array of normalized sRGB components
*/
private float[] toRGB(int pixel) {
// This method throw IllegalArgumentException according to
// Java API Specification
if (signed) {
// awt.210=The component value for this ColorModel is signed
throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
}
if (numComponents > 1) {
// awt.212=There is more than one component in this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
}
Object obj = null;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte ba[] = new byte[1];
ba[0] = (byte) pixel;
obj = ba;
break;
case DataBuffer.TYPE_USHORT:
short sa[] = new short[1];
sa[0] = (short) pixel;
obj = sa;
break;
case DataBuffer.TYPE_INT:
int ia[] = new int[1];
ia[0] = pixel;
obj = ia;
break;
}
return cs.toRGB(getNormalizedComponents(obj, null, 0));
}
/**
* @param pixel - pixel
* @param idx - index of component
* @return - RGB value from 0 to 255 pixel's component
*/
private int getRGBComponent(Object pixel, int idx) {
if (is_sRGB) {
int comp = getDefComponent(pixel, idx);
if (calcValue || bits[idx] == 8) {
return comp;
}
return colorLUTs[idx][comp] & 0xff;
} else if (is_LINEAR_RGB) {
int comp = getDefComponent(pixel, idx);
if (calcValue || bits[idx] == LINEAR_RGB_Length) {
return from_LINEAR_RGB_LUT[comp] & 0xff;
}
return colorLUTs[idx][comp] & 0xff;
}
float normComp[] = getNormalizedComponents(pixel, null, 0);
float rgbComp[] = cs.toRGB(normComp);
return (int) (rgbComp[idx] * 255.0f + 0.5f);
}
/**
* @param pixel - pixel
* @param idx - index of component
* @return - tentative value of the pixel component
*/
private int getDefComponent(Object pixel, int idx) {
int comp = 0;
calcValue = false;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte ba[] = (byte[]) pixel;
comp = ba[idx] & 0xff;
if (needAlphaDivide) {
int alpha = ba[numColorComponents] & 0xff;
if (alpha == 0) {
comp = 0;
} else {
float normAlpha = scaleFactors[numColorComponents] * alpha;
comp = (int) (comp * fFactor / normAlpha + 0.5f);
}
calcValue = true;
}
return comp;
case DataBuffer.TYPE_USHORT:
short usa[] = (short[]) pixel;
comp = usa[idx] & 0xffff;
if (needAlphaDivide) {
int alpha = usa[numColorComponents] & 0xffff;
if (alpha == 0) {
comp = 0;
} else {
float normAlpha = scaleFactors[numColorComponents] * alpha;
comp = (int) (comp * fFactor / normAlpha + 0.5f);
}
calcValue = true;
}
return comp;
case DataBuffer.TYPE_INT:
int ia[] = (int[]) pixel;
comp = ia[idx];
if (needAlphaDivide) {
int alpha = ia[numColorComponents];
if (alpha == 0) {
comp = 0;
} else {
float normAlpha = scaleFactors[numColorComponents] * alpha;
comp = (int) (comp * fFactor / normAlpha + 0.5f);
}
calcValue = true;
}
return comp;
case DataBuffer.TYPE_SHORT:
short sa[] = (short[]) pixel;
comp = sa[idx];
if (needAlphaDivide) {
int alpha = sa[numColorComponents];
if (alpha == 0) {
comp = 0;
} else {
float normAlpha = scaleFactors[numColorComponents] * alpha;
comp = (int) (comp * fFactor / normAlpha + 0.5f);
}
calcValue = true;
}
return comp;
case DataBuffer.TYPE_FLOAT:
float fa[] = (float[]) pixel;
if (needAlphaDivide) {
float alpha = fa[numColorComponents];
if (fa[numColorComponents] == 0.0f) {
comp = 0;
} else {
comp = (int) (fa[idx] * fFactor / alpha + 0.5f);
}
} else {
comp = (int) (fa[idx] * fFactor + 0.5f);
}
calcValue = true;
return comp;
case DataBuffer.TYPE_DOUBLE:
double da[] = (double[]) pixel;
if (needAlphaDivide) {
if (da[numColorComponents] == 0.0) {
comp = 0;
} else {
comp = (int) (da[idx] * fFactor / da[numColorComponents] +
0.5);
}
} else {
comp = (int) (da[idx] * fFactor + 0.5);
}
calcValue = true;
return comp;
default:
// awt.214=This Color Model doesn't support this transferType
throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
}
}
}