* TIFFCodec codec = new TIFFCodec();
* codec.setFile("image.tif", CodecMode.LOAD);
* codec.process();
* PixelImage loadedImage = codec.getImage();
*
* Saving images is not supported by this codec.
*
* * Note that you can write your own decoder (extending {@link TIFFDecoder}) for any compression type * you want. *
* ** Note that you can write your own decoder (extending {@link TIFFDecoder}) for any compression type * you want. *
* *Writing TIFFs is not supported. * I don't know if or when it will be supported.
* ** Later, the concept of tiles was added to the TIFF specs. * Tiled TIFFs are separated into rectangles that not only had a defineable * height but also a defineable width (tile width and tile height are also stored in * corresponding tags). *
* Obviously, strips are just a special case of tiles, with the tile width being equal * to image width. * That is why JIU internally only deals with tiles. * The only difference: No row padding takes place for strips. * In a tiled image with a tile height of 10 and an image height of 14, * the image is two tiles high. * *
* TIFF was created by Aldus and now belongs to Adobe, who offer a specification document: * TIFF * (Tagged Image File Format) 6.0 Specification (updated on Web September, 20 1995, * document dated June, 3 1992) (PDF: 385 KB / 121 pages). *
* Other good references include the homepage * of libtiff, a free C library to read and write TIFF files and * The Unofficial TIFF * homepage by Niles Ritter. * Also see the TIFF section * of the Open Directory. *
* TIFF is used for various specialized tasks. * As an example, see GeoTIFF (geographical * data) or EXIF * (digital camera metadata; this is actually a TIFF directory embedded in a JPEG header). *
* Here's a list of features that make TIFF quite complex: *
* Why this is necessary remains a mystery to me. Marco
*
* @param value the int value which may have to be adjusted
* @return the value parameter which may have been modified
*/
private int adjustInt(int value, int type)
{
if (getByteOrder() == BYTE_ORDER_MOTOROLA)
{
if (type == TAG_TYPE_BYTE)
{
return ((value >> 24) & 0xff);
}
else
if (type == TAG_TYPE_SHORT)
{
return ((value >> 16) & 0xff) | (((value >> 24) & 0xff) << 8);
}
else
{
return value;
}
}
else
{
return value;
}
}
private static TIFFDecoder createDecoder(TIFFCodec codec, TIFFImageFileDirectory ifd, int tileIndex) throws
IOException,
UnsupportedTypeException
{
Integer compression = new Integer(ifd.getCompression());
Class decoderClass = (Class)decoders.get(compression);
if (decoderClass == null)
{
throw new UnsupportedTypeException("Could not create decoder for this compression type: " +
compression.intValue());
}
Object instance;
try
{
instance = decoderClass.newInstance();
}
catch (Exception e)
{
throw new UnsupportedTypeException("Could not create decoder for this compression type.");
}
if (instance instanceof TIFFDecoder)
{
TIFFDecoder decoder = (TIFFDecoder)instance;
decoder.setCodec(codec);
decoder.setTileIndex(tileIndex);
decoder.setImageFileDirectory(ifd);
try
{
decoder.initialize();
}
catch (MissingParameterException mpe)
{
throw new UnsupportedTypeException("Unable to initialize decoder: " + mpe.toString());
}
return decoder;
}
else
{
throw new UnsupportedTypeException("Could not create decoder for this compression type.");
}
}
/**
* Returns the current byte order, either
* {@link #BYTE_ORDER_INTEL} or
* {@link #BYTE_ORDER_MOTOROLA}.
* @return current byte order
*/
public int getByteOrder()
{
return byteOrder;
}
public String getFormatName()
{
return "Tagged Image File Format (TIFF)";
}
public String[] getMimeTypes()
{
return new String[] {"image/tiff", "image/tif"};
}
/**
* Returns the name of a tag in English.
* @param id of the tag for which a name is to be returned
* @return tag name as String or a question mark ?
*/
public static String getTagName(int id)
{
switch(id)
{
case(TAG_ARTIST): return "Artist";
case(TAG_BAD_FAX_LINES): return "Bad fax lines";
case(TAG_BITS_PER_SAMPLE): return "Bits per sample";
case(TAG_CELL_LENGTH): return "Cell length";
case(TAG_CELL_WIDTH): return "Cell width";
case(TAG_CLEAN_FAX_DATA): return "Clean fax data";
case(TAG_COLOR_MAP): return "Color map";
case(TAG_COMPRESSION): return "Compression";
case(TAG_CONSECUTIVE_BAD_FAX_LINES): return "Consecutive bad fax lines";
case(TAG_COPYRIGHT): return "Copyright";
case(TAG_DATE_TIME): return "Date and time";
case(TAG_DOCUMENT_NAME): return "Document name";
case(TAG_EXTRA_SAMPLES): return "Extra samples";
case(TAG_FILL_ORDER): return "Fill order";
case(TAG_FREE_BYTE_COUNTS): return "Free byte counts";
case(TAG_FREE_OFFSETS): return "Free offsets";
case(TAG_GRAY_RESPONSE_CURVE): return "Gray response curve";
case(TAG_GRAY_RESPONSE_UNIT): return "Gray response unit";
case(TAG_HOST_COMPUTER): return "Host computer";
case(TAG_IMAGE_DESCRIPTION): return "Image description";
case(TAG_IMAGE_LENGTH): return "Image length";
case(TAG_IMAGE_WIDTH): return "Image width";
case(TAG_MAKE): return "Make";
case(TAG_MAX_SAMPLE_VALUE): return "Maximum sample value";
case(TAG_MIN_SAMPLE_VALUE): return "Minimum sample value";
case(TAG_MODEL): return "Model";
case(TAG_NEW_SUBFILE_TYPE): return "New subfile type";
case(TAG_ORIENTATION): return "Orientation";
case(TAG_PHOTOMETRIC_INTERPRETATION): return "Photometric interpretation";
case(TAG_PLANAR_CONFIGURATION): return "Planar configuration";
case(TAG_PREDICTOR): return "Predictor";
case(TAG_RESOLUTION_UNIT): return "Resolution unit";
case(TAG_RESOLUTION_X): return "Resolution X";
case(TAG_RESOLUTION_Y): return "Resolution Y";
case(TAG_ROWS_PER_STRIP): return "Rows per strip";
case(TAG_SAMPLES_PER_PIXEL): return "Samples per pixel";
case(TAG_SOFTWARE): return "Software";
case(TAG_STRIP_BYTE_COUNTS): return "Strip byte counts";
case(TAG_STRIP_OFFSETS): return "Strip offsets";
case(TAG_TILE_BYTE_COUNTS): return "Byte counts";
case(TAG_TILE_HEIGHT): return "Tile height";
case(TAG_TILE_OFFSETS): return "Tile offsets";
case(TAG_TILE_WIDTH): return "Tile width";
default: return "?";
}
}
public boolean isLoadingSupported()
{
return true;
}
public boolean isSavingSupported()
{
return false;
}
/**
* Attempts to load an image from a file in the TIFF format.
* Some options can be given to this codec before the call
* to this load method.
*
0,
* the second 1 and so on. The default is 0.null on failure
*/
private TIFFImageFileDirectory readImageFileDirectory() throws
InvalidFileStructureException,
IOException
{
TIFFImageFileDirectory result = new TIFFImageFileDirectory();
RandomAccessFile in = getRandomAccessFile();
in.seek(nextIfdOffset);
short numTags = readShort();
if (numTags < 0)
{
throw new InvalidFileStructureException("Number of tags in IFD " +
"smaller than 1 @" + nextIfdOffset + ": " + numTags);
}
for (int i = 0; i < numTags; i++)
{
TIFFTag tag = readTag();
if (tag != null)
{
result.append(tag);
}
}
nextIfdOffset = in.readInt();
return result;
}
/**
* Reads a 32 bit signed integer value, regarding the current byte order.
* @return the loaded value
* @see #getByteOrder
*/
private int readInt() throws IOException
{
RandomAccessFile in = getRandomAccessFile();
int result = in.readInt();
if (getByteOrder() == BYTE_ORDER_INTEL)
{
int r1 = (result >> 24) & 0xff;
int r2 = (result >> 16) & 0xff;
int r3 = (result >> 8) & 0xff;
int r4 = result & 0xff;
return r1 | (r2 << 8) | (r3 << 16) | (r4 << 24);
}
else
{
return result;
}
}
/**
* Reads a 16 bit signed integer value, regarding the current byte order.
* @return the loaded value
*/
private short readShort() throws IOException
{
RandomAccessFile in = getRandomAccessFile();
short result = in.readShort();
if (getByteOrder() == BYTE_ORDER_INTEL)
{
int r1 = (result >> 8) & 0xff;
int r2 = result & 0xff;
return (short)((r2 << 8) | r1);
}
else
{
return result;
}
}
/**
* Loads a String of a given length from current position of input file.
* Characters are one-byte ASCII.
* Non-text characters are dropped.
* @param length number of characters in a row to be loaded
* @return loaded String
* @throws IOException if there were reading errors or an unexpected
* end of file
*/
private String readString(int length) throws IOException
{
RandomAccessFile in = getRandomAccessFile();
StringBuffer sb = new StringBuffer(length - 1);
while (length-- > 0)
{
int value = in.read();
if (value >= 32 && value < 256)
{
sb.append((char)value);
}
}
return sb.toString();
}
/**
* Reads a TIFF tag and all data belonging to it and returns a
* TIFFTag object.
* The additional data is somewhere in the TIFF file.
* The current position will be stored, the method will seek to the offset
* position and load the data.
*
* @return TIFFTag containing information on the tag
*/
private TIFFTag readTag() throws
InvalidFileStructureException,
IOException
{
RandomAccessFile in = getRandomAccessFile();
int id = readShort() & 0xffff;
int type = readShort() & 0xffff;
int count = readInt();
int offset = readInt();
if (count < 1)
{
//throw new InvalidFileStructureException("Invalid count value for tag " + id + " (" + count + ").");
return null;
}
Vector vector = null;
// perform weird bitshifting magic if necessary
if (count == 1 &&
(type == TAG_TYPE_BYTE || type == TAG_TYPE_SHORT || type == TAG_TYPE_LONG))
{
offset = adjustInt(offset, type);
}
else
if (count <= 4 && type == TAG_TYPE_BYTE)
{
vector = new Vector();
for (int i = 0; i < count; i++)
{
byte b = (byte)((offset << (i * 8)) & 0xff);
vector.addElement(new Byte(b));
}
}
else
if (count >= 1)
{
long oldOffset = in.getFilePointer();
in.seek(offset);
vector = new Vector();
if (type == TAG_TYPE_ASCII)
{
vector.addElement(readString(count));
}
else
if (type == TAG_TYPE_BYTE)
{
for (int i = 0; i < count; i++)
{
byte b = in.readByte();
vector.addElement(new Byte(b));
}
}
else
if (type == TAG_TYPE_SHORT)
{
for (int i = 0; i < count; i++)
{
int s = readShort();
vector.addElement(new Short((short)s));
}
}
else
if (type == TAG_TYPE_LONG)
{
for (int i = 0; i < count; i++)
{
int v = adjustInt(readInt(), type);
vector.addElement(new Integer(v));
}
}
else
if (type == TAG_TYPE_RATIONAL)
{
for (int i = 0; i < count; i++)
{
int v1 = adjustInt(readInt(), TAG_TYPE_LONG);
int v2 = adjustInt(readInt(), TAG_TYPE_LONG);
vector.addElement(new TIFFRational(v1, v2));
}
}
in.seek(oldOffset);
}
TIFFTag result = new TIFFTag(id, type, count, offset);
result.setVector(vector);
return result;
}
/**
* Register a {@link TIFFDecoder} class.
* TIFF knows many compression types, and JIU only supports some of them.
* To register an external TIFFDecoder class with TIFFCodec, call this method
* with the class field of your decoder.
* As an example, for your TIFFDecoderMyCompression class,
* call TIFFCodec.registerDecoder(TIFFDecoderMyCompression.class).
* It will be checked if
* decoderClass.newInstance() instanceof TIFFDecoder
* is true and, if so, the class will be added to an internal list.
* Whenever a TIFF file is to be decoded, the correct decoder is determined
* (each decoder knows about the compression types it supports via the getCompressionTypes method)
* and for each tile or strip such a decoder object will be created.
*/
public static void registerDecoder(Class decoderClass)
{
if (decoderClass == null)
{
return;
}
Object instance;
try
{
instance = decoderClass.newInstance();
}
catch (Exception e)
{
return;
}
if (instance instanceof TIFFDecoder)
{
TIFFDecoder decoder = (TIFFDecoder)instance;
Integer[] compressionTypes = decoder.getCompressionTypes();
if (compressionTypes == null)
{
return;
}
int index = 0;
while (index < compressionTypes.length)
{
Integer type = compressionTypes[index++];
if (type != null)
{
decoders.put(type, decoderClass);
}
}
}
}
/**
* Sets the byte order to the argument.
* The byte order in a TIFF file is either {@link #BYTE_ORDER_INTEL} or
* {@link #BYTE_ORDER_MOTOROLA}.
* @param newByteOrder the new byte order to be set
* @throws IllegalArgumentException if the argument is not one of the above
* mentioned constants
*/
private void setByteOrder(int newByteOrder)
{
if (newByteOrder == BYTE_ORDER_INTEL ||
newByteOrder == BYTE_ORDER_MOTOROLA)
{
byteOrder = newByteOrder;
}
else
{
throw new IllegalArgumentException("Byte order must be either " +
"BYTE_ORDER_INTEL or BYTE_ORDER_MOTOROLA.");
}
}
public void setFile(String fileName, CodecMode codecMode) throws
IOException,
UnsupportedCodecModeException
{
if (codecMode == CodecMode.LOAD)
{
setRandomAccessFile(new RandomAccessFile(fileName, "r"), CodecMode.LOAD);
}
else
{
throw new UnsupportedCodecModeException("This TIFF codec can only load images.");
}
}
/**
* Skips a given number of image file directories in this TIFF files.
* Throws an exception if there were errors or not enough image file
* directories.
* @param numDirectories the number of directories to be skipped,
* should be non-negative
* @throws IllegalArgumentException if argument is negative
* @throws InvalidFileStructureException if there aren't enough image
* file directories
* @throws IOExceptions if there were errors reading or skipping data
*/
private void skipImageFileDirectories(int numDirectories) throws
InvalidFileStructureException,
IOException
{
RandomAccessFile in = getRandomAccessFile();
if (numDirectories < 0)
{
throw new IllegalArgumentException("Cannot skip negative number " +
"of image file directories: " + numDirectories);
}
int skipped = 0;
while (numDirectories-- > 0)
{
in.seek(nextIfdOffset);
short numTags = readShort();
in.skipBytes(numTags * 12);
nextIfdOffset = readInt();
if (nextIfdOffset == 0)
{
throw new InvalidFileStructureException("Could only skip " +
skipped + " image file directories, no more images in file.");
}
skipped++;
}
}
}