TMI-21: Implemented getRawImageType and getImageTypes for CMYK/YCCK.

TMI-16: Refactorings, cleaner color space determination + tests for thumbnail readers.

imageio/imageio-jpeg/src/test/java/com/twelvemonkeys/imageio/plugins/jpeg/AbstractThumbnailReaderTest.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2012, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.plugins.jpeg;
+
+import com.twelvemonkeys.imageio.stream.URLImageInputStreamSpi;
+
+import javax.imageio.ImageIO;
+import javax.imageio.spi.IIORegistry;
+import javax.imageio.stream.ImageInputStream;
+import java.io.IOException;
+import java.net.URL;
+
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * AbstractThumbnailReaderTest
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: AbstractThumbnailReaderTest.java,v 1.0 04.05.12 15:55 haraldk Exp$
+ */
+public abstract class AbstractThumbnailReaderTest {
+    static {
+        IIORegistry.getDefaultInstance().registerServiceProvider(new URLImageInputStreamSpi());
+    }
+
+    protected abstract ThumbnailReader createReader(
+            ThumbnailReadProgressListener progressListener, int imageIndex, int thumbnailIndex, ImageInputStream stream
+    ) throws IOException;
+
+    protected final ImageInputStream createStream(final String name) throws IOException {
+        URL resource = getClass().getResource(name);
+        ImageInputStream stream = ImageIO.createImageInputStream(resource);
+        assertNotNull("Could not create stream for resource " + resource, stream);
+        return stream;
+    }
+}

imageio/imageio-jpeg/src/test/java/com/twelvemonkeys/imageio/plugins/jpeg/EXIFThumbnailReaderTest.java

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2012, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.plugins.jpeg;
+
+import com.twelvemonkeys.imageio.metadata.CompoundDirectory;
+import com.twelvemonkeys.imageio.metadata.exif.EXIFReader;
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEG;
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegment;
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegmentUtil;
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import javax.imageio.ImageIO;
+import javax.imageio.stream.ImageInputStream;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * EXIFThumbnailReaderTest
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: EXIFThumbnailReaderTest.java,v 1.0 04.05.12 15:55 haraldk Exp$
+ */
+public class EXIFThumbnailReaderTest extends AbstractThumbnailReaderTest {
+
+    @Override
+    protected EXIFThumbnailReader createReader(final ThumbnailReadProgressListener progressListener, final int imageIndex, final int thumbnailIndex, final ImageInputStream stream) throws IOException {
+        List<JPEGSegment> segments = JPEGSegmentUtil.readSegments(stream, JPEG.APP1, "Exif");
+        stream.close();
+
+        assertNotNull(segments);
+        assertFalse(segments.isEmpty());
+
+        EXIFReader reader = new EXIFReader();
+        InputStream data = segments.get(0).data();
+        if (data.read() < 0) {
+            throw new AssertionError("EOF!");
+        }
+
+        ImageInputStream exifStream = ImageIO.createImageInputStream(data);
+        CompoundDirectory ifds = (CompoundDirectory) reader.read(exifStream);
+
+        assertEquals(2, ifds.directoryCount());
+
+        return new EXIFThumbnailReader(progressListener, imageIndex, thumbnailIndex, ifds.getDirectory(1), exifStream);
+    }
+
+    @Test
+    public void testReadJPEG() throws IOException {
+        ThumbnailReader reader = createReader(mock(ThumbnailReadProgressListener.class), 0, 0, createStream("/jpeg/cmyk-sample-multiple-chunk-icc.jpg"));
+
+        assertEquals(114, reader.getWidth());
+        assertEquals(160, reader.getHeight());
+
+        BufferedImage thumbnail = reader.read();
+        assertNotNull(thumbnail);
+        assertEquals(114, thumbnail.getWidth());
+        assertEquals(160, thumbnail.getHeight());
+    }
+
+    @Test
+    public void testReadRaw() throws IOException {
+        ThumbnailReader reader = createReader(mock(ThumbnailReadProgressListener.class), 0, 0, createStream("/jpeg/exif-rgb-thumbnail-sony-d700.jpg"));
+
+        assertEquals(80, reader.getWidth());
+        assertEquals(60, reader.getHeight());
+
+        BufferedImage thumbnail = reader.read();
+        assertNotNull(thumbnail);
+        assertEquals(80, thumbnail.getWidth());
+        assertEquals(60, thumbnail.getHeight());
+    }
+
+    @Test
+    public void testProgressListenerJPEG() throws IOException {
+        ThumbnailReadProgressListener listener = mock(ThumbnailReadProgressListener.class);
+
+        createReader(listener, 42, 43, createStream("/jpeg/cmyk-sample-multiple-chunk-icc.jpg")).read();
+
+        InOrder order = inOrder(listener);
+        order.verify(listener).processThumbnailStarted(42, 43);
+        order.verify(listener, atLeastOnce()).processThumbnailProgress(100f);
+        order.verify(listener).processThumbnailComplete();
+    }
+
+    @Test
+    public void testProgressListenerRaw() throws IOException {
+        ThumbnailReadProgressListener listener = mock(ThumbnailReadProgressListener.class);
+
+        createReader(listener, 0, 99, createStream("/jpeg/exif-rgb-thumbnail-sony-d700.jpg")).read();
+
+        InOrder order = inOrder(listener);
+        order.verify(listener).processThumbnailStarted(0, 99);
+        order.verify(listener, atLeastOnce()).processThumbnailProgress(100f);
+        order.verify(listener).processThumbnailComplete();
+    }
+}

imageio/imageio-jpeg/src/test/java/com/twelvemonkeys/imageio/plugins/jpeg/JFIFThumbnailReaderTest.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2012, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.plugins.jpeg;
+
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEG;
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegment;
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegmentUtil;
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import javax.imageio.stream.ImageInputStream;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.util.List;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+
+/**
+ * JFIFThumbnailReaderTest
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: JFIFThumbnailReaderTest.java,v 1.0 04.05.12 15:56 haraldk Exp$
+ */
+public class JFIFThumbnailReaderTest extends AbstractThumbnailReaderTest {
+    @Override
+    protected JFIFThumbnailReader createReader(ThumbnailReadProgressListener progressListener, int imageIndex, int thumbnailIndex, ImageInputStream stream) throws IOException {
+        List<JPEGSegment> segments = JPEGSegmentUtil.readSegments(stream, JPEG.APP0, "JFIF");
+        stream.close();
+
+        assertNotNull(segments);
+        assertFalse(segments.isEmpty());
+
+        return new JFIFThumbnailReader(progressListener, imageIndex, thumbnailIndex, JFIFSegment.read(segments.get(0).data()));
+    }
+
+    @Test
+    public void testReadRaw() throws IOException {
+        ThumbnailReader reader = createReader(mock(ThumbnailReadProgressListener.class), 0, 0, createStream("/jpeg/jfif-jfif-and-exif-thumbnail-sharpshot-iphone.jpg"));
+
+        assertEquals(131, reader.getWidth());
+        assertEquals(122, reader.getHeight());
+
+        BufferedImage thumbnail = reader.read();
+        assertNotNull(thumbnail);
+        assertEquals(131, thumbnail.getWidth());
+        assertEquals(122, thumbnail.getHeight());
+    }
+
+    @Test
+    public void testProgressListenerRaw() throws IOException {
+        ThumbnailReadProgressListener listener = mock(ThumbnailReadProgressListener.class);
+
+        createReader(listener, 0, 99, createStream("/jpeg/jfif-jfif-and-exif-thumbnail-sharpshot-iphone.jpg")).read();
+
+        InOrder order = inOrder(listener);
+        order.verify(listener).processThumbnailStarted(0, 99);
+        order.verify(listener, atLeastOnce()).processThumbnailProgress(100f);
+        order.verify(listener).processThumbnailComplete();
+    }
+}

imageio/imageio-jpeg/src/test/java/com/twelvemonkeys/imageio/plugins/jpeg/JFXXThumbnailReaderTest.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2012, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.plugins.jpeg;
+
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEG;
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegment;
+import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegmentUtil;
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import javax.imageio.stream.ImageInputStream;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+
+/**
+ * JFXXThumbnailReaderTest
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: JFXXThumbnailReaderTest.java,v 1.0 04.05.12 15:56 haraldk Exp$
+ */
+public class JFXXThumbnailReaderTest extends AbstractThumbnailReaderTest {
+    @Override
+    protected JFXXThumbnailReader createReader(ThumbnailReadProgressListener progressListener, int imageIndex, int thumbnailIndex, ImageInputStream stream) throws IOException {
+        List<JPEGSegment> segments = JPEGSegmentUtil.readSegments(stream, JPEG.APP0, "JFXX");
+        stream.close();
+
+        assertNotNull(segments);
+        assertFalse(segments.isEmpty());
+
+        JPEGSegment jfxx = segments.get(0);
+        return new JFXXThumbnailReader(progressListener, imageIndex, thumbnailIndex, JFXXSegment.read(jfxx.data(), jfxx.length()));
+    }
+
+    @Test
+    public void testReadJPEG() throws IOException {
+        ThumbnailReader reader = createReader(mock(ThumbnailReadProgressListener.class), 0, 0, createStream("/jpeg/jfif-jfxx-thumbnail-olympus-d320l.jpg"));
+
+        assertEquals(80, reader.getWidth());
+        assertEquals(60, reader.getHeight());
+
+        BufferedImage thumbnail = reader.read();
+        assertNotNull(thumbnail);
+        assertEquals(80, thumbnail.getWidth());
+        assertEquals(60, thumbnail.getHeight());
+    }
+
+    // TODO: Test JFXX indexed thumbnail
+    // TODO: Test JFXX RGB thumbnail
+
+    @Test
+    public void testProgressListenerRaw() throws IOException {
+        ThumbnailReadProgressListener listener = mock(ThumbnailReadProgressListener.class);
+
+        createReader(listener, 0, 99, createStream("/jpeg/jfif-jfxx-thumbnail-olympus-d320l.jpg")).read();
+
+        InOrder order = inOrder(listener);
+        order.verify(listener).processThumbnailStarted(0, 99);
+        order.verify(listener, atLeastOnce()).processThumbnailProgress(100f);
+        order.verify(listener).processThumbnailComplete();
+    }
+}

imageio/imageio-jpeg/src/test/java/com/twelvemonkeys/imageio/plugins/jpeg/JPEGImageReaderTest.java

@@ -33,17 +33,19 @@ import org.junit.Test;
 
 import javax.imageio.ImageIO;
 import javax.imageio.ImageReadParam;
+import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.spi.IIORegistry;
 import javax.imageio.spi.ImageReaderSpi;
 import java.awt.*;
+import java.awt.color.ColorSpace;
 import java.awt.image.BufferedImage;
 import java.awt.image.DataBufferByte;
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 
 import static org.junit.Assert.*;
