[maven-release-plugin] prepare release twelvemonkeys-3.9.4

(cherry picked from commit 8f5c1b409f)

bom/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>com.twelvemonkeys</groupId>
         <artifactId>twelvemonkeys</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
 
     <groupId>com.twelvemonkeys.bom</groupId>

common/common-image/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.common</groupId>
         <artifactId>common</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>common-image</artifactId>
     <packaging>jar</packaging>

common/common-io/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.common</groupId>
         <artifactId>common</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>common-io</artifactId>
     <packaging>jar</packaging>

common/common-lang/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.common</groupId>
         <artifactId>common</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>common-lang</artifactId>
     <packaging>jar</packaging>

common/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys</groupId>
         <artifactId>twelvemonkeys</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <groupId>com.twelvemonkeys.common</groupId>
     <artifactId>common</artifactId>

contrib/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys</groupId>
         <artifactId>twelvemonkeys</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <groupId>com.twelvemonkeys.contrib</groupId>
     <artifactId>contrib</artifactId>

imageio/imageio-batik/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-batik</artifactId>
     <name>TwelveMonkeys :: ImageIO :: Batik Plugin</name>
@@ -17,7 +17,7 @@
 
     <properties>
         <project.jpms.module.name>com.twelvemonkeys.imageio.batik</project.jpms.module.name>
-        <batik.version>1.15</batik.version>
+        <batik.version>1.16</batik.version>
     </properties>
 
     <build>

imageio/imageio-bmp/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-bmp</artifactId>
     <name>TwelveMonkeys :: ImageIO :: BMP plugin</name>

imageio/imageio-clippath/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-clippath</artifactId>
     <name>TwelveMonkeys :: ImageIO :: Photoshop Path Support</name>

imageio/imageio-core/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-core</artifactId>
     <name>TwelveMonkeys :: ImageIO :: Core</name>

imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/stream/MemoryCache.java

