/*******************************************************************************
* Copyright (c) 2000, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.swt.internal.image;
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import java.io.*;
final class TIFFDirectory {
TIFFRandomFileAccess file;
boolean isLittleEndian;
ImageLoader loader;
int depth;
/* Directory fields */
int subfileType;
int imageWidth;
int imageLength;
int[] bitsPerSample;
int compression;
int photometricInterpretation;
int[] stripOffsets;
int samplesPerPixel;
int rowsPerStrip;
int[] stripByteCounts;
int t4Options;
int colorMapOffset;
/* Encoder fields */
ImageData image;
LEDataOutputStream out;
static final int NO_VALUE = -1;
static final short TAG_NewSubfileType = 254;
static final short TAG_SubfileType = 255;
static final short TAG_ImageWidth = 256;
static final short TAG_ImageLength = 257;
static final short TAG_BitsPerSample = 258;
static final short TAG_Compression = 259;
static final short TAG_PhotometricInterpretation = 262;
static final short TAG_FillOrder = 266;
static final short TAG_ImageDescription = 270;
static final short TAG_StripOffsets = 273;
static final short TAG_Orientation = 274;
static final short TAG_SamplesPerPixel = 277;
static final short TAG_RowsPerStrip = 278;
static final short TAG_StripByteCounts = 279;
static final short TAG_XResolution = 282;
static final short TAG_YResolution = 283;
static final short TAG_PlanarConfiguration = 284;
static final short TAG_T4Options = 292;
static final short TAG_ResolutionUnit = 296;
static final short TAG_Software = 305;
static final short TAG_DateTime = 306;
static final short TAG_ColorMap = 320;
static final int TYPE_BYTE = 1;
static final int TYPE_ASCII = 2;
static final int TYPE_SHORT = 3;
static final int TYPE_LONG = 4;
static final int TYPE_RATIONAL = 5;
static final int FILETYPE_REDUCEDIMAGE = 1;
static final int FILETYPE_PAGE = 2;
static final int FILETYPE_MASK = 4;
static final int OFILETYPE_IMAGE = 1;
static final int OFILETYPE_REDUCEDIMAGE = 2;
static final int OFILETYPE_PAGE = 3;
/* Different compression schemes */
static final int COMPRESSION_NONE = 1;
static final int COMPRESSION_CCITT_3_1 = 2;
static final int COMPRESSION_PACKBITS = 32773;
static final int IFD_ENTRY_SIZE = 12;
public TIFFDirectory(TIFFRandomFileAccess file, boolean isLittleEndian, ImageLoader loader) {
this.file = file;
this.isLittleEndian = isLittleEndian;
this.loader = loader;
}
public TIFFDirectory(ImageData image) {
this.image = image;
}
/* PackBits decoder */
int decodePackBits(byte[] src, byte[] dest, int offsetDest) {
int destIndex = offsetDest;
int srcIndex = 0;
while (srcIndex < src.length) {
byte n = src[srcIndex];
if (n >= 0) {
/* Copy next n+1 bytes literally */
System.arraycopy(src, ++srcIndex, dest, destIndex, n + 1);
srcIndex += n + 1;
destIndex += n + 1;
} else if (n >= -127) {
/* Copy next byte -n+1 times */
byte value = src[++srcIndex];
for (int j = 0; j < -n + 1; j++) {
dest[destIndex++] = value;
}
srcIndex++;
} else {
/* Noop when n == -128 */
srcIndex++;
}
}
/* Number of bytes copied */
return destIndex - offsetDest;
}
int getEntryValue(int type, byte[] buffer, int index) {
return toInt(buffer, index + 8, type);
}
void getEntryValue(int type, byte[] buffer, int index, int[] values) throws IOException {
int start = index + 8;
int size;
int offset = toInt(buffer, start, TYPE_LONG);
switch (type) {
case TYPE_SHORT: size = 2; break;
case TYPE_LONG: size = 4; break;
case TYPE_RATIONAL: size = 8; break;
case TYPE_ASCII:
case TYPE_BYTE: size = 1; break;
default: SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT); return;
}
if (values.length * size > 4) {
buffer = new byte[values.length * size];
file.seek(offset);
file.read(buffer);
start = 0;
}
for (int i = 0; i < values.length; i++) {
values[i] = toInt(buffer, start + i * size, type);
}
}
void decodePixels(ImageData image) throws IOException {
/* Each row is byte aligned */
byte[] imageData = new byte[(imageWidth * depth + 7) / 8 * imageLength];
image.data = imageData;
int destIndex = 0;
int length = stripOffsets.length;
for (int i = 0; i < length; i++) {
/* Read a strip */
byte[] data = new byte[stripByteCounts[i]];
file.seek(stripOffsets[i]);
file.read(data);
if (compression == COMPRESSION_NONE) {
System.arraycopy(data, 0, imageData, destIndex, data.length);
destIndex += data.length;
} else if (compression == COMPRESSION_PACKBITS) {
destIndex += decodePackBits(data, imageData, destIndex);
} else if (compression == COMPRESSION_CCITT_3_1 || compression == 3) {
TIFFModifiedHuffmanCodec codec = new TIFFModifiedHuffmanCodec();
int nRows = rowsPerStrip;
if (i == length -1) {
int n = imageLength % rowsPerStrip;
if (n != 0) nRows = n;
}
destIndex += codec.decode(data, imageData, destIndex, imageWidth, nRows);
}
if (loader.hasListeners()) {
loader.notifyListeners(new ImageLoaderEvent(loader, image, i, i == length - 1));
}
}
}
PaletteData getColorMap() throws IOException {
int numColors = 1 << bitsPerSample[0];
/* R, G, B entries are 16 bit wide (2 bytes) */
int numBytes = 3 * 2 * numColors;
byte[] buffer = new byte[numBytes];
file.seek(colorMapOffset);
file.read(buffer);
RGB[] colors = new RGB[numColors];
/**
* SWT does not support 16-bit depth color formats.
* Convert the 16-bit data to 8-bit data.
* The correct way to do this is to multiply each
* 16 bit value by the value:
* (2^8 - 1) / (2^16 - 1).
* The fast way to do this is just to drop the low
* byte of the 16-bit value.
*/
int offset = isLittleEndian ? 1 : 0;
int startG = 2 * numColors;
int startB = startG + 2 * numColors;
for (int i = 0; i < numColors; i++) {
int r = buffer[offset] & 0xFF;
int g = buffer[startG + offset] & 0xFF;
int b = buffer[startB + offset] & 0xFF;
colors[i] = new RGB(r, g, b);
offset += 2;
}
return new PaletteData(colors);
}
PaletteData getGrayPalette() {
int numColors = 1 << bitsPerSample[0];
RGB[] rgbs = new RGB[numColors];
for (int i = 0; i < numColors; i++) {
int value = i * 0xFF / (numColors - 1);
if (photometricInterpretation == 0) value = 0xFF - value;
rgbs[i] = new RGB(value, value, value);
}
return new PaletteData(rgbs);
}
PaletteData getRGBPalette(int bitsR, int bitsG, int bitsB) {
int blueMask = 0;
for (int i = 0; i < bitsB; i++) {
blueMask |= 1 << i;
}
int greenMask = 0;
for (int i = bitsB; i < bitsB + bitsG; i++) {
greenMask |= 1 << i;
}
int redMask = 0;
for (int i = bitsB + bitsG; i < bitsB + bitsG + bitsR; i++) {
redMask |= 1 << i;
}
return new PaletteData(redMask, greenMask, blueMask);
}
int formatStrips(int rowByteSize, int nbrRows, byte[] data, int maxStripByteSize, int offsetPostIFD, int extraBytes, int[][] strips) {
/*
* Calculate the nbr of required strips given the following requirements:
* - each strip should, if possible, not be greater than maxStripByteSize
* - each strip should contain 1 or more entire rows
*
* Format the strip fields arrays so that the image data is stored in one
* contiguous block. This block is stored after the IFD and after any tag
* info described in the IFD.
*/
int n, nbrRowsPerStrip;
if (rowByteSize > maxStripByteSize) {
/* Each strip contains 1 row */
n = data.length / rowByteSize;
nbrRowsPerStrip = 1;
} else {
int nbr = (data.length + maxStripByteSize - 1) / maxStripByteSize;
nbrRowsPerStrip = nbrRows / nbr;
n = (nbrRows + nbrRowsPerStrip - 1) / nbrRowsPerStrip;
}
int stripByteSize = rowByteSize * nbrRowsPerStrip;
int[] offsets = new int[n];
int[] counts = new int[n];
/*
* Nbr of bytes between the end of the IFD directory and the start of
* the image data. Keep space for at least the offsets and counts
* data, each field being TYPE_LONG (4 bytes). If other tags require
* space between the IFD and the image block, use the extraBytes
* parameter.
* If there is only one strip, the offsets and counts data is stored
* directly in the IFD and we need not reserve space for it.
*/
int postIFDData = n == 1 ? 0 : n * 2 * 4;
int startOffset = offsetPostIFD + extraBytes + postIFDData; /* offset of image data */
int offset = startOffset;
for (int i = 0; i < n; i++) {
/*
* Store all strips sequentially to allow us
* to copy all pixels in one contiguous area.
*/
offsets[i] = offset;
counts[i] = stripByteSize;
offset += stripByteSize;
}
/* The last strip may contain fewer rows */
int mod = data.length % stripByteSize;
if (mod != 0) counts[counts.length - 1] = mod;
strips[0] = offsets;
strips[1] = counts;
return nbrRowsPerStrip;
}
int[] formatColorMap(RGB[] rgbs) {
/*
* In a TIFF ColorMap, all red come first, followed by
* green and blue. All values must be converted from
* 8 bit to 16 bit.
*/
int[] colorMap = new int[rgbs.length * 3];
int offsetGreen = rgbs.length;
int offsetBlue = rgbs.length * 2;
for (int i = 0; i < rgbs.length; i++) {
colorMap[i] = rgbs[i].red << 8 | rgbs[i].red;
colorMap[i + offsetGreen] = rgbs[i].green << 8 | rgbs[i].green;
colorMap[i + offsetBlue] = rgbs[i].blue << 8 | rgbs[i].blue;
}
return colorMap;
}
void parseEntries(byte[] buffer) throws IOException {
for (int offset = 0; offset < buffer.length; offset += IFD_ENTRY_SIZE) {
int tag = toInt(buffer, offset, TYPE_SHORT);
int type = toInt(buffer, offset + 2, TYPE_SHORT);
int count = toInt(buffer, offset + 4, TYPE_LONG);
switch (tag) {
case TAG_NewSubfileType: {
subfileType = getEntryValue(type, buffer, offset);
break;
}
case TAG_SubfileType: {
int oldSubfileType = getEntryValue(type, buffer, offset);
subfileType = oldSubfileType == OFILETYPE_REDUCEDIMAGE ? FILETYPE_REDUCEDIMAGE : oldSubfileType == OFILETYPE_PAGE ? FILETYPE_PAGE : 0;
break;
}
case TAG_ImageWidth: {
imageWidth = getEntryValue(type, buffer, offset);
break;
}
case TAG_ImageLength: {
imageLength = getEntryValue(type, buffer, offset);
break;
}
case TAG_BitsPerSample: {
if (type != TYPE_SHORT) SWT.error(SWT.ERROR_INVALID_IMAGE);
bitsPerSample = new int[count];
getEntryValue(type, buffer, offset, bitsPerSample);
break;
}
case TAG_Compression: {
compression = getEntryValue(type, buffer, offset);
break;
}
case TAG_FillOrder: {
/* Ignored: baseline only requires default fill order. */
break;
}
case TAG_ImageDescription: {
/* Ignored */
break;
}
case TAG_PhotometricInterpretation: {
photometricInterpretation = getEntryValue(type, buffer, offset);
break;
}
case TAG_StripOffsets: {
if (type != TYPE_LONG && type != TYPE_SHORT) SWT.error(SWT.ERROR_INVALID_IMAGE);
stripOffsets = new int[count];
getEntryValue(type, buffer, offset, stripOffsets);
break;
}
case TAG_Orientation: {
/* Ignored: baseline only requires top left orientation. */
break;
}
case TAG_SamplesPerPixel: {
if (type != TYPE_SHORT) SWT.error(SWT.ERROR_INVALID_IMAGE);
samplesPerPixel = getEntryValue(type, buffer, offset);
/* Only the basic 1 and 3 values are supported */
if (samplesPerPixel != 1 && samplesPerPixel != 3) SWT.error(SWT.ERROR_UNSUPPORTED_DEPTH);
break;
}
case TAG_RowsPerStrip: {
rowsPerStrip = getEntryValue(type, buffer, offset);
break;
}
case TAG_StripByteCounts: {
stripByteCounts = new int[count];
getEntryValue(type, buffer, offset, stripByteCounts);
break;
}
case TAG_XResolution: {
/* Ignored */
break;
}
case TAG_YResolution: {
/* Ignored */
break;
}
case TAG_PlanarConfiguration: {
/* Ignored: baseline only requires default planar configuration. */
break;
}
case TAG_T4Options: {
if (type != TYPE_LONG) SWT.error(SWT.ERROR_INVALID_IMAGE);
t4Options = getEntryValue(type, buffer, offset);
if ((t4Options & 0x1) == 1) {
/* 2-dimensional coding is not supported */
SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT);
}
break;
}
case TAG_ResolutionUnit: {
/* Ignored */
break;
}
case TAG_Software: {
/* Ignored */
break;
}
case TAG_DateTime: {
/* Ignored */
break;
}
case TAG_ColorMap: {
if (type != TYPE_SHORT) SWT.error(SWT.ERROR_INVALID_IMAGE);
/* Get the offset of the colorMap (use TYPE_LONG) */
colorMapOffset = getEntryValue(TYPE_LONG, buffer, offset);
break;
}
}
}
}
public ImageData read(int [] nextIFDOffset) throws IOException {
/* Set TIFF default values */
bitsPerSample = new int[] {1};
colorMapOffset = NO_VALUE;
compression = 1;
imageLength = NO_VALUE;
imageWidth = NO_VALUE;
photometricInterpretation = NO_VALUE;
rowsPerStrip = Integer.MAX_VALUE;
samplesPerPixel = 1;
stripByteCounts = null;
stripOffsets = null;
byte[] buffer = new byte[2];
file.read(buffer);
int numberEntries = toInt(buffer, 0, TYPE_SHORT);
buffer = new byte[IFD_ENTRY_SIZE * numberEntries];
file.read(buffer);
byte buffer2[] = new byte[4];
file.read(buffer2);
nextIFDOffset[0] = toInt(buffer2, 0, TYPE_LONG);
parseEntries(buffer);
PaletteData palette = null;
depth = 0;
switch (photometricInterpretation) {
case 0:
case 1: {
/* Bilevel or Grayscale image */
palette = getGrayPalette();
depth = bitsPerSample[0];
break;
}
case 2: {
/* RGB image */
if (colorMapOffset != NO_VALUE) SWT.error(SWT.ERROR_INVALID_IMAGE);
/* SamplesPerPixel 3 is the only value supported */
palette = getRGBPalette(bitsPerSample[0], bitsPerSample[1], bitsPerSample[2]);
depth = bitsPerSample[0] + bitsPerSample[1] + bitsPerSample[2];
break;
}
case 3: {
/* Palette Color image */
if (colorMapOffset == NO_VALUE) SWT.error(SWT.ERROR_INVALID_IMAGE);
palette = getColorMap();
depth = bitsPerSample[0];
break;
}
default: {
SWT.error(SWT.ERROR_INVALID_IMAGE);
}
}
ImageData image = ImageData.internal_new(
imageWidth,
imageLength,
depth,
palette,
1,
null,
0,
null,
null,
-1,
-1,
SWT.IMAGE_TIFF,
0,
0,
0,
0);
decodePixels(image);
return image;
}
int toInt(byte[] buffer, int i, int type) {
if (type == TYPE_LONG) {
return isLittleEndian ?
(buffer[i] & 0xFF) | ((buffer[i + 1] & 0xFF) << 8) | ((buffer[i + 2] & 0xFF) << 16) | ((buffer[i + 3] & 0xFF) << 24) :
(buffer[i + 3] & 0xFF) | ((buffer[i + 2] & 0xFF) << 8) | ((buffer[i + 1] & 0xFF) << 16) | ((buffer[i] & 0xFF) << 24);
}
if (type == TYPE_SHORT) {
return isLittleEndian ?
(buffer[i] & 0xFF) | ((buffer[i + 1] & 0xFF) << 8) :
(buffer[i + 1] & 0xFF) | ((buffer[i] & 0xFF) << 8);
}
/* Invalid type */
SWT.error(SWT.ERROR_INVALID_IMAGE);
return -1;
}
void write(int photometricInterpretation) throws IOException {
boolean isRGB = photometricInterpretation == 2;
boolean isColorMap = photometricInterpretation == 3;
boolean isBiLevel = photometricInterpretation == 0 || photometricInterpretation == 1;
int imageWidth = image.width;
int imageLength = image.height;
int rowByteSize = image.bytesPerLine;
int numberEntries = isBiLevel ? 9 : 11;
int lengthDirectory = 2 + 12 * numberEntries + 4;
/* Offset following the header and the directory */
int nextOffset = 8 + lengthDirectory;
/* Extra space used by XResolution and YResolution values */
int extraBytes = 16;
int[] colorMap = null;
if (isColorMap) {
PaletteData palette = image.palette;
RGB[] rgbs = palette.getRGBs();
colorMap = formatColorMap(rgbs);
/* The number of entries of the Color Map must match the bitsPerSample field */
if (colorMap.length != 3 * 1 << image.depth) SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT);
/* Extra space used by ColorMap values */
extraBytes += colorMap.length * 2;
}
if (isRGB) {
/* Extra space used by BitsPerSample values */
extraBytes += 6;
}
/* TIFF recommends storing the data in strips of no more than 8 Ko */
byte[] data = image.data;
int[][] strips = new int[2][];
int nbrRowsPerStrip = formatStrips(rowByteSize, imageLength, data, 8192, nextOffset, extraBytes, strips);
int[] stripOffsets = strips[0];
int[] stripByteCounts = strips[1];
int bitsPerSampleOffset = NO_VALUE;
if (isRGB) {
bitsPerSampleOffset = nextOffset;
nextOffset += 6;
}
int stripOffsetsOffset = NO_VALUE, stripByteCountsOffset = NO_VALUE;
int xResolutionOffset, yResolutionOffset, colorMapOffset = NO_VALUE;
int cnt = stripOffsets.length;
if (cnt > 1) {
stripOffsetsOffset = nextOffset;
nextOffset += 4 * cnt;
stripByteCountsOffset = nextOffset;
nextOffset += 4 * cnt;
}
xResolutionOffset = nextOffset;
nextOffset += 8;
yResolutionOffset = nextOffset;
nextOffset += 8;
if (isColorMap) {
colorMapOffset = nextOffset;
nextOffset += colorMap.length * 2;
}
/* TIFF header */
writeHeader();
/* Image File Directory */
out.writeShort(numberEntries);
writeEntry(TAG_ImageWidth, TYPE_LONG, 1, imageWidth);
writeEntry(TAG_ImageLength, TYPE_LONG, 1, imageLength);
if (isColorMap) writeEntry(TAG_BitsPerSample, TYPE_SHORT, 1, image.depth);
if (isRGB) writeEntry(TAG_BitsPerSample, TYPE_SHORT, 3, bitsPerSampleOffset);
writeEntry(TAG_Compression, TYPE_SHORT, 1, COMPRESSION_NONE);
writeEntry(TAG_PhotometricInterpretation, TYPE_SHORT, 1, photometricInterpretation);
writeEntry(TAG_StripOffsets, TYPE_LONG, cnt, cnt > 1 ? stripOffsetsOffset : stripOffsets[0]);
if (isRGB) writeEntry(TAG_SamplesPerPixel, TYPE_SHORT, 1, 3);
writeEntry(TAG_RowsPerStrip, TYPE_LONG, 1, nbrRowsPerStrip);
writeEntry(TAG_StripByteCounts, TYPE_LONG, cnt, cnt > 1 ? stripByteCountsOffset : stripByteCounts[0]);
writeEntry(TAG_XResolution, TYPE_RATIONAL, 1, xResolutionOffset);
writeEntry(TAG_YResolution, TYPE_RATIONAL, 1, yResolutionOffset);
if (isColorMap) writeEntry(TAG_ColorMap, TYPE_SHORT, colorMap.length, colorMapOffset);
/* Offset of next IFD (0 for last IFD) */
out.writeInt(0);
/* Values longer than 4 bytes Section */
/* BitsPerSample 8,8,8 */
if (isRGB) for (int i = 0; i < 3; i++) out.writeShort(8);
if (cnt > 1) {
for (int i = 0; i < cnt; i++) out.writeInt(stripOffsets[i]);
for (int i = 0; i < cnt; i++) out.writeInt(stripByteCounts[i]);
}
/* XResolution and YResolution set to 300 dpi */
for (int i = 0; i < 2; i++) {
out.writeInt(300);
out.writeInt(1);
}
/* ColorMap */
if (isColorMap) for (int i = 0; i < colorMap.length; i++) out.writeShort(colorMap[i]);
/* Image Data */
out.write(data);
}
void writeEntry(short tag, int type, int count, int value) throws IOException {
out.writeShort(tag);
out.writeShort(type);
out.writeInt(count);
out.writeInt(value);
}
void writeHeader() throws IOException {
/* little endian */
out.write(0x49);
out.write(0x49);
/* TIFF identifier */
out.writeShort(42);
/*
* Offset of the first IFD is chosen to be 8.
* It is word aligned and immediately after this header.
*/
out.writeInt(8);
}
void writeToStream(LEDataOutputStream byteStream) throws IOException {
out = byteStream;
int photometricInterpretation = -1;
/* Scanline pad must be 1 */
if (image.scanlinePad != 1) SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT);
switch (image.depth) {
case 1: {
/* Palette must be black and white or white and black */
PaletteData palette = image.palette;
RGB[] rgbs = palette.colors;
if (palette.isDirect || rgbs == null || rgbs.length != 2) SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT);
RGB rgb0 = rgbs[0];
RGB rgb1 = rgbs[1];
if (!(rgb0.red == rgb0.green && rgb0.green == rgb0.blue &&
rgb1.red == rgb1.green && rgb1.green == rgb1.blue &&
((rgb0.red == 0x0 && rgb1.red == 0xFF) || (rgb0.red == 0xFF && rgb1.red == 0x0)))) {
SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT);
}
/* 0 means a color index of 0 is imaged as white */
photometricInterpretation = image.palette.colors[0].red == 0xFF ? 0 : 1;
break;
}
case 4:
case 8: {
photometricInterpretation = 3;
break;
}
case 24: {
photometricInterpretation = 2;
break;
}
default: {
SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT);
}
}
write(photometricInterpretation);
}
}