-import static org.junit.Assert.assertEquals;
 
 /**
  * JPEGImageReaderTest
@@ -138,6 +140,8 @@ public class JPEGImageReaderTest extends ImageReaderAbstractTestCase<JPEGImageRe
         assertEquals(expectedData.length, data.length);
 
         assertJPEGPixelsEqual(expectedData, data, 0);
+
+        reader.dispose();
     }
 
     private static void assertJPEGPixelsEqual(byte[] expected, byte[] actual, int actualOffset) {
@@ -160,6 +164,8 @@ public class JPEGImageReaderTest extends ImageReaderAbstractTestCase<JPEGImageRe
         assertNotNull(image);
         assertEquals(345, image.getWidth());
         assertEquals(540, image.getHeight());
+
+        reader.dispose();
     }
 
     @Test
@@ -175,10 +181,33 @@ public class JPEGImageReaderTest extends ImageReaderAbstractTestCase<JPEGImageRe
         param.setSourceRegion(new Rectangle(0, 0, 3874, 16)); // Save some memory
         BufferedImage image = reader.read(0, param);
 
-
         assertNotNull(image);
         assertEquals(3874, image.getWidth());
         assertEquals(16, image.getHeight());
+
+        reader.dispose();
+    }
+
+    @Test
+    public void testTruncatedICCProfile() throws IOException {
+        // File contains single 'ICC_PROFILE' chunk, with a truncated (32 000 bytes) "Europe ISO Coated FOGRA27" ICC profile (by Adobe).
+        // Profile should have been about 550 000 bytes, split into multiple chunks. Written by GIMP 2.6.11
+        // See: https://bugzilla.redhat.com/show_bug.cgi?id=695246
+        JPEGImageReader reader = createReader();
+        reader.setInput(ImageIO.createImageInputStream(getClassLoaderResource("/jpeg/cmm-exception-invalid-icc-profile-data.jpg")));
+
+        assertEquals(1993, reader.getWidth(0));
+        assertEquals(1038, reader.getHeight(0));
+
+        ImageReadParam param = reader.getDefaultReadParam();
+        param.setSourceRegion(new Rectangle(reader.getWidth(0), 8));
+        BufferedImage image = reader.read(0, param);
+
+        assertNotNull(image);
+        assertEquals(1993, image.getWidth());
+        assertEquals(8, image.getHeight());
+
+        reader.dispose();
     }
 
     @Test
@@ -198,6 +227,7 @@ public class JPEGImageReaderTest extends ImageReaderAbstractTestCase<JPEGImageRe
         assertEquals(449, image.getHeight());
 
         // TODO: Need to test colors!
+        reader.dispose();
     }
 
     @Test
@@ -414,4 +444,112 @@ public class JPEGImageReaderTest extends ImageReaderAbstractTestCase<JPEGImageRe
             assertEquals((actualRGB)       & 0xff, (expectedRGB[i])       & 0xff, 5);
         }
     }
+
+    private List<TestData> getCMYKData() {
+        return Arrays.asList(
+                new TestData(getClassLoaderResource("/jpeg/cmyk-sample.jpg"), new Dimension(100, 100)),
+                new TestData(getClassLoaderResource("/jpeg/cmyk-sample-multiple-chunk-icc.jpg"), new Dimension(100, 100)),
+                new TestData(getClassLoaderResource("/jpeg/cmyk-sample-custom-icc-bright.jpg"), new Dimension(100, 100)),
+                new TestData(getClassLoaderResource("/jpeg/cmyk-sample-no-icc.jpg"), new Dimension(100, 100))
+        );
+    }
+
+    @Test
+    public void testGetImageTypesCMYK() throws IOException {
+        // Make sure CMYK images will report their embedded color profile among image types
+        JPEGImageReader reader = createReader();
+
+        List<TestData> cmykData = getCMYKData();
+
+        for (TestData data : cmykData) {
+            reader.setInput(data.getInputStream());
+            Iterator<ImageTypeSpecifier> types = reader.getImageTypes(0);
+
+            assertTrue(data + " has no image types", types.hasNext());
+
+            boolean hasRGBType = false;
+            boolean hasCMYKType = false;
+
+            while (types.hasNext()) {
+                ImageTypeSpecifier type = types.next();
+
+                int csType = type.getColorModel().getColorSpace().getType();
+                if (csType == ColorSpace.TYPE_RGB) {
+                    hasRGBType = true;
+                }
+                else if (csType == ColorSpace.TYPE_CMYK) {
+                    assertTrue("CMYK types should be delivered after RGB types (violates \"contract\" of more \"natural\" type first) for " + data, hasRGBType);
+
+                    hasCMYKType = true;
+                    break;
+                }
+            }
+
+            assertTrue("No RGB types for " + data, hasRGBType);
+            assertTrue("No CMYK types for " + data, hasCMYKType);
+        }
+
+        reader.dispose();
+    }
+
+    @Test
+    public void testGetRawImageTypeCMYK() throws IOException {
+        // Make sure images that are encoded as CMYK (not YCCK) actually return non-null for getRawImageType
+        JPEGImageReader reader = createReader();
+
+        List<TestData> cmykData = Arrays.asList(
+                new TestData(getClassLoaderResource("/jpeg/cmyk-sample.jpg"), new Dimension(100, 100)),
+                new TestData(getClassLoaderResource("/jpeg/cmyk-sample-no-icc.jpg"), new Dimension(100, 100))
+        );
+
+
+        for (TestData data : cmykData) {
+            reader.setInput(data.getInputStream());
+
+            ImageTypeSpecifier rawType = reader.getRawImageType(0);
+            assertNotNull("No raw type for " + data, rawType);
+        }
+    }
+
+    @Test
+    public void testReadCMYKAsCMYK() throws IOException {
+        // Make sure CMYK images can be read and still contain their original (embedded) color profile
+        JPEGImageReader reader = createReader();
+
+        List<TestData> cmykData = getCMYKData();
+
+        for (TestData data : cmykData) {
+            reader.setInput(data.getInputStream());
+            Iterator<ImageTypeSpecifier> types = reader.getImageTypes(0);
+
+            assertTrue(data + " has no image types", types.hasNext());
+
+            ImageTypeSpecifier cmykType = null;
+
+            while (types.hasNext()) {
+                ImageTypeSpecifier type = types.next();
+
+                int csType = type.getColorModel().getColorSpace().getType();
+                if (csType == ColorSpace.TYPE_CMYK) {
+                    cmykType = type;
+                    break;
+                }
+            }
+
+            assertNotNull("No CMYK types for " + data, cmykType);
+
+            ImageReadParam param = reader.getDefaultReadParam();
+            param.setDestinationType(cmykType);
+            param.setSourceRegion(new Rectangle(reader.getWidth(0), 8)); // We don't really need to read it all
+
+            BufferedImage image = reader.read(0, param);
+
+            assertNotNull(image);
+            assertEquals(ColorSpace.TYPE_CMYK, image.getColorModel().getColorSpace().getType());
+        }
+
+        reader.dispose();
+    }
+
+    // TODO: Test RGBA/YCbCrA handling
 }