private int encode(RenderedImage im, TIFFEncodeParam encodeParam,
int ifdOffset, boolean isLast) throws IOException {
// Cannot store a packed byte image directly so reformat it.
if(CodecUtils.isPackedByteImage(im)) {
// Get the source ColorModel.
ColorModel sourceCM = im.getColorModel();
// Create an equivalent ComponentColorModel.
ColorModel destCM =
RasterFactory.createComponentColorModel(
DataBuffer.TYPE_BYTE,
sourceCM.getColorSpace(),
sourceCM.hasAlpha(),
sourceCM.isAlphaPremultiplied(),
sourceCM.getTransparency());
// Create a raster which can contain the entire source.
Point origin = new Point(im.getMinX(), im.getMinY());
WritableRaster raster =
Raster.createWritableRaster(
destCM.createCompatibleSampleModel(im.getWidth(),
im.getHeight()),
origin);
// Copy the source data.
raster.setRect(im.getData());
// Replace the source reference with the new image.
im = new SingleTileRenderedImage(raster, destCM);
}
// Currently all images are stored uncompressed.
int compression = encodeParam.getCompression();
// Get tiled output preference.
boolean isTiled = encodeParam.getWriteTiled();
// Set bounds.
int minX = im.getMinX();
int minY = im.getMinY();
int width = im.getWidth();
int height = im.getHeight();
// Get SampleModel.
SampleModel sampleModel = im.getSampleModel();
// Retrieve and verify sample size.
int sampleSize[] = sampleModel.getSampleSize();
for(int i = 1; i < sampleSize.length; i++) {
if(sampleSize[i] != sampleSize[0]) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder0"));
}
}
// Check low bit limits.
int numBands = sampleModel.getNumBands();
if((sampleSize[0] == 1 || sampleSize[0] == 4) && numBands != 1) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder1"));
}
// Retrieve and verify data type.
int dataType = sampleModel.getDataType();
switch(dataType) {
case DataBuffer.TYPE_BYTE:
if(sampleSize[0] != 1 && sampleSize[0] != 4 &&
sampleSize[0] != 8) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder2"));
}
break;
case DataBuffer.TYPE_SHORT:
case DataBuffer.TYPE_USHORT:
if(sampleSize[0] != 16) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder3"));
}
break;
case DataBuffer.TYPE_INT:
case DataBuffer.TYPE_FLOAT:
if(sampleSize[0] != 32) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder4"));
}
break;
default:
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder5"));
}
boolean dataTypeIsShort =
dataType == DataBuffer.TYPE_SHORT ||
dataType == DataBuffer.TYPE_USHORT;
ColorModel colorModel = im.getColorModel();
if (colorModel != null &&
colorModel instanceof IndexColorModel &&
dataType != DataBuffer.TYPE_BYTE) {
// Don't support (unsigned) short palette-color images.
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder6"));
}
IndexColorModel icm = null;
int sizeOfColormap = 0;
int colormap[] = null;
// Set image type.
int imageType = TIFF_UNSUPPORTED;
int numExtraSamples = 0;
int extraSampleType = EXTRA_SAMPLE_UNSPECIFIED;
if(colorModel instanceof IndexColorModel) { // Bilevel or palette
icm = (IndexColorModel)colorModel;
int mapSize = icm.getMapSize();
if(sampleSize[0] == 1 && numBands == 1) { // Bilevel image
if (mapSize != 2) {
throw new IllegalArgumentException(
JaiI18N.getString("TIFFImageEncoder7"));
}
byte r[] = new byte[mapSize];
icm.getReds(r);
byte g[] = new byte[mapSize];
icm.getGreens(g);
byte b[] = new byte[mapSize];
icm.getBlues(b);
if ((r[0] & 0xff) == 0 &&
(r[1] & 0xff) == 255 &&
(g[0] & 0xff) == 0 &&
(g[1] & 0xff) == 255 &&
(b[0] & 0xff) == 0 &&
(b[1] & 0xff) == 255) {
imageType = TIFF_BILEVEL_BLACK_IS_ZERO;
} else if ((r[0] & 0xff) == 255 &&
(r[1] & 0xff) == 0 &&
(g[0] & 0xff) == 255 &&
(g[1] & 0xff) == 0 &&
(b[0] & 0xff) == 255 &&
(b[1] & 0xff) == 0) {
imageType = TIFF_BILEVEL_WHITE_IS_ZERO;
} else {
imageType = TIFF_PALETTE;
}
} else if(numBands == 1) { // Non-bilevel image.
// Palette color image.
imageType = TIFF_PALETTE;
}
} else if(colorModel == null) {
if(sampleSize[0] == 1 && numBands == 1) { // bilevel
imageType = TIFF_BILEVEL_BLACK_IS_ZERO;
} else { // generic image
imageType = TIFF_GENERIC;
if(numBands > 1) {
numExtraSamples = numBands - 1;
}
}
} else { // colorModel is non-null but not an IndexColorModel
ColorSpace colorSpace = colorModel.getColorSpace();
switch(colorSpace.getType()) {
case ColorSpace.TYPE_CMYK:
imageType = TIFF_CMYK;
break;
case ColorSpace.TYPE_GRAY:
imageType = TIFF_GRAY;
break;
case ColorSpace.TYPE_Lab:
imageType = TIFF_CIELAB;
break;
case ColorSpace.TYPE_RGB:
if(compression == COMP_JPEG_TTN2 &&
encodeParam.getJPEGCompressRGBToYCbCr()) {
imageType = TIFF_YCBCR;
} else {
imageType = TIFF_RGB;
}
break;
case ColorSpace.TYPE_YCbCr:
imageType = TIFF_YCBCR;
break;
default:
imageType = TIFF_GENERIC; // generic
break;
}
if(imageType == TIFF_GENERIC) {
numExtraSamples = numBands - 1;
} else if(numBands > 1) {
numExtraSamples = numBands - colorSpace.getNumComponents();
}
if(numExtraSamples == 1 && colorModel.hasAlpha()) {
extraSampleType = colorModel.isAlphaPremultiplied() ?
EXTRA_SAMPLE_ASSOCIATED_ALPHA :
EXTRA_SAMPLE_UNASSOCIATED_ALPHA;
}
}
if(imageType == TIFF_UNSUPPORTED) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder8"));
}
// Check JPEG compatibility.
if(compression == COMP_JPEG_TTN2) {
if(imageType == TIFF_PALETTE) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder11"));
} else if(!(sampleSize[0] == 8 &&
(imageType == TIFF_GRAY ||
imageType == TIFF_RGB ||
imageType == TIFF_YCBCR))) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder9"));
}
}
// Check bilevel encoding compatibility.
if((imageType != TIFF_BILEVEL_WHITE_IS_ZERO &&
imageType != TIFF_BILEVEL_BLACK_IS_ZERO) &&
(compression == COMP_GROUP3_1D ||
compression == COMP_GROUP3_2D ||
compression == COMP_GROUP4)) {
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder12"));
}
int photometricInterpretation = -1;
switch (imageType) {
case TIFF_BILEVEL_WHITE_IS_ZERO:
photometricInterpretation = 0;
break;
case TIFF_BILEVEL_BLACK_IS_ZERO:
photometricInterpretation = 1;
break;
case TIFF_GRAY:
case TIFF_GENERIC:
// Since the CS_GRAY colorspace is always of type black_is_zero
photometricInterpretation = 1;
break;
case TIFF_PALETTE:
photometricInterpretation = 3;
icm = (IndexColorModel)colorModel;
sizeOfColormap = icm.getMapSize();
byte r[] = new byte[sizeOfColormap];
icm.getReds(r);
byte g[] = new byte[sizeOfColormap];
icm.getGreens(g);
byte b[] = new byte[sizeOfColormap];
icm.getBlues(b);
int redIndex = 0, greenIndex = sizeOfColormap;
int blueIndex = 2 * sizeOfColormap;
colormap = new int[sizeOfColormap * 3];
for (int i=0; i<sizeOfColormap; i++) {
colormap[redIndex++] = (r[i] << 8) & 0xffff;
colormap[greenIndex++] = (g[i] << 8) & 0xffff;
colormap[blueIndex++] = (b[i] << 8) & 0xffff;
}
sizeOfColormap *= 3;
break;
case TIFF_RGB:
photometricInterpretation = 2;
break;
case TIFF_CMYK:
photometricInterpretation = 5;
break;
case TIFF_YCBCR:
photometricInterpretation = 6;
break;
case TIFF_CIELAB:
photometricInterpretation = 8;
break;
default:
throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder8"));
}
// Initialize tile dimensions.
int tileWidth;
int tileHeight;
if(isTiled) {
tileWidth = encodeParam.getTileWidth() > 0 ?
encodeParam.getTileWidth() : im.getTileWidth();
tileHeight = encodeParam.getTileHeight() > 0 ?
encodeParam.getTileHeight() : im.getTileHeight();
} else {
tileWidth = width;
// XXX Set rows per strip based on memory value if not specified?
tileHeight = encodeParam.getTileHeight() > 0 ?
encodeParam.getTileHeight() : DEFAULT_ROWS_PER_STRIP;
}
// Re-tile for JPEG conformance if needed.
JPEGEncodeParam jep = null;
if(compression == COMP_JPEG_TTN2) {
// Get JPEGEncodeParam from encodeParam.
jep = encodeParam.getJPEGEncodeParam();
// Determine maximum subsampling.
int maxSubH = jep.getHorizontalSubsampling(0);
int maxSubV = jep.getVerticalSubsampling(0);
for(int i = 1; i < numBands; i++) {
int subH = jep.getHorizontalSubsampling(i);
if(subH > maxSubH) {
maxSubH = subH;
}
int subV = jep.getVerticalSubsampling(i);
if(subV > maxSubV) {
maxSubV = subV;
}
}
int factorV = 8*maxSubV;
tileHeight =
(int)((float)tileHeight/(float)factorV + 0.5F)*factorV;
if(tileHeight < factorV) {
tileHeight = factorV;
}
if(isTiled) {
int factorH = 8*maxSubH;
tileWidth =
(int)((float)tileWidth/(float)factorH + 0.5F)*factorH;
if(tileWidth < factorH) {
tileWidth = factorH;
}
}
}
int numTiles;
if(isTiled) {
// NB: Parentheses are used in this statement for correct rounding.
numTiles =
((width + tileWidth - 1)/tileWidth) *
((height + tileHeight - 1)/tileHeight);
} else {
numTiles = (int)Math.ceil((double)height/(double)tileHeight);
}
long tileByteCounts[] = new long[numTiles];
long bytesPerRow =
(long)Math.ceil((sampleSize[0] / 8.0) * tileWidth * numBands);
long bytesPerTile = bytesPerRow * tileHeight;
for (int i=0; i<numTiles; i++) {
tileByteCounts[i] = bytesPerTile;
}
if(!isTiled) {
// Last strip may have lesser rows
long lastStripRows = height - (tileHeight * (numTiles-1));
tileByteCounts[numTiles-1] = lastStripRows * bytesPerRow;
}
long totalBytesOfData = bytesPerTile * (numTiles - 1) +
tileByteCounts[numTiles-1];
// The data will be written after the IFD: create the array here
// but fill it in later.
long tileOffsets[] = new long[numTiles];
// Basic fields - have to be in increasing numerical order.
// ImageWidth 256
// ImageLength 257
// BitsPerSample 258
// Compression 259
// PhotoMetricInterpretation 262
// StripOffsets 273
// RowsPerStrip 278
// StripByteCounts 279
// XResolution 282
// YResolution 283
// ResolutionUnit 296
// Create Directory
SortedSet fields = new TreeSet();
// Image Width
fields.add(new TIFFField(TIFFImageDecoder.TIFF_IMAGE_WIDTH,
TIFFField.TIFF_LONG, 1,
(Object)(new long[] {(long)width})));
// Image Length
fields.add(new TIFFField(TIFFImageDecoder.TIFF_IMAGE_LENGTH,
TIFFField.TIFF_LONG, 1,
new long[] {(long)height}));
fields.add(new TIFFField(TIFFImageDecoder.TIFF_BITS_PER_SAMPLE,
TIFFField.TIFF_SHORT, numBands,
intsToChars(sampleSize)));
fields.add(new TIFFField(TIFFImageDecoder.TIFF_COMPRESSION,
TIFFField.TIFF_SHORT, 1,
new char[] {(char)compression}));
fields.add(
new TIFFField(TIFFImageDecoder.TIFF_PHOTOMETRIC_INTERPRETATION,
TIFFField.TIFF_SHORT, 1,
new char[] {(char)photometricInterpretation}));
if(!isTiled) {
fields.add(new TIFFField(TIFFImageDecoder.TIFF_STRIP_OFFSETS,
TIFFField.TIFF_LONG, numTiles,
(long[])tileOffsets));
}
fields.add(new TIFFField(TIFFImageDecoder.TIFF_SAMPLES_PER_PIXEL,
TIFFField.TIFF_SHORT, 1,
new char[] {(char)numBands}));
if(!isTiled) {
fields.add(new TIFFField(TIFFImageDecoder.TIFF_ROWS_PER_STRIP,
TIFFField.TIFF_LONG, 1,
new long[] {(long)tileHeight}));
fields.add(new TIFFField(TIFFImageDecoder.TIFF_STRIP_BYTE_COUNTS,
TIFFField.TIFF_LONG, numTiles,
(long[])tileByteCounts));
}
if (colormap != null) {
fields.add(new TIFFField(TIFFImageDecoder.TIFF_COLORMAP,
TIFFField.TIFF_SHORT, sizeOfColormap,
intsToChars(colormap)));
}
if(isTiled) {
fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_WIDTH,
TIFFField.TIFF_LONG, 1,
new long[] {(long)tileWidth}));
fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_LENGTH,
TIFFField.TIFF_LONG, 1,
new long[] {(long)tileHeight}));
fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_OFFSETS,
TIFFField.TIFF_LONG, numTiles,
(long[])tileOffsets));
fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_BYTE_COUNTS,
TIFFField.TIFF_LONG, numTiles,
(long[])tileByteCounts));
}
if(numExtraSamples > 0) {
int[] extraSamples = new int[numExtraSamples];
for(int i = 0; i < numExtraSamples; i++) {
extraSamples[i] = extraSampleType;
}
fields.add(new TIFFField(TIFFImageDecoder.TIFF_EXTRA_SAMPLES,
TIFFField.TIFF_SHORT, numExtraSamples,
intsToChars(extraSamples)));
}
// Data Sample Format Extension fields.
if(dataType != DataBuffer.TYPE_BYTE) {
// SampleFormat
int[] sampleFormat = new int[numBands];
if(dataType == DataBuffer.TYPE_FLOAT) {
sampleFormat[0] = 3;
} else if(dataType == DataBuffer.TYPE_USHORT) {
sampleFormat[0] = 1;
} else {
sampleFormat[0] = 2;
}
for(int b = 1; b < numBands; b++) {
sampleFormat[b] = sampleFormat[0];
}
fields.add(new TIFFField(TIFFImageDecoder.TIFF_SAMPLE_FORMAT,
TIFFField.TIFF_SHORT, numBands,
intsToChars(sampleFormat)));
// NOTE: We don't bother setting the SMinSampleValue and
// SMaxSampleValue fields as these both default to the
// extrema of the respective data types. Probably we should
// check for the presence of the "extrema" property and
// use it if available.
}
// Bilevel compression variables.
boolean inverseFill = encodeParam.getReverseFillOrder();
boolean T4encode2D = encodeParam.getT4Encode2D();
boolean T4PadEOLs = encodeParam.getT4PadEOLs();
TIFFFaxEncoder faxEncoder = null;
// Add bilevel compression fields.
if((imageType == TIFF_BILEVEL_BLACK_IS_ZERO ||
imageType == TIFF_BILEVEL_WHITE_IS_ZERO) &&
(compression == COMP_GROUP3_1D ||
compression == COMP_GROUP3_2D ||
compression == COMP_GROUP4)) {
// Create the encoder.
faxEncoder = new TIFFFaxEncoder(inverseFill);
// FillOrder field.
fields.add(new TIFFField(TIFFImageDecoder.TIFF_FILL_ORDER,
TIFFField.TIFF_SHORT, 1,
new char[] {inverseFill ?
(char)2 : (char)1}));
if(compression == COMP_GROUP3_2D) {
// T4Options field.
long T4Options = 0x00000000;
if(T4encode2D) {
T4Options |= 0x00000001;
}
if(T4PadEOLs) {
T4Options |= 0x00000004;
}
fields.add(new TIFFField(TIFFImageDecoder.TIFF_T4_OPTIONS,
TIFFField.TIFF_LONG, 1,
new long[] {T4Options}));
} else if(compression == COMP_GROUP4) {
// T6Options field.
fields.add(new TIFFField(TIFFImageDecoder.TIFF_T6_OPTIONS,
TIFFField.TIFF_LONG, 1,
new long[] {(long)0x00000000}));
}
}
// Initialize some JPEG variables.
com.sun.image.codec.jpeg.JPEGEncodeParam jpegEncodeParam = null;
com.sun.image.codec.jpeg.JPEGImageEncoder jpegEncoder = null;
int jpegColorID = 0;
if(compression == COMP_JPEG_TTN2) {
// Initialize JPEG color ID.
jpegColorID =
com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_UNKNOWN;
switch(imageType) {
case TIFF_GRAY:
case TIFF_PALETTE:
jpegColorID =
com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_GRAY;
break;
case TIFF_RGB:
jpegColorID =
com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_RGB;
break;
case TIFF_YCBCR:
jpegColorID =
com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_YCbCr;
break;
}
// Get the JDK encoding parameters.
Raster tile00 = im.getTile(im.getMinTileX(), im.getMinTileY());
jpegEncodeParam =
com.sun.image.codec.jpeg.JPEGCodec.getDefaultJPEGEncodeParam(
tile00, jpegColorID);
// Modify per values passed in.
JPEGImageEncoder.modifyEncodeParam(jep, jpegEncodeParam, numBands);
// JPEGTables field.
if(jep.getWriteImageOnly()) {
// Write an abbreviated tables-only stream to JPEGTables field.
jpegEncodeParam.setImageInfoValid(false);
jpegEncodeParam.setTableInfoValid(true);
ByteArrayOutputStream tableStream =
new ByteArrayOutputStream();
jpegEncoder =
com.sun.image.codec.jpeg.JPEGCodec.createJPEGEncoder(
tableStream,
jpegEncodeParam);
jpegEncoder.encode(tile00);
byte[] tableData = tableStream.toByteArray();
fields.add(new TIFFField(TIFF_JPEG_TABLES,
TIFFField.TIFF_UNDEFINED,
tableData.length,
tableData));
// Reset encoder so it's recreated below.
jpegEncoder = null;
}
}
if(imageType == TIFF_YCBCR) {
// YCbCrSubSampling: 2 is the default so we must write 1 as
// we do not (yet) do any subsampling.
int subsampleH = 1;
int subsampleV = 1;
// If JPEG, update values.
if(compression == COMP_JPEG_TTN2) {
// Determine maximum subsampling.
subsampleH = jep.getHorizontalSubsampling(0);
subsampleV = jep.getVerticalSubsampling(0);
for(int i = 1; i < numBands; i++) {
int subH = jep.getHorizontalSubsampling(i);
if(subH > subsampleH) {
subsampleH = subH;
}
int subV = jep.getVerticalSubsampling(i);
if(subV > subsampleV) {
subsampleV = subV;
}
}
}
fields.add(new TIFFField(TIFF_YCBCR_SUBSAMPLING,
TIFFField.TIFF_SHORT, 2,
new char[] {(char)subsampleH,
(char)subsampleV}));
// YCbCr positioning.
fields.add(new TIFFField(TIFF_YCBCR_POSITIONING,
TIFFField.TIFF_SHORT, 1,
new char[] {compression == COMP_JPEG_TTN2 ?
(char)1 : (char)2}));
// Reference black/white.
long[][] refbw;
if(compression == COMP_JPEG_TTN2) {
refbw =
new long[][] { // no headroon/footroom
{0, 1}, {255, 1}, {128, 1}, {255, 1}, {128, 1}, {255, 1}
};
} else {
refbw =
new long[][] { // CCIR 601.1 headroom/footroom (presumptive)
{15, 1}, {235, 1}, {128, 1}, {240, 1}, {128, 1}, {240, 1}
};
}
fields.add(new TIFFField(TIFF_REF_BLACK_WHITE,
TIFFField.TIFF_RATIONAL, 6,
refbw));
}
// ---- No more automatically generated fields should be added
// after this point. ----
// Add extra fields specified via the encoding parameters.
TIFFField[] extraFields = encodeParam.getExtraFields();
if(extraFields != null) {
ArrayList extantTags = new ArrayList(fields.size());
Iterator fieldIter = fields.iterator();
while(fieldIter.hasNext()) {
TIFFField fld = (TIFFField)fieldIter.next();
extantTags.add(new Integer(fld.getTag()));
}
int numExtraFields = extraFields.length;
for(int i = 0; i < numExtraFields; i++) {
TIFFField fld = extraFields[i];
Integer tagValue = new Integer(fld.getTag());
if(!extantTags.contains(tagValue)) {
fields.add(fld);
extantTags.add(tagValue);
}
}
}
// ---- No more fields of any type should be added after this. ----
// Determine the size of the IFD which is written after the header
// of the stream or after the data of the previous image in a
// multi-page stream.
int dirSize = getDirectorySize(fields);
// The first data segment is written after the field overflow
// following the IFD so initialize the first offset accordingly.
tileOffsets[0] = ifdOffset + dirSize;
// Branch here depending on whether data are being comrpressed.
// If not, then the IFD is written immediately.
// If so then there are three possibilities:
// A) the OutputStream is a SeekableOutputStream (outCache null);
// B) the OutputStream is not a SeekableOutputStream and a file cache
// is used (outCache non-null, tempFile non-null);
// C) the OutputStream is not a SeekableOutputStream and a memory cache
// is used (outCache non-null, tempFile null).
OutputStream outCache = null;
byte[] compressBuf = null;
File tempFile = null;
int nextIFDOffset = 0;
boolean skipByte = false;
Deflater deflater = null;
int deflateLevel = Deflater.DEFAULT_COMPRESSION;
boolean jpegRGBToYCbCr = false;
if(compression == COMP_NONE) {
// Determine the number of bytes of padding necessary between
// the end of the IFD and the first data segment such that the
// alignment of the data conforms to the specification (required
// for uncompressed data only).
int numBytesPadding = 0;
if(sampleSize[0] == 16 && tileOffsets[0] % 2 != 0) {
numBytesPadding = 1;
tileOffsets[0]++;
} else if(sampleSize[0] == 32 && tileOffsets[0] % 4 != 0) {
numBytesPadding = (int)(4 - tileOffsets[0] % 4);
tileOffsets[0] += numBytesPadding;
}
// Update the data offsets (which TIFFField stores by reference).
for (int i = 1; i < numTiles; i++) {
tileOffsets[i] = tileOffsets[i-1] + tileByteCounts[i-1];
}
if(!isLast) {
// Determine the offset of the next IFD.
nextIFDOffset = (int)(tileOffsets[0] + totalBytesOfData);
// IFD offsets must be on a word boundary.
if(nextIFDOffset % 2 != 0) {
nextIFDOffset++;
skipByte = true;
}
}
// Write the IFD and field overflow before the image data.
writeDirectory(ifdOffset, fields, nextIFDOffset);
// Write any padding bytes needed between the end of the IFD
// and the start of the actual image data.
if(numBytesPadding != 0) {
for(int padding = 0; padding < numBytesPadding; padding++) {
output.write((byte)0);
}
}
} else {
// If compressing, the cannot be written yet as the size of the
// data segments is unknown.
if((output instanceof SeekableOutputStream)) {
// Simply seek to the first data segment position.
((SeekableOutputStream)output).seek(tileOffsets[0]);
} else {
// Cache the original OutputStream.
outCache = output;
try {
// Attempt to create a temporary file.
tempFile = File.createTempFile("jai-SOS-", ".tmp");
tempFile.deleteOnExit();
RandomAccessFile raFile =
new RandomAccessFile(tempFile, "rw");
output = new SeekableOutputStream(raFile);
// XXX Be sure that this file is deleted no matter how
// this method is exited!
} catch(Exception e) {
tempFile = null;
// Allocate memory for the entire image data (!).
output = new ByteArrayOutputStream((int)totalBytesOfData);
}
}
int bufSize = 0;
switch(compression) {
case COMP_GROUP3_1D:
// This initial buffer size is based on an alternating 1-0
// pattern generating the most bits when converted to code
// words: 9 bits out for each pair of bits in. So the number
// of bit pairs is determined, multiplied by 9, converted to
// bytes, and a ceil() is taken to account for fill bits at the
// end of each line. The "2" addend accounts for the case
// of the pattern beginning with black. The buffer is intended
// to hold only a single row.
bufSize = (int)Math.ceil((((tileWidth + 1)/2)*9 + 2)/8.0);
break;
case COMP_GROUP3_2D:
case COMP_GROUP4:
// Calculate the maximum row as the G3-1D size plus the EOL,
// multiply this by the number of rows in the tile, and add
// 6 EOLs for the RTC (return to control).
bufSize = (int)Math.ceil((((tileWidth + 1)/2)*9 + 2)/8.0);
bufSize = tileHeight*(bufSize + 2) + 12;
break;
case COMP_PACKBITS:
bufSize = (int)(bytesPerTile +
((bytesPerRow+127)/128)*tileHeight);
break;
case COMP_JPEG_TTN2:
bufSize = 0;
// Set color conversion flag.
if(imageType == TIFF_YCBCR &&
colorModel != null &&
colorModel.getColorSpace().getType() ==
ColorSpace.TYPE_RGB) {
jpegRGBToYCbCr = true;
}
break;
case COMP_DEFLATE: