diff --git a/src/java/org/apache/xmlgraphics/image/codec/tiff/CompressionValue.java b/src/java/org/apache/xmlgraphics/image/codec/tiff/CompressionValue.java
new file mode 100644
index 0000000..b1fe2ed
--- /dev/null
+++ b/src/java/org/apache/xmlgraphics/image/codec/tiff/CompressionValue.java
@@ -0,0 +1,84 @@
+/*
+ * 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.
+ */
+
+package org.apache.xmlgraphics.image.codec.tiff;
+
+
+/** Enumerates the possible compression values for TIFF images. */
+public enum CompressionValue {
+    /** No compression. */
+    NONE(1),
+    /**
+     * Modified Huffman Compression (CCITT Group 3 1D facsimile compression).
+     * <p><b>Not currently supported.</b>
+     */
+    GROUP3_1D(2),
+    /**
+     * CCITT T.4 bilevel compression (CCITT Group 3 2D facsimile compression).
+     * <p><b>Not currently supported.</b>
+     */
+    GROUP3_2D(3),
+    /**
+     * CCITT T.6 bilevel compression (CCITT Group 4 facsimile compression).
+     * <p><b>Not currently supported.</b>
+     */
+    GROUP4(4),
+    /** LZW compression. <p><b>Not supported.</b> */
+    LZW(5),
+    /**
+     * Code for original JPEG-in-TIFF compression which has been depricated (for many good reasons)
+     * in favor of Tech Note 2 JPEG compression (compression scheme 7).
+     * <p><b>Not supported.</b>
+     */
+    JPEG_BROKEN(6),
+    /** <a href="ftp://ftp.sgi.com/graphics/tiff/TTN2.draft.txt"> JPEG-in-TIFF</a> compression. */
+    JPEG_TTN2(7),
+    /** Byte-oriented run-length encoding "PackBits" compression. */
+    PACKBITS(32773),
+    /**
+     * <a href="http://info.internet.isi.edu:80/in-notes/rfc/files/rfc1951.txt">
+     * DEFLATE</a> lossless compression (also known as "Zip-in-TIFF").
+     */
+    DEFLATE(32946);
+
+    private final int compressionValue;
+
+    private CompressionValue(int compressionValue) {
+        this.compressionValue = compressionValue;
+    }
+
+    int getValue() {
+        return compressionValue;
+    }
+
+    /**
+     * Gets the compression value given the name of the compression type.
+     * @param name the compression name
+     * @return the compression value
+     */
+    public static CompressionValue getValue(String name) {
+        if (name == null) {
+            return PACKBITS;
+        }
+        for (CompressionValue cv : CompressionValue.values()) {
+            if (cv.toString().equalsIgnoreCase(name)) {
+                return cv;
+            }
+        }
+        throw new IllegalArgumentException("Unknown compression value: " + name);
+    }
+}
diff --git a/src/java/org/apache/xmlgraphics/image/codec/tiff/ExtraSamplesType.java b/src/java/org/apache/xmlgraphics/image/codec/tiff/ExtraSamplesType.java
new file mode 100644
index 0000000..5600092
--- /dev/null
+++ b/src/java/org/apache/xmlgraphics/image/codec/tiff/ExtraSamplesType.java
@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+package org.apache.xmlgraphics.image.codec.tiff;
+
+import java.awt.image.ColorModel;
+
+enum ExtraSamplesType {
+    UNSPECIFIED(0),
+    ASSOCIATED_ALPHA(1),
+    UNASSOCIATED_ALPHA(2);
+
+    private final int typeValue;
+
+    private ExtraSamplesType(int value) {
+        this.typeValue = value;
+    }
+
+    static ExtraSamplesType getValue(ColorModel colorModel, int numExtraSamples) {
+        if (numExtraSamples == 1 && colorModel.hasAlpha()) {
+            return colorModel.isAlphaPremultiplied() ? ASSOCIATED_ALPHA : UNASSOCIATED_ALPHA;
+        }
+        return UNSPECIFIED;
+    }
+
+    int getValue() {
+        return typeValue;
+    }
+}
\ No newline at end of file
diff --git a/src/java/org/apache/xmlgraphics/image/codec/tiff/ImageInfo.java b/src/java/org/apache/xmlgraphics/image/codec/tiff/ImageInfo.java
new file mode 100644
index 0000000..f30286a
--- /dev/null
+++ b/src/java/org/apache/xmlgraphics/image/codec/tiff/ImageInfo.java
@@ -0,0 +1,213 @@
+/*
+ * 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.
+ */
+
+package org.apache.xmlgraphics.image.codec.tiff;
+
+import java.awt.color.ColorSpace;
+import java.awt.image.ColorModel;
+import java.awt.image.IndexColorModel;
+import java.awt.image.RenderedImage;
+
+final class ImageInfo {
+
+    // Default values
+    private static final int DEFAULT_ROWS_PER_STRIP = 8;
+
+    private final int numExtraSamples;
+    private final ExtraSamplesType extraSampleType;
+    private final ImageType imageType;
+    private final int colormapSize;
+    private final char[] colormap;
+    private final int tileWidth;
+    private final int tileHeight;
+    private final int numTiles;
+    private final long bytesPerRow;
+    private final long bytesPerTile;
+
+    private ImageInfo(ImageInfoBuilder builder) {
+        this.numExtraSamples = builder.numExtraSamples;
+        this.extraSampleType = builder.extraSampleType;
+        this.imageType = builder.imageType;
+        this.colormapSize = builder.colormapSize;
+        this.colormap = copyColormap(builder.colormap);
+        this.tileWidth = builder.tileWidth;
+        this.tileHeight = builder.tileHeight;
+        this.numTiles = builder.numTiles;
+        this.bytesPerRow = builder.bytesPerRow;
+        this.bytesPerTile = builder.bytesPerTile;
+    }
+
+    private static char[] copyColormap(char[] colorMap) {
+        if (colorMap == null) {
+            return null;
+        }
+        char[] copy = new char[colorMap.length];
+        System.arraycopy(colorMap, 0, copy, 0, colorMap.length);
+        return copy;
+    }
+
+    private static int getNumberOfExtraSamplesForColorSpace(ColorSpace colorSpace,
+            ImageType imageType, int numBands) {
+        if (imageType == ImageType.GENERIC) {
+            return numBands - 1;
+        } else if (numBands > 1) {
+            return numBands - colorSpace.getNumComponents();
+        } else {
+            return 0;
+        }
+    }
+
+    private static char[] createColormap(final int sizeOfColormap, byte[] r, byte[] g, byte[] b) {
+        int redIndex = 0;
+        int greenIndex = sizeOfColormap;
+        int blueIndex = 2 * sizeOfColormap;
+        char[] colormap = new char[sizeOfColormap * 3];
+        for (int i = 0; i < sizeOfColormap; i++) {
+            // beware of sign extended bytes
+            colormap[redIndex++] = convertColorToColormapChar(0xff & r[i]);
+            colormap[greenIndex++] = convertColorToColormapChar(0xff & g[i]);
+            colormap[blueIndex++] = convertColorToColormapChar(0xff & b[i]);
+        }
+        return colormap;
+    }
+
+    private static char convertColorToColormapChar(int color) {
+        return (char) (color << 8 | color);
+    }
+
+    int getNumberOfExtraSamples() {
+        return numExtraSamples;
+    }
+
+    ExtraSamplesType getExtraSamplesType() {
+        return extraSampleType;
+    }
+
+    ImageType getType() {
+        return imageType;
+    }
+
+    int getColormapSize() {
+        return colormapSize;
+    }
+
+    char[] getColormap() {
+        return copyColormap(colormap);
+    }
+
+    int getTileWidth() {
+        return tileWidth;
+    }
+
+    int getTileHeight() {
+        return tileHeight;
+    }
+
+    int getNumTiles() {
+        return numTiles;
+    }
+
+    long getBytesPerRow() {
+        return bytesPerRow;
+    }
+
+    long getBytesPerTile() {
+        return bytesPerTile;
+    }
+
+    static ImageInfo newInstance(RenderedImage im, int dataTypeSize, int numBands,
+            ColorModel colorModel, TIFFEncodeParam params) {
+        ImageInfoBuilder builder = new ImageInfoBuilder();
+        if (colorModel instanceof IndexColorModel) { // Bilevel or palette
+            IndexColorModel indexColorModel = (IndexColorModel) colorModel;
+            int colormapSize = indexColorModel.getMapSize();
+            byte[] r = new byte[colormapSize];
+            indexColorModel.getReds(r);
+            byte[] g = new byte[colormapSize];
+            indexColorModel.getGreens(g);
+            byte[] b = new byte[colormapSize];
+            indexColorModel.getBlues(b);
+
+            builder.imageType = ImageType.getTypeFromRGB(colormapSize, r, g, b, dataTypeSize,
+                    numBands);
+            if (builder.imageType == ImageType.PALETTE) {
+                builder.colormap = createColormap(colormapSize, r, g, b);
+                builder.colormapSize = colormapSize * 3;
+            }
+        } else if (colorModel == null) {
+            if (dataTypeSize == 1 && numBands == 1) { // bilevel
+                builder.imageType = ImageType.BILEVEL_BLACK_IS_ZERO;
+            } else {
+                builder.imageType = ImageType.GENERIC;
+                builder.numExtraSamples = numBands > 1 ? numBands - 1 : 0;
+            }
+        } else {
+            ColorSpace colorSpace = colorModel.getColorSpace();
+            builder.imageType = ImageType.getTypeFromColorSpace(colorSpace, params);
+            builder.numExtraSamples = getNumberOfExtraSamplesForColorSpace(colorSpace,
+                    builder.imageType, numBands);
+            builder.extraSampleType = ExtraSamplesType.getValue(colorModel,
+                    builder.numExtraSamples);
+        }
+
+        // Initialize tile dimensions.
+        final int width = im.getWidth();
+        final int height = im.getHeight();
+        if (params.getWriteTiled()) {
+            builder.tileWidth = params.getTileWidth() > 0 ? params.getTileWidth() : width;
+            builder.tileHeight = params.getTileHeight() > 0 ? params.getTileHeight() : height;
+            // NB: Parentheses are used in this statement for correct rounding.
+            builder.numTiles = ((width + builder.tileWidth - 1) / builder.tileWidth)
+                    * ((height + builder.tileHeight - 1) / builder.tileHeight);
+        } else {
+            builder.tileWidth = width;
+            builder.tileHeight = params.getTileHeight() > 0 ? params.getTileHeight()
+                    : DEFAULT_ROWS_PER_STRIP;
+            builder.numTiles = (int) Math.ceil(height / (double) builder.tileHeight);
+        }
+        builder.setBytesPerRow(dataTypeSize, numBands)
+        .setBytesPerTile();
+        return builder.build();
+    }
+
+    private static final class ImageInfoBuilder {
+        private ImageType imageType = ImageType.UNSUPPORTED;
+        private int numExtraSamples;
+        private char[] colormap;
+        private int colormapSize;
+        private ExtraSamplesType extraSampleType = ExtraSamplesType.UNSPECIFIED;
+        private int tileWidth;
+        private int tileHeight;
+        private int numTiles;
+        private long bytesPerRow;
+        private long bytesPerTile;
+
+        private ImageInfoBuilder setBytesPerRow(int dataTypeSize, int numBands) {
+            bytesPerRow = (long) Math.ceil((dataTypeSize / 8.0) * tileWidth * numBands);
+            return this;
+        }
+
+        private ImageInfoBuilder setBytesPerTile() {
+            bytesPerTile = bytesPerRow * tileHeight;
+            return this;
+        }
+
+        private ImageInfo build() {
+            return new ImageInfo(this);
+        }
+    }
+}
diff --git a/src/java/org/apache/xmlgraphics/image/codec/tiff/ImageType.java b/src/java/org/apache/xmlgraphics/image/codec/tiff/ImageType.java
new file mode 100644
index 0000000..188ea1f
--- /dev/null
+++ b/src/java/org/apache/xmlgraphics/image/codec/tiff/ImageType.java
@@ -0,0 +1,103 @@
+/*
+ * 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.
+ */
+
+package org.apache.xmlgraphics.image.codec.tiff;
+
+import java.awt.color.ColorSpace;
+
+import org.apache.xmlgraphics.image.codec.util.PropertyUtil;
+
+enum ImageType {
+    UNSUPPORTED(-1),
+    BILEVEL_WHITE_IS_ZERO(0),
+    BILEVEL_BLACK_IS_ZERO(1),
+    GRAY(1),
+    PALETTE(3),
+    RGB(2),
+    CMYK(5),
+    YCBCR(6),
+    CIELAB(8),
+    GENERIC(1);
+
+    private final int photometricInterpretation;
+
+    private ImageType(int photometricInterpretation) {
+        this.photometricInterpretation = photometricInterpretation;
+    }
+
+    int getPhotometricInterpretation() {
+        return photometricInterpretation;
+    }
+
+    static ImageType getTypeFromRGB(int mapSize, byte[] r, byte[] g, byte[] b,
+            int dataTypeSize, int numBands) {
+        if (numBands == 1) {
+            if (dataTypeSize == 1) { // Bilevel image
+                if (mapSize != 2) {
+                    throw new IllegalArgumentException(PropertyUtil.getString("TIFFImageEncoder7"));
+                }
+
+                if (isBlackZero(r, g, b)) {
+                    return BILEVEL_BLACK_IS_ZERO;
+                } else if (isWhiteZero(r, g, b)) {
+                    return BILEVEL_WHITE_IS_ZERO;
+                }
+            }
+            return PALETTE;
+        }
+        return UNSUPPORTED;
+    }
+
+    private static boolean rgbIsValueAt(byte[] r, byte[] g, byte[] b, byte value, int i) {
+        return r[i] == value && g[i] == value && b[i] == value;
+    }
+
+    private static boolean bilevelColorValue(byte[] r, byte[] g, byte[] b, int blackValue,
+            int whiteValue) {
+        return rgbIsValueAt(r, g, b, (byte) blackValue, 0)
+                && rgbIsValueAt(r, g, b, (byte) whiteValue, 1);
+    }
+
+    private static boolean isBlackZero(byte[] r, byte[] g, byte[] b) {
+        return bilevelColorValue(r, g, b, 0, 0xff);
+    }
+
+    private static boolean isWhiteZero(byte[] r, byte[] g, byte[] b) {
+        return bilevelColorValue(r, g, b, 0xff, 0);
+    }
+
+    static ImageType getTypeFromColorSpace(ColorSpace colorSpace, TIFFEncodeParam params) {
+        switch (colorSpace.getType()) {
+        case ColorSpace.TYPE_CMYK:
+            return CMYK;
+        case ColorSpace.TYPE_GRAY:
+            return GRAY;
+        case ColorSpace.TYPE_Lab:
+            return CIELAB;
+        case ColorSpace.TYPE_RGB:
+            if (params.getJPEGCompressRGBToYCbCr()) {
+                return ImageType.YCBCR;
+            } else {
+                return ImageType.RGB;
+            }
+        case ColorSpace.TYPE_YCbCr:
+            return YCBCR;
+        default:
+            return GENERIC;
+        }
+    }
+}
diff --git a/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFEncodeParam.java b/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFEncodeParam.java
index 5afe0d2..d70e76c 100644
--- a/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFEncodeParam.java
+++ b/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFEncodeParam.java
@@ -45,59 +45,9 @@
  */
 public class TIFFEncodeParam implements ImageEncodeParam {
 
-    /** No compression. */
-    public static final int COMPRESSION_NONE          = 1;
+    private CompressionValue compression = CompressionValue.NONE;
 
-    /**
-     * Modified Huffman Compression (CCITT Group 3 1D facsimile compression).
-     * <p><b>Not currently supported.</b>
-     */
-    public static final int COMPRESSION_GROUP3_1D     = 2;
-
-    /**
-     * CCITT T.4 bilevel compression (CCITT Group 3 2D facsimile compression).
-     * <p><b>Not currently supported.</b>
-     */
-    public static final int COMPRESSION_GROUP3_2D     = 3;
-
-    /**
-     * CCITT T.6 bilevel compression (CCITT Group 4 facsimile compression).
-     * <p><b>Not currently supported.</b>
-     */
-    public static final int COMPRESSION_GROUP4        = 4;
-
-    /**
-     * LZW compression.
-     * <p><b>Not supported.</b>
-     */
-    public static final int COMPRESSION_LZW           = 5;
-
-    /**
-     * Code for original JPEG-in-TIFF compression which has been
-     * depricated (for many good reasons) in favor of Tech Note 2
-     * JPEG compression (compression scheme 7).
-     * <p><b>Not supported.</b>
-     */
-    public static final int COMPRESSION_JPEG_BROKEN   = 6;
-
-    /**
-     * <a href="ftp://ftp.sgi.com/graphics/tiff/TTN2.draft.txt">
-     * JPEG-in-TIFF</a> compression.
-     */
-    public static final int COMPRESSION_JPEG_TTN2     = 7;
-
-    /** Byte-oriented run-length encoding "PackBits" compression. */
-    public static final int COMPRESSION_PACKBITS      = 32773;
-
-    /**
-     * <a href="http://info.internet.isi.edu:80/in-notes/rfc/files/rfc1951.txt">
-     * DEFLATE</a> lossless compression (also known as "Zip-in-TIFF").
-     */
-    public static final int COMPRESSION_DEFLATE       = 32946;
-
-    private int compression = COMPRESSION_NONE;
-
-    private boolean writeTiled = false;
+    private boolean writeTiled;
     private int tileWidth;
     private int tileHeight;
 
@@ -117,10 +67,8 @@
         //nop
     }
 
-    /**
-     * Returns the value of the compression parameter.
-     */
-    public int getCompression() {
+    /** Returns the value of the compression parameter. */
+    public CompressionValue getCompression() {
         return compression;
     }
 
@@ -141,12 +89,12 @@
      *
      * @param compression    The compression type.
      */
-    public void setCompression(int compression) {
+    public void setCompression(CompressionValue compression) {
 
         switch(compression) {
-        case COMPRESSION_NONE:
-        case COMPRESSION_PACKBITS:
-        case COMPRESSION_DEFLATE:
+        case NONE:
+        case PACKBITS:
+        case DEFLATE:
             // Do nothing.
             break;
         default:
diff --git a/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageDecoder.java b/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageDecoder.java
index 30375cb..0ddaeb2 100644
--- a/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageDecoder.java
+++ b/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageDecoder.java
@@ -22,7 +22,6 @@
 import java.awt.image.RenderedImage;
 import java.io.IOException;
 
-import org.apache.xmlgraphics.image.codec.util.ImageDecodeParam;
 import org.apache.xmlgraphics.image.codec.util.ImageDecoderImpl;
 import org.apache.xmlgraphics.image.codec.util.PropertyUtil;
 import org.apache.xmlgraphics.image.codec.util.SeekableStream;
@@ -74,8 +73,7 @@
 
     public static final int TIFF_ICC_PROFILE                = 34675;
 
-    public TIFFImageDecoder(SeekableStream input,
-                            ImageDecodeParam param) {
+    public TIFFImageDecoder(SeekableStream input, TIFFDecodeParam param) {
         super(input, param);
     }
 
@@ -87,6 +85,6 @@
         if  ((page < 0) || (page >= getNumPages())) {
             throw new IOException(PropertyUtil.getString("TIFFImageDecoder0"));
         }
-        return new TIFFImage(input, (TIFFDecodeParam)param, page);
+        return new TIFFImage(input, (TIFFDecodeParam) param, page);
     }
 }
diff --git a/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageEncoder.java b/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageEncoder.java
index 8b70ce2..5a29ef1 100644
--- a/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageEncoder.java
+++ b/src/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageEncoder.java
@@ -20,7 +20,6 @@
 package org.apache.xmlgraphics.image.codec.tiff;
 
 import java.awt.Rectangle;
-import java.awt.color.ColorSpace;
 import java.awt.image.ColorModel;
 import java.awt.image.ComponentSampleModel;
 import java.awt.image.DataBuffer;
@@ -61,37 +60,13 @@
  */
 public class TIFFImageEncoder extends ImageEncoderImpl {
 
-    // Image Types
-    private static final int TIFF_UNSUPPORTED           = -1;
-    private static final int TIFF_BILEVEL_WHITE_IS_ZERO = 0;
-    private static final int TIFF_BILEVEL_BLACK_IS_ZERO = 1;
-    private static final int TIFF_GRAY                  = 2;
-    private static final int TIFF_PALETTE               = 3;
-    private static final int TIFF_RGB                   = 4;
-    private static final int TIFF_CMYK                  = 5;
-    private static final int TIFF_YCBCR                 = 6;
-    private static final int TIFF_CIELAB                = 7;
-    private static final int TIFF_GENERIC               = 8;
-
-    // Compression types
-    private static final int COMP_NONE      = 1;
-    private static final int COMP_JPEG_TTN2 = 7;
-    private static final int COMP_PACKBITS  = 32773;
-    private static final int COMP_DEFLATE   = 32946;
-
     // Incidental tags
     private static final int TIFF_JPEG_TABLES       = 347;
     private static final int TIFF_YCBCR_SUBSAMPLING = 530;
     private static final int TIFF_YCBCR_POSITIONING = 531;
     private static final int TIFF_REF_BLACK_WHITE   = 532;
 
-    // ExtraSamples types
-    private static final int EXTRA_SAMPLE_UNSPECIFIED        = 0;
-    private static final int EXTRA_SAMPLE_ASSOCIATED_ALPHA   = 1;
-    private static final int EXTRA_SAMPLE_UNASSOCIATED_ALPHA = 2;
 
-    // Default values
-    private static final int DEFAULT_ROWS_PER_STRIP = 8;
 
     public TIFFImageEncoder(OutputStream output, ImageEncodeParam param) {
         super(output, param);
@@ -197,9 +172,9 @@
     private int encode(RenderedImage im, TIFFEncodeParam encodeParam,
                        int ifdOffset, boolean isLast) throws IOException {
         // Currently all images are stored uncompressed.
-        int compression = encodeParam.getCompression();
+        CompressionValue compression = encodeParam.getCompression();
 
-        if (compression == COMP_JPEG_TTN2) {
+        if (compression == CompressionValue.JPEG_TTN2) {
             throw new IllegalArgumentException(PropertyUtil.getString("TIFFImageEncoder12"));
         }
 
@@ -214,263 +189,31 @@
 
         // 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(PropertyUtil.getString("TIFFImageEncoder0"));
-            }
-        }
-
-        // Check low bit limits.
-        int numBands = sampleModel.getNumBands();
-        if ((sampleSize[0] == 1 || sampleSize[0] == 4) && numBands != 1) {
-            throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder1"));
-        }
-
-        // Retrieve and verify data type.
-        int dataType = sampleModel.getDataType();
-        switch(dataType) {
-        case DataBuffer.TYPE_BYTE:
-            if (sampleSize[0] != 1 && sampleSize[0] == 4 &&    // todo does this make sense??
-               sampleSize[0] != 8) {                          // we get error only for 4
-                throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder2"));
-            }
-            break;
-        case DataBuffer.TYPE_SHORT:
-        case DataBuffer.TYPE_USHORT:
-            if (sampleSize[0] != 16) {
-                throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder3"));
-            }
-            break;
-        case DataBuffer.TYPE_INT:
-        case DataBuffer.TYPE_FLOAT:
-            if (sampleSize[0] != 32) {
-                throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder4"));
-            }
-            break;
-        default:
-            throw new RuntimeException(PropertyUtil.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(PropertyUtil.getString("TIFFImageEncoder6"));
-        }
-        IndexColorModel icm = null;
-        int sizeOfColormap = 0;
-        char[] colormap = null;
+        int[] sampleSize = sampleModel.getSampleSize();
+        int dataTypeSize = sampleSize[0];
+        int numBands = sampleModel.getNumBands();
+        int dataType = sampleModel.getDataType();
+        validateImage(dataTypeSize, sampleSize, numBands, dataType, colorModel);
+
+        boolean dataTypeIsShort = dataType == DataBuffer.TYPE_SHORT
+                || dataType == DataBuffer.TYPE_USHORT;
 
         // 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();
+        ImageInfo imageInfo = ImageInfo.newInstance(im, dataTypeSize, numBands, colorModel,
+                encodeParam);
 
-            if (sampleSize[0] == 1 && numBands == 1) { // Bilevel image
-
-                if (mapSize != 2) {
-                    throw new IllegalArgumentException(PropertyUtil.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) {
+        if (imageInfo.getType() == ImageType.UNSUPPORTED) {
             throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder8"));
         }
 
-        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 char[sizeOfColormap * 3];
-            for (int i = 0; i < sizeOfColormap; i++) {
-                int tmp = 0xff & r[i];   // beware of sign extended bytes
-                colormap[redIndex++]   = (char)((tmp << 8) | tmp);
-                tmp = 0xff & g[i];
-                colormap[greenIndex++] = (char)((tmp << 8) | tmp);
-                tmp = 0xff & b[i];
-                colormap[blueIndex++]  = (char)((tmp << 8) | tmp);
-            }
-
-            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(PropertyUtil.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;
-
-            tileHeight = encodeParam.getTileHeight() > 0 ?
-                encodeParam.getTileHeight() : DEFAULT_ROWS_PER_STRIP;
-        }
-
-        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);
-        }
+        final int numTiles = imageInfo.getNumTiles();
+        final long bytesPerTile = imageInfo.getBytesPerTile();
+        final long bytesPerRow = imageInfo.getBytesPerRow();
+        final int tileHeight = imageInfo.getTileHeight();
+        final int tileWidth = imageInfo.getTileWidth();
 
         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;
         }
@@ -480,12 +223,7 @@
             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 totalBytesOfData = bytesPerTile * (numTiles - 1) + tileByteCounts[numTiles - 1];
         long[] tileOffsets = new long[numTiles];
 
         // Basic fields - have to be in increasing numerical order.
@@ -502,7 +240,7 @@
         // ResolutionUnit                 296
 
         // Create Directory
-        SortedSet fields = new TreeSet();
+        SortedSet<TIFFField> fields = new TreeSet<TIFFField>();
 
         // Image Width
         fields.add(new TIFFField(TIFFImageDecoder.TIFF_IMAGE_WIDTH,
@@ -516,7 +254,7 @@
 
         char [] shortSampleSize = new char[numBands];
         for (int i = 0; i < numBands; i++) {
-            shortSampleSize[i] = (char)sampleSize[i];
+            shortSampleSize[i] = (char) dataTypeSize;
         }
         fields.add(new TIFFField(TIFFImageDecoder.TIFF_BITS_PER_SAMPLE,
                                  TIFFField.TIFF_SHORT, numBands,
@@ -524,12 +262,12 @@
 
         fields.add(new TIFFField(TIFFImageDecoder.TIFF_COMPRESSION,
                                  TIFFField.TIFF_SHORT, 1,
-                                 new char[] {(char)compression}));
+                                 new char[] {(char)compression.getValue()}));
 
         fields.add(
             new TIFFField(TIFFImageDecoder.TIFF_PHOTOMETRIC_INTERPRETATION,
                           TIFFField.TIFF_SHORT, 1,
-                                 new char[] {(char)photometricInterpretation}));
+                      new char[] {(char) imageInfo.getType().getPhotometricInterpretation()}));
 
         if (!isTiled) {
             fields.add(new TIFFField(TIFFImageDecoder.TIFF_STRIP_OFFSETS,
@@ -551,10 +289,10 @@
                                      tileByteCounts));
         }
 
-        if (colormap != null) {
+        if (imageInfo.getColormap() != null) {
             fields.add(new TIFFField(TIFFImageDecoder.TIFF_COLORMAP,
-                                     TIFFField.TIFF_SHORT, sizeOfColormap,
-                                     colormap));
+                    TIFFField.TIFF_SHORT, imageInfo.getColormapSize(),
+                    imageInfo.getColormap()));
         }
 
         if (isTiled) {
@@ -575,13 +313,13 @@
                                      tileByteCounts));
         }
 
-        if (numExtraSamples > 0) {
-            char[] extraSamples = new char[numExtraSamples];
-            for (int i = 0; i < numExtraSamples; i++) {
-                extraSamples[i] = (char)extraSampleType;
+        if (imageInfo.getNumberOfExtraSamples() > 0) {
+            char[] extraSamples = new char[imageInfo.getNumberOfExtraSamples()];
+            for (int i = 0; i < imageInfo.getNumberOfExtraSamples(); i++) {
+                extraSamples[i] = (char) imageInfo.getExtraSamplesType().getValue();
             }
             fields.add(new TIFFField(TIFFImageDecoder.TIFF_EXTRA_SAMPLES,
-                                     TIFFField.TIFF_SHORT, numExtraSamples,
+                    TIFFField.TIFF_SHORT, imageInfo.getNumberOfExtraSamples(),
                                      extraSamples));
         }
 
@@ -610,7 +348,7 @@
             // use it if available.
         }
 
-        if (imageType == TIFF_YCBCR) {
+        if (imageInfo.getType() == ImageType.YCBCR) {
             // YCbCrSubSampling: 2 is the default so we must write 1 as
             // we do not (yet) do any subsampling.
             char subsampleH = 1;
@@ -625,7 +363,7 @@
             fields.add(new TIFFField(TIFF_YCBCR_POSITIONING,
                                      TIFFField.TIFF_SHORT, 1,
                                      new char[]
-                {(char)((compression == COMP_JPEG_TTN2) ? 1 : 2)}));
+                    {(char) ((compression == CompressionValue.JPEG_TTN2) ? 1 : 2)}));
 
             // Reference black/white.
             long[][] refbw;
@@ -691,16 +429,16 @@
         Deflater deflater = null;
         boolean jpegRGBToYCbCr = false;
 
-        if (compression == COMP_NONE) {
+        if (compression == CompressionValue.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) {
+            if (dataTypeSize == 16 && tileOffsets[0] % 2 != 0) {
                 numBytesPadding = 1;
                 tileOffsets[0]++;
-            } else if (sampleSize[0] == 32 && tileOffsets[0] % 4 != 0) {
+            } else if (dataTypeSize == 32 && tileOffsets[0] % 4 != 0) {
                 numBytesPadding = (int)(4 - tileOffsets[0] % 4);
                 tileOffsets[0] += numBytesPadding;
             }
@@ -758,11 +496,11 @@
 
             int bufSize = 0;
             switch(compression) {
-            case COMP_PACKBITS:
-                bufSize = (int)(bytesPerTile + ((bytesPerRow + 127) / 128) * tileHeight);
+            case PACKBITS:
+                bufSize = (int) (bytesPerTile + ((bytesPerRow + 127) / 128) * tileHeight);
                 break;
-            case COMP_DEFLATE:
-                bufSize = (int)bytesPerTile;
+            case DEFLATE:
+                bufSize = (int) bytesPerTile;
                 deflater = new Deflater(encodeParam.getDeflateLevel());
                 break;
             default:
@@ -781,16 +519,16 @@
 
         // Whether to test for contiguous data.
         boolean checkContiguous =
-            ((sampleSize[0] == 1 &&
+            ((dataTypeSize == 1 &&
               sampleModel instanceof MultiPixelPackedSampleModel &&
               dataType == DataBuffer.TYPE_BYTE) ||
-             (sampleSize[0] == 8 &&
+             (dataTypeSize == 8 &&
               sampleModel instanceof ComponentSampleModel));
 
         // Also create a buffer to hold tileHeight lines of the
         // data to be written to the file, so we can use array writes.
         byte[] bpixels = null;
-        if (compression != COMP_JPEG_TTN2) {
+        if (compression != CompressionValue.JPEG_TTN2) {
             if (dataType == DataBuffer.TYPE_BYTE) {
                 bpixels = new byte[tileHeight * tileWidth * numBands];
             } else if (dataTypeIsShort) {
@@ -816,9 +554,9 @@
                     im.getData(new Rectangle(col, row, tileWidth, rows));
 
                 boolean useDataBuffer = false;
-                if (compression != COMP_JPEG_TTN2) { // JPEG access Raster
+                if (compression != CompressionValue.JPEG_TTN2) { // JPEG access Raster
                     if (checkContiguous) {
-                        if (sampleSize[0] == 8) { // 8-bit
+                        if (dataTypeSize == 8) { // 8-bit
                             ComponentSampleModel csm =
                                 (ComponentSampleModel)src.getSampleModel();
                             int[] bankIndices = csm.getBankIndices();
@@ -866,7 +604,7 @@
 
                 int pixel = 0;
                 int k = 0;
-                switch (sampleSize[0]) {
+                switch (dataTypeSize) {
 
                 case 1:
 
@@ -881,18 +619,18 @@
                                           src.getSampleModelTranslateX(),
                                           row -
                                           src.getSampleModelTranslateY());
-                        if (lineStride == (int)bytesPerRow) {
+                        if (lineStride == bytesPerRow) {
                             System.arraycopy(btmp, inOffset,
                                              bpixels, 0,
-                                             (int)bytesPerRow * rows);
+                                             (int) bytesPerRow * rows);
                         } else {
                             int outOffset = 0;
                             for (int j = 0; j < rows; j++) {
                                 System.arraycopy(btmp, inOffset,
                                                  bpixels, outOffset,
-                                                 (int)bytesPerRow);
+                                                 (int) bytesPerRow);
                                 inOffset += lineStride;
-                                outOffset += (int)bytesPerRow;
+                                outOffset += bytesPerRow;
                             }
                         }
                     } else {
@@ -927,16 +665,16 @@
                         }
                     }
 
-                    if (compression == COMP_NONE) {
+                    if (compression == CompressionValue.NONE) {
                         output.write(bpixels, 0, rows * ((tileWidth + 7) / 8));
-                    } else if (compression == COMP_PACKBITS) {
+                    } else if (compression == CompressionValue.PACKBITS) {
                         int numCompressedBytes =
                             compressPackBits(bpixels, rows,
-                                             (int)bytesPerRow,
+                                             bytesPerRow,
                                              compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
                         output.write(compressBuf, 0, numCompressedBytes);
-                    } else if (compression == COMP_DEFLATE) {
+                    } else if (compression == CompressionValue.DEFLATE) {
                         int numCompressedBytes =
                             deflate(deflater, bpixels, compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
@@ -966,16 +704,16 @@
                         }
                     }
 
-                    if (compression == COMP_NONE) {
+                    if (compression == CompressionValue.NONE) {
                         output.write(bpixels, 0, rows * ((tileWidth + 1) / 2));
-                    } else if (compression == COMP_PACKBITS) {
+                    } else if (compression == CompressionValue.PACKBITS) {
                         int numCompressedBytes =
                             compressPackBits(bpixels, rows,
-                                             (int)bytesPerRow,
+                                             bytesPerRow,
                                              compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
                         output.write(compressBuf, 0, numCompressedBytes);
-                    } else if (compression == COMP_DEFLATE) {
+                    } else if (compression == CompressionValue.DEFLATE) {
                         int numCompressedBytes =
                             deflate(deflater, bpixels, compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
@@ -985,7 +723,7 @@
 
                 case 8:
 
-                    if (compression != COMP_JPEG_TTN2) {
+                    if (compression != CompressionValue.JPEG_TTN2) {
                         if (useDataBuffer) {
                             byte[] btmp =
                                 ((DataBufferByte)src.getDataBuffer()).getData();
@@ -997,19 +735,19 @@
                                               row -
                                               src.getSampleModelTranslateY());
                             int lineStride = csm.getScanlineStride();
-                            if (lineStride == (int)bytesPerRow) {
+                            if (lineStride == bytesPerRow) {
                                 System.arraycopy(btmp,
                                                  inOffset,
                                                  bpixels, 0,
-                                                 (int)bytesPerRow * rows);
+                                                 (int) bytesPerRow * rows);
                             } else {
                                 int outOffset = 0;
                                 for (int j = 0; j < rows; j++) {
                                     System.arraycopy(btmp, inOffset,
                                                      bpixels, outOffset,
-                                                     (int)bytesPerRow);
+                                                     (int) bytesPerRow);
                                     inOffset += lineStride;
-                                    outOffset += (int)bytesPerRow;
+                                    outOffset += bytesPerRow;
                                 }
                             }
                         } else {
@@ -1019,16 +757,16 @@
                         }
                     }
 
-                    if (compression == COMP_NONE) {
+                    if (compression == CompressionValue.NONE) {
                         output.write(bpixels, 0, size);
-                    } else if (compression == COMP_PACKBITS) {
+                    } else if (compression == CompressionValue.PACKBITS) {
                         int numCompressedBytes =
                             compressPackBits(bpixels, rows,
-                                             (int)bytesPerRow,
+                                             bytesPerRow,
                                              compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
                         output.write(compressBuf, 0, numCompressedBytes);
-                    } else if (compression == COMP_DEFLATE) {
+                    } else if (compression == CompressionValue.DEFLATE) {
                         int numCompressedBytes =
                             deflate(deflater, bpixels, compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
@@ -1045,16 +783,16 @@
                         bpixels[ls++] = (byte) (value & 0x00ff);
                     }
 
-                    if (compression == COMP_NONE) {
+                    if (compression == CompressionValue.NONE) {
                         output.write(bpixels, 0, size*2);
-                    } else if (compression == COMP_PACKBITS) {
+                    } else if (compression == CompressionValue.PACKBITS) {
                         int numCompressedBytes =
                             compressPackBits(bpixels, rows,
-                                             (int)bytesPerRow,
+                                             bytesPerRow,
                                              compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
                         output.write(compressBuf, 0, numCompressedBytes);
-                    } else if (compression == COMP_DEFLATE) {
+                    } else if (compression == CompressionValue.DEFLATE) {
                         int numCompressedBytes =
                             deflate(deflater, bpixels, compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
@@ -1082,16 +820,16 @@
                             bpixels[lf++] = (byte)( value & 0x000000ff);
                         }
                     }
-                    if (compression == COMP_NONE) {
+                    if (compression == CompressionValue.NONE) {
                         output.write(bpixels, 0, size*4);
-                    } else if (compression == COMP_PACKBITS) {
+                    } else if (compression == CompressionValue.PACKBITS) {
                         int numCompressedBytes =
                             compressPackBits(bpixels, rows,
-                                             (int)bytesPerRow,
+                                             bytesPerRow,
                                              compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
                         output.write(compressBuf, 0, numCompressedBytes);
-                    } else if (compression == COMP_DEFLATE) {
+                    } else if (compression == CompressionValue.DEFLATE) {
                         int numCompressedBytes =
                             deflate(deflater, bpixels, compressBuf);
                         tileByteCounts[tileNum++] = numCompressedBytes;
@@ -1103,7 +841,7 @@
             }
         }
 
-        if (compression == COMP_NONE) {
+        if (compression == CompressionValue.NONE) {
             // Write an extra byte for IFD word alignment if needed.
             if (skipByte) {
                 output.write((byte)0);
@@ -1209,6 +947,50 @@
         return nextIFDOffset;
     }
 
+    private void validateImage(int dataTypeSize, int[] sampleSize, int numBands, int dataType,
+            ColorModel colorModel) {
+        // Retrieve and verify sample size.
+        for (int i = 1; i < sampleSize.length; i++) {
+            if (sampleSize[i] != dataTypeSize) {
+                throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder0"));
+            }
+        }
+
+        // Check low bit limits.
+        if ((dataTypeSize == 1 || dataTypeSize == 4) && numBands != 1) {
+            throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder1"));
+        }
+
+        // Retrieve and verify data type.
+        switch (dataType) {
+        case DataBuffer.TYPE_BYTE:
+            if (dataTypeSize != 1 && dataTypeSize == 4 && // todo does this make sense??
+                    dataTypeSize != 8) { // we get error only for 4
+                throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder2"));
+            }
+            break;
+        case DataBuffer.TYPE_SHORT:
+        case DataBuffer.TYPE_USHORT:
+            if (dataTypeSize != 16) {
+                throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder3"));
+            }
+            break;
+        case DataBuffer.TYPE_INT:
+        case DataBuffer.TYPE_FLOAT:
+            if (dataTypeSize != 32) {
+                throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder4"));
+            }
+            break;
+        default:
+            throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder5"));
+        }
+
+        if (colorModel instanceof IndexColorModel && dataType != DataBuffer.TYPE_BYTE) {
+            // Don't support (unsigned) short palette-color images.
+            throw new RuntimeException(PropertyUtil.getString("TIFFImageEncoder6"));
+        }
+    }
+
     /**
      * Calculates the size of the IFD.
      */
@@ -1515,12 +1297,12 @@
      * Performs PackBits compression on a tile of data.
      */
     private static int compressPackBits(byte[] data, int numRows,
-                                        int bytesPerRow, byte[] compData) {
+                                        long bytesPerRow, byte[] compData) {
         int inOffset = 0;
         int outOffset = 0;
 
         for (int i = 0; i < numRows; i++) {
-            outOffset = packBits(data, inOffset, bytesPerRow,
+            outOffset = packBits(data, inOffset, (int) bytesPerRow,
                                  compData, outOffset);
             inOffset += bytesPerRow;
         }
diff --git a/src/java/org/apache/xmlgraphics/image/writer/internal/TIFFImageWriter.java b/src/java/org/apache/xmlgraphics/image/writer/internal/TIFFImageWriter.java
index 9af7a0e..0907e0c 100644
--- a/src/java/org/apache/xmlgraphics/image/writer/internal/TIFFImageWriter.java
+++ b/src/java/org/apache/xmlgraphics/image/writer/internal/TIFFImageWriter.java
@@ -23,6 +23,7 @@
 import java.io.IOException;
 import java.io.OutputStream;
 
+import org.apache.xmlgraphics.image.codec.tiff.CompressionValue;
 import org.apache.xmlgraphics.image.codec.tiff.TIFFEncodeParam;
 import org.apache.xmlgraphics.image.codec.tiff.TIFFField;
 import org.apache.xmlgraphics.image.codec.tiff.TIFFImageDecoder;
@@ -57,21 +58,9 @@
     private TIFFEncodeParam createTIFFEncodeParams(ImageWriterParams params) {
         TIFFEncodeParam encodeParams = new TIFFEncodeParam();
         if (params == null) {
-            encodeParams.setCompression(TIFFEncodeParam.COMPRESSION_NONE);
+            encodeParams.setCompression(CompressionValue.NONE);
         } else {
-            if (params.getCompressionMethod() == null) {
-                //PackBits as default
-                encodeParams.setCompression(TIFFEncodeParam.COMPRESSION_PACKBITS);
-            } else if ("PackBits".equalsIgnoreCase(params.getCompressionMethod())) {
-                encodeParams.setCompression(TIFFEncodeParam.COMPRESSION_PACKBITS);
-            } else if ("NONE".equalsIgnoreCase(params.getCompressionMethod())) {
-                encodeParams.setCompression(TIFFEncodeParam.COMPRESSION_NONE);
-            } else if ("Deflate".equalsIgnoreCase(params.getCompressionMethod())) {
-                encodeParams.setCompression(TIFFEncodeParam.COMPRESSION_DEFLATE);
-            } else {
-                throw new UnsupportedOperationException("Compression method not supported: "
-                        + params.getCompressionMethod());
-            }
+            encodeParams.setCompression(CompressionValue.getValue(params.getCompressionMethod()));
 
             if (params.getResolution() != null) {
                 int numPixX;
diff --git a/test/java/org/apache/xmlgraphics/image/codec/tiff/ImageInfoTestCase.java b/test/java/org/apache/xmlgraphics/image/codec/tiff/ImageInfoTestCase.java
new file mode 100644
index 0000000..9885fac
--- /dev/null
+++ b/test/java/org/apache/xmlgraphics/image/codec/tiff/ImageInfoTestCase.java
@@ -0,0 +1,188 @@
+/*
+ * 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.
+ */
+
+package org.apache.xmlgraphics.image.codec.tiff;
+
+import java.awt.color.ColorSpace;
+import java.awt.image.ColorModel;
+import java.awt.image.IndexColorModel;
+import java.awt.image.RenderedImage;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import static org.apache.xmlgraphics.image.codec.tiff.ExtraSamplesType.UNSPECIFIED;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.BILEVEL_BLACK_IS_ZERO;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.BILEVEL_WHITE_IS_ZERO;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.CIELAB;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.CMYK;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.GENERIC;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.GRAY;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.RGB;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.YCBCR;
+
+public class ImageInfoTestCase {
+
+    private ColorSpace colorSpace;
+    private ColorModel colorModel;
+    private RenderedImage image;
+    private TIFFEncodeParam params;
+
+    @Before
+    public void setUp() {
+        colorSpace = mock(ColorSpace.class);
+        colorModel = new TestColorModel(colorSpace, true);
+        image = mock(RenderedImage.class);
+        params = mock(TIFFEncodeParam.class);
+    }
+
+    @Test
+    public void testNullColorModel() {
+        testImageInfo(ImageInfo.newInstance(image, 1, 1, null, params),
+                BILEVEL_BLACK_IS_ZERO, 0, null, 0, UNSPECIFIED);
+
+        for (int i = 2; i < 10; i += 2) {
+            testImageInfo(ImageInfo.newInstance(image, 1, i, null, params),
+                    GENERIC, i - 1, null, 0, UNSPECIFIED);
+        }
+    }
+
+    @Test
+    public void testNonIndexColorModel() {
+        testTheColorSpaceType(ColorSpace.TYPE_CMYK, false, CMYK);
+        testTheColorSpaceType(ColorSpace.TYPE_GRAY, false, GRAY);
+        testTheColorSpaceType(ColorSpace.TYPE_RGB, true, YCBCR);
+        testTheColorSpaceType(ColorSpace.TYPE_RGB, false, RGB);
+    }
+
+    private void testTheColorSpaceType(int colorSpaceType, boolean getJpegCompress, ImageType expectedType) {
+        when(colorSpace.getType()).thenReturn(colorSpaceType);
+        TIFFEncodeParam params = mock(TIFFEncodeParam.class);
+        when(params.getJPEGCompressRGBToYCbCr()).thenReturn(getJpegCompress);
+
+        testImageInfo(ImageInfo.newInstance(image, 1, 1, colorModel, params),
+                expectedType, 0, null, 0, UNSPECIFIED);
+    }
+
+    @Test
+    public void testNonIndexColorModelWithNumBandsGreaterThan1() {
+        testWithNumOfBandsGreaterThan1(ColorSpace.TYPE_GRAY, GRAY, 3, 1);
+        testWithNumOfBandsGreaterThan1(ColorSpace.TYPE_Lab, CIELAB, 6, 3);
+        testWithNumOfBandsGreaterThan1(ColorSpace.TYPE_CMYK, CMYK, 5, 2);
+    }
+
+    private void testWithNumOfBandsGreaterThan1(int colorSpaceType, ImageType type, int numBands,
+            int numComponents) {
+        when(colorSpace.getType()).thenReturn(colorSpaceType);
+        when(colorSpace.getNumComponents()).thenReturn(numComponents);
+        testImageInfo(ImageInfo.newInstance(image, 2, numBands, colorModel, params),
+                type, numBands - numComponents, null, 0, UNSPECIFIED);
+    }
+
+    private void testImageInfo(ImageInfo imageInfo, ImageType imageType, int numExtraSamples,
+            char[] colormap, int colormapSize, ExtraSamplesType extraSamplesType) {
+        assertEquals(imageType, imageInfo.getType());
+        assertEquals(numExtraSamples, imageInfo.getNumberOfExtraSamples());
+        assertArrayEquals(colormap, imageInfo.getColormap());
+        assertEquals(colormapSize, imageInfo.getColormapSize());
+        assertEquals(extraSamplesType, imageInfo.getExtraSamplesType());
+    }
+
+    @Test
+    public void testIndexColorModel() {
+        byte[] blackIsZero = new byte[] {0, (byte) 0xff};
+        IndexColorModel icm = new IndexColorModel(1, 2, blackIsZero, blackIsZero, blackIsZero);
+        testImageInfo(ImageInfo.newInstance(image, 1, 1, icm, params),
+                BILEVEL_BLACK_IS_ZERO, 0, null, 0, UNSPECIFIED);
+
+        byte[] whiteIsZero = new byte[] {(byte) 0xff, 0};
+        icm = new IndexColorModel(1, 2, whiteIsZero, whiteIsZero, whiteIsZero);
+        testImageInfo(ImageInfo.newInstance(image, 1, 1, icm, params),
+                BILEVEL_WHITE_IS_ZERO, 0, null, 0, UNSPECIFIED);
+    }
+
+    @Test
+    public void testTileWidthHeight() {
+        when(params.getWriteTiled()).thenReturn(true);
+
+        when(image.getWidth()).thenReturn(10);
+        when(image.getHeight()).thenReturn(10);
+
+        for (int i = 1; i < 10000; i += 200) {
+            when(params.getTileWidth()).thenReturn(i);
+            when(params.getTileHeight()).thenReturn(i);
+            int numTiles = ((10 + i - 1) / i) * ((10 + i - 1) / i);
+            long bytesPerRow = (long) Math.ceil((1 / 8.0) * i * 1);
+            long bytesPerTile = bytesPerRow * i;
+
+            testTileOnImageInfo(ImageInfo.newInstance(image, 1, 1, colorModel, params),
+                    i, i, numTiles, bytesPerRow, bytesPerTile);
+        }
+    }
+
+    private void testTileOnImageInfo(ImageInfo imageInfo, int tileWidth, int tileHeight,
+            int numTiles, long bytesPerRow, long bytesPerTile) {
+        assertEquals(tileWidth, imageInfo.getTileWidth());
+        assertEquals(tileHeight, imageInfo.getTileHeight());
+        assertEquals(numTiles, imageInfo.getNumTiles());
+        assertEquals(bytesPerRow, imageInfo.getBytesPerRow());
+        assertEquals(bytesPerTile, imageInfo.getBytesPerTile());
+    }
+
+    @Test
+    public void testGetColormap() {
+        ImageInfo sut = ImageInfo.newInstance(image, 1, 1,
+                new IndexColorModel(1, 2, new byte[2], new byte[2], new byte[2], new byte[2]), params);
+        char[] colormap = sut.getColormap();
+        assertEquals(0, colormap[0]);
+        colormap[0] = 1;
+        //  Assert that getColormap() returns a defensive copy
+        assertEquals(0, sut.getColormap()[0]);
+    }
+
+    private static final class TestColorModel extends ColorModel {
+
+        protected TestColorModel(ColorSpace cspace, boolean isAlphaPremultiplied) {
+            super(1, new int[] {1, 1}, cspace, isAlphaPremultiplied, isAlphaPremultiplied, 1, 1);
+        }
+
+        @Override
+        public int getRed(int pixel) {
+            return 0;
+        }
+
+        @Override
+        public int getGreen(int pixel) {
+            return 0;
+        }
+
+        @Override
+        public int getBlue(int pixel) {
+            return 0;
+        }
+
+        @Override
+        public int getAlpha(int pixel) {
+            return 0;
+        }
+    }
+}
diff --git a/test/java/org/apache/xmlgraphics/image/codec/tiff/ImageTypeTestCase.java b/test/java/org/apache/xmlgraphics/image/codec/tiff/ImageTypeTestCase.java
new file mode 100644
index 0000000..6761617
--- /dev/null
+++ b/test/java/org/apache/xmlgraphics/image/codec/tiff/ImageTypeTestCase.java
@@ -0,0 +1,122 @@
+/*
+ * 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.
+ */
+
+package org.apache.xmlgraphics.image.codec.tiff;
+
+import java.awt.color.ColorSpace;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.BILEVEL_BLACK_IS_ZERO;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.BILEVEL_WHITE_IS_ZERO;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.CIELAB;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.CMYK;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.GENERIC;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.GRAY;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.PALETTE;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.RGB;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.UNSUPPORTED;
+import static org.apache.xmlgraphics.image.codec.tiff.ImageType.YCBCR;
+
+public class ImageTypeTestCase {
+    private static final class ColorContainer {
+        private final byte[] r;
+        private final byte[] g;
+        private final byte[] b;
+
+        private ColorContainer(byte[] r, byte[] g, byte[] b) {
+            this.r = r;
+            this.b = b;
+            this.g = g;
+        }
+    }
+
+    private ColorContainer blackIsZero;
+    private ColorContainer whiteIsZero;
+
+    @Before
+    public void setUp() {
+        byte[] blackSetToZero = {0, (byte) 0xff};
+        blackIsZero = new ColorContainer(blackSetToZero, blackSetToZero, blackSetToZero);
+        byte[] whiteSetToZero = {(byte) 0xff, 0};
+        whiteIsZero = new ColorContainer(whiteSetToZero, whiteSetToZero, whiteSetToZero);
+    }
+
+    @Test
+    public void testPhotometricInterpretationValue() {
+        assertEquals(0, BILEVEL_WHITE_IS_ZERO.getPhotometricInterpretation());
+        assertEquals(1, BILEVEL_BLACK_IS_ZERO.getPhotometricInterpretation());
+        assertEquals(1, GRAY.getPhotometricInterpretation());
+        assertEquals(3, PALETTE.getPhotometricInterpretation());
+        assertEquals(2, RGB.getPhotometricInterpretation());
+        assertEquals(5, CMYK.getPhotometricInterpretation());
+        assertEquals(6, YCBCR.getPhotometricInterpretation());
+        assertEquals(8, CIELAB.getPhotometricInterpretation());
+        assertEquals(1, GENERIC.getPhotometricInterpretation());
+    }
+
+    @Test
+    public void testGetTypeFromRGB() {
+        assertEquals(BILEVEL_BLACK_IS_ZERO, ImageType.getTypeFromRGB(2,
+                blackIsZero.r, blackIsZero.g, blackIsZero.b, 1, 1));
+        assertEquals(BILEVEL_WHITE_IS_ZERO, ImageType.getTypeFromRGB(2,
+                whiteIsZero.r, whiteIsZero.g, whiteIsZero.b, 1, 1));
+        // Test all other values (i.e. not including 0xff)
+        for (int b = 0; b < 255; b++) {
+            assertEquals(PALETTE, ImageType.getTypeFromRGB(2,
+                    make2ByteArray(0, b), make2ByteArray(0, b), make2ByteArray(0, b), 1, 1));
+            assertEquals(PALETTE, ImageType.getTypeFromRGB(2,
+                    make2ByteArray(b, 0), make2ByteArray(b, 0), make2ByteArray(b, 0), 1, 1));
+            if (b != 1) {
+                assertEquals(UNSUPPORTED, ImageType.getTypeFromRGB(2, null, null, null, 1, b));
+            }
+        }
+    }
+
+    private byte[] make2ByteArray(int b1, int b2) {
+        return new byte[] {(byte) b1, (byte) b2};
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testException() {
+        assertEquals(UNSUPPORTED, ImageType.getTypeFromRGB(1, null, null, null, 1, 1));
+    }
+
+    @Test
+    public void testGetTypeFromColorSpace() {
+        testIndividualColorSpaceType(CMYK, ColorSpace.TYPE_CMYK, false);
+        testIndividualColorSpaceType(GRAY, ColorSpace.TYPE_GRAY, false);
+        testIndividualColorSpaceType(CIELAB, ColorSpace.TYPE_Lab, false);
+        testIndividualColorSpaceType(YCBCR, ColorSpace.TYPE_YCbCr, false);
+        testIndividualColorSpaceType(YCBCR, ColorSpace.TYPE_RGB, true);
+        testIndividualColorSpaceType(RGB, ColorSpace.TYPE_RGB, false);
+    }
+
+    private void testIndividualColorSpaceType(ImageType expected, int type, boolean getJpegCompress) {
+        ColorSpace colorSpace = mock(ColorSpace.class);
+        when(colorSpace.getType()).thenReturn(type);
+        TIFFEncodeParam params = mock(TIFFEncodeParam.class);
+        when(params.getJPEGCompressRGBToYCbCr()).thenReturn(getJpegCompress);
+
+        assertEquals(expected, ImageType.getTypeFromColorSpace(colorSpace, params));
+    }
+}
diff --git a/test/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageEncoderTestCase.java b/test/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageEncoderTestCase.java
new file mode 100644
index 0000000..1603679
--- /dev/null
+++ b/test/java/org/apache/xmlgraphics/image/codec/tiff/TIFFImageEncoderTestCase.java
@@ -0,0 +1,63 @@
+/*
+ * 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.
+ */
+
+package org.apache.xmlgraphics.image.codec.tiff;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+import org.apache.commons.io.IOUtils;
+
+public class TIFFImageEncoderTestCase {
+
+    @Test
+    public void testGrayImage() throws IOException {
+        testImage(BufferedImage.TYPE_BYTE_GRAY, "gray.tiff");
+    }
+
+    @Test
+    public void testBilevelImage() throws IOException {
+        testImage(BufferedImage.TYPE_BYTE_BINARY, "bilevel.tiff");
+    }
+
+    private void testImage(int imageType, String imageFileName) throws IOException {
+        ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
+        TIFFImageEncoder encoder = new TIFFImageEncoder(byteStream, null);
+        encoder.encode(getImage(imageType));
+        byte[] actualArray = IOUtils.toByteArray(getClass().getResource(imageFileName).openStream());
+        assertArrayEquals(byteStream.toByteArray(), actualArray);
+    }
+
+    private RenderedImage getImage(int imageType) {
+        BufferedImage img = new BufferedImage(400, 400, imageType);
+        img.getSampleModel();
+        Graphics gfx = img.getGraphics();
+        gfx.setColor(Color.RED);
+        gfx.fillRect(10, 10, 100, 100);
+        gfx.setColor(Color.WHITE);
+        gfx.fillRect(50, 50, 100, 100);
+        return img;
+    }
+}
diff --git a/test/java/org/apache/xmlgraphics/image/codec/tiff/bilevel.tiff b/test/java/org/apache/xmlgraphics/image/codec/tiff/bilevel.tiff
new file mode 100644
index 0000000..23ec9da
--- /dev/null
+++ b/test/java/org/apache/xmlgraphics/image/codec/tiff/bilevel.tiff
Binary files differ
diff --git a/test/java/org/apache/xmlgraphics/image/codec/tiff/gray.tiff b/test/java/org/apache/xmlgraphics/image/codec/tiff/gray.tiff
new file mode 100644
index 0000000..3f66bd5
--- /dev/null
+++ b/test/java/org/apache/xmlgraphics/image/codec/tiff/gray.tiff
Binary files differ