@@ -17,8 +17,12 @@ final class MemoryCache implements Cache {
 
     final static int BLOCK_SIZE = 1 << 13;
 
+    private static final byte[] NULL_BLOCK = new byte[0];
+
     private final List<byte[]> cache = new ArrayList<>();
     private final ReadableByteChannel channel;
+
+    private int maxBlock = Integer.MAX_VALUE;
     private long length;
     private long position;
     private long start;
@@ -34,12 +38,14 @@ final class MemoryCache implements Cache {
 
     byte[] fetchBlock() throws IOException {
         long currPos = position;
-
         long index = currPos / BLOCK_SIZE;
 
         if (index >= Integer.MAX_VALUE) {
             throw new IOException("Memory cache max size exceeded");
         }
+        if (index > maxBlock) {
+            return NULL_BLOCK;
+        }
 
         while (index >= cache.size()) {
             byte[] block;
@@ -51,7 +57,14 @@ final class MemoryCache implements Cache {
             }
 
             cache.add(block);
-            length += readBlock(block);
+            int bytesRead = readBlock(block);
+            length += bytesRead;
+
+            if (bytesRead < BLOCK_SIZE) {
+                // Last block, EOF found
+                maxBlock = (int) index;
+                return block;
+            }
         }
 
         return cache.get((int) index);
@@ -63,7 +76,7 @@ final class MemoryCache implements Cache {
         while (wrapped.hasRemaining()) {
             int count = channel.read(wrapped);
             if (count == -1) {
-                // Last block
+                // Last block, EOF found
                 break;
             }
         }
@@ -84,12 +97,12 @@ final class MemoryCache implements Cache {
     @Override
     public int read(ByteBuffer dest) throws IOException {
         byte[] buffer = fetchBlock();
-        int bufferPos = (int) (position % BLOCK_SIZE);
 
         if (position >= length) {
             return -1;
         }
 
+        int bufferPos = (int) (position % BLOCK_SIZE);
         int len = min(dest.remaining(), (int) min(BLOCK_SIZE - bufferPos, length - position));
         dest.put(buffer, bufferPos, len);
 

imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/stream/SubImageInputStream.java

@@ -53,20 +53,20 @@ public final class SubImageInputStream extends ImageInputStreamImpl {
     /**
      * Creates a {@link ImageInputStream}, reading up to a maximum number of bytes from the underlying stream.
      *
-     * @param pStream the underlying stream
-     * @param pLength the maximum length to read from the stream.
-     * Note that {@code pStream} may contain less than this maximum number of bytes.
+     * @param stream the underlying stream
+     * @param length the maximum length to read from the stream.
+     * Note that {@code stream} may contain less than this maximum number of bytes.
      *
-     * @throws IOException if {@code pStream}'s position can't be determined.
-     * @throws IllegalArgumentException if {@code pStream == null} or {@code pLength < 0}
+     * @throws IOException if {@code stream}'s position can't be determined.
+     * @throws IllegalArgumentException if {@code stream == null} or {@code length < 0}
      */
-    public SubImageInputStream(final ImageInputStream pStream, final long pLength) throws IOException {
-        Validate.notNull(pStream, "stream");
-        Validate.isTrue(pLength >= 0, pLength, "length < 0: %d");
+    public SubImageInputStream(final ImageInputStream stream, final long length) throws IOException {
+        Validate.notNull(stream, "stream");
+        Validate.isTrue(length >= 0, length, "length < 0: %d");
 
-        stream = pStream;
-        startPos = pStream.getStreamPosition();
-        length = pLength;
+        this.stream = stream;
+        this.startPos = stream.getStreamPosition();
+        this.length = length;
     }
 
     public int read() throws IOException {
@@ -84,14 +84,14 @@ public final class SubImageInputStream extends ImageInputStreamImpl {
         }
     }
 
-    public int read(final byte[] pBytes, final int pOffset, final int pLength) throws IOException {
+    public int read(final byte[] bytes, final int off, final int len) throws IOException {
         if (streamPos >= length) { // Local EOF
             return -1;
         }
 
-        // Safe cast, as pLength can never cause int overflow
-        int length = (int) Math.min(pLength, this.length - streamPos);
-        int count = stream.read(pBytes, pOffset, length);
+        // Safe cast, as len can never cause int overflow
+        int length = (int) Math.min(len, this.length - streamPos);
+        int count = stream.read(bytes, off, length);
 
         if (count >= 0) {
             streamPos += count;
@@ -113,18 +113,18 @@ public final class SubImageInputStream extends ImageInputStreamImpl {
     }
 
     @Override
-    public void seek(final long pPosition) throws IOException {
-        if (pPosition < getFlushedPosition()) {
+    public void seek(final long position) throws IOException {
+        if (position < getFlushedPosition()) {
             throw new IndexOutOfBoundsException("pos < flushedPosition");
         }
 
-        stream.seek(startPos + pPosition);
-        streamPos = pPosition;
+        stream.seek(startPos + position);
+        streamPos = position;
     }
 
-    @SuppressWarnings({"FinalizeDoesntCallSuperFinalize"})
+    @SuppressWarnings("MethodDoesntCallSuperMethod")
     @Override
-    protected void finalize() throws Throwable {
+    protected void finalize() {
         // Empty finalizer (for improved performance; no need to call super.finalize() in this case)
     }
 }

imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/stream/BufferedChannelImageInputStreamMemoryCacheTest.java

@@ -402,6 +402,24 @@ public class BufferedChannelImageInputStreamMemoryCacheTest {
             assertEquals(-1, stream.read());
         }
     }
+    @Test
+    public void testSeekWayPastEOFShouldNotThrowOOME() throws IOException {
+        byte[] bytes = new byte[9];
+        InputStream input = randomDataToInputStream(bytes);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            stream.seek(Integer.MAX_VALUE * 4L * 512L); // ~4 TB
+
+            assertEquals(-1, stream.read()); // No OOME should happen...
+
+            stream.seek(0);
+            for (byte value : bytes) {
+                assertEquals(value, stream.readByte());
+            }
+
+            assertEquals(-1, stream.read());
+        }
+    }
 
     @Test
     public void testClose() throws IOException {

imageio/imageio-hdr/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-hdr</artifactId>
     <name>TwelveMonkeys :: ImageIO :: HDR plugin</name>

imageio/imageio-icns/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-icns</artifactId>
     <name>TwelveMonkeys :: ImageIO :: ICNS plugin</name>

imageio/imageio-iff/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-iff</artifactId>
     <name>TwelveMonkeys :: ImageIO :: IFF plugin</name>

imageio/imageio-jpeg-jai-interop/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-jpeg-jai-interop</artifactId>
     <name>TwelveMonkeys :: ImageIO :: JPEG/JAI TIFF Interop</name>

imageio/imageio-jpeg-jep262-interop/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-jpeg-jep262-interop</artifactId>
     <name>TwelveMonkeys :: ImageIO :: JPEG/JEP-262 Interop</name>

imageio/imageio-jpeg/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-jpeg</artifactId>
     <name>TwelveMonkeys :: ImageIO :: JPEG plugin</name>

imageio/imageio-metadata/pom.xml

@@ -3,7 +3,7 @@
     <parent>
 	<groupId>com.twelvemonkeys.imageio</groupId>
 	<artifactId>imageio</artifactId>        
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>imageio-metadata</artifactId>

imageio/imageio-pcx/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-pcx</artifactId>
     <name>TwelveMonkeys :: ImageIO :: PCX plugin</name>

imageio/imageio-pdf/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-pdf</artifactId>
     <name>TwelveMonkeys :: ImageIO :: PDF plugin</name>

imageio/imageio-pict/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-pict</artifactId>
     <name>TwelveMonkeys :: ImageIO :: PICT plugin</name>

imageio/imageio-pnm/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-pnm</artifactId>
     <name>TwelveMonkeys :: ImageIO :: PNM plugin</name>

imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/HeaderWriter.java

@@ -30,8 +30,6 @@
 
 package com.twelvemonkeys.imageio.plugins.pnm;
 
-import com.twelvemonkeys.imageio.ImageWriterBase;
-
 import org.w3c.dom.NodeList;
 
 import javax.imageio.IIOImage;
@@ -40,7 +38,7 @@ import javax.imageio.metadata.IIOMetadataFormatImpl;
 import javax.imageio.metadata.IIOMetadataNode;
 import javax.imageio.spi.ImageWriterSpi;
 import javax.imageio.stream.ImageOutputStream;
-import java.awt.image.DataBuffer;
+import java.awt.image.*;
 import java.io.IOException;
 import java.util.Locale;
 
@@ -53,11 +51,7 @@ abstract class HeaderWriter {
         this.imageOutput = imageOutput;
     }
 
-    public static void write(final IIOImage image, final ImageWriterBase writer, final ImageOutputStream imageOutput) throws IOException {
-        createHeaderWriter(writer.getFormatName(), imageOutput).writeHeader(image, writer.getOriginatingProvider());
-    }
-
-    private static HeaderWriter createHeaderWriter(final String formatName, final ImageOutputStream imageOutput) {
+    static HeaderWriter createHeaderWriter(final String formatName, final ImageOutputStream imageOutput) {
         if (formatName.equals("pam")) {
             return new PAMHeaderWriter(imageOutput);
         }
@@ -83,25 +77,36 @@ abstract class HeaderWriter {
         return image.hasRaster() ? image.getRaster().getNumBands() : image.getRenderedImage().getSampleModel().getNumBands();
     }
 
+    protected final SampleModel getSampleModel(final IIOImage image) {
+        return image.hasRaster() ? image.getRaster().getSampleModel() : image.getRenderedImage().getSampleModel();
+    }
+
     protected int getMaxVal(final IIOImage image) {
         int transferType = getTransferType(image);
 
-        if (transferType == DataBuffer.TYPE_BYTE) {
-            return PNM.MAX_VAL_8BIT;
-        }
-        else if (transferType == DataBuffer.TYPE_USHORT) {
-            return PNM.MAX_VAL_16BIT;
-        }
-//        else if (transferType == DataBuffer.TYPE_INT) {
-        // TODO: Support TYPE_INT through conversion, if number of channels is 3 or 4 (TYPE_INT_RGB, TYPE_INT_ARGB)
-//        }
-        else {
-            throw new IllegalArgumentException("Unsupported data type: " + transferType);
+        switch (transferType) {
+            case DataBuffer.TYPE_BYTE:
+                return PNM.MAX_VAL_8BIT;
+
+            case DataBuffer.TYPE_USHORT:
+                return PNM.MAX_VAL_16BIT;
+
+            case DataBuffer.TYPE_INT:
+                // We support TYPE_INT through conversion, if number of channels is 3 or 4 (TYPE_INT_RGB, TYPE_INT_ARGB)
+                SampleModel sampleModel = getSampleModel(image);
+                int numBands = sampleModel.getNumBands();
+
+                if (sampleModel instanceof SinglePixelPackedSampleModel && (numBands == 3 || numBands == 4)) {
+                    return PNM.MAX_VAL_8BIT;
+                }
+                // ...else fall through
+            default:
+                throw new IllegalArgumentException("Unsupported data type: " + transferType);
         }
     }
 
     protected final int getTransferType(final IIOImage image) {
-        return  image.hasRaster() ? image.getRaster().getTransferType() : image.getRenderedImage().getSampleModel().getTransferType();
+        return image.hasRaster() ? image.getRaster().getTransferType() : image.getRenderedImage().getSampleModel().getTransferType();
     }
 
     protected final void writeComments(final IIOMetadata metadata, final ImageWriterSpi provider) throws IOException {
@@ -120,5 +125,4 @@ abstract class HeaderWriter {
             }
         }
     }
-
 }

imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PAMHeaderWriter.java

@@ -30,6 +30,8 @@
 
 package com.twelvemonkeys.imageio.plugins.pnm;
 
+import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
+
 import javax.imageio.IIOImage;
 import javax.imageio.spi.ImageWriterSpi;
 import javax.imageio.stream.ImageOutputStream;
@@ -44,6 +46,8 @@ final class PAMHeaderWriter extends HeaderWriter {
 
     @Override
     public void writeHeader(final IIOImage image, final ImageWriterSpi provider) throws IOException {
+        TupleType tupleType = tupleType(image);
+
         // Write PAM magic
         imageOutput.writeShort(PNM.PAM);
         imageOutput.write('\n');
@@ -52,12 +56,19 @@ final class PAMHeaderWriter extends HeaderWriter {
         // Write width/height and number of channels
         imageOutput.write(String.format("WIDTH %s\nHEIGHT %s\n", getWidth(image), getHeight(image)).getBytes(UTF_8));
         imageOutput.write(String.format("DEPTH %s\n", getNumBands(image)).getBytes(UTF_8));
-
-        // TODO: maxSample (8 or16 bit)
         imageOutput.write(String.format("MAXVAL %s\n", getMaxVal(image)).getBytes(UTF_8));
-
-        // TODO: Determine tuple type based on input color model and image data
-        TupleType tupleType = getNumBands(image) > 3 ? TupleType.RGB_ALPHA : TupleType.RGB;
         imageOutput.write(String.format("TUPLTYPE %s\nENDHDR\n", tupleType).getBytes(UTF_8));
     }
+
+    private static TupleType tupleType(IIOImage image) {
+        TupleType tupleType = image.hasRaster()
+                ? TupleType.forPAM(image.getRaster())
+                : TupleType.forPAM(ImageTypeSpecifiers.createFromRenderedImage(image.getRenderedImage()));
+
+        if (tupleType == null) {
+            throw new IllegalArgumentException("Unknown TupleType for " + (image.hasRaster() ? image.getRaster() : image.getRenderedImage()));
+        }
+
+        return tupleType;
+    }
 }

imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PAMImageWriterSpi.java

@@ -45,12 +45,11 @@ public final class PAMImageWriterSpi extends ImageWriterSpiBase {
         super(new PAMProviderInfo());
     }
 
-    public boolean canEncodeImage(final ImageTypeSpecifier pType) {
-        // TODO: FixMe
-        return true;
+    public boolean canEncodeImage(final ImageTypeSpecifier type) {
+        return TupleType.forPAM(type) != null;
     }
 
-    public ImageWriter createWriterInstance(final Object pExtension) {
+    public ImageWriter createWriterInstance(final Object extension) {
         return new PNMImageWriter(this);
     }
 

imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PFMHeaderParser.java

@@ -69,7 +69,7 @@ final class PFMHeaderParser extends HeaderParser {
     public PNMHeader parse() throws IOException {
         int width = 0;
         int height = 0;
-        float maxSample = tupleType == TupleType.BLACKANDWHITE_WHITE_IS_ZERO ? 1 : 0; // PBM has no maxSample line
+        float maxSample = 0;
 
         List<String> comments = new ArrayList<>();
 
@@ -77,7 +77,7 @@ final class PFMHeaderParser extends HeaderParser {
             String line = input.readLine();
 
             if (line == null) {
-                throw new IIOException("Unexpeced end of stream");
+                throw new IIOException("Unexpected end of stream");
             }
 
             int commentStart = line.indexOf('#');

imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PNMHeaderWriter.java

@@ -30,6 +30,8 @@
 
 package com.twelvemonkeys.imageio.plugins.pnm;
 
+import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
+
 import javax.imageio.IIOImage;
 import javax.imageio.spi.ImageWriterSpi;
 import javax.imageio.stream.ImageOutputStream;
@@ -45,8 +47,7 @@ final class PNMHeaderWriter extends HeaderWriter {
     @Override
     public void writeHeader(final IIOImage image, final ImageWriterSpi provider) throws IOException {
         // Write P4/P5/P6 magic (Support only RAW formats for now; if we are to support PLAIN formats, pass parameter)
-        // TODO: Determine PBM, PBM or PPM based on input color model and image data?
-        short type = PNM.PPM;
+        short type = type(image);
         imageOutput.writeShort(type);
         imageOutput.write('\n');
 
@@ -61,4 +62,35 @@ final class PNMHeaderWriter extends HeaderWriter {
             imageOutput.write(String.format("%s\n", getMaxVal(image)).getBytes(UTF_8));
         }
     }
+
+    private short type(IIOImage image) {
+        TupleType type = tupleType(image);
+
+        if (type != null) {
+            switch (type) {
+                case BLACKANDWHITE_WHITE_IS_ZERO:
+                    return PNM.PBM;
+                case GRAYSCALE:
+                    return PNM.PGM;
+                case RGB:
+                    return PNM.PPM;
+                default:
+                    // fall through...
+            }
+        }
+
+        throw new IllegalArgumentException("Unsupported tupleType: " + type);
+    }
+
+    private static TupleType tupleType(IIOImage image) {
+        TupleType tupleType = image.hasRaster()
+                ? TupleType.forPNM(image.getRaster())
+                : TupleType.forPNM(ImageTypeSpecifiers.createFromRenderedImage(image.getRenderedImage()));
+
+        if (tupleType == null) {
+            throw new IllegalArgumentException("Unknown TupleType for " + (image.hasRaster() ? image.getRaster() : image.getRenderedImage()));
+        }
+
+        return tupleType;
+    }
 }

imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PNMImageWriter.java

@@ -31,14 +31,17 @@
 package com.twelvemonkeys.imageio.plugins.pnm;
 
 import com.twelvemonkeys.imageio.ImageWriterBase;
+import com.twelvemonkeys.imageio.util.RasterUtils;
 
-import javax.imageio.*;
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
 import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.spi.ImageWriterSpi;
-import java.awt.image.BufferedImage;
-import java.awt.image.DataBuffer;
-import java.awt.image.Raster;
-import java.awt.image.SampleModel;
+import javax.imageio.stream.ImageOutputStream;
+import java.awt.image.*;
 import java.io.File;
 import java.io.IOException;
 
@@ -69,7 +72,7 @@ public final class PNMImageWriter extends ImageWriterBase {
         // TODO: Issue warning if streamMetadata is non-null?
         // TODO: Issue warning if IIOImage contains thumbnails or other data we can't store?
 
-        HeaderWriter.write(image, this, imageOutput);
+        writeHeader(image, this, imageOutput);
 
         // TODO: Sub region
         // TODO: Subsampling
@@ -80,16 +83,20 @@ public final class PNMImageWriter extends ImageWriterBase {
         processImageComplete();
     }
 
+    private void writeHeader(final IIOImage image, final ImageWriterBase writer, final ImageOutputStream imageOutput) throws IOException {
+        HeaderWriter.createHeaderWriter(writer.getFormatName(), imageOutput).writeHeader(image, writer.getOriginatingProvider());
+    }
+
     private void writeImageData(final IIOImage image) throws IOException {
-        // - dump data as is (or convert, if TYPE_INT_xxx)
+        // - dump data as is (or convert, if TYPE_INT_xxx
         // Enforce RGB/CMYK order for such data!
 
         // TODO: Loop over x/y tiles, using 0,0 is only valid for BufferedImage
         // TODO: PNM/PAM does not support tiling, we must iterate all tiles along the x-axis for each row we write
         Raster tile = image.hasRaster() ? image.getRaster() : image.getRenderedImage().getTile(0, 0);
+        tile = tile.getTransferType() == DataBuffer.TYPE_INT ? RasterUtils.asByteRaster(tile) : tile;
 
         SampleModel sampleModel = tile.getSampleModel();
-
         DataBuffer dataBuffer = tile.getDataBuffer();
 
         int tileWidth = tile.getWidth();

imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PNMImageWriterSpi.java

@@ -48,12 +48,11 @@ public final class PNMImageWriterSpi extends ImageWriterSpiBase {
         super(new PNMProviderInfo());
     }
 
-    public boolean canEncodeImage(final ImageTypeSpecifier pType) {
-        // TODO: FixMe: Support only 1 bit b/w, 8-16 bit gray and 8-16 bit/sample RGB
-        return true;
+    public boolean canEncodeImage(final ImageTypeSpecifier type) {
+        return TupleType.forPNM(type) != null;
     }
 
-    public ImageWriter createWriterInstance(final Object pExtension) {
+    public ImageWriter createWriterInstance(final Object extension) {
         return new PNMImageWriter(this);
     }
 

imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/TupleType.java

@@ -30,7 +30,10 @@
 
 package com.twelvemonkeys.imageio.plugins.pnm;
 
+import javax.imageio.ImageTypeSpecifier;
 import java.awt.*;
+import java.awt.color.*;
+import java.awt.image.*;
 
 enum TupleType {
     // Official:
@@ -80,4 +83,150 @@ enum TupleType {
     public boolean isValidMaxSample(int maxSample) {
         return maxSample >= minMaxSample && maxSample <= maxMaxSample;
     }
+
+    
+    static TupleType forPNM(Raster raster) {
+        return filterPNM(forPAM(raster));
+    }
+
+    static TupleType forPNM(ImageTypeSpecifier type) {
+        return filterPNM(forPAM(type));
+    }
+
+    private static TupleType filterPNM(TupleType tupleType) {
+        if (tupleType == null) {
+            return null;
+        }
+
+        switch (tupleType) {
+            case BLACKANDWHITE:
+                return BLACKANDWHITE_WHITE_IS_ZERO;
+            case GRAYSCALE:
+            case RGB:
+                return tupleType;
+            default:
+                return null;
+        }
+    }
+
+    static TupleType forPAM(Raster raster) {
+        SampleModel sampleModel = raster.getSampleModel();
+        switch (sampleModel.getTransferType()) {
+            case DataBuffer.TYPE_BYTE:
+            case DataBuffer.TYPE_USHORT:
+            case DataBuffer.TYPE_INT:
+                // B/W, Gray or RGB
+                int bands = sampleModel.getNumBands();
+
+                if (bands == 1 && sampleModel.getSampleSize(0) == 1) {
+                    return TupleType.BLACKANDWHITE;
+                }
+                else if (bands == 2 && sampleModel.getSampleSize(0) == 1 && sampleModel.getSampleSize(1) == 1) {
+                    return TupleType.BLACKANDWHITE_ALPHA;
+                }
+
+                // We can only write 8 or 16 bits/band
+                if (!(sampleModel.getSampleSize(0) == 8 || sampleModel.getSampleSize(0) == 16)) {
+                    return null;
+                }
+                for (int i = 1; i < bands; i++) {
+                    if (sampleModel.getSampleSize(0) != sampleModel.getSampleSize(i)) {
+                        return null;
+                    }
+                }
+
+                if (bands == 1) {
+                    return TupleType.GRAYSCALE;
+                }
+                else if (bands == 2) {
+                    return TupleType.GRAYSCALE_ALPHA;
+                }
+                else if (bands == 3) {
+                    return TupleType.RGB;
+                }
+                else if (bands == 4) {
+                    return TupleType.RGB_ALPHA;
+                }
+                // ...else fall through...
+        }
+
+        return null;
+    }
+    
+    static TupleType forPAM(ImageTypeSpecifier type) {
+        // Support only 1 bit b/w, 8-16 bit gray and 8-16 bit/sample RGB
+        switch (type.getBufferedImageType()) {
+            // 1 bit b/w  or b/w + a
+            case BufferedImage.TYPE_BYTE_BINARY:
+                switch (type.getNumBands()) {
+                    case 1:
+                        return type.getBitsPerBand(0) == 1 ? TupleType.BLACKANDWHITE : null;
+                    case 2:
+                        return type.getBitsPerBand(0) == 2 || type.getBitsPerBand(0) == 1 && type.getBitsPerBand(1) == 1 ? TupleType.BLACKANDWHITE_ALPHA : null;
+                    default:
+                        return null;
+                }
+                // Gray
+            case BufferedImage.TYPE_BYTE_GRAY:
+            case BufferedImage.TYPE_USHORT_GRAY:
+                return TupleType.GRAYSCALE;
+            // RGB
+            case BufferedImage.TYPE_3BYTE_BGR:
+            case BufferedImage.TYPE_INT_RGB:
+            case BufferedImage.TYPE_INT_BGR:
+                return TupleType.RGB;
+            // RGBA
+            case BufferedImage.TYPE_4BYTE_ABGR:
+            case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+            case BufferedImage.TYPE_INT_ARGB:
+            case BufferedImage.TYPE_INT_ARGB_PRE:
+                return TupleType.RGB_ALPHA;
+            default:
+                // BYTE, USHORT or INT (packed)
+                switch (type.getSampleModel().getTransferType()) {
+                    case DataBuffer.TYPE_BYTE:
+                    case DataBuffer.TYPE_USHORT:
+                    case DataBuffer.TYPE_INT:
+                        // Gray or RGB
+                        ColorModel colorModel = type.getColorModel();
+
+                        if (!(colorModel instanceof IndexColorModel)) {
+                            ColorSpace cs = colorModel.getColorSpace();
+
+                            // We can only write 8 or 16 bits/band
+                            int bands = type.getNumBands();
+                            if (!(type.getBitsPerBand(0) == 8 || type.getBitsPerBand(0) == 16)) {
+                                return null;
+                            }
+                            for (int i = 1; i < bands; i++) {
+                                if (type.getBitsPerBand(0) != type.getBitsPerBand(i)) {
+                                    return null;
+                                }
+                            }
+
+                            if (cs.getType() == ColorSpace.TYPE_GRAY && bands == 1) {
+                                return TupleType.GRAYSCALE;
+                            }
+                            else if (cs.getType() == ColorSpace.TYPE_GRAY && colorModel.hasAlpha() && bands == 2) {
+                                return TupleType.GRAYSCALE_ALPHA;
+                            }
+                            else if (cs.getType() == ColorSpace.TYPE_RGB && bands == 3) {
+                                return TupleType.RGB;
+                            }
+                            else if (cs.getType() == ColorSpace.TYPE_RGB && colorModel.hasAlpha() && bands == 4) {
+                                return TupleType.RGB_ALPHA;
+                            }
+                            else if (cs.getType() == ColorSpace.TYPE_CMYK && bands == 4) {
+                                return TupleType.CMYK;
+                            }
+                            else if (cs.getType() == ColorSpace.TYPE_CMYK && colorModel.hasAlpha() && bands == 5) {
+                                return TupleType.CMYK_ALPHA;
+                            }
+                            // ...else fall through...
+                        }
+                }
+        }
+
+        return null;
+    }
 }

imageio/imageio-pnm/src/test/java/com/twelvemonkeys/imageio/plugins/pnm/PAMImageWriterSpiTest.java

@@ -30,15 +30,23 @@
 
 package com.twelvemonkeys.imageio.plugins.pnm;
 
+import com.twelvemonkeys.imageio.color.ColorSpaces;
+
 import org.junit.Test;
 
+import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.ImageWriter;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.spi.ImageWriterSpi;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.image.*;
 
 import static com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfoTest.assertClassExists;
 import static com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfoTest.assertClassesExist;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 /**
  * PAMImageWriterSpiTest.
@@ -65,4 +73,85 @@ public class PAMImageWriterSpiTest {
     public void getOutputTypes() {
         assertNotNull(spi.getOutputTypes());
     }
+
+    @Test
+    public void canEncodeImageBinary() {
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_BINARY)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_BINARY)));
+    }
+
+    @Test
+    public void canNotEncodeImageIndexed() {
+        assertFalse(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_INDEXED)));
+        assertFalse(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_INDEXED)));
+    }
+
+    @Test
+    public void canEncodeImageGray() {
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_USHORT_GRAY)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_USHORT_GRAY)));
+    }
+
+    @Test
+    public void canEncodeImageGrayAlpha() {
+        ComponentColorModel grayAlphaByte = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);
+        assertTrue(spi.canEncodeImage(new ImageTypeSpecifier(grayAlphaByte, grayAlphaByte.createCompatibleSampleModel(1, 1))));
+
+        ComponentColorModel grayAlphaUShort = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_USHORT);
+        assertTrue(spi.canEncodeImage(new ImageTypeSpecifier(grayAlphaUShort, grayAlphaUShort.createCompatibleSampleModel(1, 1))));
+    }
+
+    @Test
+    public void canEncodeImageRGB() {
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_3BYTE_BGR)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_INT_BGR)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_BGR)));
+    }
+
+    @Test
+    public void canEncodeImageARGB() {
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_4BYTE_ABGR)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_4BYTE_ABGR_PRE)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR_PRE)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB_PRE)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB_PRE)));
+    }
+
+    @Test
+    public void canEncodeImageCMYK() {
+        ComponentColorModel cmykByte = new ComponentColorModel(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
+        assertTrue(spi.canEncodeImage(new ImageTypeSpecifier(cmykByte, cmykByte.createCompatibleSampleModel(1, 1))));
+
+        ComponentColorModel cmykUShort = new ComponentColorModel(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), false, false, Transparency.OPAQUE, DataBuffer.TYPE_USHORT);
+        assertTrue(spi.canEncodeImage(new ImageTypeSpecifier(cmykUShort, cmykUShort.createCompatibleSampleModel(1, 1))));
+
+        ComponentColorModel cmykAlphaByte = new ComponentColorModel(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);
+        assertTrue(spi.canEncodeImage(new ImageTypeSpecifier(cmykAlphaByte, cmykAlphaByte.createCompatibleSampleModel(1, 1))));
+
+        ComponentColorModel cmykAlphaUShort = new ComponentColorModel(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_USHORT);
+        assertTrue(spi.canEncodeImage(new ImageTypeSpecifier(cmykAlphaUShort, cmykAlphaUShort.createCompatibleSampleModel(1, 1))));
+    }
+
+    @Test
+    public void canNotEncodeImageNonGrayOrRGB() {
+        ComponentColorModel xyzByte = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_CIEXYZ), false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
+        assertFalse(spi.canEncodeImage(new ImageTypeSpecifier(xyzByte, xyzByte.createCompatibleSampleModel(1, 1))));
+
+        ComponentColorModel xyzUshort = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_CIEXYZ), false, false, Transparency.OPAQUE, DataBuffer.TYPE_USHORT);
+        assertFalse(spi.canEncodeImage(new ImageTypeSpecifier(xyzUshort, xyzUshort.createCompatibleSampleModel(1, 1))));
+    }
 }

imageio/imageio-pnm/src/test/java/com/twelvemonkeys/imageio/plugins/pnm/PAMImageWriterTest.java

@@ -0,0 +1,37 @@
+package com.twelvemonkeys.imageio.plugins.pnm;
+
+import com.twelvemonkeys.imageio.color.ColorSpaces;
+import com.twelvemonkeys.imageio.util.ImageWriterAbstractTest;
+
+import javax.imageio.spi.ImageWriterSpi;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.image.*;
+import java.util.Arrays;
+import java.util.List;
+
+public class PAMImageWriterTest extends ImageWriterAbstractTest<PNMImageWriter> {
+    // NOTE: It's the same writer, however, the different SPI configures PAM mode, and enables extra formats
+    @Override
+    protected ImageWriterSpi createProvider() {
+        return new PAMImageWriterSpi();
+    }
+
+    @Override
+    protected List<? extends RenderedImage> getTestData() {
+        return Arrays.asList(
+                new BufferedImage(100, 100, BufferedImage.TYPE_BYTE_BINARY),
+                new BufferedImage(100, 100, BufferedImage.TYPE_3BYTE_BGR),
+                new BufferedImage(100, 100, BufferedImage.TYPE_BYTE_GRAY),
+                new BufferedImage(100, 100, BufferedImage.TYPE_USHORT_GRAY),
+                new BufferedImage(100, 100, BufferedImage.TYPE_4BYTE_ABGR),
+                new BufferedImage(100, 100, BufferedImage.TYPE_INT_BGR),
+                new BufferedImage(10, 10, BufferedImage.TYPE_INT_BGR),
+                new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB),
+                new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB_PRE),
+                new BufferedImage(new ComponentColorModel(ColorSpaces.getColorSpace(ColorSpace.CS_GRAY), true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_USHORT), Raster.createInterleavedRaster(DataBuffer.TYPE_USHORT, 10, 10, 2, null), false, null),
+                new BufferedImage(new ComponentColorModel(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE), Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, 10, 10, 4, null), false, null),
+                new BufferedImage(new ComponentColorModel(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_USHORT), Raster.createInterleavedRaster(DataBuffer.TYPE_USHORT, 10, 10, 5, null), false, null)
+        );
+    }
+}

imageio/imageio-pnm/src/test/java/com/twelvemonkeys/imageio/plugins/pnm/PNMImageWriterSpiTest.java

@@ -32,13 +32,19 @@ package com.twelvemonkeys.imageio.plugins.pnm;
 
 import org.junit.Test;
 
+import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.ImageWriter;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.spi.ImageWriterSpi;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.image.*;
 
 import static com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfoTest.assertClassExists;
 import static com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfoTest.assertClassesExist;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 /**
  * PNMImageWriterSpiTest.
@@ -65,4 +71,70 @@ public class PNMImageWriterSpiTest {
     public void getOutputTypes() {
         assertNotNull(spi.getOutputTypes());
     }
+
+    @Test
+    public void canEncodeImageBinary() {
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_BINARY)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_BINARY)));
+    }
+
+    @Test
+    public void canNotEncodeImageIndexed() {
+        assertFalse(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_INDEXED)));
+        assertFalse(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_INDEXED)));
+    }
+
+    @Test
+    public void canEncodeImageGray() {
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_USHORT_GRAY)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_USHORT_GRAY)));
+    }
+
+    @Test
+    public void canNotEncodeImageGrayAlpha() {
+        ComponentColorModel grayAlphaByte = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);
+        assertFalse(spi.canEncodeImage(new ImageTypeSpecifier(grayAlphaByte, grayAlphaByte.createCompatibleSampleModel(1, 1))));
+
+        ComponentColorModel grayAlphaUShort = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_USHORT);
+        assertFalse(spi.canEncodeImage(new ImageTypeSpecifier(grayAlphaUShort, grayAlphaUShort.createCompatibleSampleModel(1, 1))));
+    }
+
+    @Test
+    public void canEncodeImageRGB() {
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_3BYTE_BGR)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB)));
+
+        assertTrue(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_INT_BGR)));
+        assertTrue(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_BGR)));
+    }
+
+    @Test
+    public void canNotEncodeImageARGB() {
+        assertFalse(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_4BYTE_ABGR)));
+        assertFalse(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR)));
+
+        assertFalse(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_4BYTE_ABGR_PRE)));
+        assertFalse(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR_PRE)));
+
+        assertFalse(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB)));
+        assertFalse(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB)));
+
+        assertFalse(spi.canEncodeImage(new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB_PRE)));
+        assertFalse(spi.canEncodeImage(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB_PRE)));
+    }
+
+    @Test
+    public void canNotEncodeImageNonGrayOrRGB() {
+        ComponentColorModel xyzByte = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_CIEXYZ), false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
+        assertFalse(spi.canEncodeImage(new ImageTypeSpecifier(xyzByte, xyzByte.createCompatibleSampleModel(1, 1))));
+
+        ComponentColorModel xyzUshort = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_CIEXYZ), false, false, Transparency.OPAQUE, DataBuffer.TYPE_USHORT);
+        assertFalse(spi.canEncodeImage(new ImageTypeSpecifier(xyzUshort, xyzUshort.createCompatibleSampleModel(1, 1))));
+    }
 }

imageio/imageio-pnm/src/test/java/com/twelvemonkeys/imageio/plugins/pnm/PNMImageWriterTest.java

@@ -3,8 +3,7 @@ package com.twelvemonkeys.imageio.plugins.pnm;
 import com.twelvemonkeys.imageio.util.ImageWriterAbstractTest;
 
 import javax.imageio.spi.ImageWriterSpi;
-import java.awt.image.BufferedImage;
-import java.awt.image.RenderedImage;
+import java.awt.image.*;
 import java.util.Arrays;
 import java.util.List;
 
@@ -17,10 +16,12 @@ public class PNMImageWriterTest extends ImageWriterAbstractTest<PNMImageWriter>
     @Override
     protected List<? extends RenderedImage> getTestData() {
         return Arrays.asList(
+                new BufferedImage(100, 100, BufferedImage.TYPE_BYTE_BINARY),
                 new BufferedImage(100, 100, BufferedImage.TYPE_3BYTE_BGR),
                 new BufferedImage(100, 100, BufferedImage.TYPE_BYTE_GRAY),
                 new BufferedImage(100, 100, BufferedImage.TYPE_USHORT_GRAY),
-                new BufferedImage(100, 100, BufferedImage.TYPE_4BYTE_ABGR)
+                new BufferedImage(100, 100, BufferedImage.TYPE_INT_BGR),
+                new BufferedImage(10, 10, BufferedImage.TYPE_INT_BGR)
         );
     }
 }

imageio/imageio-psd/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-psd</artifactId>
     <name>TwelveMonkeys :: ImageIO :: PSD plugin</name>

imageio/imageio-psd/src/main/java/com/twelvemonkeys/imageio/plugins/psd/PSDImageReader.java

@@ -944,7 +944,7 @@ public final class PSDImageReader extends ImageReaderBase {
                 if (metadata.layerInfo == null) {
                     while (imageInput.getStreamPosition() + 12 < metadata.layerAndMaskInfoStart + layerAndMaskInfoLength) {
                         int resSig = imageInput.readInt();
-                        if (resSig != PSD.RESOURCE_TYPE) {
+                        if (resSig != PSD.RESOURCE_TYPE && resSig != PSD.RESOURCE_TYPE_LONG) {
                             processWarningOccurred(String.format("Bad resource alignment, expected: '8BIM' was '%s'", PSDUtil.intToStr(resSig)));
                             break;
                         }

imageio/imageio-psd/src/main/java/com/twelvemonkeys/imageio/plugins/psd/PSDUtil.java

@@ -103,7 +103,8 @@ final class PSDUtil {
                                                      final int[] byteCounts, long compressedLength) throws IOException {
         switch (compression) {
             case PSD.COMPRESSION_NONE:
-                return new SubImageInputStream(stream, stream.length());
+                long streamLength = stream.length();
+                return new SubImageInputStream(stream, streamLength < 0 ? Long.MAX_VALUE : streamLength);
 
             case PSD.COMPRESSION_RLE:
                 return new DirectImageInputStream(new SequenceInputStream(new LazyPackBitsStreamEnumeration(byteCounts, stream)));

imageio/imageio-psd/src/test/java/com/twelvemonkeys/imageio/plugins/psd/PSDUtilDecompressorStreamTest.java

@@ -31,10 +31,12 @@
 package com.twelvemonkeys.imageio.plugins.psd;
 
 import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
+import com.twelvemonkeys.imageio.stream.DirectImageInputStream;
 
 import org.junit.Test;
 
 import javax.imageio.stream.ImageInputStream;
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
 
 import static com.twelvemonkeys.imageio.plugins.psd.PSDUtil.createDecompressorStream;
@@ -65,6 +67,29 @@ public class PSDUtilDecompressorStreamTest {
         }
     }
 
+    @Test
+    public void testUncompressedUnknownLength() throws IOException {
+        // Data represents 3 x 3 raster with 8 bit samples, all 0x7f's
+        byte[] data = new byte[] {
+                0x7f, 0x7f, 0x7f,
+                0x7f, 0x7f, 0x7f,
+                0x7f, 0x7f, 0x7f
+        };
+        try (ImageInputStream input = createDecompressorStream(new DirectImageInputStream(new ByteArrayInputStream(data)), PSD.COMPRESSION_NONE, 3, 8, null, 9)) {
+            byte[] row = new byte[3];
+
+            for (int y = 0; y < 3; y++) {
+                input.readFully(row);
+
+                for (byte b : row) {
+                    assertEquals((byte) 0x7f, b);
+                }
+            }
+
+            assertEquals(-1, input.read());
+        }
+    }
+
     @Test
     public void testPackBits() throws IOException {
         // Data represents 3 x 3 raster with 8 bit samples, all 42's

imageio/imageio-reference/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-reference</artifactId>
     <name>TwelveMonkeys :: ImageIO :: JDK Reference Tests</name>

imageio/imageio-sgi/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-sgi</artifactId>
     <name>TwelveMonkeys :: ImageIO :: SGI plugin</name>

imageio/imageio-tga/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-tga</artifactId>
     <name>TwelveMonkeys :: ImageIO :: TGA plugin</name>

imageio/imageio-thumbsdb/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-thumbsdb</artifactId>
     <name>TwelveMonkeys :: ImageIO :: Thumbs.db plugin</name>

imageio/imageio-tiff-jai-interop/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-tiff-jai-interop</artifactId>
     <name>TwelveMonkeys :: ImageIO :: TIFF/JAI Metadata Interop</name>

imageio/imageio-tiff-jdk-interop/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-tiff-jdk-interop</artifactId>
     <name>TwelveMonkeys :: ImageIO :: TIFF/JDK JPEG Interop</name>

imageio/imageio-tiff/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-tiff</artifactId>
     <name>TwelveMonkeys :: ImageIO :: TIFF plugin</name>

imageio/imageio-webp/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-webp</artifactId>
     <name>TwelveMonkeys :: ImageIO :: WebP plugin</name>

imageio/imageio-webp/src/main/java/com/twelvemonkeys/imageio/plugins/webp/WebPImageReader.java

@@ -511,16 +511,16 @@ final class WebPImageReader extends ImageReaderBase {
     }
 
     private void readAlpha(BufferedImage destination, ImageReadParam param, final int width, final int height) throws IOException {
+        int compression = (int) lsbBitReader.readBits(2);
+        int filtering = (int) lsbBitReader.readBits(2);
+        int preProcessing = (int) lsbBitReader.readBits(2);
         int reserved = (int) lsbBitReader.readBits(2);
+
         if (reserved != 0) {
             // Spec says SHOULD be 0
             processWarningOccurred(String.format("Unexpected 'ALPH' chunk reserved value, expected 0: %d", reserved));
         }
 
-        int preProcessing = (int) lsbBitReader.readBits(2);
-        int filtering = (int) lsbBitReader.readBits(2);
-        int compression = (int) lsbBitReader.readBits(2);
-
         if (DEBUG) {
             System.out.println("preProcessing: " + preProcessing);
             System.out.println("filtering: " + filtering);

imageio/imageio-webp/src/test/java/com/twelvemonkeys/imageio/plugins/webp/WebPImageReaderTest.java

@@ -1,11 +1,8 @@
 package com.twelvemonkeys.imageio.plugins.webp;
 
-import static java.util.Arrays.asList;
+import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
 
-import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.io.IOException;
-import java.util.List;
+import org.junit.Test;
 
 import javax.imageio.ImageIO;
 import javax.imageio.ImageReadParam;
@@ -13,10 +10,13 @@ import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import javax.imageio.stream.MemoryCacheImageInputStream;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.IOException;
+import java.util.List;
 
-import org.junit.Test;
-
-import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
 
 /**
  * WebPImageReaderTest
@@ -141,4 +141,25 @@ public class WebPImageReaderTest extends ImageReaderAbstractTest<WebPImageReader
             reader.dispose();
         }
     }
+
+    @Test
+    public void testReadAlphaTransparent() throws IOException {
+        WebPImageReader reader = createReader();
+
+        try (ImageInputStream stream = ImageIO.createImageInputStream(getClassLoaderResource("/webp/1_webp_a.webp"))) {
+            reader.setInput(stream);
+            BufferedImage image = reader.read(0);
+
+            assertEquals(Transparency.TRANSLUCENT, image.getTransparency());
+
+            assertRGBEquals("Expected transparent corner (0, 0)", 0x00000000, image.getRGB(0, 0) & 0xFF000000, 8);
+            assertRGBEquals("Expected opaque center (200, 150)", 0xff9a4e01, image.getRGB(200, 150), 8);
+            assertRGBEquals("Expected transparent corner (399, 0)", 0x00000000, image.getRGB(399, 0) & 0xFF000000, 8);
+            assertRGBEquals("Expected transparent corner (0, 300)", 0x00000000, image.getRGB(0, 300) & 0xFF000000, 8);
+            assertRGBEquals("Expected transparent corner (399, 300)", 0x00000000, image.getRGB(399, 300) & 0xFF000000, 8);
+        }
+        finally {
+            reader.dispose();
+        }
+    }
 }

imageio/imageio-xwd/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.twelvemonkeys.imageio</groupId>
         <artifactId>imageio</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <artifactId>imageio-xwd</artifactId>
     <name>TwelveMonkeys :: ImageIO :: XWD plugin</name>

imageio/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>com.twelvemonkeys</groupId>
         <artifactId>twelvemonkeys</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.twelvemonkeys.imageio</groupId>

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.twelvemonkeys</groupId>
     <artifactId>twelvemonkeys</artifactId>
-    <version>3.9.2</version>
+    <version>3.9.4</version>
     <packaging>pom</packaging>
     <name>TwelveMonkeys</name>
     <description>TwelveMonkeys parent POM</description>
@@ -80,7 +80,7 @@
         <connection>scm:git:https://github.com/haraldk/TwelveMonkeys</connection>
         <developerConnection>scm:git:ssh://git@github.com/haraldk/TwelveMonkeys</developerConnection>
         <url>https://github.com/haraldk/TwelveMonkeys</url>
-        <tag>twelvemonkeys-3.9.2</tag>
+        <tag>twelvemonkeys-3.9.4</tag>
     </scm>
 
     <distributionManagement>

servlet/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>com.twelvemonkeys</groupId>
         <artifactId>twelvemonkeys</artifactId>
-        <version>3.9.2</version>
+        <version>3.9.4</version>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>