// Default is using 24 bits per pixel.
int bitsPerPixel = 24;
boolean isPalette = false;
int paletteEntries = 0;
IndexColorModel icm = null;
RenderedImage input = null;
Raster inputRaster = null;
boolean writeRaster = image.hasRaster();
Rectangle sourceRegion = param.getSourceRegion();
SampleModel sampleModel = null;
ColorModel colorModel = null;
compImageSize = 0;
if (writeRaster) {
inputRaster = image.getRaster();
sampleModel = inputRaster.getSampleModel();
colorModel = ImageUtil.createColorModel(null, sampleModel);
if (sourceRegion == null)
sourceRegion = inputRaster.getBounds();
else
sourceRegion = sourceRegion.intersection(inputRaster.getBounds());
} else {
input = image.getRenderedImage();
sampleModel = input.getSampleModel();
colorModel = input.getColorModel();
Rectangle rect = new Rectangle(input.getMinX(), input.getMinY(),
input.getWidth(), input.getHeight());
if (sourceRegion == null)
sourceRegion = rect;
else
sourceRegion = sourceRegion.intersection(rect);
}
IIOMetadata imageMetadata = image.getMetadata();
BMPMetadata bmpImageMetadata = null;
if (imageMetadata != null
&& imageMetadata instanceof BMPMetadata)
{
bmpImageMetadata = (BMPMetadata)imageMetadata;
} else {
ImageTypeSpecifier imageType =
new ImageTypeSpecifier(colorModel, sampleModel);
bmpImageMetadata = (BMPMetadata)getDefaultImageMetadata(imageType,
param);
}
if (sourceRegion.isEmpty())
throw new RuntimeException(I18N.getString("BMPImageWrite0"));
int scaleX = param.getSourceXSubsampling();
int scaleY = param.getSourceYSubsampling();
int xOffset = param.getSubsamplingXOffset();
int yOffset = param.getSubsamplingYOffset();
// cache the data type;
int dataType = sampleModel.getDataType();
sourceRegion.translate(xOffset, yOffset);
sourceRegion.width -= xOffset;
sourceRegion.height -= yOffset;
int minX = sourceRegion.x / scaleX;
int minY = sourceRegion.y / scaleY;
w = (sourceRegion.width + scaleX - 1) / scaleX;
h = (sourceRegion.height + scaleY - 1) / scaleY;
xOffset = sourceRegion.x % scaleX;
yOffset = sourceRegion.y % scaleY;
Rectangle destinationRegion = new Rectangle(minX, minY, w, h);
boolean noTransform = destinationRegion.equals(sourceRegion);
// Raw data can only handle bytes, everything greater must be ASCII.
int[] sourceBands = param.getSourceBands();
boolean noSubband = true;
int numBands = sampleModel.getNumBands();
if (sourceBands != null) {
sampleModel = sampleModel.createSubsetSampleModel(sourceBands);
colorModel = null;
noSubband = false;
numBands = sampleModel.getNumBands();
} else {
sourceBands = new int[numBands];
for (int i = 0; i < numBands; i++)
sourceBands[i] = i;
}
int[] bandOffsets = null;
boolean bgrOrder = true;
if (sampleModel instanceof ComponentSampleModel) {
bandOffsets = ((ComponentSampleModel)sampleModel).getBandOffsets();
if (sampleModel instanceof BandedSampleModel) {
// for images with BandedSampleModel we can not work
// with raster directly and must use writePixels()
bgrOrder = false;
} else {
// we can work with raster directly only in case of
// BGR component order.
// In any other case we must use writePixels()
for (int i = 0; i < bandOffsets.length; i++) {
bgrOrder &= (bandOffsets[i] == (bandOffsets.length - i - 1));
}
}
} else {
if (sampleModel instanceof SinglePixelPackedSampleModel) {
// BugId 4892214: we can not work with raster directly
// if image have different color order than RGB.
// We should use writePixels() for such images.
int[] bitOffsets = ((SinglePixelPackedSampleModel)sampleModel).getBitOffsets();
for (int i=0; i<bitOffsets.length-1; i++) {
bgrOrder &= bitOffsets[i] > bitOffsets[i+1];
}
}
}
if (bandOffsets == null) {
// we will use getPixels() to extract pixel data for writePixels()
// Please note that getPixels() provides rgb bands order.
bandOffsets = new int[numBands];
for (int i = 0; i < numBands; i++)
bandOffsets[i] = i;
}
noTransform &= bgrOrder;
int sampleSize[] = sampleModel.getSampleSize();
//XXX: check more
// Number of bytes that a scanline for the image written out will have.
int destScanlineBytes = w * numBands;
switch(bmpParam.getCompressionMode()) {
case ImageWriteParam.MODE_EXPLICIT:
compressionType = getCompressionType(bmpParam.getCompressionType());
break;
case ImageWriteParam.MODE_COPY_FROM_METADATA:
compressionType = bmpImageMetadata.compression;
break;
case ImageWriteParam.MODE_DEFAULT:
compressionType = getPreferredCompressionType(colorModel, sampleModel);
break;
default:
// ImageWriteParam.MODE_DISABLED:
compressionType = BI_RGB;
}
if (!canEncodeImage(compressionType, colorModel, sampleModel)) {
throw new IOException("Image can not be encoded with compression type "
+ compressionTypeNames[compressionType]);
}
byte r[] = null, g[] = null, b[] = null, a[] = null;
if (compressionType == BMPConstants.BI_BITFIELDS) {
bitsPerPixel =
DataBuffer.getDataTypeSize(sampleModel.getDataType());
if (bitsPerPixel != 16 && bitsPerPixel != 32) {
// we should use 32bpp images in case of BI_BITFIELD
// compression to avoid color conversion artefacts
bitsPerPixel = 32;
// Setting this flag to false ensures that generic
// writePixels() will be used to store image data
noTransform = false;
}
destScanlineBytes = w * bitsPerPixel + 7 >> 3;
isPalette = true;
paletteEntries = 3;
r = new byte[paletteEntries];
g = new byte[paletteEntries];
b = new byte[paletteEntries];
a = new byte[paletteEntries];
int rmask = 0x00ff0000;
int gmask = 0x0000ff00;
int bmask = 0x000000ff;
if (bitsPerPixel == 16) {
/* NB: canEncodeImage() ensures we have image of
* either USHORT_565_RGB or USHORT_555_RGB type here.
* Technically, it should work for other direct color
* model types but it might be non compatible with win98
* and friends.
*/
if (colorModel instanceof DirectColorModel) {
DirectColorModel dcm = (DirectColorModel)colorModel;
rmask = dcm.getRedMask();
gmask = dcm.getGreenMask();
bmask = dcm.getBlueMask();
} else {
// it is unlikely, but if it happens, we should throw
// an exception related to unsupported image format
throw new IOException("Image can not be encoded with " +
"compression type " +
compressionTypeNames[compressionType]);
}
}
writeMaskToPalette(rmask, 0, r, g, b, a);
writeMaskToPalette(gmask, 1, r, g, b, a);
writeMaskToPalette(bmask, 2, r, g, b, a);
if (!noTransform) {
// prepare info for writePixels procedure
bitMasks = new int[3];
bitMasks[0] = rmask;
bitMasks[1] = gmask;
bitMasks[2] = bmask;
bitPos = new int[3];
bitPos[0] = firstLowBit(rmask);
bitPos[1] = firstLowBit(gmask);
bitPos[2] = firstLowBit(bmask);
}
if (colorModel instanceof IndexColorModel) {
icm = (IndexColorModel)colorModel;
}
} else { // handle BI_RGB compression
if (colorModel instanceof IndexColorModel) {
isPalette = true;
icm = (IndexColorModel)colorModel;
paletteEntries = icm.getMapSize();
if (paletteEntries <= 2) {
bitsPerPixel = 1;
destScanlineBytes = w + 7 >> 3;
} else if (paletteEntries <= 16) {
bitsPerPixel = 4;
destScanlineBytes = w + 1 >> 1;
} else if (paletteEntries <= 256) {
bitsPerPixel = 8;
} else {
// Cannot be written as a Palette image. So write out as
// 24 bit image.
bitsPerPixel = 24;
isPalette = false;
paletteEntries = 0;
destScanlineBytes = w * 3;
}
if (isPalette == true) {
r = new byte[paletteEntries];
g = new byte[paletteEntries];
b = new byte[paletteEntries];
a = new byte[paletteEntries];
icm.getAlphas(a);
icm.getReds(r);
icm.getGreens(g);
icm.getBlues(b);
}
} else {
// Grey scale images
if (numBands == 1) {