#784 TIFF: No longer return incorrect standard image type for RGB with custom ICC profile

(cherry picked from commit b2f7cada21)
#786 TIFF: No longer create custom Inflater, to avoid resource leak
2026-05-19 00:00:03 -04:00 · 2023-07-19 13:12:51 +02:00 · 2023-07-19 13:12:51 +02:00 · 2023-07-19 13:12:50 +02:00 · 2023-07-19 13:12:50 +02:00 · 2023-07-19 13:12:50 +02:00
158 changed files with 7361 additions and 2924 deletions
@@ -0,0 +1,13 @@
+version: 2
+updates:
+  # Maven/Java library updates
+  - package-ecosystem: "maven"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    open-pull-requests-limit: 10
+  # GitHub actions updates
+  - package-ecosystem: "github-actions"
+    directory: "/.github/workflows"
+    schedule:
+      interval: "daily"
@@ -1,6 +1,14 @@
 name: CI

-on: [ push, pull_request ]
+on:
+  push:
+    branches:
+      - '**'
+      - '!dependabot/**'
+  pull_request:
+    branches: [ 'master' ]
+
+permissions: read-all

 jobs:
  test:
@@ -9,20 +17,22 @@ jobs:
      fail-fast: false
      matrix:
        os: [ ubuntu-latest, windows-latest, macos-latest ]
-        java: [ 8, 11, 17 ]
+        java: [ 8, 11, 17, 20 ]
    runs-on: ${{ matrix.os }}
+    permissions:
+      checks: write
    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v2
+      - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
+      - uses: actions/setup-java@5ffc13f4174014e2d4d4572b3d74c3fa61aeb2c2 # v3.11.0
        with:
          distribution: 'temurin'
          java-version: ${{ matrix.java }}
          java-package: jdk
          cache: 'maven'
      - name: Run Tests
-        run: mvn test
+        run: mvn --batch-mode --no-transfer-progress test
      - name: Publish Test Report
-        uses: mikepenz/action-junit-report@v2
+        uses: mikepenz/action-junit-report@150e2f992e4fad1379da2056d1d1c279f520e058 # v3.8.0
        if: ${{ !cancelled() }}
        with:
          report_paths: "**/target/surefire-reports/TEST*.xml"
@@ -31,15 +41,17 @@ jobs:
  test_oracle:
    name: Test Oracle JDK 8 with KCMS=${{ matrix.kcms }}
    runs-on: ubuntu-latest
+    permissions:
+      checks: write
    strategy:
      matrix:
        kcms: [ true, false ]
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
      - run: |
          download_url="https://javadl.oracle.com/webapps/download/AutoDL?BundleId=245038_d3c52aa6bfa54d3ca74e617f18309292"
          wget -O $RUNNER_TEMP/java_package.tar.gz $download_url
-      - uses: actions/setup-java@v2
+      - uses: actions/setup-java@5ffc13f4174014e2d4d4572b3d74c3fa61aeb2c2 # v3.11.0
        with:
          distribution: 'jdkfile'
          jdkFile: ${{ runner.temp }}/java_package.tar.gz
@@ -52,9 +64,9 @@ jobs:
      - name: Display Java version
        run: java -version
      - name: Run Tests
-        run: mvn test
+        run: mvn --batch-mode --no-transfer-progress test
      - name: Publish Test Report
-        uses: mikepenz/action-junit-report@v2
+        uses: mikepenz/action-junit-report@150e2f992e4fad1379da2056d1d1c279f520e058 # v3.8.0
        if: ${{ !cancelled() }}
        with:
          report_paths: "**/target/surefire-reports/TEST*.xml"
@@ -66,9 +78,9 @@ jobs:
    if: github.ref == 'refs/heads/master' # only perform on latest master
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
      - name: Set up Maven Central
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@5ffc13f4174014e2d4d4572b3d74c3fa61aeb2c2 # v3.11.0
        with: # running setup-java again overwrites the settings.xml
          distribution: 'temurin'
          java-version: '8'
@@ -80,11 +92,11 @@ jobs:
          gpg-passphrase: MAVEN_CENTRAL_GPG_PASSPHRASE # env variable for GPG private key passphrase (3)
      - name: Get Project Version
        run: |
-          echo "PROJECT_VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)" >> $GITHUB_ENV
+          echo "PROJECT_VERSION=$(mvn --batch-mode help:evaluate -Dexpression=project.version -q -DforceStdout)" >> $GITHUB_ENV
      - name: Publish to Maven Central
        if: ${{ endsWith(env.PROJECT_VERSION, '-SNAPSHOT') }}
-        run: mvn deploy -P release -DskipTests
+        run: mvn --batch-mode --no-transfer-progress deploy -P release -DskipTests
        env:
          MAVEN_CENTRAL_USERNAME: ${{ secrets.SONATYPE_USERNAME }} # must be the same env variable name as (1)
          MAVEN_CENTRAL_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }} # must be the same env variable name as (2)
-          MAVEN_CENTRAL_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }} # must be the same env variable name as (3)
+          MAVEN_CENTRAL_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }} # must be the same env variable name as (3)
@@ -4,6 +4,8 @@
 [![StackOverflow](https://img.shields.io/badge/stack_overflow-twelvemonkeys-orange.svg)](https://stackoverflow.com/questions/tagged/twelvemonkeys)
 [![Donate](https://img.shields.io/badge/donate-PayPal-blue.svg)](https://paypal.me/haraldk76/100)

+![Logo](logo.png)
+
 ## About

 TwelveMonkeys ImageIO provides extended image file format support for the Java platform, through plugins for the `javax.imageio.*` package.
@@ -50,7 +52,7 @@ As there is lots of legacy data out there, we see the need for open implementati


 **Important note on using Batik:** *Please read [The Apache™ XML Graphics Project - Security](https://xmlgraphics.apache.org/security.html), 
-and make sure you use version 1.14 or later.*
+and make sure you use an updated and secure version.*

 Note that GIF, PNG and WBMP formats are already supported through the ImageIO API, using the
 [JDK standard plugins](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/package-summary.html).
@@ -272,12 +274,12 @@ To depend on the JPEG and TIFF plugin using Maven, add the following to your POM
    <dependency>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio-jpeg</artifactId>
-        <version>3.8.1</version>
+        <version>3.9.4</version>
    </dependency>
    <dependency>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio-tiff</artifactId>
-        <version>3.8.1</version>
+        <version>3.9.4</version>
    </dependency>

    <!--
@@ -287,7 +289,7 @@ To depend on the JPEG and TIFF plugin using Maven, add the following to your POM
    <dependency>
        <groupId>com.twelvemonkeys.servlet</groupId>
        <artifactId>servlet</artifactId>
-        <version>3.8.1</version>
+        <version>3.9.4</version>
    </dependency>

    <!--
@@ -296,7 +298,7 @@ To depend on the JPEG and TIFF plugin using Maven, add the following to your POM
    <dependency>
        <groupId>com.twelvemonkeys.servlet</groupId>
        <artifactId>servlet</artifactId>
-        <version>3.8.1</version>
+        <version>3.9.4</version>
        <classifier>jakarta</classifier>
    </dependency>
 </dependencies>
@@ -306,13 +308,13 @@ To depend on the JPEG and TIFF plugin using Maven, add the following to your POM

 To depend on the JPEG and TIFF plugin in your IDE or program, add all of the following JARs to your class path:

-    twelvemonkeys-common-lang-3.8.1.jar
-    twelvemonkeys-common-io-3.8.1.jar
-    twelvemonkeys-common-image-3.8.1.jar
-    twelvemonkeys-imageio-core-3.8.1.jar
-    twelvemonkeys-imageio-metadata-3.8.1.jar
-    twelvemonkeys-imageio-jpeg-3.8.1.jar
-    twelvemonkeys-imageio-tiff-3.8.1.jar
+    twelvemonkeys-common-lang-3.9.4.jar
+    twelvemonkeys-common-io-3.9.4.jar
+    twelvemonkeys-common-image-3.9.4.jar
+    twelvemonkeys-imageio-core-3.9.4.jar
+    twelvemonkeys-imageio-metadata-3.9.4.jar
+    twelvemonkeys-imageio-jpeg-3.9.4.jar
+    twelvemonkeys-imageio-tiff-3.9.4.jar

 #### Deploying the plugins in a web app

@@ -378,81 +380,50 @@ Other "fat" JAR bundlers will probably have similar mechanisms to merge entries

 ### Links to prebuilt binaries

-##### Latest version (3.8.1)
+##### Latest version (3.9.4)

-Requires Java 7 or later.
+The latest version that will run on Java 7 is 3.9.4. Later versions will require Java 8 or later.
 
 Common dependencies
-* [common-lang-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.8.1/common-lang-3.8.1.jar)
-* [common-io-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.8.1/common-io-3.8.1.jar)
-* [common-image-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.8.1/common-image-3.8.1.jar)
+* [common-lang-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.9.4/common-lang-3.9.4.jar)
+* [common-io-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.9.4/common-io-3.9.4.jar)
+* [common-image-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.9.4/common-image-3.9.4.jar)

 ImageIO dependencies
-* [imageio-core-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.8.1/imageio-core-3.8.1.jar)
-* [imageio-metadata-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.8.1/imageio-metadata-3.8.1.jar)
+* [imageio-core-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.9.4/imageio-core-3.9.4.jar)
+* [imageio-metadata-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.9.4/imageio-metadata-3.9.4.jar)

 ImageIO plugins
-* [imageio-bmp-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-bmp/3.8.1/imageio-bmp-3.8.1.jar)
-* [imageio-hdr-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-hdr/3.8.1/imageio-hdr-3.8.1.jar)
-* [imageio-icns-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.8.1/imageio-icns-3.8.1.jar)
-* [imageio-iff-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.8.1/imageio-iff-3.8.1.jar)
-* [imageio-jpeg-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.8.1/imageio-jpeg-3.8.1.jar)
-* [imageio-pcx-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pcx/3.8.1/imageio-pcx-3.8.1.jar)
-* [imageio-pict-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.8.1/imageio-pict-3.8.1.jar)
-* [imageio-pnm-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pnm/3.8.1/imageio-pnm-3.8.1.jar)
-* [imageio-psd-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.8.1/imageio-psd-3.8.1.jar)
-* [imageio-sgi-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-sgi/3.8.1/imageio-sgi-3.8.1.jar)
-* [imageio-tga-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tga/3.8.1/imageio-tga-3.8.1.jar)
-* [imageio-thumbsdb-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.8.1/imageio-thumbsdb-3.8.1.jar)
-* [imageio-tiff-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.8.1/imageio-tiff-3.8.1.jar)
-* [imageio-webp-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-webp/3.8.1/imageio-webp-3.8.1.jar)
-* [imageio-xwd-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-xwd/3.8.1/imageio-xwd-3.8.1.jar)
+* [imageio-bmp-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-bmp/3.9.4/imageio-bmp-3.9.4.jar)
+* [imageio-hdr-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-hdr/3.9.4/imageio-hdr-3.9.4.jar)
+* [imageio-icns-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.9.4/imageio-icns-3.9.4.jar)
+* [imageio-iff-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.9.4/imageio-iff-3.9.4.jar)
+* [imageio-jpeg-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.9.4/imageio-jpeg-3.9.4.jar)
+* [imageio-pcx-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pcx/3.9.4/imageio-pcx-3.9.4.jar)
+* [imageio-pict-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.9.4/imageio-pict-3.9.4.jar)
+* [imageio-pnm-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pnm/3.9.4/imageio-pnm-3.9.4.jar)
+* [imageio-psd-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.9.4/imageio-psd-3.9.4.jar)
+* [imageio-sgi-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-sgi/3.9.4/imageio-sgi-3.9.4.jar)
+* [imageio-tga-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tga/3.9.4/imageio-tga-3.9.4.jar)
+* [imageio-thumbsdb-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.9.4/imageio-thumbsdb-3.9.4.jar)
+* [imageio-tiff-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.9.4/imageio-tiff-3.9.4.jar)
+* [imageio-webp-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-webp/3.9.4/imageio-webp-3.9.4.jar)
+* [imageio-xwd-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-xwd/3.9.4/imageio-xwd-3.9.4.jar)

 ImageIO plugins requiring 3rd party libs
-* [imageio-batik-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.8.1/imageio-batik-3.8.1.jar)
+* [imageio-batik-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.9.4/imageio-batik-3.9.4.jar)

 Photoshop Path support for ImageIO
-* [imageio-clippath-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-clippath/3.8.1/imageio-clippath-3.8.1.jar)
+* [imageio-clippath-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-clippath/3.9.4/imageio-clippath-3.9.4.jar)

 Servlet support
-* [servlet-3.8.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.8.1/servlet-3.8.1.jar)
-
-##### Old version (3.0.x)
-
-Use this version for projects that requires Java 6 or need the JMagick support. *Does not support Java 8 or later*.
-
-Common dependencies
-* [common-lang-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.0.2/common-lang-3.0.2.jar)
-* [common-io-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.0.2/common-io-3.0.2.jar)
-* [common-image-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.0.2/common-image-3.0.2.jar)
- 
-ImageIO dependencies
-* [imageio-core-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.0.2/imageio-core-3.0.2.jar)
-* [imageio-metadata-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.0.2/imageio-metadata-3.0.2.jar)
- 
-ImageIO plugins
-* [imageio-jpeg-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.0.2/imageio-jpeg-3.0.2.jar)
-* [imageio-tiff-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.0.2/imageio-tiff-3.0.2.jar)
-* [imageio-psd-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.0.2/imageio-psd-3.0.2.jar)
-* [imageio-pict-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.0.2/imageio-pict-3.0.2.jar)
-* [imageio-iff-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.0.2/imageio-iff-3.0.2.jar)
-* [imageio-icns-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.0.2/imageio-icns-3.0.2.jar)
-* [imageio-ico-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-ico/3.0.2/imageio-ico-3.0.2.jar)
-* [imageio-thumbsdb-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.0.2/imageio-thumbsdb-3.0.2.jar)
- 
-ImageIO plugins requiring 3rd party libs
-* [imageio-batik-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.0.2/imageio-batik-3.0.2.jar)
-* [imageio-jmagick-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jmagick/3.0.2/imageio-jmagick-3.0.2.jar)
- 
-Servlet support
-* [servlet-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.0.2/servlet-3.0.2.jar)
-
+* [servlet-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.9.4/servlet-3.9.4.jar)

 ## License

 This project is provided under the OSI approved [BSD license](https://opensource.org/licenses/BSD-3-Clause):

-    Copyright (c) 2008-2020, Harald Kuhr
+    Copyright (c) 2008-2022, Harald Kuhr
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
@@ -484,8 +455,9 @@ This project is provided under the OSI approved [BSD license](https://opensource

 q: How do I use it?

-a: The easiest way is to build your own project using Maven, and just add dependencies to the specific plug-ins you need.
- If you don't use Maven, make sure you have all the necessary JARs in classpath. See the Install section above.
+a: The easiest way is to build your own project using Maven, Gradle or other build tool with dependency management, 
+and just add dependencies to the specific plug-ins you need.
+ If you don't use such a build tool, make sure you have all the necessary JARs in classpath. See the Install section above.


 q: What changes do I have to make to my code in order to use the plug-ins?
@@ -503,27 +475,41 @@ q: How does it work?

 a: The TwelveMonkeys ImageIO project contains plug-ins for ImageIO. ImageIO uses a service lookup mechanism, to discover plug-ins at runtime. 

-All you have have to do, is to make sure you have the TwelveMonkeys JARs in your classpath.
+All you have to do, is to make sure you have the TwelveMonkeys ImageIO JARs in your classpath.

 You can read more about the registry and the lookup mechanism in the [IIORegistry API doc](https://docs.oracle.com/javase/7/docs/api/javax/imageio/spi/IIORegistry.html).

 The fine print: The TwelveMonkeys service providers for JPEG, BMP and TIFF, overrides the onRegistration method, and
 utilizes the pairwise partial ordering mechanism of the `IIOServiceRegistry` to make sure it is installed before
-the Sun/Oracle provided `JPEGImageReader` and `BMPImageReader`, and the Apple provided `TIFFImageReader` on OS X, 
+the Sun/Oracle provided `JPEGImageReader`, `BMPImageReader` `TIFFImageReader`, and the Apple provided `TIFFImageReader` on OS X, 
 respectively. Using the pairwise ordering will not remove any functionality form these implementations, but in most 
 cases you'll end up using the TwelveMonkeys plug-ins instead.

+
 q: Why is there no support for common formats like GIF or PNG?

-a: The short answer is simply that the built-in support in ImageIO for these formats are good enough as-is.
+a: The short answer is simply that the built-in support in ImageIO for these formats are considered good enough as-is.
 If you are looking for better PNG write performance on Java 7 and 8, see [JDK9 PNG Writer Backport](https://github.com/gredler/jdk9-png-writer-backport).


+q: When is the next release? What is the current release schedule?
+
+a: The goal is to make monthly releases, containing bug fixes and minor new features. 
+And quarterly releases with more "major" features.
+
+
+q: I love this project! How can I help?
+
+a: Have a look at the open issues, and see if there are any issues you can help fix, or provide sample file or create test cases for.
+It is also possible for you or your organization to become a sponsor, through GitHub Sponsors. 
+Providing funding will allow us to spend more time on fixing bugs and implementing new features. 
+
+
 q: What about JAI? Several of the formats are already supported by JAI.

 a: While JAI (and jai-imageio in particular) have support for some of the same formats, JAI has some major issues.
 The most obvious being:
- It's not actively developed. No issues has been fixed for years.
+- It's not actively developed. No issue has been fixed for years.
 - To get full format support, you need native libs.
 Native libs does not exist for several popular platforms/architectures, and further the native libs are not open source.
 Some environments may also prevent deployment of native libs, which brings us back to square one.
@@ -0,0 +1,5 @@
+# Security Policy
+
+To report a security issue, please disclose it at [security advisory](https://github.com/haraldk/TwelveMonkeys/security/advisories/new).
+
+Vulnerabilities will be disclosed in a best effort base.
@@ -5,7 +5,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>

    <groupId>com.twelvemonkeys.bom</groupId>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>common-image</artifactId>
    <packaging>jar</packaging>
@@ -79,7 +79,7 @@ public final class BufferedImageFactory {
    private int scanSize;

    private ColorModel sourceColorModel;
-    private Hashtable sourceProperties; // ImageConsumer API dictates Hashtable
+    private Hashtable<?, ?> sourceProperties; // ImageConsumer API dictates Hashtable

    private Object sourcePixels;

@@ -91,21 +91,21 @@ public final class BufferedImageFactory {

    /**
     * Creates a {@code BufferedImageFactory}.
-     * @param pSource the source image
-     * @throws IllegalArgumentException if {@code pSource == null}
+     * @param source the source image
+     * @throws IllegalArgumentException if {@code source == null}
     */
-    public BufferedImageFactory(final Image pSource) {
-        this(pSource != null ? pSource.getSource() : null);
+    public BufferedImageFactory(final Image source) {
+        this(source != null ? source.getSource() : null);
    }

    /**
     * Creates a {@code BufferedImageFactory}.
-     * @param pSource the source image producer
-     * @throws IllegalArgumentException if {@code pSource == null}
+     * @param source the source image producer
+     * @throws IllegalArgumentException if {@code source == null}
     */
-    public BufferedImageFactory(final ImageProducer pSource) {
-        Validate.notNull(pSource, "source");
-        producer = pSource;
+    public BufferedImageFactory(final ImageProducer source) {
+        Validate.notNull(source, "source");
+        producer = source;
    }

    /**
@@ -155,44 +155,44 @@ public final class BufferedImageFactory {
    /**
     * Sets the source region (AOI) for the new image.
     *
-     * @param pRegion the source region
+     * @param region the source region
     */
-    public void setSourceRegion(final Rectangle pRegion) {
+    public void setSourceRegion(final Rectangle region) {
        // Re-fetch everything, if region changed
-        if (x != pRegion.x || y != pRegion.y || width != pRegion.width || height != pRegion.height) {
+        if (x != region.x || y != region.y || width != region.width || height != region.height) {
            dispose();
        }

-        x = pRegion.x;
-        y = pRegion.y;
-        width = pRegion.width;
-        height = pRegion.height;
+        x = region.x;
+        y = region.y;
+        width = region.width;
+        height = region.height;
    }

    /**
     * Sets the source subsampling for the new image.
     *
-     * @param pXSub horizontal subsampling factor
-     * @param pYSub vertical subsampling factor
+     * @param xSubsampling horizontal subsampling factor
+     * @param ySubsampling vertical subsampling factor
     */
-    public void setSourceSubsampling(int pXSub, int pYSub) {
+    public void setSourceSubsampling(int xSubsampling, int ySubsampling) {
        // Re-fetch everything, if subsampling changed
-        if (xSub != pXSub || ySub != pYSub) {
+        if (xSub != xSubsampling || ySub != ySubsampling) {
            dispose();
        }

-        if (pXSub > 1) {
-            xSub = pXSub;
+        if (xSubsampling > 1) {
+            xSub = xSubsampling;
        }
-        if (pYSub > 1) {
-            ySub = pYSub;
+        if (ySubsampling > 1) {
+            ySub = ySubsampling;
        }
    }

-    private synchronized void doFetch(boolean pColorModelOnly) throws ImageConversionException {
-        if (!fetching && (!pColorModelOnly && buffered == null || buffered == null && sourceColorModel == null)) {
+    private synchronized void doFetch(final boolean colorModelOnly) throws ImageConversionException {
+        if (!fetching && (!colorModelOnly && buffered == null || buffered == null && sourceColorModel == null)) {
            // NOTE: Subsampling is only applied if extracting full image
-            if (!pColorModelOnly && (xSub > 1 || ySub > 1)) {
+            if (!colorModelOnly && (xSub > 1 || ySub > 1)) {
                // If only sampling a region, the region must be scaled too
                if (width > 0 && height > 0) {
                    width = (width + xSub - 1) / xSub;
@@ -207,38 +207,41 @@ public final class BufferedImageFactory {

            // Start fetching
            fetching = true;
-            readColorModelOnly = pColorModelOnly;
+            readColorModelOnly = colorModelOnly;

            producer.startProduction(consumer); // Note: If single-thread (synchronous), this call will block

            // Wait until the producer wakes us up, by calling imageComplete
            while (fetching) {
                try {
-                    wait(200l);
+                    wait(200L);
                }
                catch (InterruptedException e) {
                    throw new ImageConversionException("Image conversion aborted: " + e.getMessage(), e);
                }
            }

-            if (consumerException != null) {
-                throw new ImageConversionException("Image conversion failed: " + consumerException.getMessage(), consumerException);
-            }
+            try {
+                if (consumerException != null) {
+                    throw new ImageConversionException("Image conversion failed: " + consumerException.getMessage(), consumerException);
+                }

-            if (pColorModelOnly) {
-                createColorModel();
+                if (colorModelOnly) {
+                    createColorModel();
+                }
+                else {
+                    createBuffered();
+                }
            }
-            else {
-                createBuffered();
+            finally {
+                // Clean up, in case any objects are copied/cloned, so we can free resources
+                freeResources();
            }
        }
    }

    private void createColorModel() {
        colorModel = sourceColorModel;
-
-        // Clean up, in case any objects are copied/cloned, so we can free resources
-        freeResources();
    }

    private void createBuffered() {
@@ -253,8 +256,9 @@ public final class BufferedImageFactory {
            }
        }

-        // Clean up, in case any objects are copied/cloned, so we can free resources
-        freeResources();
+        if (buffered == null) {
+            throw new ImageConversionException("Could not create BufferedImage");
+        }
    }

    private void freeResources() {
@@ -280,27 +284,27 @@ public final class BufferedImageFactory {
    /**
     * Adds a progress listener to this factory.
     *
-     * @param pListener the progress listener
+     * @param listener the progress listener
     */
-    public void addProgressListener(ProgressListener pListener) {
-        if (pListener == null) {
+    public void addProgressListener(ProgressListener listener) {
+        if (listener == null) {
            return;
        }

        if (listeners == null) {
-            listeners = new CopyOnWriteArrayList<ProgressListener>();
+            listeners = new CopyOnWriteArrayList<>();
        }

-        listeners.add(pListener);
+        listeners.add(listener);
    }

    /**
     * Removes a progress listener from this factory.
     *
-     * @param pListener the progress listener
+     * @param listener the progress listener
     */
-    public void removeProgressListener(ProgressListener pListener) {
-        if (pListener == null) {
+    public void removeProgressListener(ProgressListener listener) {
+        if (listener == null) {
            return;
        }

@@ -308,7 +312,7 @@ public final class BufferedImageFactory {
            return;
        }

-        listeners.remove(pListener);
+        listeners.remove(listener);
    }

    /**
@@ -324,21 +328,22 @@ public final class BufferedImageFactory {
     * Converts an array of {@code int} pixels to an array of {@code short}
     * pixels. The conversion is done, by masking out the
     * <em>higher 16 bits</em> of the {@code int}.
-     *
+     * <p>
     * For any given {@code int}, the {@code short} value is computed as
     * follows:
     * <blockquote>{@code
     * short value = (short) (intValue & 0x0000ffff);
     * }</blockquote>
+     * </p>
     *
-     * @param pPixels the pixel data to convert
-     * @return an array of {@code short}s, same lenght as {@code pPixels}
+     * @param inputPixels the pixel data to convert
+     * @return an array of {@code short}s, same length as {@code inputPixels}
     */
-    private static short[] toShortPixels(int[] pPixels) {
-        short[] pixels = new short[pPixels.length];
+    private static short[] toShortPixels(int[] inputPixels) {
+        short[] pixels = new short[inputPixels.length];

        for (int i = 0; i < pixels.length; i++) {
-            pixels[i] = (short) (pPixels[i] & 0xffff);
+            pixels[i] = (short) (inputPixels[i] & 0xffff);
        }

        return pixels;
@@ -351,17 +356,17 @@ public final class BufferedImageFactory {
     * @see BufferedImageFactory#addProgressListener
     * @see BufferedImageFactory#removeProgressListener
     */
-    public static interface ProgressListener extends EventListener {
+    public interface ProgressListener extends EventListener {

        /**
         * Reports progress to this listener.
         * Invoked by the {@code BufferedImageFactory} to report progress in
         * the image decoding.
         *
-         * @param pFactory the factory reporting the progress
-         * @param pPercentage the percentage of progress
+         * @param factory the factory reporting the progress
+         * @param percentage the percentage of progress
         */
-        void progress(BufferedImageFactory pFactory, float pPercentage);
+        void progress(BufferedImageFactory factory, float percentage);
    }

    private class Consumer implements ImageConsumer {
@@ -446,18 +451,18 @@ public final class BufferedImageFactory {
            processProgress(pY + pHeight);
        }

-        public void setPixels(int pX, int pY, int pWidth, int pHeight, ColorModel pModel, short[] pPixels, int pOffset, int pScanSize) {
-            setPixelsImpl(pX, pY, pWidth, pHeight, pModel, pPixels, pOffset, pScanSize);
+        public void setPixels(int x, int y, int width, int height, ColorModel colorModel, short[] pixels, int offset, int scanSize) {
+            setPixelsImpl(x, y, width, height, colorModel, pixels, offset, scanSize);
        }

-        private void setColorModelOnce(final ColorModel pModel) {
+        private void setColorModelOnce(final ColorModel colorModel) {
            // NOTE: There seems to be a "bug" in AreaAveragingScaleFilter, as it
            // first passes the original color model through in setColorModel, then
            // later replaces it with the default RGB in the first setPixels call
            // (this is probably allowed according to the spec, but it's a waste of time and space).
-            if (sourceColorModel != pModel) {
-                if (/*sourceColorModel == null ||*/ sourcePixels == null) {
-                    sourceColorModel = pModel;
+            if (sourceColorModel != colorModel) {
+                if (sourcePixels == null) {
+                    sourceColorModel = colorModel;
                }
                else {
                    throw new IllegalStateException("Change of ColorModel after pixel delivery not supported");
@@ -470,17 +475,16 @@ public final class BufferedImageFactory {
            }
        }

-        public void imageComplete(int pStatus) {
+        @Override
+        public void imageComplete(int status) {
            fetching = false;

            if (producer != null) {
                producer.removeConsumer(this);
            }

-            switch (pStatus) {
-                case ImageConsumer.IMAGEERROR:
-                    consumerException = new ImageConversionException("ImageConsumer.IMAGEERROR");
-                break;
+            if (status == ImageConsumer.IMAGEERROR) {
+                consumerException = new ImageConversionException("ImageConsumer.IMAGEERROR");
            }

            synchronized (BufferedImageFactory.this) {
@@ -488,16 +492,18 @@ public final class BufferedImageFactory {
            }
        }

-        public void setColorModel(ColorModel pModel) {
-            setColorModelOnce(pModel);
+        @Override
+        public void setColorModel(ColorModel colorModel) {
+            setColorModelOnce(colorModel);
        }

-        public void setDimensions(int pWidth, int pHeight) {
+        @Override
+        public void setDimensions(int w, int h) {
            if (width < 0) {
-                width = pWidth - x;
+                width = w - x;
            }
            if (height < 0) {
-                height = pHeight - y;
+                height = h - y;
            }

            // Hmm.. Special case, but is it a good idea?
@@ -506,27 +512,31 @@ public final class BufferedImageFactory {
            }
        }

-        public void setHints(int pHintflags) {
+        @Override
+        public void setHints(int hintFlags) {
           // ignore
        }

-        public void setPixels(int pX, int pY, int pWidth, int pHeight, ColorModel pModel, byte[] pPixels, int pOffset, int pScanSize) {
-            setPixelsImpl(pX, pY, pWidth, pHeight, pModel, pPixels, pOffset, pScanSize);
+        @Override
+        public void setPixels(int x, int y, int width, int height, ColorModel colorModel, byte[] pixels, int offset, int scanSize) {
+            setPixelsImpl(x, y, width, height, colorModel, pixels, offset, scanSize);
        }

-        public void setPixels(int pX, int pY, int pWeigth, int pHeight, ColorModel pModel, int[] pPixels, int pOffset, int pScanSize) {
-            if (pModel.getTransferType() == DataBuffer.TYPE_USHORT) {
+        @Override
+        public void setPixels(int x, int y, int width, int height, ColorModel colorModel, int[] pixels, int offset, int scanSize) {
+            if (colorModel.getTransferType() == DataBuffer.TYPE_USHORT) {
                // NOTE: Workaround for limitation in ImageConsumer API
                // Convert int[] to short[], to be compatible with the ColorModel
-                setPixelsImpl(pX, pY, pWeigth, pHeight, pModel, toShortPixels(pPixels), pOffset, pScanSize);
+                setPixelsImpl(x, y, width, height, colorModel, toShortPixels(pixels), offset, scanSize);
            }
            else {
-                setPixelsImpl(pX, pY, pWeigth, pHeight, pModel, pPixels, pOffset, pScanSize);
+                setPixelsImpl(x, y, width, height, colorModel, pixels, offset, scanSize);
            }
        }

-        public void setProperties(Hashtable pProperties) {
-            sourceProperties = pProperties;
+        @Override
+        public void setProperties(Hashtable properties) {
+            sourceProperties = properties;
        }
    }

@@ -34,14 +34,13 @@ import org.junit.Ignore;
 import org.junit.Test;

 import java.awt.*;
-import java.awt.color.ColorSpace;
-import java.awt.image.BufferedImage;
-import java.awt.image.ColorModel;
-import java.awt.image.ImageProducer;
-import java.awt.image.IndexColorModel;
+import java.awt.color.*;
+import java.awt.image.*;
 import java.net.URL;

-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;

 /**
 * BufferedImageFactoryTestCase
@@ -260,9 +259,9 @@ public class BufferedImageFactoryTest {

        // Listener should abort ASAP
        factory.addProgressListener(new BufferedImageFactory.ProgressListener() {
-            public void progress(BufferedImageFactory pFactory, float pPercentage) {
-                if (pPercentage > 5) {
-                    pFactory.abort();
+            public void progress(BufferedImageFactory factory, float percentage) {
+                if (percentage > 5) {
+                    factory.abort();
                }
            }
        });
@@ -343,7 +342,7 @@ public class BufferedImageFactoryTest {
        VerifyingListener listener = new VerifyingListener(factory);
        factory.addProgressListener(listener);
        factory.removeProgressListener(new BufferedImageFactory.ProgressListener() {
-            public void progress(BufferedImageFactory pFactory, float pPercentage) {
+            public void progress(BufferedImageFactory factory, float percentage) {
            }
        });
        factory.getBufferedImage();
@@ -380,11 +379,11 @@ public class BufferedImageFactoryTest {
            this.factory = factory;
        }

-        public void progress(BufferedImageFactory pFactory, float pPercentage) {
-            assertEquals(factory, pFactory);
-            assertTrue(pPercentage >= progress && pPercentage <= 100f);
+        public void progress(BufferedImageFactory factory, float percentage) {
+            assertEquals(this.factory, factory);
+            assertTrue(percentage >= progress && percentage <= 100f);

-            progress = pPercentage;
+            progress = percentage;
        }


@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>common-io</artifactId>
    <packaging>jar</packaging>
@@ -41,21 +41,20 @@ import java.io.InputStream;
 * underlying stream.
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
- * @version $Id: //depot/branches/personal/haraldk/twelvemonkeys/release-2/twelvemonkeys-core/src/main/java/com/twelvemonkeys/io/SubStream.java#2 $
 */
 public final class SubStream extends FilterInputStream {
    private long bytesLeft;
    private int markLimit;

    /**
-     * Creates a {@code SubStream} of the given {@code pStream}.
+     * Creates a {@code SubStream} of the given {@code stream}.
     *
-     * @param pStream the underlying input stream
-     * @param pLength maximum number of bytes to read drom this stream
+     * @param stream the underlying input stream
+     * @param length maximum number of bytes to read from this stream
     */
-    public SubStream(final InputStream pStream, final long pLength) {
-        super(Validate.notNull(pStream, "stream"));
-        bytesLeft = pLength;
+    public SubStream(final InputStream stream, final long length) {
+        super(Validate.notNull(stream, "stream"));
+        bytesLeft = length;
    }

    /**
@@ -73,13 +72,13 @@ public final class SubStream extends FilterInputStream {

    @Override
    public int available() throws IOException {
-        return (int) Math.min(super.available(), bytesLeft);
+        return (int) findMaxLen(super.available());
    }

    @Override
-    public void mark(int pReadLimit) {
-        super.mark(pReadLimit);// This either succeeds or does nothing...
-        markLimit = pReadLimit;
+    public void mark(int readLimit) {
+        super.mark(readLimit);// This either succeeds or does nothing...
+        markLimit = readLimit;
    }

    @Override
@@ -93,44 +92,42 @@ public final class SubStream extends FilterInputStream {
        if (bytesLeft-- <= 0) {
            return -1;
        }
+
        return super.read();
    }

    @Override
-    public final int read(byte[] pBytes) throws IOException {
-        return read(pBytes, 0, pBytes.length);
+    public int read(byte[] bytes) throws IOException {
+        return read(bytes, 0, bytes.length);
    }

    @Override
-    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 (bytesLeft <= 0) {
            return -1;
        }

-        int read = super.read(pBytes, pOffset, (int) findMaxLen(pLength));
+        int read = super.read(bytes, off, (int) findMaxLen(len));
        bytesLeft = read < 0 ? 0 : bytesLeft - read;
+
        return read;
    }

+    @Override
+    public long skip(long length) throws IOException {
+        long skipped = super.skip(findMaxLen(length));// Skips 0 or more, never -1
+        bytesLeft -= skipped;
+
+        return skipped;
+    }
+
    /**
     * Finds the maximum number of bytes we can read or skip, from this stream.
     *
-     * @param pLength the requested length
+     * @param length the requested length
     * @return the maximum number of bytes to read
     */
-    private long findMaxLen(long pLength) {
-        if (bytesLeft < pLength) {
-            return (int) Math.max(bytesLeft, 0);
-        }
-        else {
-            return pLength;
-        }
-    }
-
-    @Override
-    public long skip(long pLength) throws IOException {
-        long skipped = super.skip(findMaxLen(pLength));// Skips 0 or more, never -1
-        bytesLeft -= skipped;
-        return skipped;
+    private long findMaxLen(long length) {
+        return bytesLeft < length ? Math.max(bytesLeft, 0) : length;
    }
 }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>common-lang</artifactId>
    <packaging>jar</packaging>
@@ -904,7 +904,7 @@ public final class StringUtil {
        }
        catch (ParseException pe) {
            // Wrap in RuntimeException
-            throw new IllegalArgumentException(pe.getMessage());
+            throw new IllegalArgumentException(pe.getMessage() + " at pos " + pe.getErrorOffset());
        }
    }

@@ -593,8 +593,8 @@ public class StringUtilTest {
        cal.clear();
        cal.set(Calendar.HOUR, 1);
        cal.set(Calendar.MINUTE, 2);
-        date = StringUtil.toDate("1:02 am",
-                                 DateFormat.getTimeInstance(DateFormat.SHORT, Locale.US));
+        format = new SimpleDateFormat("HH:mm");
+        date = StringUtil.toDate("1:02", format);
        assertNotNull(date);
        assertEquals(cal.getTime(), date);
    }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <groupId>com.twelvemonkeys.common</groupId>
    <artifactId>common</artifactId>
@@ -47,7 +47,7 @@
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
-            <version>4.13.1</version>
+            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <groupId>com.twelvemonkeys.contrib</groupId>
    <artifactId>contrib</artifactId>
@@ -65,7 +65,7 @@
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
-            <version>4.13.1</version>
+            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</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.14</batik.version>
+        <batik.version>1.16</batik.version>
    </properties>

    <build>
@@ -51,7 +51,7 @@
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
-            <version>2.11.0</version>
+            <version>2.13.0</version>
            <scope>provided</scope>
        </dependency>

@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-bmp</artifactId>
    <name>TwelveMonkeys :: ImageIO :: BMP plugin</name>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-clippath</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Photoshop Path Support</name>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-core</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Core</name>
@@ -0,0 +1,627 @@
+package com.twelvemonkeys.imageio;
+
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataNode;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.image.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import static com.twelvemonkeys.imageio.StandardImageMetadataSupport.ColorSpaceType.*;
+import static com.twelvemonkeys.lang.Validate.isTrue;
+import static com.twelvemonkeys.lang.Validate.notNull;
+
+/**
+ * Base class for easy read-only implementation of the standard image metadata format.
+ * Chroma, Data and Transparency nodes values are based on the required
+ * {@link ImageTypeSpecifier}.
+ * Other values or overrides may be specified using the builder.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ */
+public class StandardImageMetadataSupport extends AbstractMetadata {
+
+    // The only required field, most standard metadata can be extracted from the type
+    private final ImageTypeSpecifier type;
+    protected final ColorSpaceType colorSpaceType;
+    protected final boolean blackIsZero;
+    private final IndexColorModel palette;
+    protected final String compressionName;
+    protected final boolean compressionLossless;
+    protected final PlanarConfiguration planarConfiguration;
+    private final int[] bitsPerSample;
+    private final int[] significantBits;
+    private final int[] sampleMSB;
+    protected final Double pixelAspectRatio;
+    protected final ImageOrientation orientation;
+    protected final String formatVersion;
+    protected final SubimageInterpretation subimageInterpretation;
+    private final Calendar documentCreationTime; // TODO: This field should be a LocalDateTime or other java.time type, Consider a long timestamp + TimeZone to avoid messing up the API...
+    private final Collection<TextEntry> textEntries;
+
+    protected StandardImageMetadataSupport(Builder builder) {
+        notNull(builder, "builder");
+
+        // Baseline
+        type = builder.type;
+
+        // Chroma
+        colorSpaceType = builder.colorSpaceType;
+        blackIsZero = builder.blackIsZero;
+        palette = builder.palette;
+
+        // Compression
+        compressionName = builder.compressionName;
+        compressionLossless = builder.compressionLossless;
+
+        // Data
+        planarConfiguration = builder.planarConfiguration;
+        bitsPerSample = builder.bitsPerSample;
+        significantBits = builder.significantBits;
+        sampleMSB = builder.sampleMSB;
+
+        // Dimension
+        orientation = builder.orientation;
+        pixelAspectRatio = builder.pixelAspectRatio;
+
+        // Document
+        formatVersion = builder.formatVersion;
+        documentCreationTime = builder.documentCreationTime;
+        subimageInterpretation = builder.subimageInterpretation;
+
+        // Text
+        textEntries = builder.textEntries;
+    }
+
+    public static Builder builder(ImageTypeSpecifier type) {
+        return new Builder(type);
+    }
+
+    public static class Builder {
+        private final ImageTypeSpecifier type;
+        private ColorSpaceType colorSpaceType;
+        private boolean blackIsZero = true;
+        private IndexColorModel palette;
+        private String compressionName;
+        private boolean compressionLossless = true;
+        private PlanarConfiguration planarConfiguration;
+        public int[] bitsPerSample;
+        private int[] significantBits;
+        private int[] sampleMSB;
+        private Double pixelAspectRatio;
+        private ImageOrientation orientation = ImageOrientation.Normal;
+        private String formatVersion;
+        private SubimageInterpretation subimageInterpretation;
+        private Calendar documentCreationTime; // TODO: This field should be a LocalDateTime or other java.time type
+        private final Collection<TextEntry> textEntries = new ArrayList<>();
+
+        protected Builder(ImageTypeSpecifier type) {
+            this.type = notNull(type, "type");
+        }
+
+        public Builder withColorSpaceType(ColorSpaceType colorSpaceType) {
+            this.colorSpaceType = colorSpaceType;
+
+            return this;
+        }
+
+        public Builder withBlackIsZero(boolean blackIsZero) {
+            this.blackIsZero = blackIsZero;
+
+            return this;
+        }
+
+        public Builder withPalette(IndexColorModel palette) {
+            this.palette = palette;
+
+            return this;
+        }
+
+        public Builder withCompressionTypeName(String compressionName) {
+            this.compressionName = notNull(compressionName, "compressionName").equalsIgnoreCase("none") ? null : compressionName;
+
+            return this;
+        }
+
+        public Builder withCompressionLossless(boolean lossless) {
+            this.compressionLossless = isTrue(lossless || compressionName != null, lossless, "Lossy compression requires compression name");
+
+            return this;
+        }
+
+        public Builder withPlanarConfiguration(PlanarConfiguration planarConfiguration) {
+            this.planarConfiguration = planarConfiguration;
+
+            return this;
+        }
+
+        public Builder withBitsPerSample(int... bitsPerSample) {
+            this.bitsPerSample = bitsPerSample;
+
+            return this;
+        }
+
+        public Builder withSignificantBitsPerSample(int... significantBits) {
+            this.significantBits = isTrue(significantBits.length == 1 || significantBits.length == type.getNumBands(),
+                                          significantBits,
+                                          String.format("single value or %d values expected", type.getNumBands()));
+
+            return this;
+        }
+
+        public Builder withSampleMSB(int... sampleMSB) {
+            this.sampleMSB = isTrue(sampleMSB.length == 1 || sampleMSB.length == type.getNumBands(),
+                                          sampleMSB,
+                                          String.format("single value or %d values expected", type.getNumBands()));
+
+            return this;
+        }
+
+        public Builder withPixelAspectRatio(Double pixelAspectRatio) {
+            this.pixelAspectRatio = pixelAspectRatio;
+
+            return this;
+        }
+
+        public Builder withOrientation(ImageOrientation orientation) {
+            this.orientation = notNull(orientation, "orientation");
+
+            return this;
+        }
+
+        public Builder withFormatVersion(String formatVersion) {
+            this.formatVersion = notNull(formatVersion, "formatVersion");
+
+            return this;
+        }
+
+        public Builder withSubimageInterpretation(SubimageInterpretation interpretation) {
+            this.subimageInterpretation = interpretation;
+
+            return this;
+        }
+
+        public Builder withDocumentCreationTime(Calendar creationTime) {
+            this.documentCreationTime = creationTime;
+
+            return this;
+        }
+
+        public Builder withTextEntries(Map<String, String> entries) {
+            return withTextEntries(toTextEntries(notNull(entries, "entries").entrySet()));
+        }
+
+        private Collection<TextEntry> toTextEntries(Collection<Map.Entry<String, String>> entries) {
+            TextEntry[] result = new TextEntry[entries.size()];
+
+            int i = 0;
+            for (Map.Entry<String, String> entry : entries) {
+                result[i++] = new TextEntry(entry.getKey(), entry.getValue());
+            }
+
+            return Arrays.asList(result);
+        }
+
+        public Builder withTextEntries(Collection<TextEntry> entries) {
+            this.textEntries.addAll(notNull(entries, "entries"));
+
+            return this;
+        }
+
+        public Builder withTextEntry(String keyword, String value) {
+            if (value != null && !value.isEmpty()) {
+                this.textEntries.add(new TextEntry(notNull(keyword, "keyword"), value));
+            }
+
+            return this;
+        }
+
+        public IIOMetadata build() {
+            return new StandardImageMetadataSupport(this);
+        }
+    }
+
+    protected enum ColorSpaceType {
+        XYZ(3),
+        Lab(3),
+        Luv(3),
+        YCbCr(3),
+        Yxy(3),
+        YCCK(4),
+        PhotoYCC(3),
+        RGB(3),
+        GRAY(1),
+        HSV(3),
+        HLS(3),
+        CMYK(3),
+        CMY(3),
+
+        // Generic types (so much extra work, because Java names can't start with a number, phew...)
+        GENERIC_2CLR(2, "2CLR"),
+        GENERIC_3CLR(3, "3CLR"),
+        GENERIC_4CLR(4, "4CLR"),
+        GENERIC_5CLR(5, "5CLR"),
+        GENERIC_6CLR(6, "6CLR"),
+        GENERIC_7CLR(7, "7CLR"),
+        GENERIC_8CLR(8, "8CLR"),
+        GENERIC_9CLR(9, "9CLR"),
+        GENERIC_ACLR(0xA, "ACLR"),
+        GENERIC_BCLR(0xB, "BCLR"),
+        GENERIC_CCLR(0xC, "CCLR"),
+        GENERIC_DCLR(0xD, "DCLR"),
+        GENERIC_ECLR(0xE, "ECLR"),
+        GENERIC_FCLR(0xF, "FCLR");
+
+        final int numChannels;
+        private final String nameOverride;
+
+        ColorSpaceType(int numChannels) {
+            this(numChannels, null);
+        }
+        ColorSpaceType(int numChannels, String nameOverride) {
+            this.numChannels = numChannels;
+            this.nameOverride = nameOverride;
+        }
+
+        @Override
+        public String toString() {
+            return nameOverride != null ? nameOverride : super.toString();
+        }
+    }
+
+    protected enum PlanarConfiguration {
+        PixelInterleaved,
+        PlaneInterleaved,
+        LineInterleaved,
+        TileInterleaved
+    }
+
+    protected enum ImageOrientation {
+        Normal,
+        Rotate90,
+        Rotate180,
+        Rotate270,
+        FlipH,
+        FlipV,
+        FlipHRotate90,
+        FlipVRotate90
+    }
+
+    protected enum SubimageInterpretation {
+        Standalone,
+        SinglePage,
+        FullResolution,
+        ReducedResolution,
+        PyramidLayer,
+        Preview,
+        VolumeSlice,
+        ObjectView,
+        Panorama,
+        AnimationFrame,
+        TransparencyMask,
+        CompositingLayer,
+        SpectralSlice,
+        Unknown
+    }
+
+    @Override
+    protected IIOMetadataNode getStandardChromaNode() {
+        IIOMetadataNode chromaNode = new IIOMetadataNode("Chroma");
+
+        ColorModel colorModel = colorSpaceType != null ? null : type.getColorModel();
+        ColorSpaceType csType = colorSpaceType != null ? colorSpaceType : colorSpaceType(colorModel.getColorSpace());
+        int numComponents = colorSpaceType != null ? colorSpaceType.numChannels : colorModel.getNumComponents();
+
+        IIOMetadataNode colorSpaceTypeNode = new IIOMetadataNode("ColorSpaceType");
+        chromaNode.appendChild(colorSpaceTypeNode);
+        colorSpaceTypeNode.setAttribute("name", csType.toString());
+
+        IIOMetadataNode numChannelsNode = new IIOMetadataNode("NumChannels");
+        numChannelsNode.setAttribute("value", String.valueOf(numComponents));
+        chromaNode.appendChild(numChannelsNode);
+
+        IIOMetadataNode blackIsZeroNode = new IIOMetadataNode("BlackIsZero");
+        blackIsZeroNode.setAttribute("value", booleanString(blackIsZero));
+        chromaNode.appendChild(blackIsZeroNode);
+
+        if (colorModel instanceof IndexColorModel || palette != null) {
+            IndexColorModel colorMap = palette != null ? palette : (IndexColorModel) colorModel;
+
+            IIOMetadataNode paletteNode = new IIOMetadataNode("Palette");
+            chromaNode.appendChild(paletteNode);
+
+            for (int i = 0; i < colorMap.getMapSize(); i++) {
+                IIOMetadataNode paletteEntryNode = new IIOMetadataNode("PaletteEntry");
+                paletteNode.appendChild(paletteEntryNode);
+
+                paletteEntryNode.setAttribute("index", Integer.toString(i));
+                paletteEntryNode.setAttribute("red", Integer.toString(colorMap.getRed(i)));
+                paletteEntryNode.setAttribute("green", Integer.toString(colorMap.getGreen(i)));
+                paletteEntryNode.setAttribute("blue", Integer.toString(colorMap.getBlue(i)));
+
+                // Assumption: BITMASK transparency will use single transparent pixel
+                if (colorMap.getTransparency() == Transparency.TRANSLUCENT) {
+                    paletteEntryNode.setAttribute("alpha", Integer.toString(colorMap.getAlpha(i)));
+                }
+            }
+
+            if (colorMap.getTransparentPixel() != -1) {
+                IIOMetadataNode backgroundIndexNode = new IIOMetadataNode("BackgroundIndex");
+                chromaNode.appendChild(backgroundIndexNode);
+                backgroundIndexNode.setAttribute("value", Integer.toString(colorMap.getTransparentPixel()));
+            }
+        }
+
+        // TODO: BackgroundColor?
+
+        return chromaNode;
+    }
+
+    private static ColorSpaceType colorSpaceType(ColorSpace colorSpace) {
+        switch (colorSpace.getType()) {
+            case ColorSpace.TYPE_XYZ:
+                return XYZ;
+            case ColorSpace.TYPE_Lab:
+                return Lab;
+            case ColorSpace.TYPE_Luv:
+                return Luv;
+            case ColorSpace.TYPE_YCbCr:
+                return YCbCr;
+            case ColorSpace.TYPE_Yxy:
+                return Yxy;
+                // Note: Can't map to YCCK or PhotoYCC, as there's no corresponding constant in java.awt.ColorSpace
+            case ColorSpace.TYPE_RGB:
+                return RGB;
+            case ColorSpace.TYPE_GRAY:
+                return GRAY;
+            case ColorSpace.TYPE_HSV:
+                return HSV;
+            case ColorSpace.TYPE_HLS:
+                return HLS;
+            case ColorSpace.TYPE_CMYK:
+                return CMYK;
+            case ColorSpace.TYPE_CMY:
+                return CMY;
+            default:
+                int numComponents = colorSpace.getNumComponents();
+                if (numComponents == 1) {
+                    return GRAY;
+                }
+                else if (numComponents < 16) {
+                    return ColorSpaceType.valueOf("GENERIC_" + Integer.toHexString(numComponents) + "CLR");
+                }
+        }
+
+        throw new IllegalArgumentException("Unknown ColorSpace type: " + colorSpace);
+    }
+
+    protected static final class TextEntry {
+        static final List<String> COMPRESSIONS = Arrays.asList("none", "lzw", "zip", "bzip", "other");
+
+        final String keyword;
+        final String value;
+        final String language;
+        final String encoding;
+        final String compression;
+
+        public TextEntry(final String keyword, final String value) {
+            this(keyword, value, null, null, null);
+        }
+
+        public TextEntry(final String keyword, final String value, final String language, final String encoding, final String compression) {
+            this.keyword = keyword;
+            this.value = notNull(value, "value");
+            this.language = language;
+            this.encoding = encoding;
+            this.compression = isTrue(compression == null || COMPRESSIONS.contains(compression), compression, String.format("Unknown compression: %s (expected: %s)", compression, COMPRESSIONS));
+        }
+    }
+
+    @Override
+    protected IIOMetadataNode getStandardCompressionNode() {
+        if (compressionName == null) {
+            return null;
+        }
+
+        IIOMetadataNode node = new IIOMetadataNode("Compression");
+
+        IIOMetadataNode compressionTypeName = new IIOMetadataNode("CompressionTypeName");
+        compressionTypeName.setAttribute("value", compressionName);
+        node.appendChild(compressionTypeName);
+
+        IIOMetadataNode lossless = new IIOMetadataNode("Lossless");
+        lossless.setAttribute("value", booleanString(compressionLossless));
+        node.appendChild(lossless);
+
+        return node;
+    }
+
+    protected static String booleanString(boolean booleanValue) {
+        return booleanValue ? "TRUE" : "FALSE";
+    }
+
+    @Override
+    protected IIOMetadataNode getStandardDataNode() {
+        IIOMetadataNode dataNode = new IIOMetadataNode("Data");
+
+        IIOMetadataNode planarConfigurationNode = new IIOMetadataNode("PlanarConfiguration");
+        dataNode.appendChild(planarConfigurationNode);
+        planarConfigurationNode.setAttribute("value", planarConfiguration != null ? planarConfiguration.toString() :
+                                                  (type.getSampleModel() instanceof BandedSampleModel ? "PlaneInterleaved" : "PixelInterleaved"));
+
+        String sampleFormatValue = colorSpaceType == null && type.getColorModel() instanceof IndexColorModel
+                                   ? "Index"
+                                   : sampleFormat(type.getSampleModel());
+
+        if (sampleFormatValue != null) {
+            IIOMetadataNode sampleFormatNode = new IIOMetadataNode("SampleFormat");
+            sampleFormatNode.setAttribute("value", sampleFormatValue);
+            dataNode.appendChild(sampleFormatNode);
+        }
+
+        int[] bitsPerSample = this.bitsPerSample != null ? this.bitsPerSample : type.getSampleModel().getSampleSize();
+        IIOMetadataNode bitsPerSampleNode = new IIOMetadataNode("BitsPerSample");
+        bitsPerSampleNode.setAttribute("value", createListValue(bitsPerSample.length, bitsPerSample));
+        dataNode.appendChild(bitsPerSampleNode);
+
+        if (significantBits != null) {
+            String significantBitsValue = createListValue(type.getNumBands(), significantBits);
+            if (!significantBitsValue.equals(bitsPerSampleNode.getAttribute("value"))) {
+                IIOMetadataNode significantBitsPerSampleNode = new IIOMetadataNode("SignificantBitsPerSample");
+                significantBitsPerSampleNode.setAttribute("value", significantBitsValue);
+                dataNode.appendChild(significantBitsPerSampleNode);
+            }
+        }
+
+        if (sampleMSB != null) {
+            // TODO: Only if different from default!
+            IIOMetadataNode sampleMSBNode = new IIOMetadataNode("SampleMSB");
+            sampleMSBNode.setAttribute("value", createListValue(type.getNumBands(), sampleMSB));
+            dataNode.appendChild(sampleMSBNode);
+        }
+
+        return dataNode;
+    }
+
+    private static String createListValue(final int itemCount, final int... values) {
+        StringBuilder buffer = new StringBuilder();
+
+        for (int i = 0; i < itemCount; i++) {
+            if (buffer.length() > 0) {
+                buffer.append(' ');
+            }
+
+            buffer.append(values[i % values.length]);
+        }
+
+        return buffer.toString();
+    }
+
+    private static String sampleFormat(SampleModel sampleModel) {
+        switch (sampleModel.getDataType()) {
+            case DataBuffer.TYPE_SHORT:
+            case DataBuffer.TYPE_INT:
+                if (sampleModel instanceof ComponentSampleModel) {
+                    return "SignedIntegral";
+                }
+                // Otherwise fall-through, most likely a *PixelPackedSampleModel
+            case DataBuffer.TYPE_BYTE:
+            case DataBuffer.TYPE_USHORT:
+                return "UnsignedIntegral";
+            case DataBuffer.TYPE_FLOAT:
+            case DataBuffer.TYPE_DOUBLE:
+                return "Real";
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    protected IIOMetadataNode getStandardDimensionNode() {
+        IIOMetadataNode dimensionNode = new IIOMetadataNode("Dimension");
+
+        if (pixelAspectRatio != null) {
+            IIOMetadataNode pixelAspectRatioNode = new IIOMetadataNode("PixelAspectRatio");
+            pixelAspectRatioNode.setAttribute("value", String.valueOf(pixelAspectRatio));
+            dimensionNode.appendChild(pixelAspectRatioNode);
+        }
+
+        IIOMetadataNode imageOrientationNode = new IIOMetadataNode("ImageOrientation");
+        imageOrientationNode.setAttribute("value", orientation.toString());
+        dimensionNode.appendChild(imageOrientationNode);
+
+        return dimensionNode.hasChildNodes() ? dimensionNode : null;
+    }
+
+    @Override
+    protected IIOMetadataNode getStandardDocumentNode() {
+        IIOMetadataNode documentNode = new IIOMetadataNode("Document");
+
+        if (formatVersion != null) {
+            IIOMetadataNode formatVersionNode = new IIOMetadataNode("FormatVersion");
+            documentNode.appendChild(formatVersionNode);
+            formatVersionNode.setAttribute("value", formatVersion);
+        }
+
+        if (subimageInterpretation != null) {
+            IIOMetadataNode subImageInterpretationNode = new IIOMetadataNode("SubimageInterpretation");
+            documentNode.appendChild(subImageInterpretationNode);
+            subImageInterpretationNode.setAttribute("value", subimageInterpretation.toString());
+        }
+
+        if (documentCreationTime != null) {
+            IIOMetadataNode imageCreationTimeNode = new IIOMetadataNode("ImageCreationTime");
+            documentNode.appendChild(imageCreationTimeNode);
+
+            imageCreationTimeNode.setAttribute("year", String.valueOf(documentCreationTime.get(Calendar.YEAR)));
+            imageCreationTimeNode.setAttribute("month", String.valueOf(documentCreationTime.get(Calendar.MONTH) + 1));
+            imageCreationTimeNode.setAttribute("day", String.valueOf(documentCreationTime.get(Calendar.DAY_OF_MONTH)));
+            imageCreationTimeNode.setAttribute("hour", String.valueOf(documentCreationTime.get(Calendar.HOUR_OF_DAY)));
+            imageCreationTimeNode.setAttribute("minute", String.valueOf(documentCreationTime.get(Calendar.MINUTE)));
+            imageCreationTimeNode.setAttribute("second", String.valueOf(documentCreationTime.get(Calendar.SECOND)));
+        }
+
+        return documentNode.hasChildNodes() ? documentNode : null;
+    }
+
+    @Override
+    protected IIOMetadataNode getStandardTextNode() {
+        if (textEntries.isEmpty()) {
+            return null;
+        }
+
+        IIOMetadataNode textNode = new IIOMetadataNode("Text");
+
+        // DocumentName, ImageDescription, Make, Model, PageName, Software, Artist, HostComputer, InkNames, Copyright:
+        // /Text/TextEntry@keyword = field name, /Text/TextEntry@value = field value.
+
+        for (TextEntry entry : textEntries) {
+            IIOMetadataNode textEntryNode = new IIOMetadataNode("TextEntry");
+            textNode.appendChild(textEntryNode);
+            if (entry.keyword != null) {
+                textEntryNode.setAttribute("keyword", entry.keyword);
+            }
+            textEntryNode.setAttribute("value", entry.value);
+            if (entry.language != null) {
+                textEntryNode.setAttribute("language", entry.language);
+            }
+            if (entry.encoding != null) {
+                textEntryNode.setAttribute("encoding", entry.encoding);
+            }
+            if (entry.compression != null) {
+                textEntryNode.setAttribute("compression", entry.compression);
+            }
+        }
+
+        return textNode;
+
+    }
+
+    @Override
+    protected IIOMetadataNode getStandardTransparencyNode() {
+        IIOMetadataNode transparencyNode = new IIOMetadataNode("Transparency");
+
+        ColorModel colorModel = type.getColorModel();
+
+        IIOMetadataNode alphaNode = new IIOMetadataNode("Alpha");
+        transparencyNode.appendChild(alphaNode);
+        alphaNode.setAttribute("value", colorModel.hasAlpha() ? (colorModel.isAlphaPremultiplied() ? "premultiplied" : "nonpremultiplied") : "none");
+
+        if (colorModel instanceof IndexColorModel) {
+            IndexColorModel icm = (IndexColorModel) colorModel;
+            if (icm.getTransparentPixel() != -1) {
+                IIOMetadataNode transparentIndexNode = new IIOMetadataNode("TransparentIndex");
+                transparencyNode.appendChild(transparentIndexNode);
+                transparentIndexNode.setAttribute("value", Integer.toString(icm.getTransparentPixel()));
+            }
+        }
+
+        return transparencyNode;
+    }
+}
@@ -0,0 +1,348 @@
+/*
+ * Copyright (c) 2022, 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 of the copyright holder 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 HOLDER 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.stream;
+
+import javax.imageio.stream.ImageInputStreamImpl;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.FileChannel;
+import java.nio.channels.SeekableByteChannel;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+
+import static com.twelvemonkeys.lang.Validate.notNull;
+import static java.lang.Math.max;
+
+/**
+ * A buffered {@link javax.imageio.stream.ImageInputStream} that is backed by a {@link java.nio.channels.SeekableByteChannel}
+ * and provides greatly improved performance
+ * compared to {@link javax.imageio.stream.FileCacheImageInputStream} or {@link javax.imageio.stream.MemoryCacheImageInputStream}
+ * for shorter reads, like single byte or bit reads.
+ */
+final class BufferedChannelImageInputStream extends ImageInputStreamImpl {
+    private static final Closeable CLOSEABLE_STUB = new Closeable() {
+        @Override public void close() {}
+    };
+
+    static final int DEFAULT_BUFFER_SIZE = 8192;
+
+    private ByteBuffer byteBuffer = ByteBuffer.allocate(DEFAULT_BUFFER_SIZE);
+    private byte[] buffer = byteBuffer.array();
+    private int bufferPos;
+    private int bufferLimit;
+
+    private final ByteBuffer integralCache = ByteBuffer.allocate(8);
+    private final byte[] integralCacheArray = integralCache.array();
+
+    private SeekableByteChannel channel;
+    private Closeable closeable;
+
+    /**
+     * Constructs a {@code BufferedChannelImageInputStream} that will read from a given {@code File}.
+     *
+     * @param file a {@code File} to read from.
+     * @throws IllegalArgumentException if {@code file} is {@code null}.
+     * @throws SecurityException        if a security manager is installed, and it denies read access to the file.
+     * @throws IOException              if an I/O error occurs while opening the file.
+     */
+    public BufferedChannelImageInputStream(final File file) throws IOException {
+        this(notNull(file, "file").toPath());
+    }
+
+    /**
+     * Constructs a {@code BufferedChannelImageInputStream} that will read from a given {@code Path}.
+     *
+     * @param file a {@code Path} to read from.
+     * @throws IllegalArgumentException      if {@code file} is {@code null}.
+     * @throws UnsupportedOperationException if the {@code file} is associated with a provider that does not support creating file channels.
+     * @throws IOException                   if an I/O error occurs while opening the file.
+     * @throws SecurityException             if a security manager is installed, and it denies read access to the file.
+     */
+    public BufferedChannelImageInputStream(final Path file) throws IOException {
+        this(FileChannel.open(notNull(file, "file"), StandardOpenOption.READ), true);
+    }
+
+    /**
+     * Constructs a {@code BufferedChannelImageInputStream} that will read from a given {@code RandomAccessFile}.
+     *
+     * @param file a {@code RandomAccessFile} to read from.
+     * @throws IllegalArgumentException if {@code file} is {@code null}.
+     */
+    public BufferedChannelImageInputStream(final RandomAccessFile file) {
+        // Closing the RAF is inconsistent, but emulates the behavior of javax.imageio.stream.FileImageInputStream
+        this(notNull(file, "file").getChannel(), true);
+    }
+
+    /**
+     * Constructs a {@code BufferedChannelImageInputStream} that will read from a given {@code FileInputStream}.
+     * <p>
+     * Closing this stream will <em>not</em> close the {@code FileInputStream}.
+     * </p>
+     *
+     * @param inputStream a {@code FileInputStream} to read from.
+     * @throws IllegalArgumentException if {@code inputStream} is {@code null}.
+     */
+    public BufferedChannelImageInputStream(final FileInputStream inputStream) {
+        this(notNull(inputStream, "inputStream").getChannel(), false);
+    }
+
+    /**
+     * Constructs a {@code BufferedChannelImageInputStream} that will read from a given {@code SeekableByteChannel}.
+     * <p>
+     * Closing this stream will <em>not</em> close the {@code SeekableByteChannel}.
+     * </p>
+     *
+     * @param channel a {@code SeekableByteChannel} to read from.
+     * @throws IllegalArgumentException if {@code channel} is {@code null}.
+     */
+    public BufferedChannelImageInputStream(final SeekableByteChannel channel) {
+        this(notNull(channel, "channel"), false);
+    }
+
+    /**
+     * Constructs a {@code BufferedChannelImageInputStream} that will read from a given {@code Cache}.
+     * <p>
+     * Closing this stream will close the {@code Cache}.
+     * </p>
+     *
+     * @param cache a {@code SeekableByteChannel} to read from.
+     * @throws IllegalArgumentException if {@code channel} is {@code null}.
+     */
+    BufferedChannelImageInputStream(final Cache cache) {
+        this(notNull(cache, "cache"), true);
+    }
+
+    private BufferedChannelImageInputStream(final SeekableByteChannel channel, boolean closeChannelOnClose) {
+        this.channel = notNull(channel, "channel");
+        this.closeable = closeChannelOnClose ? this.channel : CLOSEABLE_STUB;
+    }
+
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    private boolean fillBuffer() throws IOException {
+        byteBuffer.rewind();
+        int length = channel.read(byteBuffer);
+        bufferPos = 0;
+        bufferLimit = max(length, 0);
+
+        return bufferLimit > 0;
+    }
+
+    private boolean bufferEmpty() {
+        return bufferPos >= bufferLimit;
+    }
+
+    @Override
+    public void setByteOrder(ByteOrder byteOrder) {
+        super.setByteOrder(byteOrder);
+        integralCache.order(byteOrder);
+    }
+
+    @Override
+    public int read() throws IOException {
+        checkClosed();
+
+        if (bufferEmpty() && !fillBuffer()) {
+            return -1;
+        }
+
+        bitOffset = 0;
+        streamPos++;
+
+        return buffer[bufferPos++] & 0xff;
+    }
+
+    @Override
+    public int read(final byte[] bytes, final int offset, final int length) throws IOException {
+        checkClosed();
+        bitOffset = 0;
+
+        if (bufferEmpty()) {
+            // Bypass buffer if buffer is empty for reads longer than buffer
+            if (length >= buffer.length) {
+                return readDirect(bytes, offset, length);
+            }
+            else if (!fillBuffer()) {
+                return -1;
+            }
+        }
+
+        int fromBuffer = readBuffered(bytes, offset, length);
+
+        if (length > fromBuffer) {
+            // Due to known bugs in certain JDK-bundled ImageIO plugins expecting read to behave as readFully,
+            // we'll read as much as possible from the buffer, and the rest directly after
+            return fromBuffer + max(0, readDirect(bytes, offset + fromBuffer, length - fromBuffer));
+        }
+
+        return fromBuffer;
+    }
+
+    private int readDirect(final byte[] bytes, final int offset, final int length) throws IOException {
+        // Invalidate the buffer, as its contents is no longer in sync with the stream's position.
+        bufferLimit = 0;
+
+        ByteBuffer wrapped = ByteBuffer.wrap(bytes, offset, length);
+        int read = 0;
+        while (wrapped.hasRemaining()) {
+            int count = channel.read(wrapped);
+            if (count == -1) {
+                if (read == 0) {
+                    return -1;
+                }
+
+                break;
+            }
+
+            read += count;
+        }
+
+        streamPos += read;
+
+        return read;
+    }
+
+    private int readBuffered(final byte[] bytes, final int offset, final int length) {
+        // Read as much as possible from buffer
+        int available = Math.min(bufferLimit - bufferPos, length);
+
+        if (available > 0) {
+            System.arraycopy(buffer, bufferPos, bytes, offset, available);
+            bufferPos += available;
+            streamPos += available;
+        }
+
+        return available;
+    }
+
+    public long length() {
+        // WTF?! This method is allowed to throw IOException in the interface...
+        try {
+            checkClosed();
+            return channel.size();
+        }
+        catch (IOException ignore) {
+        }
+
+        return -1;
+    }
+
+    public void close() throws IOException {
+        super.close();
+
+        buffer = null;
+        byteBuffer = null;
+
+        channel = null;
+
+        try {
+            closeable.close();
+        }
+        finally {
+            closeable = null;
+        }
+    }
+
+    // Need to override the readShort(), readInt() and readLong() methods,
+    // because the implementations in ImageInputStreamImpl expects the
+    // read(byte[], int, int) to always read the expected number of bytes,
+    // causing uninitialized values, alignment issues and EOFExceptions at
+    // random places...
+    // Notes:
+    // * readUnsignedXx() is covered by their signed counterparts
+    // * readChar() is covered by readShort()
+    // * readFloat() and readDouble() is covered by readInt() and readLong()
+    //   respectively.
+    // * readLong() may be covered by two readInt()s, we'll override to be safe
+
+    @Override
+    public short readShort() throws IOException {
+        readFully(integralCacheArray, 0, 2);
+
+        return integralCache.getShort(0);
+    }
+
+    @Override
+    public int readInt() throws IOException {
+        readFully(integralCacheArray, 0, 4);
+
+        return integralCache.getInt(0);
+    }
+
+    @Override
+    public long readLong() throws IOException {
+        readFully(integralCacheArray, 0, 8);
+
+        return integralCache.getLong(0);
+    }
+
+    @Override
+    public void seek(long position) throws IOException {
+        checkClosed();
+
+        if (position < flushedPos) {
+            throw new IndexOutOfBoundsException("position < flushedPos!");
+        }
+
+        bitOffset = 0;
+
+        if (streamPos == position) {
+            return;
+        }
+
+        // Optimized to not invalidate buffer if new position is within current buffer
+        long newBufferPos = bufferPos + position - streamPos;
+        if (newBufferPos >= 0 && newBufferPos < bufferLimit) {
+            bufferPos = (int) newBufferPos;
+        }
+        else {
+            // Will invalidate buffer
+            bufferLimit = 0;
+            channel.position(position);
+        }
+
+        streamPos = position;
+    }
+
+    @Override
+    public void flushBefore(final long pos) throws IOException {
+        super.flushBefore(pos);
+
+        if (channel instanceof Cache) {
+            // In case of memory cache, free up memory
+            ((Cache) channel).flushBefore(pos);
+        }
+    }
+}
@@ -49,6 +49,7 @@ import static java.lang.Math.max;
 * {@link File} or {@link RandomAccessFile} can be used as input.
 *
 * @see javax.imageio.stream.FileImageInputStream
+ * @deprecated Use {@link BufferedChannelImageInputStream} instead.
 */
 // TODO: Create a memory-mapped version?
 //  Or not... From java.nio.channels.FileChannel.map:
@@ -57,6 +58,7 @@ import static java.lang.Math.max;
 //      the usual {@link #read read} and {@link #write write} methods.  From the
 //      standpoint of performance it is generally only worth mapping relatively
 //      large files into memory.
+@Deprecated
 public final class BufferedFileImageInputStream extends ImageInputStreamImpl {
    static final int DEFAULT_BUFFER_SIZE = 8192;

@@ -190,10 +192,10 @@ public final class BufferedFileImageInputStream extends ImageInputStreamImpl {
    public void close() throws IOException {
        super.close();

-        raf.close();
-
-        raf = null;
        buffer = null;
+
+        raf.close();
+        raf = null;
    }

    // Need to override the readShort(), readInt() and readLong() methods,
@@ -37,18 +37,19 @@ import javax.imageio.spi.ServiceRegistry;
 import javax.imageio.stream.ImageInputStream;
 import java.io.File;
 import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.file.NoSuchFileException;
 import java.util.Iterator;
 import java.util.Locale;

 /**
 * BufferedFileImageInputStreamSpi
- * Experimental
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @author last modified by $Author: haraldk$
 * @version $Id: BufferedFileImageInputStreamSpi.java,v 1.0 May 15, 2008 2:14:59 PM haraldk Exp$
 */
-public class BufferedFileImageInputStreamSpi extends ImageInputStreamSpi {
+public final class BufferedFileImageInputStreamSpi extends ImageInputStreamSpi {
    public BufferedFileImageInputStreamSpi() {
        this(new StreamProviderInfo());
    }
@@ -69,12 +70,13 @@ public class BufferedFileImageInputStreamSpi extends ImageInputStreamSpi {
        }
    }

-    public ImageInputStream createInputStreamInstance(final Object input, final boolean pUseCache, final File pCacheDir) {
+    @Override
+    public ImageInputStream createInputStreamInstance(final Object input, final boolean useCacheFile, final File cacheDir) throws IOException {
        if (input instanceof File) {
            try {
-                return new BufferedFileImageInputStream((File) input);
+                return new BufferedChannelImageInputStream((File) input);
            }
-            catch (FileNotFoundException e) {
+            catch (FileNotFoundException | NoSuchFileException e) {
                // For consistency with the JRE bundled SPIs, we'll return null here,
                // even though the spec does not say that's allowed.
                // The problem is that the SPIs can only declare that they support an input type like a File,
@@ -91,7 +93,8 @@ public class BufferedFileImageInputStreamSpi extends ImageInputStreamSpi {
        return false;
    }

-    public String getDescription(final Locale pLocale) {
+    @Override
+    public String getDescription(final Locale locale) {
        return "Service provider that instantiates an ImageInputStream from a File";
    }

@@ -0,0 +1,78 @@
+package com.twelvemonkeys.imageio.stream;
+
+import com.twelvemonkeys.imageio.spi.ProviderInfo;
+
+import javax.imageio.spi.ImageInputStreamSpi;
+import javax.imageio.spi.ServiceRegistry;
+import javax.imageio.stream.ImageInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.SeekableByteChannel;
+import java.util.Iterator;
+import java.util.Locale;
+
+/**
+ * BufferedInputStreamImageInputStreamSpi.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: BufferedInputStreamImageInputStreamSpi.java,v 1.0 08/09/2022 haraldk Exp$
+ */
+public final class BufferedInputStreamImageInputStreamSpi extends ImageInputStreamSpi {
+    public BufferedInputStreamImageInputStreamSpi() {
+        this(new StreamProviderInfo());
+    }
+
+    private BufferedInputStreamImageInputStreamSpi(ProviderInfo providerInfo) {
+        super(providerInfo.getVendorName(), providerInfo.getVersion(), InputStream.class);
+    }
+
+    @Override
+    public void onRegistration(final ServiceRegistry registry, final Class<?> category) {
+        Iterator<ImageInputStreamSpi> providers = registry.getServiceProviders(ImageInputStreamSpi.class, new InputStreamFilter(), true);
+
+        while (providers.hasNext()) {
+            ImageInputStreamSpi provider = providers.next();
+            if (provider != this) {
+                registry.setOrdering(ImageInputStreamSpi.class, this, provider);
+            }
+        }
+    }
+
+    @Override
+    public ImageInputStream createInputStreamInstance(final Object input, final boolean useCacheFile, final File cacheDir) throws IOException {
+        if (input instanceof InputStream) {
+            ReadableByteChannel channel = Channels.newChannel((InputStream) input);
+
+            if (channel instanceof SeekableByteChannel) {
+                // Special case for FileInputStream/FileChannel, we can get a seekable channel directly
+                return new BufferedChannelImageInputStream((SeekableByteChannel) channel);
+            }
+
+            // Otherwise, create a cache for backwards seeking
+            return new BufferedChannelImageInputStream(useCacheFile ? new FileCache(channel, cacheDir) : new MemoryCache(channel));
+        }
+
+        throw new IllegalArgumentException("Expected input of type InputStream: " + input);
+    }
+
+    @Override
+    public boolean canUseCacheFile() {
+        return true;
+    }
+
+    @Override
+    public String getDescription(final Locale locale) {
+        return "Service provider that instantiates an ImageInputStream from an InputStream";
+    }
+
+    private static class InputStreamFilter implements ServiceRegistry.Filter {
+        @Override
+        public boolean filter(final Object provider) {
+            return ((ImageInputStreamSpi) provider).getInputClass() == InputStream.class;
+        }
+    }
+}
@@ -48,7 +48,7 @@ import java.util.Locale;
 * @author last modified by $Author: haraldk$
 * @version $Id: BufferedRAFImageInputStreamSpi.java,v 1.0 May 15, 2008 2:14:59 PM haraldk Exp$
 */
-public class BufferedRAFImageInputStreamSpi extends ImageInputStreamSpi {
+public final class BufferedRAFImageInputStreamSpi extends ImageInputStreamSpi {
    public BufferedRAFImageInputStreamSpi() {
        this(new StreamProviderInfo());
    }
@@ -69,9 +69,10 @@ public class BufferedRAFImageInputStreamSpi extends ImageInputStreamSpi {
        }
    }

-    public ImageInputStream createInputStreamInstance(final Object input, final boolean pUseCache, final File pCacheDir) {
+    @Override
+    public ImageInputStream createInputStreamInstance(final Object input, final boolean useCacheFile, final File cacheDir) {
        if (input instanceof RandomAccessFile) {
-            return new BufferedFileImageInputStream((RandomAccessFile) input);
+            return new BufferedChannelImageInputStream((RandomAccessFile) input);
        }

        throw new IllegalArgumentException("Expected input of type RandomAccessFile: " + input);
@@ -82,7 +83,8 @@ public class BufferedRAFImageInputStreamSpi extends ImageInputStreamSpi {
        return false;
    }

-    public String getDescription(final Locale pLocale) {
+    @Override
+    public String getDescription(final Locale locale) {
        return "Service provider that instantiates an ImageInputStream from a RandomAccessFile";
    }

@@ -48,18 +48,18 @@ public final class ByteArrayImageInputStream extends ImageInputStreamImpl {
    private final int dataOffset;
    private final int dataLength;

-    public ByteArrayImageInputStream(final byte[] pData) {
-        this(pData, 0, pData != null ? pData.length : -1);
+    public ByteArrayImageInputStream(final byte[] data) {
+        this(data, 0, data != null ? data.length : -1);
    }

-    public ByteArrayImageInputStream(final byte[] pData, int offset, int length) {
-        data = notNull(pData, "data");
-        dataOffset = isBetween(0, pData.length, offset, "offset");
-        dataLength = isBetween(0, pData.length - offset, length, "length");
+    public ByteArrayImageInputStream(final byte[] data, int offset, int length) {
+        this.data = notNull(data, "data");
+        dataOffset = isMax(data.length, offset, "offset");
+        dataLength = isMax(data.length - offset, length, "length");
    }

-    private static int isBetween(final int low, final int high, final int value, final String name) {
-        return isTrue(value >= low && value <= high, value, String.format("%s out of range [%d, %d]: %d", name, low, high, value));
+    private static int isMax(final int high, final int value, final String name) {
+        return isTrue(value >= 0 && value <= high, value, String.format("%s out of range [0, %d]: %d", name, high, value));
    }

    public int read() throws IOException {
@@ -72,14 +72,14 @@ public final class ByteArrayImageInputStream extends ImageInputStreamImpl {
        return data[((int) streamPos++) + dataOffset] & 0xff;
    }

-    public int read(byte[] pBuffer, int pOffset, int pLength) throws IOException {
+    public int read(byte[] buffer, int offset, int len) throws IOException {
        if (streamPos >= dataLength) {
            return -1;
        }

-        int length = (int) Math.min(this.dataLength - streamPos, pLength);
+        int length = (int) Math.min(dataLength - streamPos, len);
        bitOffset = 0;
-        System.arraycopy(data, (int) streamPos + dataOffset, pBuffer, pOffset, length);
+        System.arraycopy(data, (int) streamPos + dataOffset, buffer, offset, length);
        streamPos += length;

        return length;
@@ -45,7 +45,7 @@ import java.util.Locale;
 * @author last modified by $Author: haraldk$
 * @version $Id: ByteArrayImageInputStreamSpi.java,v 1.0 May 15, 2008 2:12:12 PM haraldk Exp$
 */
-public class ByteArrayImageInputStreamSpi extends ImageInputStreamSpi {
+public final class ByteArrayImageInputStreamSpi extends ImageInputStreamSpi {

    public ByteArrayImageInputStreamSpi() {
        this(new StreamProviderInfo());
@@ -55,16 +55,17 @@ public class ByteArrayImageInputStreamSpi extends ImageInputStreamSpi {
        super(providerInfo.getVendorName(), providerInfo.getVersion(), byte[].class);
    }

-    public ImageInputStream createInputStreamInstance(Object pInput, boolean pUseCache, File pCacheDir) {
-        if (pInput instanceof byte[]) {
-            return new ByteArrayImageInputStream((byte[]) pInput);
-        }
-        else {
-            throw new IllegalArgumentException("Expected input of type byte[]: " + pInput);
+    @Override
+    public ImageInputStream createInputStreamInstance(Object input, boolean useCacheFile, File cacheDir) {
+        if (input instanceof byte[]) {
+            return new ByteArrayImageInputStream((byte[]) input);
        }
+
+        throw new IllegalArgumentException("Expected input of type byte[]: " + input);
    }

-    public String getDescription(Locale pLocale) {
+    @Override
+    public String getDescription(Locale locale) {
        return "Service provider that instantiates an ImageInputStream from a byte array";
    }

@@ -0,0 +1,7 @@
+package com.twelvemonkeys.imageio.stream;
+
+import java.nio.channels.SeekableByteChannel;
+
+interface Cache extends SeekableByteChannel {
+    void flushBefore(long pos);
+}
@@ -125,7 +125,7 @@ public final class DirectImageInputStream extends ImageInputStreamImpl {

    @Override
    public void close() throws IOException {
-        // We could seek to EOF here, but the usual case
+        // We could seek to EOF here, but the usual case is we know where the next chunk of data is

        stream.close();
        super.close();
@@ -0,0 +1,112 @@
+package com.twelvemonkeys.imageio.stream;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
+import java.nio.channels.NonWritableChannelException;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.SeekableByteChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static com.twelvemonkeys.lang.Validate.isTrue;
+import static com.twelvemonkeys.lang.Validate.notNull;
+import static java.lang.Math.max;
+import static java.nio.file.StandardOpenOption.DELETE_ON_CLOSE;
+import static java.nio.file.StandardOpenOption.READ;
+import static java.nio.file.StandardOpenOption.WRITE;
+
+// Note: We could consider creating a memory-mapped version...
+// But, from java.nio.channels.FileChannel.map:
+//      For most operating systems, mapping a file into memory is more
+//      expensive than reading or writing a few tens of kilobytes of data via
+//      the usual {@link #read read} and {@link #write write} methods.  From the
+//      standpoint of performance it is generally only worth mapping relatively
+//      large files into memory.
+final class FileCache implements Cache {
+    final static int BLOCK_SIZE = 1 << 13;
+
+    private final FileChannel cache;
+    private final ReadableByteChannel channel;
+
+    // TODO: Perhaps skip this constructor?
+    FileCache(InputStream stream, File cacheDir) throws IOException {
+        // Stream will be closed with channel, documented behavior
+        this(Channels.newChannel(notNull(stream, "stream")), cacheDir);
+    }
+
+    public FileCache(ReadableByteChannel channel, File cacheDir) throws IOException {
+        this.channel = notNull(channel, "channel");
+        isTrue(cacheDir == null || cacheDir.isDirectory(), cacheDir, "%s is not a directory");
+
+        // Create a temp file to hold our cache,
+        // will be deleted when this channel is closed, as we close the cache
+        Path cacheFile = cacheDir == null
+                         ? Files.createTempFile("imageio", ".tmp")
+                         : Files.createTempFile(cacheDir.toPath(), "imageio", ".tmp");
+
+        cache = FileChannel.open(cacheFile, DELETE_ON_CLOSE, READ, WRITE);
+    }
+
+    @SuppressWarnings("StatementWithEmptyBody")
+    void fetch() throws IOException {
+        while (cache.position() >= cache.size() && cache.transferFrom(channel, cache.size(), max(cache.position() - cache.size(), BLOCK_SIZE)) > 0) {
+            // Continue transfer...
+        }
+    }
+
+    @Override
+    public boolean isOpen() {
+        return channel.isOpen();
+    }
+
+    @Override
+    public void close() throws IOException {
+        cache.close();
+    }
+
+    @Override
+    public int read(ByteBuffer dest) throws IOException {
+        fetch();
+
+        if (cache.position() >= cache.size()) {
+            return -1;
+        }
+
+        return cache.read(dest);
+    }
+
+    @Override
+    public long position() throws IOException {
+        return cache.position();
+    }
+
+    @Override
+    public SeekableByteChannel position(long newPosition) throws IOException {
+        cache.position(newPosition);
+        return this;
+    }
+
+    @Override
+    public long size() {
+        // We could allow the size to grow, but that means the stream cannot rely on this size, so we'll just pretend we don't know...
+        return -1;
+    }
+
+    @Override
+    public int write(ByteBuffer src) {
+        throw new NonWritableChannelException();
+    }
+
+    @Override
+    public SeekableByteChannel truncate(long size) {
+        throw new NonWritableChannelException();
+    }
+
+    @Override public void flushBefore(long pos) {
+    }
+}
+
@@ -0,0 +1,165 @@
+package com.twelvemonkeys.imageio.stream;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.NonWritableChannelException;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.SeekableByteChannel;
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.twelvemonkeys.lang.Validate.notNull;
+import static java.lang.Math.min;
+
+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;
+
+    // TODO: Maybe get rid of this constructor, as we don't want to do this if we have a FileInputStream/FileChannel...
+    MemoryCache(InputStream stream) {
+        this(Channels.newChannel(notNull(stream, "stream")));
+    }
+
+    public MemoryCache(ReadableByteChannel channel) {
+        this.channel = notNull(channel, "channel");
+    }
+
+    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;
+            try {
+                block = new byte[BLOCK_SIZE];
+            }
+            catch (OutOfMemoryError e) {
+                throw new IOException("No more memory for cache: " + cache.size() * BLOCK_SIZE);
+            }
+
+            cache.add(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);
+    }
+
+    private int readBlock(final byte[] block) throws IOException {
+        ByteBuffer wrapped = ByteBuffer.wrap(block);
+
+        while (wrapped.hasRemaining()) {
+            int count = channel.read(wrapped);
+            if (count == -1) {
+                // Last block, EOF found
+                break;
+            }
+        }
+
+        return wrapped.position();
+    }
+
+    @Override
+    public boolean isOpen() {
+        return channel.isOpen();
+    }
+
+    @Override
+    public void close() throws IOException {
+        cache.clear();
+    }
+
+    @Override
+    public int read(ByteBuffer dest) throws IOException {
+        byte[] buffer = fetchBlock();
+
+        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);
+
+        position += len;
+
+        return len;
+    }
+
+    @Override
+    public long position() throws IOException {
+        return position;
+    }
+
+    @Override
+    public SeekableByteChannel position(long newPosition) throws IOException {
+        if (newPosition < start) {
+            throw new IOException("Seek before flush position");
+        }
+
+        this.position = newPosition;
+
+        return this;
+    }
+
+    @Override
+    public long size() throws IOException {
+        // We could allow the size to grow, but that means the stream cannot rely on this size, so we'll just pretend we don't know...
+        return -1;
+    }
+
+    @Override
+    public int write(ByteBuffer src) {
+        throw new NonWritableChannelException();
+    }
+
+    @Override
+    public SeekableByteChannel truncate(long size) {
+        throw new NonWritableChannelException();
+    }
+
+    @Override
+    public void flushBefore(long pos) {
+        if (pos < start) {
+            throw new IndexOutOfBoundsException("pos < flushed position");
+        }
+        if (pos > position) {
+            throw new IndexOutOfBoundsException("pos > current position");
+        }
+
+        int blocks = (int) (pos / BLOCK_SIZE); // Overflow guarded for in fetchBlock
+
+        // Clear blocks no longer needed
+        for (int i = 0; i < blocks; i++) {
+            cache.set(i, null);
+        }
+
+        start = pos;
+    }
+}
+
@@ -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)
    }
 }
@@ -33,9 +33,7 @@ package com.twelvemonkeys.imageio.stream;
 import com.twelvemonkeys.imageio.spi.ProviderInfo;

 import javax.imageio.spi.ImageInputStreamSpi;
-import javax.imageio.stream.FileCacheImageInputStream;
 import javax.imageio.stream.ImageInputStream;
-import javax.imageio.stream.MemoryCacheImageInputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
@@ -52,7 +50,7 @@ import java.util.Locale;
 * @version $Id: URLImageInputStreamSpi.java,v 1.0 May 15, 2008 2:14:59 PM haraldk Exp$
 */
 // TODO: URI instead of URL?
-public class URLImageInputStreamSpi extends ImageInputStreamSpi {
+public final class URLImageInputStreamSpi extends ImageInputStreamSpi {
    public URLImageInputStreamSpi() {
        this(new StreamProviderInfo());
    }
@@ -64,53 +62,28 @@ public class URLImageInputStreamSpi extends ImageInputStreamSpi {
    // TODO: Create a URI or URLImageInputStream class, with a getUR[I|L] method, to allow for multiple file formats
    // The good thing with that is that it does not clash with the built-in Sun-stuff or other people's hacks
    // The bad thing is that most people don't expect there to be an UR[I|L]ImageInputStreamSpi..
-    public ImageInputStream createInputStreamInstance(final Object pInput, final boolean pUseCache, final File pCacheDir) throws IOException {
-        if (pInput instanceof URL) {
-            URL url = (URL) pInput;
+    @Override
+    public ImageInputStream createInputStreamInstance(final Object input, final boolean useCacheFile, final File cacheDir) throws IOException {
+        if (input instanceof URL) {
+            URL url = (URL) input;

            // Special case for file protocol, a lot faster than FileCacheImageInputStream
            if ("file".equals(url.getProtocol())) {
                try {
-                    return new BufferedFileImageInputStream(new File(url.toURI()));
+                    return new BufferedChannelImageInputStream(new File(url.toURI()));
                }
-                catch (URISyntaxException ignore) {
-                    // This should never happen, but if it does, we'll fall back to using the stream  
-                    ignore.printStackTrace();
+                catch (URISyntaxException shouldNeverHappen) {
+                    // This should never happen, but if it does, we'll fall back to using the stream
+                    shouldNeverHappen.printStackTrace();
                }
            }

            // Otherwise revert to cached
-            final InputStream urlStream = url.openStream();
-            if (pUseCache) {
-                return new FileCacheImageInputStream(urlStream, pCacheDir) {
-                    @Override
-                    public void close() throws IOException {
-                        try {
-                            super.close();
-                        }
-                        finally {
-                            urlStream.close(); // NOTE: If this line throws IOE, it will shadow the original..
-                        }
-                    }
-                };
-            }
-            else {
-                return new MemoryCacheImageInputStream(urlStream) {
-                    @Override
-                    public void close() throws IOException {
-                        try {
-                            super.close();
-                        }
-                        finally {
-                            urlStream.close(); // NOTE: If this line throws IOE, it will shadow the original..
-                        }
-                    }
-                };
-            }
-        }
-        else {
-            throw new IllegalArgumentException("Expected input of type URL: " + pInput);
+            InputStream urlStream = url.openStream();
+            return new BufferedChannelImageInputStream(useCacheFile ? new FileCache(urlStream, cacheDir) : new MemoryCache(urlStream));
        }
+
+        throw new IllegalArgumentException("Expected input of type URL: " + input);
    }

    @Override
@@ -118,7 +91,7 @@ public class URLImageInputStreamSpi extends ImageInputStreamSpi {
        return true;
    }

-    public String getDescription(final Locale pLocale) {
+    public String getDescription(final Locale locale) {
        return "Service provider that instantiates an ImageInputStream from a URL";
    }
 }
@@ -30,21 +30,14 @@

 package com.twelvemonkeys.imageio.util;

-import static com.twelvemonkeys.lang.Validate.isTrue;
-import static com.twelvemonkeys.lang.Validate.notNull;
-
-import java.awt.color.ColorSpace;
-import java.awt.image.BufferedImage;
-import java.awt.image.ColorModel;
-import java.awt.image.DataBuffer;
-import java.awt.image.DirectColorModel;
-import java.awt.image.IndexColorModel;
-import java.awt.image.MultiPixelPackedSampleModel;
-import java.awt.image.SampleModel;
+import com.twelvemonkeys.imageio.color.DiscreteAlphaIndexColorModel;

 import javax.imageio.ImageTypeSpecifier;
+import java.awt.color.*;
+import java.awt.image.*;

-import com.twelvemonkeys.imageio.color.DiscreteAlphaIndexColorModel;
+import static com.twelvemonkeys.lang.Validate.isTrue;
+import static com.twelvemonkeys.lang.Validate.notNull;

 /**
 * Factory class for creating {@code ImageTypeSpecifier}s.
@@ -58,28 +51,52 @@ import com.twelvemonkeys.imageio.color.DiscreteAlphaIndexColorModel;
 */
 public final class ImageTypeSpecifiers {

+    private static final ImageTypeSpecifier TYPE_INT_RGB = createPackedOddBits(ColorSpace.getInstance(ColorSpace.CS_sRGB), 24,
+                                                                               0xFF0000,
+                                                                               0x00FF00,
+                                                                               0x0000FF,
+                                                                               0x0,
+                                                                               DataBuffer.TYPE_INT,
+                                                                               false);
+    private static final ImageTypeSpecifier TYPE_INT_BGR = createPackedOddBits(ColorSpace.getInstance(ColorSpace.CS_sRGB), 24,
+                                                                               0x0000FF,
+                                                                               0x00FF00,
+                                                                               0xFF0000,
+                                                                               0x0,
+                                                                               DataBuffer.TYPE_INT,
+                                                                               false);
+    private static final ImageTypeSpecifier TYPE_USHORT_565_RGB = createPackedOddBits(ColorSpace.getInstance(ColorSpace.CS_sRGB), 16,
+                                                                                      0xF800,
+                                                                                      0x07E0,
+                                                                                      0x001F,
+                                                                                      0x0,
+                                                                                      DataBuffer.TYPE_USHORT,
+                                                                                      false);
+    private static final ImageTypeSpecifier TYPE_USHORT_555_RGB = createPackedOddBits(ColorSpace.getInstance(ColorSpace.CS_sRGB), 15,
+                                                                                      0x7C00,
+                                                                                      0x03E0,
+                                                                                      0x001F,
+                                                                                      0x0,
+                                                                                      DataBuffer.TYPE_USHORT,
+                                                                                      false);
+
    private ImageTypeSpecifiers() {}

    public static ImageTypeSpecifier createFromBufferedImageType(final int bufferedImageType) {
        switch (bufferedImageType) {
-            // ImageTypeSpecifier unconditionally uses bits == 32, we'll use a workaround for the USHORT types
+            // ImageTypeSpecifier unconditionally uses bits == 32, we'll use a workaround for the INT_RGB and USHORT types
+            case BufferedImage.TYPE_INT_RGB:
+                return TYPE_INT_RGB;
+
+            case BufferedImage.TYPE_INT_BGR:
+                return TYPE_INT_BGR;
+
            case BufferedImage.TYPE_USHORT_565_RGB:
-                return createPacked(ColorSpace.getInstance(ColorSpace.CS_sRGB),
-                        0xF800,
-                        0x07E0,
-                        0x001F,
-                        0x0,
-                        DataBuffer.TYPE_USHORT,
-                        false);
+                return TYPE_USHORT_565_RGB;

            case BufferedImage.TYPE_USHORT_555_RGB:
-                return createPacked(ColorSpace.getInstance(ColorSpace.CS_sRGB),
-                        0x7C00,
-                        0x03E0,
-                        0x001F,
-                        0x0,
-                        DataBuffer.TYPE_USHORT,
-                        false);
+                return TYPE_USHORT_555_RGB;
+
            default:
        }

@@ -90,23 +107,41 @@ public final class ImageTypeSpecifiers {
                                                  final int redMask, final int greenMask,
                                                  final int blueMask, final int alphaMask,
                                                  final int transferType, boolean isAlphaPremultiplied) {
-        if (transferType == DataBuffer.TYPE_BYTE || transferType == DataBuffer.TYPE_USHORT) {
+        int bits = calculateRequiredBits(redMask | greenMask | blueMask | alphaMask);
+        if (bits != 32) {
            // ImageTypeSpecifier unconditionally uses bits == 32, we'll use a workaround for BYTE/USHORT types
-            notNull(colorSpace, "colorSpace");
-            isTrue(colorSpace.getType() == ColorSpace.TYPE_RGB, colorSpace, "ColorSpace must be TYPE_RGB");
-            isTrue(redMask != 0 || greenMask != 0 || blueMask != 0 || alphaMask != 0, "No mask has at least 1 bit set");
-
-            int bits = transferType == DataBuffer.TYPE_BYTE ? 8 : 16;
-
-            ColorModel colorModel = new DirectColorModel(colorSpace, bits, redMask, greenMask, blueMask, alphaMask,
-                    isAlphaPremultiplied, transferType);
-
-            return new ImageTypeSpecifier(colorModel, colorModel.createCompatibleSampleModel(1, 1));
+            return createPackedOddBits(colorSpace, bits, redMask, greenMask, blueMask, alphaMask, transferType, isAlphaPremultiplied);
        }

        return ImageTypeSpecifier.createPacked(colorSpace, redMask, greenMask, blueMask, alphaMask, transferType, isAlphaPremultiplied);
    }

+    private static int calculateRequiredBits(int mask) {
+        // See https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious
+        int r = 1;
+
+        while ((mask >>>= 1) != 0) {
+            r++;
+        }
+
+        return r;
+    }
+
+    static ImageTypeSpecifier createPackedOddBits(final ColorSpace colorSpace, int bits,
+                                                  final int redMask, final int greenMask,
+                                                  final int blueMask, final int alphaMask,
+                                                  final int transferType, boolean isAlphaPremultiplied) {
+        // ImageTypeSpecifier unconditionally uses bits == 32, we'll use a workaround
+        notNull(colorSpace, "colorSpace");
+        isTrue(colorSpace.getType() == ColorSpace.TYPE_RGB, colorSpace, "ColorSpace must be TYPE_RGB");
+        isTrue(redMask != 0 || greenMask != 0 || blueMask != 0 || alphaMask != 0, "No mask has at least 1 bit set");
+
+        ColorModel colorModel = new DirectColorModel(colorSpace, bits, redMask, greenMask, blueMask, alphaMask,
+                                                     isAlphaPremultiplied, transferType);
+
+        return new ImageTypeSpecifier(colorModel, colorModel.createCompatibleSampleModel(1, 1));
+    }
+
    public static ImageTypeSpecifier createInterleaved(final ColorSpace colorSpace,
                                                       final int[] bandOffsets,
                                                       final int dataType,
@@ -235,4 +270,20 @@ public final class ImageTypeSpecifiers {
        ColorModel colorModel = new DiscreteAlphaIndexColorModel(pColorModel, extraSamples, hasAlpha);
        return new ImageTypeSpecifier(colorModel, colorModel.createCompatibleSampleModel(1, 1));
    }
+
+    public static ImageTypeSpecifier createFromRenderedImage(RenderedImage image) {
+        if (image == null) {
+            throw new IllegalArgumentException("image == null!");
+        }
+
+        if (image instanceof BufferedImage) {
+            int bufferedImageType = ((BufferedImage) image).getType();
+
+            if (bufferedImageType != BufferedImage.TYPE_CUSTOM) {
+                return createFromBufferedImageType(bufferedImageType);
+            }
+        }
+
+        return new ImageTypeSpecifier(image);
+    }
 }
@@ -1,4 +1,5 @@
 com.twelvemonkeys.imageio.stream.BufferedFileImageInputStreamSpi
 com.twelvemonkeys.imageio.stream.BufferedRAFImageInputStreamSpi
+com.twelvemonkeys.imageio.stream.BufferedInputStreamImageInputStreamSpi
 # Use SPI loading as a hook for early profile activation
 com.twelvemonkeys.imageio.color.ProfileDeferralActivator$Spi
@@ -0,0 +1,332 @@
+package com.twelvemonkeys.imageio;
+
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport.ColorSpaceType;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport.ImageOrientation;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport.PlanarConfiguration;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport.SubimageInterpretation;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport.TextEntry;
+import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
+
+import org.junit.Test;
+import org.w3c.dom.NodeList;
+
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataNode;
+import java.awt.image.*;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import static com.twelvemonkeys.imageio.StandardImageMetadataSupport.builder;
+import static org.junit.Assert.*;
+
+public class StandardImageMetadataSupportTest {
+    @Test(expected = IllegalArgumentException.class)
+    public void createNullBuilder() {
+        new StandardImageMetadataSupport(null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void createNullType() {
+        new StandardImageMetadataSupport(builder(null));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void builderNullType() {
+        builder(null).build();
+    }
+
+    @Test
+    public void createValid() {
+        IIOMetadata metadata = new StandardImageMetadataSupport(builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB)));
+        assertNotNull(metadata);
+    }
+
+    @Test
+    public void builderValid() {
+        IIOMetadata metadata = builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB))
+                .build();
+
+        assertNotNull(metadata);
+    }
+
+    @Test
+    public void compressionValuesUnspecified() {
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .build();
+
+        assertNull(metadata.getStandardCompressionNode());
+    }
+
+    @Test
+    public void compressionValuesNone() {
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withCompressionTypeName("nOnE") // Case-insensitive
+                .build();
+
+        assertNull(metadata.getStandardCompressionNode());
+    }
+
+    @Test
+    public void compressionValuesName() {
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withCompressionTypeName("foo")
+                .build();
+
+        IIOMetadataNode compressionNode = metadata.getStandardCompressionNode();
+        assertNotNull(compressionNode);
+
+        IIOMetadataNode compressionName = (IIOMetadataNode) compressionNode.getElementsByTagName("CompressionTypeName").item(0);
+        assertEquals("foo", compressionName.getAttribute("value"));
+
+        // Defaults to lossless true
+        IIOMetadataNode compressionLossless = (IIOMetadataNode) compressionNode.getElementsByTagName("Lossless").item(0);
+        assertEquals("TRUE", compressionLossless.getAttribute("value"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void withCompressionLossyIllegal() {
+        builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withCompressionLossless(false);
+    }
+
+    @Test
+    public void compressionValuesLossy() {
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withCompressionTypeName("bar")
+                .withCompressionLossless(false)
+                .build();
+
+        IIOMetadataNode compressionNode = metadata.getStandardCompressionNode();
+        assertNotNull(compressionNode);
+
+        IIOMetadataNode compressionName = (IIOMetadataNode) compressionNode.getElementsByTagName("CompressionTypeName").item(0);
+        assertEquals("bar", compressionName.getAttribute("value"));
+
+        IIOMetadataNode compressionLossless = (IIOMetadataNode) compressionNode.getElementsByTagName("Lossless").item(0);
+        assertEquals("FALSE", compressionLossless.getAttribute("value"));
+    }
+
+    @Test
+    public void withDocumentValuesDefault() {
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .build();
+
+        IIOMetadataNode documentNode = metadata.getStandardDocumentNode();
+        assertNull(documentNode);
+    }
+
+    @Test
+    public void withDocumentValues() {
+        Calendar creationTime = Calendar.getInstance();
+        creationTime.set(2022, Calendar.SEPTEMBER, 8, 14, 5, 0);
+
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withFormatVersion("42")
+                .withDocumentCreationTime(creationTime)
+                .build();
+
+        IIOMetadataNode documentNode = metadata.getStandardDocumentNode();
+        assertNotNull(documentNode);
+
+        IIOMetadataNode formatVersion = (IIOMetadataNode) documentNode.getElementsByTagName("FormatVersion").item(0);
+        assertEquals("42", formatVersion.getAttribute("value"));
+
+        IIOMetadataNode imageCreationTime = (IIOMetadataNode) documentNode.getElementsByTagName("ImageCreationTime").item(0);
+        assertEquals("2022", imageCreationTime.getAttribute("year"));
+        assertEquals("9", imageCreationTime.getAttribute("month"));
+        assertEquals("8", imageCreationTime.getAttribute("day"));
+        assertEquals("14", imageCreationTime.getAttribute("hour"));
+        assertEquals("5", imageCreationTime.getAttribute("minute"));
+        assertEquals("0", imageCreationTime.getAttribute("second"));
+    }
+
+    @Test
+    public void withTextValuesDefault() {
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .build();
+
+        IIOMetadataNode textNode = metadata.getStandardTextNode();
+        assertNull(textNode);
+    }
+
+    @Test
+    public void withTextValuesSingle() {
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withTextEntry("foo", "bar")
+                .build();
+
+        IIOMetadataNode textNode = metadata.getStandardTextNode();
+        assertNotNull(textNode);
+
+        IIOMetadataNode textEntry = (IIOMetadataNode) textNode.getElementsByTagName("TextEntry").item(0);
+        assertEquals("foo", textEntry.getAttribute("keyword"));
+        assertEquals("bar", textEntry.getAttribute("value"));
+    }
+
+    @Test
+    public void withTextValuesMap() {
+        Map<String, String> entries = new HashMap<>();
+        entries.put("foo", "bar");
+        entries.put("bar", "xyzzy");
+
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withTextEntries(entries)
+                .build();
+
+        IIOMetadataNode textNode = metadata.getStandardTextNode();
+        assertNotNull(textNode);
+
+        NodeList textEntries = textNode.getElementsByTagName("TextEntry");
+        assertEquals(entries.size(), textEntries.getLength());
+
+        int i = 0;
+        for (Entry<String, String> entry : entries.entrySet()) {
+            IIOMetadataNode textEntry = (IIOMetadataNode) textEntries.item(i);
+            assertEquals(entry.getKey(), textEntry.getAttribute("keyword"));
+            assertEquals(entry.getValue(), textEntry.getAttribute("value"));
+
+            i++;
+        }
+    }
+
+    @Test
+    public void withTextValuesList() {
+        List<TextEntry> entries = Arrays.asList(
+                new TextEntry(null, "foo"), // No key allowed
+                new TextEntry("foo", "bar"),
+                new TextEntry("bar", "xyzzy"),
+                new TextEntry("bar", "nothing happens..."), // Duplicates allowed
+                new TextEntry("everything", "válüè", "unknown", "UTF-8", "zip")
+        );
+
+        StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withTextEntries(entries)
+                .build();
+
+        IIOMetadataNode textNode = metadata.getStandardTextNode();
+        assertNotNull(textNode);
+
+        NodeList textEntries = textNode.getElementsByTagName("TextEntry");
+        assertEquals(entries.size(), textEntries.getLength());
+
+        for (int i = 0; i < entries.size(); i++) {
+            TextEntry entry = entries.get(i);
+            IIOMetadataNode textEntry = (IIOMetadataNode) textEntries.item(i);
+
+            assertAttributeEqualOrAbsent(entry.keyword, textEntry, "keyword");
+
+            assertEquals(entry.value, textEntry.getAttribute("value"));
+
+            assertAttributeEqualOrAbsent(entry.language, textEntry, "language");
+            assertAttributeEqualOrAbsent(entry.encoding, textEntry, "encoding");
+            assertAttributeEqualOrAbsent(entry.compression, textEntry, "compression");
+        }
+    }
+
+    private static void assertAttributeEqualOrAbsent(final String expectedValue, IIOMetadataNode node, final String attribute) {
+        if (expectedValue != null) {
+            assertEquals(expectedValue, node.getAttribute(attribute));
+        }
+        else {
+            assertFalse(node.hasAttribute(attribute));
+        }
+    }
+
+    @Test
+    public void withPlanarColorspaceType() {
+        // See: https://docs.oracle.com/javase/7/docs/api/javax/imageio/metadata/doc-files/standard_metadata.html
+        Collection<String> allowedValues = Arrays.asList(
+                "XYZ", "Lab", "Luv", "YCbCr", "Yxy", "YCCK", "PhotoYCC",
+                "RGB", "GRAY", "HSV", "HLS", "CMYK", "CMY",
+                "2CLR", "3CLR", "4CLR", "5CLR", "6CLR", "7CLR", "8CLR",
+                "9CLR", "ACLR", "BCLR", "CCLR", "DCLR", "ECLR", "FCLR"
+        );
+
+        for (ColorSpaceType value : ColorSpaceType.values()) {
+            StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                    .withColorSpaceType(value)
+                    .build();
+
+            assertNotNull(metadata);
+
+            IIOMetadataNode documentNode = metadata.getStandardChromaNode();
+            assertNotNull(documentNode);
+
+            IIOMetadataNode subImageInterpretation = (IIOMetadataNode) documentNode.getElementsByTagName("ColorSpaceType").item(0);
+            assertEquals(value.toString(), subImageInterpretation.getAttribute("name")); // Format oddity: Why is this not "value"?
+            assertTrue(allowedValues.contains(value.toString()));
+        }
+    }
+
+    @Test
+    public void withPlanarConfiguration() {
+        // See: https://docs.oracle.com/javase/7/docs/api/javax/imageio/metadata/doc-files/standard_metadata.html
+        Collection<String> allowedValues = Arrays.asList("PixelInterleaved", "PlaneInterleaved", "LineInterleaved", "TileInterleaved");
+
+        for (PlanarConfiguration value : PlanarConfiguration.values()) {
+            StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR))
+                    .withPlanarConfiguration(value)
+                    .build();
+
+            assertNotNull(metadata);
+
+            IIOMetadataNode documentNode = metadata.getStandardDataNode();
+            assertNotNull(documentNode);
+
+            IIOMetadataNode subImageInterpretation = (IIOMetadataNode) documentNode.getElementsByTagName("PlanarConfiguration").item(0);
+            assertEquals(value.toString(), subImageInterpretation.getAttribute("value"));
+            assertTrue(allowedValues.contains(value.toString()));
+        }
+    }
+
+    @Test
+    public void withImageOrientation() {
+        // See: https://docs.oracle.com/javase/7/docs/api/javax/imageio/metadata/doc-files/standard_metadata.html
+        Collection<String> allowedValues = Arrays.asList("Normal", "Rotate90", "Rotate180", "Rotate270", "FlipH", "FlipV", "FlipHRotate90", "FlipVRotate90");
+
+        for (ImageOrientation value : ImageOrientation.values()) {
+            StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                    .withOrientation(value)
+                    .build();
+
+            assertNotNull(metadata);
+
+            IIOMetadataNode documentNode = metadata.getStandardDimensionNode();
+            assertNotNull(documentNode);
+
+            IIOMetadataNode subImageInterpretation = (IIOMetadataNode) documentNode.getElementsByTagName("ImageOrientation").item(0);
+            assertEquals(value.toString(), subImageInterpretation.getAttribute("value"));
+            assertTrue(allowedValues.contains(value.toString()));
+        }
+    }
+
+    @Test
+    public void withSubimageInterpretation() {
+        // See: https://docs.oracle.com/javase/7/docs/api/javax/imageio/metadata/doc-files/standard_metadata.html
+        Collection<String> allowedValues = Arrays.asList(
+                "Standalone", "SinglePage", "FullResolution", "ReducedResolution", "PyramidLayer",
+                "Preview", "VolumeSlice", "ObjectView", "Panorama", "AnimationFrame",
+                "TransparencyMask", "CompositingLayer", "SpectralSlice", "Unknown"
+        );
+
+        for (SubimageInterpretation value : SubimageInterpretation.values()) {
+            StandardImageMetadataSupport metadata = (StandardImageMetadataSupport) builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB))
+                    .withSubimageInterpretation(value)
+                    .build();
+
+            assertNotNull(metadata);
+
+            IIOMetadataNode documentNode = metadata.getStandardDocumentNode();
+            assertNotNull(documentNode);
+
+            IIOMetadataNode subImageInterpretation = (IIOMetadataNode) documentNode.getElementsByTagName("SubimageInterpretation").item(0);
+            assertEquals(value.toString(), subImageInterpretation.getAttribute("value"));
+            assertTrue(allowedValues.contains(value.toString()));
+        }
+    }
+}
@@ -36,9 +36,11 @@ import java.awt.color.ColorSpace;
 import java.awt.color.ICC_ColorSpace;
 import java.awt.color.ICC_Profile;
 import java.io.IOException;
+import java.lang.reflect.Method;
 import java.util.Arrays;

 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assume.assumeFalse;
 import static org.mockito.Mockito.*;

 public class KCMSSanitizerStrategyTest {
@@ -56,6 +58,8 @@ public class KCMSSanitizerStrategyTest {

    @Test
    public void testFixProfileUpdateHeader() throws Exception {
+        assumeICC_ProfileNotSealed(); // Ignores test for JDK 19+
+
        byte[] header = new byte[128];
        header[ICC_Profile.icHdrRenderingIntent + 3] = 1;
        ICC_Profile profile = mock(ICC_Profile.class);
@@ -69,6 +73,17 @@ public class KCMSSanitizerStrategyTest {
        verify(profile).setData(eq(ICC_Profile.icSigHead), any(byte[].class));
    }

+    static void assumeICC_ProfileNotSealed() {
+        try {
+            Method isSealed = Class.class.getMethod("isSealed");
+            Boolean result = (Boolean) isSealed.invoke(ICC_Profile.class);
+            assumeFalse("Can't mock ICC_Profile, class is sealed (as of JDK 19).", result);
+        }
+        catch (ReflectiveOperationException ignore) {
+            // We can't have sealed classes if we don't have the isSealed method...
+        }
+    }
+
    @Test
    public void testFixProfileCorbisRGB() throws IOException {
        // TODO: Consider re-writing this using mocks, to avoid dependencies on the CMS implementation
@@ -34,6 +34,7 @@ import org.junit.Test;

 import java.awt.color.ICC_Profile;

+import static com.twelvemonkeys.imageio.color.KCMSSanitizerStrategyTest.assumeICC_ProfileNotSealed;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verifyNoMoreInteractions;

@@ -46,6 +47,8 @@ public class LCMSSanitizerStrategyTest {

    @Test
    public void testFixProfile() throws Exception {
+        assumeICC_ProfileNotSealed(); // Ignores test for JDK 19+
+
        ICC_Profile profile = mock(ICC_Profile.class);
        new LCMSSanitizerStrategy().fixProfile(profile);

@@ -0,0 +1,434 @@
+/*
+ * Copyright (c) 2020, 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 of the copyright holder 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 HOLDER 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.stream;
+
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+
+import javax.imageio.stream.ImageInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.ReadableByteChannel;
+import java.util.Random;
+
+import static com.twelvemonkeys.imageio.stream.BufferedImageInputStreamTest.rangeEquals;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.verify;
+
+/**
+ * BufferedFileImageInputStreamTestCase
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: BufferedFileImageInputStreamTestCase.java,v 1.0 Apr 21, 2009 10:58:48 AM haraldk Exp$
+ */
+// TODO: Remove this test, and instead test the disk cache directly!
+public class BufferedChannelImageInputStreamFileCacheTest {
+    private final Random random = new Random(170984354357234566L);
+
+    private InputStream randomDataToInputStream(byte[] data) {
+        random.nextBytes(data);
+
+        return new ByteArrayInputStream(data);
+    }
+
+    @Test
+    public void testCreate() throws IOException {
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(new ByteArrayInputStream(new byte[0]), null))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+        }
+    }
+
+    @Test
+    public void testCreateNullStream() throws IOException {
+        try {
+            new FileCache((InputStream) null, null);
+            fail("Expected IllegalArgumentException");
+        }
+        catch (IllegalArgumentException expected) {
+            assertNotNull("Null exception message", expected.getMessage());
+            String message = expected.getMessage().toLowerCase();
+            assertTrue("Exception message does not contain parameter name", message.contains("stream"));
+            assertTrue("Exception message does not contain null", message.contains("null"));
+        }
+    }
+
+    @Test
+    public void testCreateNullChannel() throws IOException {
+        try {
+            new FileCache((ReadableByteChannel) null, null);
+            fail("Expected IllegalArgumentException");
+        }
+        catch (IllegalArgumentException expected) {
+            assertNotNull("Null exception message", expected.getMessage());
+            String message = expected.getMessage().toLowerCase();
+            assertTrue("Exception message does not contain parameter name", message.contains("channel"));
+            assertTrue("Exception message does not contain null", message.contains("null"));
+        }
+    }
+
+    @Test
+    public void testRead() throws IOException {
+        byte[] data = new byte[1024 * 1024];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            for (byte value : data) {
+                assertEquals("Wrong data read", value & 0xff, stream.read());
+            }
+
+            assertEquals("Wrong data read", -1, stream.read());
+        }
+    }
+
+    @Test
+    public void testReadArray() throws IOException {
+        byte[] data = new byte[1024 * 1024];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            byte[] result = new byte[1024];
+
+            for (int i = 0; i < data.length / result.length; i++) {
+                stream.readFully(result);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, i * result.length, result, 0, result.length));
+            }
+
+            assertEquals("Wrong data read", -1, stream.read());
+        }
+    }
+
+    @Test
+    public void testReadSkip() throws IOException {
+        byte[] data = new byte[1024 * 14];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            byte[] result = new byte[7];
+
+            for (int i = 0; i < data.length / result.length; i += 2) {
+                stream.readFully(result);
+                stream.skipBytes(result.length);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, i * result.length, result, 0, result.length));
+            }
+        }
+    }
+
+    @Test
+    public void testReadSeek() throws IOException {
+        byte[] data = new byte[1024 * 18];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            byte[] result = new byte[9];
+
+            for (int i = 0; i < data.length / result.length; i++) {
+                // Read backwards
+                long newPos = data.length - result.length - i * result.length;
+                stream.seek(newPos);
+                assertEquals("Wrong stream position", newPos, stream.getStreamPosition());
+                stream.readFully(result);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, (int) newPos, result, 0, result.length));
+            }
+        }
+    }
+
+    @Test
+    public void testReadOutsideDataSeek0Read() throws IOException {
+        byte[] data = new byte[256];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            byte[] buffer = new byte[data.length * 2];
+            stream.read(buffer);
+            stream.seek(0);
+            assertNotEquals(-1, stream.read());
+            assertNotEquals(-1, stream.read(buffer));
+        }
+    }
+
+    @Test
+    public void testReadBitRandom() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomDataToInputStream(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            for (int i = 1; i <= 64; i++) {
+                assertEquals(String.format("bit %d differ", i), (value << (i - 1L)) >>> 63L, stream.readBit());
+            }
+        }
+    }
+
+    @Test
+    public void testReadBitsRandom() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomDataToInputStream(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            for (int i = 1; i <= 64; i++) {
+                stream.seek(0);
+                assertEquals(String.format("bit %d differ", i), value >>> (64L - i), stream.readBits(i));
+                assertEquals(i % 8, stream.getBitOffset());
+            }
+        }
+    }
+
+    @Test
+    public void testReadBitsRandomOffset() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomDataToInputStream(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            for (int i = 1; i <= 60; i++) {
+                stream.seek(0);
+                stream.setBitOffset(i % 8);
+                assertEquals(String.format("bit %d differ", i), (value << (i % 8)) >>> (64L - i), stream.readBits(i));
+                assertEquals(i * 2 % 8, stream.getBitOffset());
+            }
+        }
+    }
+
+    @Test
+    public void testReadShort() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        InputStream input = randomDataToInputStream(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 2; i++) {
+                assertEquals(buffer.getShort(), stream.readShort());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 2; i++) {
+                assertEquals(buffer.getShort(), stream.readShort());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testReadInt() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        InputStream input = randomDataToInputStream(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 4; i++) {
+                assertEquals(buffer.getInt(), stream.readInt());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 4; i++) {
+                assertEquals(buffer.getInt(), stream.readInt());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testReadLong() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        InputStream input = randomDataToInputStream(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 8; i++) {
+                assertEquals(buffer.getLong(), stream.readLong());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 8; i++) {
+                assertEquals(buffer.getLong(), stream.readLong());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testSeekPastEOF() throws IOException {
+        byte[] bytes = new byte[9];
+        InputStream input = randomDataToInputStream(bytes);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            stream.seek(1000);
+
+            assertEquals(-1, stream.read());
+            assertEquals(-1, stream.read(new byte[1], 0, 1));
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readFully(new byte[1]);
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readByte();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+
+            stream.seek(0);
+            for (byte value : bytes) {
+                assertEquals(value, stream.readByte());
+            }
+
+            assertEquals(-1, stream.read());
+        }
+    }
+
+    @Test
+    public void testClose() throws IOException {
+        // Create wrapper stream
+        Cache cache = mock(Cache.class);
+        ImageInputStream stream = new BufferedChannelImageInputStream(cache);
+
+        stream.close();
+        verify(cache, only()).close();
+    }
+
+    @Test
+    public void testWorkaroundForWBMPImageReaderExpectsReadToBehaveAsReadFully() throws IOException {
+        // See #606 for details.
+        // Bug in JDK WBMPImageReader, uses read(byte[], int, int) instead of readFully(byte[], int, int).
+        // Ie: Relies on read to return all bytes at once, without blocking
+        int size = BufferedChannelImageInputStream.DEFAULT_BUFFER_SIZE * 7;
+        byte[] bytes = new byte[size];
+        InputStream input = randomDataToInputStream(bytes);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileCache(input, null))) {
+            byte[] result = new byte[size];
+            int head = stream.read(result, 0, 12);          // Provoke a buffered read
+            int len = stream.read(result, 12, size - 12);   // Rest of buffer + direct read
+
+            assertEquals(size, len + head);
+            assertArrayEquals(bytes, result);
+        }
+    }
+}
@@ -0,0 +1,452 @@
+/*
+ * Copyright (c) 2020, 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 of the copyright holder 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 HOLDER 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.stream;
+
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+
+import javax.imageio.stream.ImageInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.ReadableByteChannel;
+import java.util.Random;
+
+import static com.twelvemonkeys.imageio.stream.BufferedImageInputStreamTest.rangeEquals;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.verify;
+
+/**
+ * BufferedFileImageInputStreamTestCase
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: BufferedFileImageInputStreamTestCase.java,v 1.0 Apr 21, 2009 10:58:48 AM haraldk Exp$
+ */
+// TODO: Remove this test, and instead test the memory cache directly!
+public class BufferedChannelImageInputStreamMemoryCacheTest {
+    private final Random random = new Random(170984354357234566L);
+
+    private InputStream randomDataToInputStream(byte[] data) {
+        random.nextBytes(data);
+
+        return new ByteArrayInputStream(data);
+    }
+
+    @Test
+    public void testCreate() throws IOException {
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(new ByteArrayInputStream(new byte[0])))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+        }
+    }
+
+    @Test
+    public void testCreateNullStream() {
+        try {
+            new MemoryCache((InputStream) null);
+            fail("Expected IllegalArgumentException");
+        }
+        catch (IllegalArgumentException expected) {
+            assertNotNull("Null exception message", expected.getMessage());
+            String message = expected.getMessage().toLowerCase();
+            assertTrue("Exception message does not contain parameter name", message.contains("stream"));
+            assertTrue("Exception message does not contain null", message.contains("null"));
+        }
+    }
+
+    @Test
+    public void testCreateNullChannel() {
+        try {
+            new MemoryCache((ReadableByteChannel) null);
+            fail("Expected IllegalArgumentException");
+        }
+        catch (IllegalArgumentException expected) {
+            assertNotNull("Null exception message", expected.getMessage());
+            String message = expected.getMessage().toLowerCase();
+            assertTrue("Exception message does not contain parameter name", message.contains("channel"));
+            assertTrue("Exception message does not contain null", message.contains("null"));
+        }
+    }
+
+    @Test
+    public void testRead() throws IOException {
+        byte[] data = new byte[1024 * 1024];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            for (byte value : data) {
+                assertEquals("Wrong data read", value & 0xff, stream.read());
+            }
+
+            assertEquals("Wrong data read", -1, stream.read());
+        }
+    }
+
+    @Test
+    public void testReadArray() throws IOException {
+        byte[] data = new byte[1024 * 1024];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            byte[] result = new byte[1024];
+
+            for (int i = 0; i < data.length / result.length; i++) {
+                stream.readFully(result);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, i * result.length, result, 0, result.length));
+            }
+
+            assertEquals("Wrong data read", -1, stream.read());
+        }
+    }
+
+    @Test
+    public void testReadSkip() throws IOException {
+        byte[] data = new byte[1024 * 14];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            byte[] result = new byte[7];
+
+            for (int i = 0; i < data.length / result.length; i += 2) {
+                stream.readFully(result);
+                stream.skipBytes(result.length);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, i * result.length, result, 0, result.length));
+            }
+        }
+    }
+
+    @Test
+    public void testReadSeek() throws IOException {
+        byte[] data = new byte[1024 * 18];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            byte[] result = new byte[9];
+
+            for (int i = 0; i < data.length / result.length; i++) {
+                // Read backwards
+                long newPos = data.length - result.length - i * result.length;
+                stream.seek(newPos);
+                assertEquals("Wrong stream position", newPos, stream.getStreamPosition());
+                stream.readFully(result);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, (int) newPos, result, 0, result.length));
+            }
+        }
+    }
+
+    @Test
+    public void testReadOutsideDataSeek0Read() throws IOException {
+        byte[] data = new byte[256];
+        InputStream input = randomDataToInputStream(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            assertEquals("Stream length should be unknown", -1, stream.length());
+
+            byte[] buffer = new byte[data.length * 2];
+            stream.read(buffer);
+            stream.seek(0);
+            assertNotEquals(-1, stream.read());
+            assertNotEquals(-1, stream.read(buffer));
+        }
+    }
+
+    @Test
+    public void testReadBitRandom() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomDataToInputStream(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            for (int i = 1; i <= 64; i++) {
+                assertEquals(String.format("bit %d differ", i), (value << (i - 1L)) >>> 63L, stream.readBit());
+            }
+        }
+    }
+
+    @Test
+    public void testReadBitsRandom() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomDataToInputStream(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            for (int i = 1; i <= 64; i++) {
+                stream.seek(0);
+                assertEquals(String.format("bit %d differ", i), value >>> (64L - i), stream.readBits(i));
+                assertEquals(i % 8, stream.getBitOffset());
+            }
+        }
+    }
+
+    @Test
+    public void testReadBitsRandomOffset() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomDataToInputStream(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            for (int i = 1; i <= 60; i++) {
+                stream.seek(0);
+                stream.setBitOffset(i % 8);
+                assertEquals(String.format("bit %d differ", i), (value << (i % 8)) >>> (64L - i), stream.readBits(i));
+                assertEquals(i * 2 % 8, stream.getBitOffset());
+            }
+        }
+    }
+
+    @Test
+    public void testReadShort() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        InputStream input = randomDataToInputStream(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 2; i++) {
+                assertEquals(buffer.getShort(), stream.readShort());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 2; i++) {
+                assertEquals(buffer.getShort(), stream.readShort());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testReadInt() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        InputStream input = randomDataToInputStream(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 4; i++) {
+                assertEquals(buffer.getInt(), stream.readInt());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 4; i++) {
+                assertEquals(buffer.getInt(), stream.readInt());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testReadLong() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        InputStream input = randomDataToInputStream(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 8; i++) {
+                assertEquals(buffer.getLong(), stream.readLong());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 8; i++) {
+                assertEquals(buffer.getLong(), stream.readLong());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testSeekPastEOF() throws IOException {
+        byte[] bytes = new byte[9];
+        InputStream input = randomDataToInputStream(bytes);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            stream.seek(1000);
+
+            assertEquals(-1, stream.read());
+            assertEquals(-1, stream.read(new byte[1], 0, 1));
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readFully(new byte[1]);
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readByte();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+
+            stream.seek(0);
+            for (byte value : bytes) {
+                assertEquals(value, stream.readByte());
+            }
+
+            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 {
+        // Create wrapper stream
+        Cache cache = mock(Cache.class);
+        ImageInputStream stream = new BufferedChannelImageInputStream(cache);
+
+        stream.close();
+        verify(cache, only()).close();
+    }
+
+    @Test
+    public void testWorkaroundForWBMPImageReaderExpectsReadToBehaveAsReadFully() throws IOException {
+        // See #606 for details.
+        // Bug in JDK WBMPImageReader, uses read(byte[], int, int) instead of readFully(byte[], int, int).
+        // Ie: Relies on read to return all bytes at once, without blocking
+        int size = BufferedChannelImageInputStream.DEFAULT_BUFFER_SIZE * 7;
+        byte[] bytes = new byte[size];
+        InputStream input = randomDataToInputStream(bytes);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new MemoryCache(input))) {
+            byte[] result = new byte[size];
+            int head = stream.read(result, 0, 12);          // Provoke a buffered read
+            int len = stream.read(result, 12, size - 12);   // Rest of buffer + direct read
+
+            assertEquals(size, len + head);
+            assertArrayEquals(bytes, result);
+        }
+    }
+}
@@ -0,0 +1,431 @@
+/*
+ * Copyright (c) 2020, 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 of the copyright holder 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 HOLDER 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.stream;
+
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+
+import javax.imageio.stream.ImageInputStream;
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.SeekableByteChannel;
+import java.nio.file.Files;
+import java.util.Random;
+
+import static com.twelvemonkeys.imageio.stream.BufferedImageInputStreamTest.rangeEquals;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/**
+ * BufferedFileImageInputStreamTestCase
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: BufferedFileImageInputStreamTestCase.java,v 1.0 Apr 21, 2009 10:58:48 AM haraldk Exp$
+ */
+public class BufferedChannelImageInputStreamTest {
+    private final Random random = new Random(170984354357234566L);
+
+    private File randomDataToFile(byte[] data) throws IOException {
+        random.nextBytes(data);
+
+        File file = File.createTempFile("read", ".tmp");
+        Files.write(file.toPath(), data);
+        return file;
+    }
+
+    @Test
+    public void testCreate() throws IOException {
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(File.createTempFile("empty", ".tmp")))) {
+            assertEquals("Data length should be same as stream length", 0, stream.length());
+        }
+    }
+
+    @Test
+    public void testCreateNullFileInputStream() {
+        try {
+            new BufferedChannelImageInputStream((FileInputStream) null);
+            fail("Expected IllegalArgumentException");
+        }
+        catch (IllegalArgumentException expected) {
+            assertNotNull("Null exception message", expected.getMessage());
+            String message = expected.getMessage().toLowerCase();
+            assertTrue("Exception message does not contain parameter name", message.contains("inputstream"));
+            assertTrue("Exception message does not contain null", message.contains("null"));
+        }
+    }
+
+    @Test
+    public void testCreateNullByteChannel() {
+        try {
+            new BufferedChannelImageInputStream((SeekableByteChannel) null);
+            fail("Expected IllegalArgumentException");
+        }
+        catch (IllegalArgumentException expected) {
+            assertNotNull("Null exception message", expected.getMessage());
+            String message = expected.getMessage().toLowerCase();
+            assertTrue("Exception message does not contain parameter name", message.contains("channel"));
+            assertTrue("Exception message does not contain null", message.contains("null"));
+        }
+    }
+
+    @Test
+    public void testRead() throws IOException {
+        byte[] data = new byte[1024 * 1024];
+        File file = randomDataToFile(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            assertEquals("File length should be same as stream length", file.length(), stream.length());
+
+            for (byte value : data) {
+                assertEquals("Wrong data read", value & 0xff, stream.read());
+            }
+        }
+    }
+
+    @Test
+    public void testReadArray() throws IOException {
+        byte[] data = new byte[1024 * 1024];
+        File file = randomDataToFile(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            assertEquals("File length should be same as stream length", file.length(), stream.length());
+
+            byte[] result = new byte[1024];
+
+            for (int i = 0; i < data.length / result.length; i++) {
+                stream.readFully(result);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, i * result.length, result, 0, result.length));
+            }
+        }
+    }
+
+    @Test
+    public void testReadSkip() throws IOException {
+        byte[] data = new byte[1024 * 14];
+        File file = randomDataToFile(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            assertEquals("File length should be same as stream length", file.length(), stream.length());
+
+            byte[] result = new byte[7];
+
+            for (int i = 0; i < data.length / result.length; i += 2) {
+                stream.readFully(result);
+                stream.skipBytes(result.length);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, i * result.length, result, 0, result.length));
+            }
+        }
+    }
+
+    @Test
+    public void testReadSeek() throws IOException {
+        byte[] data = new byte[1024 * 18];
+        File file = randomDataToFile(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            assertEquals("File length should be same as stream length", file.length(), stream.length());
+
+            byte[] result = new byte[9];
+
+            for (int i = 0; i < data.length / result.length; i++) {
+                // Read backwards
+                long newPos = stream.length() - result.length - i * result.length;
+                stream.seek(newPos);
+                assertEquals("Wrong stream position", newPos, stream.getStreamPosition());
+                stream.readFully(result);
+                assertTrue("Wrong data read: " + i, rangeEquals(data, (int) newPos, result, 0, result.length));
+            }
+        }
+    }
+
+    @Test
+    public void testReadOutsideDataSeek0Read() throws IOException {
+        byte[] data = new byte[256];
+        File file = randomDataToFile(data);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            assertEquals("File length should be same as stream length", file.length(), stream.length());
+
+            byte[] buffer = new byte[data.length * 2];
+            stream.read(buffer);
+            stream.seek(0);
+            assertNotEquals(-1, stream.read());
+            assertNotEquals(-1, stream.read(buffer));
+        }
+    }
+
+    @Test
+    public void testReadBitRandom() throws IOException {
+        byte[] bytes = new byte[8];
+        File file = randomDataToFile(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            for (int i = 1; i <= 64; i++) {
+                assertEquals(String.format("bit %d differ", i), (value << (i - 1L)) >>> 63L, stream.readBit());
+            }
+        }
+    }
+
+    @Test
+    public void testReadBitsRandom() throws IOException {
+        byte[] bytes = new byte[8];
+        File file = randomDataToFile(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            for (int i = 1; i <= 64; i++) {
+                stream.seek(0);
+                assertEquals(String.format("bit %d differ", i), value >>> (64L - i), stream.readBits(i));
+                assertEquals(i % 8, stream.getBitOffset());
+            }
+        }
+    }
+
+    @Test
+    public void testReadBitsRandomOffset() throws IOException {
+        byte[] bytes = new byte[8];
+        File file = randomDataToFile(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (ImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            for (int i = 1; i <= 60; i++) {
+                stream.seek(0);
+                stream.setBitOffset(i % 8);
+                assertEquals(String.format("bit %d differ", i), (value << (i % 8)) >>> (64L - i), stream.readBits(i));
+                assertEquals(i * 2 % 8, stream.getBitOffset());
+            }
+        }
+    }
+
+    @Test
+    public void testReadShort() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        File file = randomDataToFile(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 2; i++) {
+                assertEquals(buffer.getShort(), stream.readShort());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 2; i++) {
+                assertEquals(buffer.getShort(), stream.readShort());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testReadInt() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        File file = randomDataToFile(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 4; i++) {
+                assertEquals(buffer.getInt(), stream.readInt());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 4; i++) {
+                assertEquals(buffer.getInt(), stream.readInt());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testReadLong() throws IOException {
+        byte[] bytes = new byte[8743]; // Slightly more than one buffer size
+        File file = randomDataToFile(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            stream.setByteOrder(ByteOrder.BIG_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 8; i++) {
+                assertEquals(buffer.getLong(), stream.readLong());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+
+            stream.seek(0);
+            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+            buffer.position(0);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+
+            for (int i = 0; i < bytes.length / 8; i++) {
+                assertEquals(buffer.getLong(), stream.readLong());
+            }
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testSeekPastEOF() throws IOException {
+        byte[] bytes = new byte[9];
+        File file = randomDataToFile(bytes);
+
+        try (final ImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            stream.seek(1000);
+
+            assertEquals(-1, stream.read());
+            assertEquals(-1, stream.read(new byte[1], 0, 1));
+
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readFully(new byte[1]);
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readByte();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readShort();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readInt();
+                }
+            });
+            assertThrows(EOFException.class, new ThrowingRunnable() {
+                @Override
+                public void run() throws Throwable {
+                    stream.readLong();
+                }
+            });
+
+            stream.seek(0);
+            for (byte value : bytes) {
+                assertEquals(value, stream.readByte());
+            }
+
+            assertEquals(-1, stream.read());
+        }
+    }
+
+    @Test
+    public void testCloseChannel() throws IOException {
+        SeekableByteChannel channel = mock(SeekableByteChannel.class);
+        ImageInputStream stream = new BufferedChannelImageInputStream(channel);
+
+        stream.close();
+        verify(channel, never()).close();
+    }
+
+    @Test
+    public void testWorkaroundForWBMPImageReaderExpectsReadToBehaveAsReadFully() throws IOException {
+        // See #606 for details.
+        // Bug in JDK WBMPImageReader, uses read(byte[], int, int) instead of readFully(byte[], int, int).
+        // Ie: Relies on read to return all bytes at once, without blocking
+        int size = BufferedChannelImageInputStream.DEFAULT_BUFFER_SIZE * 7;
+        byte[] bytes = new byte[size];
+        File file = randomDataToFile(bytes);
+
+        try (BufferedChannelImageInputStream stream = new BufferedChannelImageInputStream(new FileInputStream(file))) {
+            byte[] result = new byte[size];
+            int head = stream.read(result, 0, 12);          // Provoke a buffered read
+            int len = stream.read(result, 12, size - 12);   // Rest of buffer + direct read
+
+            assertEquals(size, len + head);
+            assertArrayEquals(bytes, result);
+        }
+   }
+}
@@ -45,7 +45,9 @@ import java.util.Random;

 import static com.twelvemonkeys.imageio.stream.BufferedImageInputStreamTest.rangeEquals;
 import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.verify;

 /**
 * BufferedFileImageInputStreamTestCase
@@ -54,6 +56,7 @@ import static org.mockito.Mockito.*;
 * @author last modified by $Author: haraldk$
 * @version $Id: BufferedFileImageInputStreamTestCase.java,v 1.0 Apr 21, 2009 10:58:48 AM haraldk Exp$
 */
+@Deprecated
 public class BufferedFileImageInputStreamTest {
    private final Random random = new Random(170984354357234566L);

@@ -72,6 +75,7 @@ public class BufferedFileImageInputStreamTest {
        }
    }

+    @SuppressWarnings("resource")
    @Test
    public void testCreateNullFile() throws IOException {
        try {
@@ -0,0 +1,26 @@
+package com.twelvemonkeys.imageio.stream;
+
+import javax.imageio.spi.ImageInputStreamSpi;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+
+/**
+ * BufferedInputStreamImageInputStreamSpiTest.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: BufferedInputStreamImageInputStreamSpiTest.java,v 1.0 08/09/2022 haraldk Exp$
+ */
+public class BufferedFileInputStreamImageInputStreamSpiTest extends ImageInputStreamSpiTest<InputStream> {
+    @Override
+    protected ImageInputStreamSpi createProvider() {
+        return new BufferedInputStreamImageInputStreamSpi();
+    }
+
+    @Override
+    protected InputStream createInput() throws IOException {
+        return Files.newInputStream(File.createTempFile("test-", ".tst").toPath());
+    }
+}
@@ -0,0 +1,24 @@
+package com.twelvemonkeys.imageio.stream;
+
+import javax.imageio.spi.ImageInputStreamSpi;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+/**
+ * BufferedInputStreamImageInputStreamSpiTest.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: BufferedInputStreamImageInputStreamSpiTest.java,v 1.0 08/09/2022 haraldk Exp$
+ */
+public class BufferedInputStreamImageInputStreamSpiTest extends ImageInputStreamSpiTest<InputStream> {
+    @Override
+    protected ImageInputStreamSpi createProvider() {
+        return new BufferedInputStreamImageInputStreamSpi();
+    }
+
+    @Override
+    protected InputStream createInput() {
+        return new ByteArrayInputStream(new byte[0]);
+    }
+}
@@ -30,20 +30,15 @@

 package com.twelvemonkeys.imageio.util;

-import static org.junit.Assert.assertEquals;
-
-import java.awt.color.ColorSpace;
-import java.awt.image.BufferedImage;
-import java.awt.image.ColorModel;
-import java.awt.image.DataBuffer;
-import java.awt.image.DirectColorModel;
-import java.awt.image.IndexColorModel;
-
-import javax.imageio.ImageTypeSpecifier;
+import com.twelvemonkeys.lang.Validate;

 import org.junit.Test;

-import com.twelvemonkeys.lang.Validate;
+import javax.imageio.ImageTypeSpecifier;
+import java.awt.color.*;
+import java.awt.image.*;
+
+import static org.junit.Assert.assertEquals;

 public class ImageTypeSpecifiersTest {

@@ -70,12 +65,19 @@ public class ImageTypeSpecifiersTest {
            ImageTypeSpecifier expected;

            switch (type) {
+                // Special handling for INT_RGB and BGR, due to bug in ImageTypeSpecifier for these types (DirectColorModel is 32 bits)
+                case BufferedImage.TYPE_INT_RGB:
+                    expected = createPacked(sRGB, 24, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, 0, DataBuffer.TYPE_INT, false);
+                    break;
+                case BufferedImage.TYPE_INT_BGR:
+                    expected = createPacked(sRGB, 24, DCM_BGR_RED_MASK, DCM_BGR_GRN_MASK, DCM_BGR_BLU_MASK, 0, DataBuffer.TYPE_INT, false);
+                    break;
                // Special handling for USHORT_565 and 555, due to bug in ImageTypeSpecifier for these types (DirectColorModel is 32 bits)
                case BufferedImage.TYPE_USHORT_565_RGB:
-                    expected = createPacked(sRGB, DCM_565_RED_MASK, DCM_565_GRN_MASK, DCM_565_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false);
+                    expected = createPacked(sRGB, 16, DCM_565_RED_MASK, DCM_565_GRN_MASK, DCM_565_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false);
                    break;
                case BufferedImage.TYPE_USHORT_555_RGB:
-                    expected = createPacked(sRGB, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false);
+                    expected = createPacked(sRGB, 15, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false);
                    break;
                default:
                    expected = ImageTypeSpecifier.createFromBufferedImageType(type);
@@ -86,12 +88,24 @@ public class ImageTypeSpecifiersTest {
    }

    @Test
-    public void testCreatePacked32() {
+    public void testCreatePacked24() {
        // TYPE_INT_RGB
        assertEquals(
-                ImageTypeSpecifier.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, 0, DataBuffer.TYPE_INT, false),
+                createPacked(sRGB, 24, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, 0, DataBuffer.TYPE_INT, false),
                ImageTypeSpecifiers.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, 0, DataBuffer.TYPE_INT, false)
        );
+        // TYPE_INT_BGR
+        assertEquals(
+                createPacked(sRGB, 24, DCM_BGR_RED_MASK, DCM_BGR_GRN_MASK, DCM_BGR_BLU_MASK, 0, DataBuffer.TYPE_INT, false),
+                ImageTypeSpecifiers.createPacked(sRGB, DCM_BGR_RED_MASK, DCM_BGR_GRN_MASK, DCM_BGR_BLU_MASK, 0, DataBuffer.TYPE_INT, false)
+        );
+
+        // Extra: Make sure color models bits is actually 24 (ImageTypeSpecifier equivalent returns 32)
+        assertEquals(24, ImageTypeSpecifiers.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, 0, DataBuffer.TYPE_INT, false).getColorModel().getPixelSize());
+    }
+
+    @Test
+    public void testCreatePacked32() {
        // TYPE_INT_ARGB
        assertEquals(
                ImageTypeSpecifier.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, DCM_ALPHA_MASK, DataBuffer.TYPE_INT, false),
@@ -102,35 +116,36 @@ public class ImageTypeSpecifiersTest {
                ImageTypeSpecifier.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, DCM_ALPHA_MASK, DataBuffer.TYPE_INT, true),
                ImageTypeSpecifiers.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, DCM_ALPHA_MASK, DataBuffer.TYPE_INT, true)
        );
-        // TYPE_INT_BGR
-        assertEquals(
-                ImageTypeSpecifier.createPacked(sRGB, DCM_BGR_RED_MASK, DCM_BGR_GRN_MASK, DCM_BGR_BLU_MASK, 0, DataBuffer.TYPE_INT, false),
-                ImageTypeSpecifiers.createPacked(sRGB, DCM_BGR_RED_MASK, DCM_BGR_GRN_MASK, DCM_BGR_BLU_MASK, 0, DataBuffer.TYPE_INT, false)
-        );
    }

    @Test
-    public void testCreatePacked16() {
+    public void testCreatePacked15() {
        // TYPE_USHORT_555_RGB
        assertEquals(
-                createPacked(sRGB, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false),
+                createPacked(sRGB, 15, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false),
                ImageTypeSpecifiers.createPacked(sRGB, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false)
        );
        // "SHORT 555 RGB" (impossible, only BYTE, USHORT, INT supported)

+        // Extra: Make sure color models bits is actually 15 (ImageTypeSpecifier equivalent returns 32)
+        assertEquals(15, ImageTypeSpecifiers.createPacked(sRGB, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false).getColorModel().getPixelSize());
+    }
+
+    @Test
+    public void testCreatePacked16() {
        // TYPE_USHORT_565_RGB
        assertEquals(
-                createPacked(sRGB, DCM_565_RED_MASK, DCM_565_GRN_MASK, DCM_565_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false),
+                createPacked(sRGB, 16, DCM_565_RED_MASK, DCM_565_GRN_MASK, DCM_565_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false),
                ImageTypeSpecifiers.createPacked(sRGB, DCM_565_RED_MASK, DCM_565_GRN_MASK, DCM_565_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false)
        );
        // "USHORT 4444 ARGB"
        assertEquals(
-                createPacked(sRGB, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, false),
+                createPacked(sRGB, 16,0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, false),
                ImageTypeSpecifiers.createPacked(sRGB, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, false)
        );
        // "USHORT 4444 ARGB PRE"
        assertEquals(
-                createPacked(sRGB, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, true),
+                createPacked(sRGB, 16, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, true),
                ImageTypeSpecifiers.createPacked(sRGB, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, true)
        );

@@ -142,17 +157,17 @@ public class ImageTypeSpecifiersTest {
    public void testCreatePacked8() {
        // "BYTE 332 RGB"
        assertEquals(
-                createPacked(sRGB, 0xe0, 0x1c, 0x03, 0x0, DataBuffer.TYPE_BYTE, false),
+                createPacked(sRGB, 8, 0xe0, 0x1c, 0x03, 0x0, DataBuffer.TYPE_BYTE, false),
                ImageTypeSpecifiers.createPacked(sRGB, 0xe0, 0x1c, 0x3, 0x0, DataBuffer.TYPE_BYTE, false)
        );
        // "BYTE 2222 ARGB"
        assertEquals(
-                createPacked(sRGB, 0xc0, 0x30, 0x0c, 0x03, DataBuffer.TYPE_BYTE, false),
+                createPacked(sRGB, 8, 0xc0, 0x30, 0x0c, 0x03, DataBuffer.TYPE_BYTE, false),
                ImageTypeSpecifiers.createPacked(sRGB, 0xc0, 0x30, 0x0c, 0x03, DataBuffer.TYPE_BYTE, false)
        );
        // "BYTE 2222 ARGB PRE"
        assertEquals(
-                createPacked(sRGB, 0xc0, 0x30, 0x0c, 0x03, DataBuffer.TYPE_BYTE, true),
+                createPacked(sRGB, 8, 0xc0, 0x30, 0x0c, 0x03, DataBuffer.TYPE_BYTE, true),
                ImageTypeSpecifiers.createPacked(sRGB, 0xc0, 0x30, 0x0c, 0x03, DataBuffer.TYPE_BYTE, true)
        );

@@ -160,15 +175,12 @@ public class ImageTypeSpecifiersTest {
        assertEquals(8, ImageTypeSpecifiers.createPacked(sRGB, 0xc0, 0x30, 0x0c, 0x03, DataBuffer.TYPE_BYTE, false).getColorModel().getPixelSize());
    }

-    private ImageTypeSpecifier createPacked(final ColorSpace colorSpace,
+    private ImageTypeSpecifier createPacked(final ColorSpace colorSpace, final int bits,
                                            final int redMask, final int greenMask, final int blueMask, final int alphaMask,
                                            final int transferType, final boolean isAlphaPremultiplied) {
-        Validate.isTrue(transferType == DataBuffer.TYPE_BYTE || transferType == DataBuffer.TYPE_USHORT, transferType, "transferType: %s");
+        Validate.isTrue(transferType == DataBuffer.TYPE_BYTE || transferType == DataBuffer.TYPE_USHORT || transferType == DataBuffer.TYPE_INT, transferType, "transferType: %s");

-        int bits = transferType == DataBuffer.TYPE_BYTE ? 8 : 16;
-
-        ColorModel colorModel =
-                new DirectColorModel(colorSpace, bits, redMask, greenMask, blueMask, alphaMask, isAlphaPremultiplied, transferType);
+        ColorModel colorModel = new DirectColorModel(colorSpace, bits, redMask, greenMask, blueMask, alphaMask, isAlphaPremultiplied, transferType);

        return new ImageTypeSpecifier(colorModel, colorModel.createCompatibleSampleModel(1, 1));
    }
@@ -716,6 +728,28 @@ public class ImageTypeSpecifiersTest {
        );
    }

+    @Test
+    public void testCreateFromBufferedImageTypeShouldEqualConstructor() {
+        for (int type = BufferedImage.TYPE_INT_RGB; type < BufferedImage.TYPE_BYTE_INDEXED; type++) {
+            BufferedImage image = new BufferedImage(1, 1, type);
+            ImageTypeSpecifier fromConstructor = new ImageTypeSpecifier(image);
+            ImageTypeSpecifier fromType = ImageTypeSpecifiers.createFromBufferedImageType(type);
+
+            assertEquals(fromConstructor.getColorModel(), fromType.getColorModel());
+        }
+    }
+
+    @Test
+    public void testCreateFromRenderedImageShouldEqualConstructor() {
+        for (int type = BufferedImage.TYPE_INT_RGB; type < BufferedImage.TYPE_BYTE_INDEXED; type++) {
+            BufferedImage image = new BufferedImage(1, 1, type);
+            ImageTypeSpecifier fromConstructor = new ImageTypeSpecifier(image);
+            ImageTypeSpecifier fromImage = ImageTypeSpecifiers.createFromRenderedImage(image);
+
+            assertEquals(fromConstructor.getColorModel(), fromImage.getColorModel());
+        }
+    }
+
    private static byte[] createByteLut(final int count) {
        byte[] lut = new byte[count];
        for (int i = 0; i < count; i++) {
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-hdr</artifactId>
    <name>TwelveMonkeys :: ImageIO :: HDR plugin</name>
@@ -40,11 +40,8 @@ import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.spi.ImageReaderSpi;
 import java.awt.*;
-import java.awt.color.ColorSpace;
-import java.awt.image.BufferedImage;
-import java.awt.image.DataBuffer;
-import java.awt.image.Raster;
-import java.awt.image.WritableRaster;
+import java.awt.color.*;
+import java.awt.image.*;
 import java.io.File;
 import java.io.IOException;
 import java.util.Collections;
@@ -244,10 +241,7 @@ public final class HDRImageReader extends ImageReaderBase {

    @Override
    public IIOMetadata getImageMetadata(int imageIndex) throws IOException {
-        checkBounds(imageIndex);
-        readHeader();
-
-        return new HDRMetadata(header);
+        return new HDRMetadata(getRawImageType(imageIndex), header);
    }

    public static void main(final String[] args) throws IOException {
@@ -1,83 +1,19 @@
-/*
- * Copyright (c) 2015, 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 of the copyright holder 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 HOLDER 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.hdr;

-import com.twelvemonkeys.imageio.AbstractMetadata;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport;

+import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.metadata.IIOMetadataNode;

-final class HDRMetadata extends AbstractMetadata {
-    private final HDRHeader header;
-
-    HDRMetadata(final HDRHeader header) {
-        this.header = header;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardChromaNode() {
-        IIOMetadataNode chroma = new IIOMetadataNode("Chroma");
-
-        IIOMetadataNode csType = new IIOMetadataNode("ColorSpaceType");
-        chroma.appendChild(csType);
-        csType.setAttribute("name", "RGB");
-        // TODO: Support XYZ
-
-        IIOMetadataNode numChannels = new IIOMetadataNode("NumChannels");
-        numChannels.setAttribute("value", "3");
-        chroma.appendChild(numChannels);
-
-        IIOMetadataNode blackIsZero = new IIOMetadataNode("BlackIsZero");
-        blackIsZero.setAttribute("value", "TRUE");
-        chroma.appendChild(blackIsZero);
-
-        return chroma;
-    }
-
-    // No compression
-
-    @Override
-    protected IIOMetadataNode getStandardCompressionNode() {
-        IIOMetadataNode node = new IIOMetadataNode("Compression");
-
-        IIOMetadataNode compressionTypeName = new IIOMetadataNode("CompressionTypeName");
-        compressionTypeName.setAttribute("value", "RLE");
-        node.appendChild(compressionTypeName);
-
-        IIOMetadataNode lossless = new IIOMetadataNode("Lossless");
-        lossless.setAttribute("value", "TRUE");
-        node.appendChild(lossless);
-
-        return node;
+public class HDRMetadata extends StandardImageMetadataSupport {
+    public HDRMetadata(ImageTypeSpecifier type, HDRHeader header) {
+        super(builder(type)
+                      .withCompressionTypeName("RLE")
+                      .withTextEntry("Software", header.getSoftware()));
    }

+    // For HDR, the stored sample data is UnsignedIntegral and data is 4 channels (RGB+Exp),
+    // but decoded to Real (float) 3 chanel RGB
    @Override
    protected IIOMetadataNode getStandardDataNode() {
        IIOMetadataNode node = new IIOMetadataNode("Data");
@@ -92,38 +28,4 @@ final class HDRMetadata extends AbstractMetadata {

        return node;
    }
-
-    @Override
-    protected IIOMetadataNode getStandardDimensionNode() {
-        IIOMetadataNode dimension = new IIOMetadataNode("Dimension");
-
-        // TODO: Support other orientations
-        IIOMetadataNode imageOrientation = new IIOMetadataNode("ImageOrientation");
-        imageOrientation.setAttribute("value", "Normal");
-        dimension.appendChild(imageOrientation);
-
-        return dimension;
-    }
-
-    // No document node
-
-    @Override
-    protected IIOMetadataNode getStandardTextNode() {
-        if (header.getSoftware() != null) {
-            IIOMetadataNode text = new IIOMetadataNode("Text");
-
-            IIOMetadataNode textEntry = new IIOMetadataNode("TextEntry");
-            textEntry.setAttribute("keyword", "Software");
-            textEntry.setAttribute("value", header.getSoftware());
-            text.appendChild(textEntry);
-
-            return text;
-        }
-
-        return null;
-    }
-
-    // No tiling
-
-    // No transparency
 }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-icns</artifactId>
    <name>TwelveMonkeys :: ImageIO :: ICNS plugin</name>
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2022, 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 of the copyright holder 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 HOLDER 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.icns;
+
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport;
+
+import javax.imageio.ImageTypeSpecifier;
+
+final class ICNSImageMetadata extends StandardImageMetadataSupport {
+    ICNSImageMetadata(ImageTypeSpecifier type, String compressionName) {
+        super(builder(type).withCompressionTypeName(compressionName));
+    }
+}
@@ -35,11 +35,16 @@ import com.twelvemonkeys.imageio.stream.SubImageInputStream;
 import com.twelvemonkeys.imageio.util.IIOUtil;
 import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;

-import javax.imageio.*;
+import javax.imageio.IIOException;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.*;
-import java.awt.color.ColorSpace;
+import java.awt.color.*;
 import java.awt.image.*;
 import java.io.DataInputStream;
 import java.io.File;
@@ -61,10 +66,9 @@ import java.util.List;
 * @see <a href="http://en.wikipedia.org/wiki/Apple_Icon_Image_format">Apple Icon Image format (Wikipedia)</a>
 */
 public final class ICNSImageReader extends ImageReaderBase {
-    // TODO: Support ToC resource for faster parsing/faster determine number of icons?
    // TODO: Subsampled reading for completeness, even if never used?
-    private List<IconResource> icons = new ArrayList<IconResource>();
-    private List<IconResource> masks = new ArrayList<IconResource>();
+    private final List<IconResource> icons = new ArrayList<>();
+    private final List<IconResource> masks = new ArrayList<>();
    private IconResource lastResourceRead;

    private int length;
@@ -136,7 +140,7 @@ public final class ICNSImageReader extends ImageReaderBase {
        ImageTypeSpecifier rawType = getRawImageType(imageIndex);
        IconResource resource = readIconResource(imageIndex);

-        List<ImageTypeSpecifier> specifiers = new ArrayList<ImageTypeSpecifier>();
+        List<ImageTypeSpecifier> specifiers = new ArrayList<>();

        switch (resource.depth()) {
            case 1:
@@ -230,14 +234,9 @@ public final class ICNSImageReader extends ImageReaderBase {
                packedSize -= 4;
            }

-            InputStream input = IIOUtil.createStreamAdapter(imageInput, packedSize);
-
-            try {
+            try (InputStream input = IIOUtil.createStreamAdapter(imageInput, packedSize)) {
                ICNSUtil.decompress(new DataInputStream(input), data, 0, (data.length * 24) / 32); // 24 bit data
            }
-            finally {
-                input.close();
-            }
        }
        else {
            data = new byte[resource.length - ICNS.RESOURCE_HEADER_SIZE];
@@ -491,7 +490,7 @@ public final class ICNSImageReader extends ImageReaderBase {

        String format;

-        if (Arrays.equals(ICNS.PNG_MAGIC, magic)) {
+        if (Arrays.equals(ICNS.PNG_MAGIC, Arrays.copyOfRange(magic, 0, ICNS.PNG_MAGIC.length))) {
            format = "PNG";
        }
        else if (Arrays.equals(ICNS.JPEG_2000_MAGIC, magic)) {
@@ -527,7 +526,6 @@ public final class ICNSImageReader extends ImageReaderBase {
        IconResource resource = IconResource.read(imageInput);

        if (resource.isTOC()) {
-            // TODO: IconResource.readTOC()?
            int resourceCount = (resource.length - ICNS.RESOURCE_HEADER_SIZE) / ICNS.RESOURCE_HEADER_SIZE;
            long pos = resource.start + resource.length;

@@ -570,6 +568,23 @@ public final class ICNSImageReader extends ImageReaderBase {
        }
    }

+    @Override
+    public IIOMetadata getImageMetadata(int imageIndex) throws IOException {
+        IconResource resource = readIconResource(imageIndex);
+
+        String compressionName;
+        if (resource.isForeignFormat()) {
+            // Special handling of PNG/JPEG 2000 icons
+            imageInput.seek(resource.start + ICNS.RESOURCE_HEADER_SIZE);
+            compressionName = getForeignFormat(imageInput);
+        }
+        else {
+            compressionName = resource.isCompressed() ? "RLE" : "None";
+        }
+
+        return new ICNSImageMetadata(getRawImageType(imageIndex), compressionName);
+    }
+
    private static final class ICNSBitMaskColorModel extends IndexColorModel {
        static final IndexColorModel INSTANCE = new ICNSBitMaskColorModel();

@@ -578,7 +593,6 @@ public final class ICNSImageReader extends ImageReaderBase {
        }
    }

-    @SuppressWarnings({"UnusedAssignment"})
    public static void main(String[] args) throws IOException {
        int argIndex = 0;

@@ -34,7 +34,13 @@ import com.twelvemonkeys.imageio.ImageWriterBase;
 import com.twelvemonkeys.imageio.stream.SubImageOutputStream;
 import com.twelvemonkeys.imageio.util.ProgressListenerBase;

-import javax.imageio.*;
+import javax.imageio.IIOException;
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
 import javax.imageio.event.IIOWriteWarningListener;
 import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.spi.ImageWriterSpi;
@@ -104,6 +110,7 @@ public final class ICNSImageWriter extends ImageWriterBase {
        sequenceIndex = 0;
    }

+    @SuppressWarnings("RedundantThrows")
    @Override
    public void endWriteSequence() throws IOException {
        assertOutput();
@@ -38,8 +38,13 @@ import javax.imageio.ImageIO;
 import javax.imageio.ImageReadParam;
 import javax.imageio.ImageReader;
 import javax.imageio.stream.ImageInputStream;
-import java.awt.image.BufferedImage;
-import java.io.*;
+import java.awt.image.*;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.util.Iterator;

 /**
@@ -140,17 +145,12 @@ final class SipsJP2Reader {
    }

    private static String checkErrorMessage(final Process process) throws IOException {
-        InputStream stream = process.getErrorStream();
-        
-        try {
+        try (InputStream stream = process.getErrorStream()) {
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String message = reader.readLine();

            return message != null && message.startsWith("Error: ") ? message.substring(7) : null;
        }
-        finally {
-            stream.close();
-        }
    }

    private static String[] buildCommand(final File sipsCommand, final File tempFile) {
@@ -159,19 +159,13 @@ final class SipsJP2Reader {
        };
    }

-
    private static File dumpToFile(final ImageInputStream stream) throws IOException {
        File tempFile = File.createTempFile("imageio-icns-", ".png");
        tempFile.deleteOnExit();

-        FileOutputStream out = new FileOutputStream(tempFile);
-
-        try {
+        try (FileOutputStream out = new FileOutputStream(tempFile)) {
            FileUtil.copy(IIOUtil.createStreamAdapter(stream), out);
        }
-        finally {
-            out.close();
-        }

        return tempFile;
    }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-iff</artifactId>
    <name>TwelveMonkeys :: ImageIO :: IFF plugin</name>
@@ -1,13 +1,13 @@
 package com.twelvemonkeys.imageio.plugins.iff;

 import javax.imageio.IIOException;
-import java.awt.image.BufferedImage;
-import java.awt.image.ColorModel;
-import java.awt.image.IndexColorModel;
+import java.awt.image.*;
 import java.util.ArrayList;
 import java.util.List;

+import static com.twelvemonkeys.imageio.plugins.iff.IFF.*;
 import static com.twelvemonkeys.imageio.plugins.iff.IFFUtil.toChunkStr;
+import static com.twelvemonkeys.lang.Validate.isTrue;

 /**
 * Form.
@@ -27,7 +27,7 @@ abstract class Form {

    abstract int width();
    abstract int height();
-    abstract float aspect();
+    abstract double aspect();
    abstract int bitplanes();
    abstract int compressionType();

@@ -118,7 +118,7 @@ abstract class Form {
        }

        private ILBMForm(final int formType, final BMHDChunk bitmapHeader, final CAMGChunk viewMode, final CMAPChunk colorMap, final AbstractMultiPaletteChunk multiPalette, final XS24Chunk thumbnail, final BODYChunk body) {
-            super(formType);
+            super(isTrue(validFormType(formType), formType, "Unknown IFF Form type: %s"));
            this.bitmapHeader = bitmapHeader;
            this.viewMode = viewMode;
            this.colorMap = colorMap;
@@ -127,6 +127,19 @@ abstract class Form {
            this.body = body;
        }

+        private static boolean validFormType(int formType) {
+            switch (formType) {
+                case TYPE_ACBM:
+                case TYPE_ILBM:
+                case TYPE_PBM:
+                case TYPE_RGB8:
+                case TYPE_RGBN:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
        @Override
        int width() {
            return bitmapHeader.width;
@@ -148,8 +161,8 @@ abstract class Form {
        }

        @Override
-        float aspect() {
-            return bitmapHeader.yAspect == 0 ? 0 : (bitmapHeader.xAspect / (float) bitmapHeader.yAspect);
+        double aspect() {
+            return bitmapHeader.yAspect == 0 ? 0 : (bitmapHeader.xAspect / (double) bitmapHeader.yAspect);
        }

        @Override
@@ -297,7 +310,7 @@ abstract class Form {
        }

        private DEEPForm(final int formType, final DGBLChunk deepGlobal, final DLOCChunk deepLocation, final DPELChunk deepPixel, final XS24Chunk thumbnail, final BODYChunk body) {
-            super(formType);
+            super(isTrue(validFormType(formType), formType, "Unknown IFF Form type: %s"));
            this.deepGlobal = deepGlobal;
            this.deepLocation = deepLocation;
            this.deepPixel = deepPixel;
@@ -305,6 +318,15 @@ abstract class Form {
            this.body = body;
        }

+        private static boolean validFormType(int formType) {
+            switch (formType) {
+                case TYPE_DEEP:
+                case TYPE_TVPP:
+                    return true;
+                default:
+                    return false;
+            }
+        }

        @Override
        int width() {
@@ -337,8 +359,8 @@ abstract class Form {
        }

        @Override
-        float aspect() {
-            return deepGlobal.yAspect == 0 ? 0 : deepGlobal.xAspect / (float) deepGlobal.yAspect;
+        double aspect() {
+            return deepGlobal.yAspect == 0 ? 0 : deepGlobal.xAspect / (double) deepGlobal.yAspect;
        }

        @Override
@@ -1,188 +1,83 @@
+/*
+ * Copyright (c) 2020, 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 of the copyright holder 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 HOLDER 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.iff;

-import com.twelvemonkeys.imageio.AbstractMetadata;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport;

-import javax.imageio.metadata.IIOMetadataNode;
-import java.awt.*;
-import java.awt.image.IndexColorModel;
+import javax.imageio.ImageTypeSpecifier;
+import java.awt.image.*;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.List;

 import static com.twelvemonkeys.imageio.plugins.iff.IFF.*;
-import static com.twelvemonkeys.lang.Validate.isTrue;
+import static com.twelvemonkeys.imageio.plugins.iff.IFFUtil.toChunkStr;
 import static com.twelvemonkeys.lang.Validate.notNull;
+import static java.util.Collections.emptyList;

-final class IFFImageMetadata extends AbstractMetadata {
-    private final Form header;
-    private final IndexColorModel colorMap;
-    private final List<GenericChunk> meta;
-
-    IFFImageMetadata(Form header, IndexColorModel colorMap) {
-        this.header = notNull(header, "header");
-        isTrue(validFormType(header.formType), header.formType, "Unknown IFF Form type: %s");
-        this.colorMap = colorMap;
-        this.meta = header.meta;
+final class IFFImageMetadata extends StandardImageMetadataSupport {
+    IFFImageMetadata(ImageTypeSpecifier type, Form header, IndexColorModel palette) {
+        this(builder(type), notNull(header, "header"), palette);
    }

-    private boolean validFormType(int formType) {
-        switch (formType) {
-            default:
-                return false;
-            case TYPE_ACBM:
-            case TYPE_DEEP:
-            case TYPE_ILBM:
-            case TYPE_PBM:
-            case TYPE_RGB8:
-            case TYPE_RGBN:
-            case TYPE_TVPP:
-                return true;
-        }
+    private IFFImageMetadata(Builder builder, Form header, IndexColorModel palette) {
+        super(builder.withPalette(palette)
+                     .withCompressionTypeName(compressionName(header))
+                     .withBitsPerSample(bitsPerSample(header))
+                     .withPlanarConfiguration(planarConfiguration(header))
+                     .withPixelAspectRatio(header.aspect() != 0 ? header.aspect() : null)
+                     .withFormatVersion("1.0")
+                     .withTextEntries(textEntries(header)));
    }

-    @Override
-    protected IIOMetadataNode getStandardChromaNode() {
-        IIOMetadataNode chroma = new IIOMetadataNode("Chroma");
-
-        IIOMetadataNode csType = new IIOMetadataNode("ColorSpaceType");
-        chroma.appendChild(csType);
-
-        switch (header.bitplanes()) {
-            case 8:
-                if (colorMap == null) {
-                    csType.setAttribute("name", "GRAY");
-                    break;
-                }
-            case 1:
-            case 2:
-            case 3:
+    private static String compressionName(Form header) {
+        switch (header.compressionType()) {
+            case BMHDChunk.COMPRESSION_NONE:
+                return "None";
+            case BMHDChunk.COMPRESSION_BYTE_RUN:
+                return "RLE";
            case 4:
-            case 5:
-            case 6:
-            case 7:
-            case 24:
-            case 25:
-            case 32:
-                csType.setAttribute("name", "RGB");
-                break;
+                // Compression type 4 means different things for different FORM types, we support
+                // Impulse RGB8 RLE compression: 24 bit RGB + 1 bit mask + 7 bit run count
+                if (header.formType == TYPE_RGB8) {
+                    return "RGB8";
+                }
            default:
-                csType.setAttribute("name", "Unknown");
+                return "Unknown";
        }
-
-        // NOTE: Channels in chroma node reflects channels in color model (see data node, for channels in data)
-        IIOMetadataNode numChannels = new IIOMetadataNode("NumChannels");
-        chroma.appendChild(numChannels);
-        if (colorMap == null && header.bitplanes() == 8) {
-            numChannels.setAttribute("value", Integer.toString(1));
-        }
-        else if (header.bitplanes() == 25 || header.bitplanes() == 32) {
-            numChannels.setAttribute("value", Integer.toString(4));
-        }
-        else {
-            numChannels.setAttribute("value", Integer.toString(3));
-        }
-
-        IIOMetadataNode blackIsZero = new IIOMetadataNode("BlackIsZero");
-        chroma.appendChild(blackIsZero);
-        blackIsZero.setAttribute("value", "TRUE");
-
-        // NOTE: TGA files may contain a color map, even if true color...
-        // Not sure if this is a good idea to expose to the meta data,
-        // as it might be unexpected... Then again...
-        if (colorMap != null) {
-            IIOMetadataNode palette = new IIOMetadataNode("Palette");
-            chroma.appendChild(palette);
-
-            for (int i = 0; i < colorMap.getMapSize(); i++) {
-                IIOMetadataNode paletteEntry = new IIOMetadataNode("PaletteEntry");
-                palette.appendChild(paletteEntry);
-                paletteEntry.setAttribute("index", Integer.toString(i));
-
-                paletteEntry.setAttribute("red", Integer.toString(colorMap.getRed(i)));
-                paletteEntry.setAttribute("green", Integer.toString(colorMap.getGreen(i)));
-                paletteEntry.setAttribute("blue", Integer.toString(colorMap.getBlue(i)));
-            }
-
-            if (colorMap.getTransparentPixel() != -1) {
-               IIOMetadataNode backgroundIndex = new IIOMetadataNode("BackgroundIndex");
-               chroma.appendChild(backgroundIndex);
-               backgroundIndex.setAttribute("value", Integer.toString(colorMap.getTransparentPixel()));
-            }
-        }
-
-        // TODO: TVPP TVPaint Project files have a MIXR chunk with a background color
-        //  and also a BGP1 (background pen 1?) and BGP2 chunks
-//        if (extensions != null && extensions.getBackgroundColor() != 0) {
-//            Color background = new Color(extensions.getBackgroundColor(), true);
-//
-//            IIOMetadataNode backgroundColor = new IIOMetadataNode("BackgroundColor");
-//            chroma.appendChild(backgroundColor);
-//
-//            backgroundColor.setAttribute("red", Integer.toString(background.getRed()));
-//            backgroundColor.setAttribute("green", Integer.toString(background.getGreen()));
-//            backgroundColor.setAttribute("blue", Integer.toString(background.getBlue()));
-//        }
-
-        return chroma;
    }

-    @Override
-    protected IIOMetadataNode getStandardCompressionNode() {
-        if (header.compressionType() == BMHDChunk.COMPRESSION_NONE) {
-            return null; // All defaults
-        }
+    private static int[] bitsPerSample(Form header) {
+        int bitplanes = header.bitplanes();

-        IIOMetadataNode node = new IIOMetadataNode("Compression");
-
-        IIOMetadataNode compressionTypeName = new IIOMetadataNode("CompressionTypeName");
-        compressionTypeName.setAttribute("value", "RLE");
-        node.appendChild(compressionTypeName);
-
-        IIOMetadataNode lossless = new IIOMetadataNode("Lossless");
-        lossless.setAttribute("value", "TRUE");
-        node.appendChild(lossless);
-
-        return node;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDataNode() {
-        IIOMetadataNode data = new IIOMetadataNode("Data");
-
-        // PlanarConfiguration
-        IIOMetadataNode planarConfiguration = new IIOMetadataNode("PlanarConfiguration");
-        switch (header.formType) {
-            case TYPE_DEEP:
-            case TYPE_TVPP:
-            case TYPE_RGB8:
-            case TYPE_PBM:
-                planarConfiguration.setAttribute("value", "PixelInterleaved");
-                break;
-            case TYPE_ILBM:
-                planarConfiguration.setAttribute("value", "PlaneInterleaved");
-                break;
-            default:
-                planarConfiguration.setAttribute("value", "Unknown " + IFFUtil.toChunkStr(header.formType));
-                break;
-        }
-        data.appendChild(planarConfiguration);
-
-        IIOMetadataNode sampleFormat = new IIOMetadataNode("SampleFormat");
-        sampleFormat.setAttribute("value", colorMap != null ? "Index" : "UnsignedIntegral");
-        data.appendChild(sampleFormat);
-
-        // BitsPerSample
-        IIOMetadataNode bitsPerSample = new IIOMetadataNode("BitsPerSample");
-        String value = bitsPerSampleValue(header.bitplanes());
-        bitsPerSample.setAttribute("value", value);
-        data.appendChild(bitsPerSample);
-
-        // SignificantBitsPerSample not in format
-        // SampleMSB not in format
-
-        return data;
-    }
-
-    private String bitsPerSampleValue(int bitplanes) {
        switch (bitplanes) {
            case 1:
            case 2:
@@ -192,91 +87,47 @@ final class IFFImageMetadata extends AbstractMetadata {
            case 6:
            case 7:
            case 8:
-                return Integer.toString(bitplanes);
+                return new int[] {bitplanes};
            case 24:
-                return "8 8 8";
+                return new int[] {8, 8, 8};
            case 25:
                if (header.formType != TYPE_RGB8) {
                    throw new IllegalArgumentException(String.format("25 bit depth only supported for FORM type RGB8: %s", IFFUtil.toChunkStr(header.formType)));
                }

-                return "8 8 8 1";
+                return new int[] {8, 8, 8, 1};
            case 32:
-                return "8 8 8 8";
+                return new int[] {8, 8, 8, 8};
            default:
                throw new IllegalArgumentException("Unknown bit count: " + bitplanes);
        }
    }

-    @Override
-    protected IIOMetadataNode getStandardDimensionNode() {
-        if (header.aspect() == 0) {
-            return null;
+    private static PlanarConfiguration planarConfiguration(Form header) {
+        switch (header.formType) {
+            case TYPE_DEEP:
+            case TYPE_TVPP:
+            case TYPE_RGB8:
+            case TYPE_PBM:
+                return PlanarConfiguration.PixelInterleaved;
+            case TYPE_ILBM:
+                return PlanarConfiguration.PlaneInterleaved;
+            default:
+                return null;
        }
-
-        IIOMetadataNode dimension = new IIOMetadataNode("Dimension");
-
-        // PixelAspectRatio
-        IIOMetadataNode pixelAspectRatio = new IIOMetadataNode("PixelAspectRatio");
-        pixelAspectRatio.setAttribute("value", String.valueOf(header.aspect()));
-        dimension.appendChild(pixelAspectRatio);
-
-        // TODO: HorizontalScreenSize?
-        // TODO: VerticalScreenSize?
-
-        return dimension;
    }

-    @Override
-    protected IIOMetadataNode getStandardDocumentNode() {
-        IIOMetadataNode document = new IIOMetadataNode("Document");
-
-        IIOMetadataNode formatVersion = new IIOMetadataNode("FormatVersion");
-        document.appendChild(formatVersion);
-        formatVersion.setAttribute("value",  "1.0");
-
-        return document;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardTextNode() {
-        if (meta.isEmpty()) {
-            return null;
+    private static List<TextEntry> textEntries(Form header) {
+        if (header.meta.isEmpty()) {
+            return emptyList();
        }

-        IIOMetadataNode text = new IIOMetadataNode("Text");
-
-        // /Text/TextEntry@keyword = field name, /Text/TextEntry@value = field value.
-        for (GenericChunk chunk : meta) {
-            IIOMetadataNode node = new IIOMetadataNode("TextEntry");
-            node.setAttribute("keyword", IFFUtil.toChunkStr(chunk.chunkId));
-            node.setAttribute("value", new String(chunk.data, chunk.chunkId == IFF.CHUNK_UTF8 ? StandardCharsets.UTF_8 : StandardCharsets.US_ASCII));
-            text.appendChild(node);
+        List<TextEntry> text = new ArrayList<>();
+        for (GenericChunk chunk : header.meta) {
+            text.add(new TextEntry(toChunkStr(chunk.chunkId),
+                    new String(chunk.data, chunk.chunkId == IFF.CHUNK_UTF8 ? StandardCharsets.UTF_8:StandardCharsets.US_ASCII)));
        }

        return text;
    }
-
-    @Override
-    protected IIOMetadataNode getStandardTransparencyNode() {
-        if ((colorMap == null || !colorMap.hasAlpha()) && header.bitplanes() != 32 && header.bitplanes() != 25) {
-            return null;
-        }
-
-        IIOMetadataNode transparency = new IIOMetadataNode("Transparency");
-
-        if (header.bitplanes() == 25 || header.bitplanes() == 32) {
-            IIOMetadataNode alpha = new IIOMetadataNode("Alpha");
-            alpha.setAttribute("value", header.premultiplied() ? "premultiplied" : "nonpremultiplied");
-            transparency.appendChild(alpha);
-        }
-
-        if  (colorMap != null && colorMap.getTransparency() == Transparency.BITMASK) {
-            IIOMetadataNode transparentIndex = new IIOMetadataNode("TransparentIndex");
-            transparentIndex.setAttribute("value", Integer.toString(colorMap.getTransparentPixel()));
-            transparency.appendChild(transparentIndex);
-        }
-
-        return transparency;
-    }
 }
@@ -38,14 +38,19 @@ import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
 import com.twelvemonkeys.io.enc.DecoderStream;
 import com.twelvemonkeys.io.enc.PackBitsDecoder;

-import javax.imageio.*;
+import javax.imageio.IIOException;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.*;
-import java.awt.color.ColorSpace;
+import java.awt.color.*;
 import java.awt.image.*;
 import java.io.DataInputStream;
+import java.io.EOFException;
 import java.io.File;
 import java.io.IOException;
 import java.util.Arrays;
@@ -350,9 +355,7 @@ public final class IFFImageReader extends ImageReaderBase {

    @Override
    public IIOMetadata getImageMetadata(int imageIndex) throws IOException {
-        init(imageIndex);
-
-        return new IFFImageMetadata(header, header.colorMap());
+        return new IFFImageMetadata(getRawImageType(imageIndex), header, header.colorMap());
    }

    @Override
@@ -1,24 +1,37 @@
 package com.twelvemonkeys.imageio.plugins.iff;

+import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
+
 import org.junit.Test;
 import org.junit.function.ThrowingRunnable;
 import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;

 import javax.imageio.IIOException;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.metadata.IIOMetadataFormatImpl;
 import javax.imageio.metadata.IIOMetadataNode;
-import java.awt.image.IndexColorModel;
+import java.awt.image.*;
 import java.nio.charset.StandardCharsets;

+import static java.awt.image.BufferedImage.*;
 import static org.junit.Assert.*;

 public class IFFImageMetadataTest {
+
+    private static final ImageTypeSpecifier TYPE_8_BIT_GRAY = ImageTypeSpecifiers.createFromBufferedImageType(TYPE_BYTE_GRAY);
+    private static final ImageTypeSpecifier TYPE_8_BIT_PALETTE = ImageTypeSpecifiers.createFromBufferedImageType(TYPE_BYTE_INDEXED);
+    private static final ImageTypeSpecifier TYPE_24_BIT_RGB = ImageTypeSpecifiers.createFromBufferedImageType(TYPE_3BYTE_BGR);
+    private static final ImageTypeSpecifier TYPE_32_BIT_ARGB = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR);
+    private static final ImageTypeSpecifier TYPE_32_BIT_ARGB_DEEP = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR_PRE);
+
    @Test
    public void testStandardFeatures() throws IIOException {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        final IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        final IFFImageMetadata metadata = new IFFImageMetadata(TYPE_24_BIT_RGB, header, header.colorMap());

        // Standard metadata format
        assertTrue(metadata.isStandardMetadataFormatSupported());
@@ -51,9 +64,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_GRAY, header, header.colorMap());

-        IIOMetadataNode chroma = metadata.getStandardChromaNode();
+        IIOMetadataNode chroma = getStandardNode(metadata, "Chroma");
        assertNotNull(chroma);
        assertEquals("Chroma", chroma.getNodeName());
        assertEquals(3, chroma.getLength());
@@ -78,9 +91,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_24_BIT_RGB, header, header.colorMap());

-        IIOMetadataNode chroma = metadata.getStandardChromaNode();
+        IIOMetadataNode chroma = getStandardNode(metadata, "Chroma");
        assertNotNull(chroma);
        assertEquals("Chroma", chroma.getNodeName());
        assertEquals(3, chroma.getLength());
@@ -106,9 +119,10 @@ public class IFFImageMetadataTest {
                          .with(new BMHDChunk(300, 200, 1, BMHDChunk.MASK_TRANSPARENT_COLOR, BMHDChunk.COMPRESSION_BYTE_RUN, 1));

        byte[] bw = {0, (byte) 0xff};
-        IFFImageMetadata metadata = new IFFImageMetadata(header, new IndexColorModel(header.bitplanes(), bw.length, bw, bw, bw, header.transparentIndex()));
+        ImageTypeSpecifier fromIndexColorModel = ImageTypeSpecifiers.createFromIndexColorModel(new IndexColorModel(header.bitplanes(), bw.length, bw, bw, bw, header.transparentIndex()));
+        IFFImageMetadata metadata = new IFFImageMetadata(fromIndexColorModel, header, header.colorMap());

-        IIOMetadataNode chroma = metadata.getStandardChromaNode();
+        IIOMetadataNode chroma = getStandardNode(metadata, "Chroma");
        assertNotNull(chroma);
        assertEquals("Chroma", chroma.getNodeName());
        assertEquals(5, chroma.getLength());
@@ -119,7 +133,7 @@ public class IFFImageMetadataTest {

        IIOMetadataNode numChannels = (IIOMetadataNode) colorSpaceType.getNextSibling();
        assertEquals("NumChannels", numChannels.getNodeName());
-        assertEquals("3", numChannels.getAttribute("value"));
+        assertEquals("4", numChannels.getAttribute("value"));

        IIOMetadataNode blackIsZero = (IIOMetadataNode) numChannels.getNextSibling();
        assertEquals("BlackIsZero", blackIsZero.getNodeName());
@@ -153,9 +167,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_24_BIT_RGB, header, header.colorMap());

-        IIOMetadataNode compression = metadata.getStandardCompressionNode();
+        IIOMetadataNode compression = getStandardNode(metadata, "Compression");
        assertNotNull(compression);
        assertEquals("Compression", compression.getNodeName());
        assertEquals(2, compression.getLength());
@@ -176,9 +190,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_NONE, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_24_BIT_RGB, header, header.colorMap());

-        assertNull(metadata.getStandardCompressionNode()); // No compression, all default...
+        assertNull(getStandardNode(metadata, "Compression")); // No compression, all default...
    }

    @Test
@@ -186,9 +200,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_GRAY, header, header.colorMap());

-        IIOMetadataNode data = metadata.getStandardDataNode();
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
        assertNotNull(data);
        assertEquals("Data", data.getNodeName());
        assertEquals(3, data.getLength());
@@ -213,9 +227,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_24_BIT_RGB, header, header.colorMap());

-        IIOMetadataNode data = metadata.getStandardDataNode();
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
        assertNotNull(data);
        assertEquals("Data", data.getNodeName());
        assertEquals(3, data.getLength());
@@ -240,9 +254,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 32, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_32_BIT_ARGB, header, header.colorMap());

-        IIOMetadataNode data = metadata.getStandardDataNode();
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
        assertNotNull(data);
        assertEquals("Data", data.getNodeName());
        assertEquals(3, data.getLength());
@@ -269,9 +283,10 @@ public class IFFImageMetadataTest {
                              .with(new BMHDChunk(300, 200, i, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

            byte[] rgb = new byte[2 << i]; // Colors doesn't really matter here
-            IFFImageMetadata metadata = new IFFImageMetadata(header, new IndexColorModel(header.bitplanes(), rgb.length, rgb, rgb, rgb, 0));
+            ImageTypeSpecifier fromIndexColorModel = ImageTypeSpecifiers.createFromIndexColorModel(new IndexColorModel(header.bitplanes(), rgb.length, rgb, rgb, rgb, 0));
+            IFFImageMetadata metadata = new IFFImageMetadata(fromIndexColorModel, header, header.colorMap());

-            IIOMetadataNode data = metadata.getStandardDataNode();
+            IIOMetadataNode data = getStandardNode(metadata, "Data");
            assertNotNull(data);
            assertEquals("Data", data.getNodeName());
            assertEquals(3, data.getLength());
@@ -297,9 +312,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_PBM)
                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_GRAY, header, header.colorMap());

-        IIOMetadataNode data = metadata.getStandardDataNode();
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
        assertNotNull(data);
        assertEquals("Data", data.getNodeName());
        assertEquals(3, data.getLength());
@@ -324,9 +339,9 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_PBM)
                          .with(new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_24_BIT_RGB, header, header.colorMap());

-        IIOMetadataNode data = metadata.getStandardDataNode();
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
        assertNotNull(data);
        assertEquals("Data", data.getNodeName());
        assertEquals(3, data.getLength());
@@ -356,10 +371,20 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(bitmapHeader);

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());

-        IIOMetadataNode dimension = metadata.getStandardDimensionNode();
-        assertNull(dimension);
+        IIOMetadataNode dimension = getStandardNode(metadata, "Dimension");
+
+        if (dimension != null) {
+            assertEquals("Dimension", dimension.getNodeName());
+            assertEquals(1, dimension.getLength());
+
+            IIOMetadataNode imageOrientation = (IIOMetadataNode) dimension.getFirstChild();
+            assertEquals("ImageOrientation", imageOrientation.getNodeName());
+            assertEquals("Normal", imageOrientation.getAttribute("value"));
+
+            assertNull(imageOrientation.getNextSibling()); // No more children
+        }
    }

    @Test
@@ -368,20 +393,24 @@ public class IFFImageMetadataTest {
                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0))
                          .with(new CAMGChunk(4));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());

-        IIOMetadataNode dimension = metadata.getStandardDimensionNode();
+        IIOMetadataNode dimension = getStandardNode(metadata, "Dimension");

        // No Dimension node is okay, or one with an aspect ratio of 1.0
        if (dimension != null) {
            assertEquals("Dimension", dimension.getNodeName());
-            assertEquals(1, dimension.getLength());
+            assertEquals(2, dimension.getLength());

            IIOMetadataNode pixelAspectRatio = (IIOMetadataNode) dimension.getFirstChild();
            assertEquals("PixelAspectRatio", pixelAspectRatio.getNodeName());
            assertEquals("1.0", pixelAspectRatio.getAttribute("value"));

-            assertNull(pixelAspectRatio.getNextSibling()); // No more children
+            IIOMetadataNode imageOrientation = (IIOMetadataNode) pixelAspectRatio.getNextSibling();
+            assertEquals("ImageOrientation", imageOrientation.getNodeName());
+            assertEquals("Normal", imageOrientation.getAttribute("value"));
+
+            assertNull(imageOrientation.getNextSibling()); // No more children
        }
    }

@@ -398,18 +427,22 @@ public class IFFImageMetadataTest {
                          .with(bitmapHeader)
                          .with(viewPort);

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());

-        IIOMetadataNode dimension = metadata.getStandardDimensionNode();
+        IIOMetadataNode dimension = getStandardNode(metadata, "Dimension");
        assertNotNull(dimension);
        assertEquals("Dimension", dimension.getNodeName());
-        assertEquals(1, dimension.getLength());
+        assertEquals(2, dimension.getLength());

        IIOMetadataNode pixelAspectRatio = (IIOMetadataNode) dimension.getFirstChild();
        assertEquals("PixelAspectRatio", pixelAspectRatio.getNodeName());
        assertEquals("2.0", pixelAspectRatio.getAttribute("value"));

-        assertNull(pixelAspectRatio.getNextSibling()); // No more children
+        IIOMetadataNode imageOrientation = (IIOMetadataNode) pixelAspectRatio.getNextSibling();
+        assertEquals("ImageOrientation", imageOrientation.getNodeName());
+        assertEquals("Normal", imageOrientation.getAttribute("value"));
+
+        assertNull(imageOrientation.getNextSibling()); // No more children
    }

    @Test
@@ -425,18 +458,22 @@ public class IFFImageMetadataTest {
                          .with(bitmapHeader)
                          .with(viewPort);

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());

-        IIOMetadataNode dimension = metadata.getStandardDimensionNode();
+        IIOMetadataNode dimension = getStandardNode(metadata, "Dimension");
        assertNotNull(dimension);
        assertEquals("Dimension", dimension.getNodeName());
-        assertEquals(1, dimension.getLength());
+        assertEquals(2, dimension.getLength());

        IIOMetadataNode pixelAspectRatio = (IIOMetadataNode) dimension.getFirstChild();
        assertEquals("PixelAspectRatio", pixelAspectRatio.getNodeName());
        assertEquals("0.5", pixelAspectRatio.getAttribute("value"));

-        assertNull(pixelAspectRatio.getNextSibling()); // No more children
+        IIOMetadataNode imageOrientation = (IIOMetadataNode) pixelAspectRatio.getNextSibling();
+        assertEquals("ImageOrientation", imageOrientation.getNodeName());
+        assertEquals("Normal", imageOrientation.getAttribute("value"));
+
+        assertNull(imageOrientation.getNextSibling()); // No more children
    }

    @Test
@@ -447,18 +484,22 @@ public class IFFImageMetadataTest {
                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0))
                          .with(viewPort);

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());

-        IIOMetadataNode dimension = metadata.getStandardDimensionNode();
+        IIOMetadataNode dimension = getStandardNode(metadata, "Dimension");
        assertNotNull(dimension);
        assertEquals("Dimension", dimension.getNodeName());
-        assertEquals(1, dimension.getLength());
+        assertEquals(2, dimension.getLength());

        IIOMetadataNode pixelAspectRatio = (IIOMetadataNode) dimension.getFirstChild();
        assertEquals("PixelAspectRatio", pixelAspectRatio.getNodeName());
        assertEquals("1.0", pixelAspectRatio.getAttribute("value"));

-        assertNull(pixelAspectRatio.getNextSibling()); // No more children
+        IIOMetadataNode imageOrientation = (IIOMetadataNode) pixelAspectRatio.getNextSibling();
+        assertEquals("ImageOrientation", imageOrientation.getNodeName());
+        assertEquals("Normal", imageOrientation.getAttribute("value"));
+
+        assertNull(imageOrientation.getNextSibling()); // No more children
    }

    @Test
@@ -466,32 +507,33 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());

-        IIOMetadataNode document = metadata.getStandardDocumentNode();
+        IIOMetadataNode document = getStandardNode(metadata, "Document");
        assertNotNull(document);
        assertEquals("Document", document.getNodeName());
        assertEquals(1, document.getLength());

-        IIOMetadataNode pixelAspectRatio = (IIOMetadataNode) document.getFirstChild();
-        assertEquals("FormatVersion", pixelAspectRatio.getNodeName());
-        assertEquals("1.0", pixelAspectRatio.getAttribute("value"));
+        IIOMetadataNode formatVersion = (IIOMetadataNode) document.getFirstChild();
+        assertEquals("FormatVersion", formatVersion.getNodeName());
+        assertEquals("1.0", formatVersion.getAttribute("value"));

-        assertNull(pixelAspectRatio.getNextSibling()); // No more children
+        assertNull(formatVersion.getNextSibling()); // No more children
    }

    @Test
    public void testStandardText() throws IIOException {
-        int[] chunks = {IFF.CHUNK_ANNO, IFF.CHUNK_UTF8};
-        String[] texts = {"annotation", "äñnótâtïøñ"};
+        int[] chunks = {IFF.CHUNK_ANNO, IFF.CHUNK_ANNO, IFF.CHUNK_UTF8};
+        String[] texts = {"annotation", "dupe", "äñnótâtïøñ"};
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0))
                .with(new GenericChunk(chunks[0], texts[0].getBytes(StandardCharsets.US_ASCII)))
-                .with(new GenericChunk(chunks[1], texts[1].getBytes(StandardCharsets.UTF_8)));
+                .with(new GenericChunk(chunks[1], texts[1].getBytes(StandardCharsets.US_ASCII)))
+                .with(new GenericChunk(chunks[2], texts[2].getBytes(StandardCharsets.UTF_8)));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());

-        IIOMetadataNode text = metadata.getStandardTextNode();
+        IIOMetadataNode text = getStandardNode(metadata, "Text");
        assertNotNull(text);
        assertEquals("Text", text.getNodeName());
        assertEquals(texts.length, text.getLength());
@@ -509,10 +551,21 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_24_BIT_RGB, header, header.colorMap());

-        IIOMetadataNode transparency = metadata.getStandardTransparencyNode();
-        assertNull(transparency); // No transparency, just defaults
+        IIOMetadataNode transparency = getStandardNode(metadata, "Transparency");
+
+        if (transparency != null) {
+            assertEquals("Transparency", transparency.getNodeName());
+            assertEquals(1, transparency.getLength());
+
+            IIOMetadataNode alpha = (IIOMetadataNode) transparency.getFirstChild();
+            assertEquals("Alpha", alpha.getNodeName());
+            assertEquals("none", alpha.getAttribute("value"));
+
+            assertNull(alpha.getNextSibling()); // No more children
+        }
+        // Otherwise, no transparency, just defaults
    }

    @Test
@@ -520,18 +573,18 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_ILBM)
                          .with(new BMHDChunk(300, 200, 32, BMHDChunk.MASK_HAS_MASK, BMHDChunk.COMPRESSION_BYTE_RUN, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_32_BIT_ARGB, header, header.colorMap());

-        IIOMetadataNode transparency = metadata.getStandardTransparencyNode();
+        IIOMetadataNode transparency = getStandardNode(metadata, "Transparency");
        assertNotNull(transparency);
        assertEquals("Transparency", transparency.getNodeName());
        assertEquals(1, transparency.getLength());

-        IIOMetadataNode pixelAspectRatio = (IIOMetadataNode) transparency.getFirstChild();
-        assertEquals("Alpha", pixelAspectRatio.getNodeName());
-        assertEquals("nonpremultiplied", pixelAspectRatio.getAttribute("value"));
+        IIOMetadataNode alpha = (IIOMetadataNode) transparency.getFirstChild();
+        assertEquals("Alpha", alpha.getNodeName());
+        assertEquals("nonpremultiplied", alpha.getAttribute("value"));

-        assertNull(pixelAspectRatio.getNextSibling()); // No more children
+        assertNull(alpha.getNextSibling()); // No more children
    }

    @Test
@@ -540,28 +593,33 @@ public class IFFImageMetadataTest {
                          .with(new BMHDChunk(300, 200, 1, BMHDChunk.MASK_TRANSPARENT_COLOR, BMHDChunk.COMPRESSION_BYTE_RUN, 1));

        byte[] bw = {0, (byte) 0xff};
-        IFFImageMetadata metadata = new IFFImageMetadata(header, new IndexColorModel(header.bitplanes(), bw.length, bw, bw, bw, header.transparentIndex()));
+        ImageTypeSpecifier fromIndexColorModel = ImageTypeSpecifiers.createFromIndexColorModel(new IndexColorModel(header.bitplanes(), bw.length, bw, bw, bw, header.transparentIndex()));
+        IFFImageMetadata metadata = new IFFImageMetadata(fromIndexColorModel, header, header.colorMap());

-        IIOMetadataNode transparency = metadata.getStandardTransparencyNode();
+        IIOMetadataNode transparency = getStandardNode(metadata, "Transparency");
        assertNotNull(transparency);
        assertEquals("Transparency", transparency.getNodeName());
-        assertEquals(1, transparency.getLength());
+        assertEquals(2, transparency.getLength());

-        IIOMetadataNode pixelAspectRatio = (IIOMetadataNode) transparency.getFirstChild();
-        assertEquals("TransparentIndex", pixelAspectRatio.getNodeName());
-        assertEquals("1", pixelAspectRatio.getAttribute("value"));
+        IIOMetadataNode alpha = (IIOMetadataNode) transparency.getFirstChild();
+        assertEquals("Alpha", alpha.getNodeName());
+        assertEquals("nonpremultiplied", alpha.getAttribute("value"));

-        assertNull(pixelAspectRatio.getNextSibling()); // No more children
+        IIOMetadataNode transparentIndex = (IIOMetadataNode) alpha.getNextSibling();
+        assertEquals("TransparentIndex", transparentIndex.getNodeName());
+        assertEquals("1", transparentIndex.getAttribute("value"));
+
+        assertNull(transparentIndex.getNextSibling()); // No more children
    }

    @Test
    public void testStandardRGB8() throws IIOException {
        Form header = Form.ofType(IFF.TYPE_RGB8)
                          .with(new BMHDChunk(300, 200, 25, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0));
-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_32_BIT_ARGB, header, header.colorMap());

        // Chroma
-        IIOMetadataNode chroma = metadata.getStandardChromaNode();
+        IIOMetadataNode chroma = getStandardNode(metadata, "Chroma");
        assertNotNull(chroma);
        assertEquals("Chroma", chroma.getNodeName());
        assertEquals(3, chroma.getLength());
@@ -581,7 +639,7 @@ public class IFFImageMetadataTest {
        assertNull(blackIsZero.getNextSibling()); // No more children

        // Data
-        IIOMetadataNode data = metadata.getStandardDataNode();
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
        assertNotNull(data);
        assertEquals("Data", data.getNodeName());
        assertEquals(3, data.getLength());
@@ -601,7 +659,7 @@ public class IFFImageMetadataTest {
        assertNull(bitsPerSample.getNextSibling()); // No more children

        // Transparency
-        IIOMetadataNode transparency = metadata.getStandardTransparencyNode();
+        IIOMetadataNode transparency = getStandardNode(metadata, "Transparency");
        assertNotNull(transparency);
        assertEquals("Transparency", transparency.getNodeName());
        assertEquals(1, transparency.getLength());
@@ -624,10 +682,10 @@ public class IFFImageMetadataTest {
        Form header = Form.ofType(IFF.TYPE_DEEP)
                          .with(new DGBLChunk(8))
                          .with(dpel);
-        IFFImageMetadata metadata = new IFFImageMetadata(header, null);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_32_BIT_ARGB_DEEP, header, header.colorMap());

        // Chroma
-        IIOMetadataNode chroma = metadata.getStandardChromaNode();
+        IIOMetadataNode chroma = getStandardNode(metadata, "Chroma");
        assertNotNull(chroma);
        assertEquals("Chroma", chroma.getNodeName());
        assertEquals(3, chroma.getLength());
@@ -649,7 +707,7 @@ public class IFFImageMetadataTest {
        assertNull(blackIsZero.getNextSibling()); // No more children

        // Data
-        IIOMetadataNode data = metadata.getStandardDataNode();
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
        assertNotNull(data);
        assertEquals("Data", data.getNodeName());
        assertEquals(3, data.getLength());
@@ -669,7 +727,7 @@ public class IFFImageMetadataTest {
        assertNull(bitsPerSample.getNextSibling()); // No more children

        // Transparency
-        IIOMetadataNode transparency = metadata.getStandardTransparencyNode();
+        IIOMetadataNode transparency = getStandardNode(metadata, "Transparency");
        assertNotNull(transparency);
        assertEquals("Transparency", transparency.getNodeName());
        assertEquals(1, transparency.getLength());
@@ -680,4 +738,13 @@ public class IFFImageMetadataTest {

        assertNull(alpha.getNextSibling()); // No more children
    }
+
+    // TODO: Test RGB8 + ColorMap
+
+    private IIOMetadataNode getStandardNode(IIOMetadata metadata, String nodeName) {
+        IIOMetadataNode asTree = (IIOMetadataNode) metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);
+        NodeList nodes = asTree.getElementsByTagName(nodeName);
+
+        return nodes.getLength() > 0 ? (IIOMetadataNode) nodes.item(0) : null;
+    }
 }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-jpeg-jai-interop</artifactId>
    <name>TwelveMonkeys :: ImageIO :: JPEG/JAI TIFF Interop</name>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-jpeg-jep262-interop</artifactId>
    <name>TwelveMonkeys :: ImageIO :: JPEG/JEP-262 Interop</name>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-jpeg</artifactId>
    <name>TwelveMonkeys :: ImageIO :: JPEG plugin</name>
@@ -3,7 +3,7 @@
    <parent>
 	<groupId>com.twelvemonkeys.imageio</groupId>
 	<artifactId>imageio</artifactId>        
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>imageio-metadata</artifactId>
@@ -35,8 +35,11 @@ import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;

+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
@@ -50,6 +53,7 @@ import java.util.Iterator;
 import javax.imageio.ImageIO;
 import javax.imageio.stream.ImageInputStream;

+import com.twelvemonkeys.imageio.stream.DirectImageInputStream;
 import org.junit.Test;

 import com.twelvemonkeys.imageio.metadata.CompoundDirectory;
@@ -490,12 +494,15 @@ public class XMPReaderTest extends MetadataReaderAbstractTest {
        assertThat(exif.getEntryById("http://ns.adobe.com/exif/1.0/NativeDigest"), hasValue("36864,40960,40961,37121,37122,40962,40963,37510,40964,36867,36868,33434,33437,34850,34852,34855,34856,37377,37378,37379,37380,37381,37382,37383,37384,37385,37386,37396,41483,41484,41486,41487,41488,41492,41493,41495,41728,41729,41730,41985,41986,41987,41988,41989,41990,41991,41992,41993,41994,41995,41996,42016,0,2,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,20,22,23,24,25,26,27,28,30;A7F21D25E2C562F152B2C4ECC9E534DA"));
    }

-    @Test(timeout = 1500L)
+    @Test(timeout = 2500L)
    public void testNoExternalRequest() throws Exception {
-        // TODO: Use dynamic port?
-        try (HTTPServer server = new HTTPServer(7777)) {
-            try {
-                createReader().read(getResourceAsIIS("/xmp/xmp-jpeg-xxe.xml"));
+        String maliciousXML = resourceAsString("/xmp/xmp-jpeg-xxe.xml");
+
+        try (HTTPServer server = new HTTPServer()) {
+            String dynamicXML = maliciousXML.replace("http://localhost:7777/", "http://localhost:" + server.port() + "/");
+
+            try (DirectImageInputStream input = new DirectImageInputStream(new ByteArrayInputStream(dynamicXML.getBytes(StandardCharsets.UTF_8)));) {
+                createReader().read(input);
            } catch (IOException ioe) {
                if (ioe.getMessage().contains("501")) {
                    throw new AssertionError("Reading should not cause external requests", ioe);
@@ -507,12 +514,26 @@ public class XMPReaderTest extends MetadataReaderAbstractTest {
        }
    }

+    private String resourceAsString(String name) throws IOException {
+        StringBuilder builder = new StringBuilder(1024);
+
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(getResource(name).openStream(), StandardCharsets.UTF_8))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                builder.append(line)
+                        .append('\n');
+            }
+        }
+
+        return builder.toString();
+    }
+
    private static class HTTPServer implements AutoCloseable {
        private final ServerSocket server;
        private final Thread thread;

-        HTTPServer(int port) throws IOException {
-            server = new ServerSocket(port, 1);
+        HTTPServer() throws IOException {
+            server = new ServerSocket(0, 1);
            thread = new Thread(new Runnable() {
                @Override public void run() {
                    serve();
@@ -521,6 +542,10 @@ public class XMPReaderTest extends MetadataReaderAbstractTest {
            thread.start();
        }

+        public final int port() {
+            return server.getLocalPort();
+        }
+
        private void serve() {
            try {
                Socket client = server.accept();
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-pcx</artifactId>
    <name>TwelveMonkeys :: ImageIO :: PCX plugin</name>
@@ -45,7 +45,7 @@ import javax.imageio.metadata.IIOMetadataFormatImpl;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.*;
-import java.awt.color.ColorSpace;
+import java.awt.color.*;
 import java.awt.image.*;
 import java.io.DataInput;
 import java.io.DataInputStream;
@@ -377,10 +377,12 @@ public final class PCXImageReader extends ImageReaderBase {

    @Override
    public IIOMetadata getImageMetadata(final int imageIndex) throws IOException {
-        checkBounds(imageIndex);
-        readHeader();
-
-        return new PCXMetadata(header, getVGAPalette());
+//        checkBounds(imageIndex);
+//        readHeader();
+//
+//        return new PCXMetadata(header, getVGAPalette());
+        ImageTypeSpecifier rawType = getRawImageType(imageIndex);
+        return new PCXMetadata(rawType, header);
    }

    private IndexColorModel getVGAPalette() throws IOException {
@@ -1,236 +1,29 @@
-/*
- * Copyright (c) 2014, 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 of the copyright holder 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 HOLDER 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.pcx;

-import com.twelvemonkeys.imageio.AbstractMetadata;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport;

-import javax.imageio.metadata.IIOMetadataNode;
-import java.awt.image.IndexColorModel;
+import javax.imageio.ImageTypeSpecifier;

-final class PCXMetadata extends AbstractMetadata {
-    private final PCXHeader header;
-    private final IndexColorModel vgaPalette;
-
-    PCXMetadata(final PCXHeader header, final IndexColorModel vgaPalette) {
-        this.header = header;
-        this.vgaPalette = vgaPalette;
+final class PCXMetadata extends StandardImageMetadataSupport {
+    public PCXMetadata(ImageTypeSpecifier type, PCXHeader header) {
+        super(builder(type)
+                      .withPlanarConfiguration(planarConfiguration(header))
+                      .withCompressionTypeName(compressionName(header))
+                      .withFormatVersion(String.valueOf(header.getVersion())));
    }

-    @Override
-    protected IIOMetadataNode getStandardChromaNode() {
-        IIOMetadataNode chroma = new IIOMetadataNode("Chroma");
+    private static PlanarConfiguration planarConfiguration(PCXHeader header) {
+        return header.getChannels() > 1 ? PlanarConfiguration.LineInterleaved : null;
+    }

-        IndexColorModel palette = null;
-        boolean gray = false;
-
-        IIOMetadataNode csType = new IIOMetadataNode("ColorSpaceType");
-        switch (header.getBitsPerPixel()) {
-            case 1:
-            case 2:
-            case 4:
-                palette = header.getEGAPalette();
-                csType.setAttribute("name", "RGB");
-                break;
-            case 8:
-                // We may have IndexColorModel here for 1 channel images
-                if (header.getChannels() == 1 && vgaPalette != null) {
-                    palette = vgaPalette;
-                    csType.setAttribute("name", "RGB");
-                    break;
-                }
-                if (header.getChannels() == 1) {
-                    csType.setAttribute("name", "GRAY");
-                    gray = true;
-                    break;
-                }
-                csType.setAttribute("name", "RGB");
-                break;
-
-            case 24:
-                // Some sources says this is possible... Untested.
-                csType.setAttribute("name", "RGB");
-                break;
-
-            default:
-                csType.setAttribute("name", "Unknown");
+    private static String compressionName(PCXHeader header) {
+        switch (header.getCompression()) {
+            case PCX.COMPRESSION_NONE:
+                return "None";
+            case PCX.COMPRESSION_RLE:
+                return "RLE";
        }

-        chroma.appendChild(csType);
-
-        // NOTE: Channels in chroma node reflects channels in color model, not data! (see data node)
-        IIOMetadataNode numChannels = new IIOMetadataNode("NumChannels");
-        numChannels.setAttribute("value", gray ? "1" : "3");
-        chroma.appendChild(numChannels);
-
-        IIOMetadataNode blackIsZero = new IIOMetadataNode("BlackIsZero");
-        blackIsZero.setAttribute("value", "TRUE");
-        chroma.appendChild(blackIsZero);
-
-        if (palette != null) {
-            IIOMetadataNode paletteNode = new IIOMetadataNode("Palette");
-            chroma.appendChild(paletteNode);
-
-            for (int i = 0; i < palette.getMapSize(); i++) {
-                IIOMetadataNode paletteEntry = new IIOMetadataNode("PaletteEntry");
-                paletteEntry.setAttribute("index", Integer.toString(i));
-
-                paletteEntry.setAttribute("red", Integer.toString(palette.getRed(i)));
-                paletteEntry.setAttribute("green", Integer.toString(palette.getGreen(i)));
-                paletteEntry.setAttribute("blue", Integer.toString(palette.getBlue(i)));
-
-                paletteNode.appendChild(paletteEntry);
-            }
-        }
-
-        return chroma;
-    }
-
-    // No compression
-
-    @Override
-    protected IIOMetadataNode getStandardCompressionNode() {
-        if (header.getCompression() != PCX.COMPRESSION_NONE) {
-            IIOMetadataNode node = new IIOMetadataNode("Compression");
-
-            IIOMetadataNode compressionTypeName = new IIOMetadataNode("CompressionTypeName");
-            compressionTypeName.setAttribute("value", header.getCompression() == PCX.COMPRESSION_RLE ? "RLE" : "Uknown");
-            node.appendChild(compressionTypeName);
-
-            IIOMetadataNode lossless = new IIOMetadataNode("Lossless");
-            lossless.setAttribute("value", "TRUE");
-            node.appendChild(lossless);
-
-            return node;
-        }
-
-        return null;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDataNode() {
-        IIOMetadataNode node = new IIOMetadataNode("Data");
-
-        // Planar configuration only makes sense for multi-channel images
-        if (header.getChannels() > 1) {
-            IIOMetadataNode planarConfiguration = new IIOMetadataNode("PlanarConfiguration");
-            planarConfiguration.setAttribute("value", "LineInterleaved");
-            node.appendChild(planarConfiguration);
-        }
-
-        IIOMetadataNode sampleFormat = new IIOMetadataNode("SampleFormat");
-
-        switch (header.getBitsPerPixel()) {
-            case 1:
-            case 2:
-            case 4:
-                sampleFormat.setAttribute("value", "Index");
-                break;
-            case 8:
-                if (header.getChannels() == 1 && vgaPalette != null) {
-                    sampleFormat.setAttribute("value", "Index");
-                    break;
-                }
-                // Else fall through for GRAY
-            default:
-                sampleFormat.setAttribute("value", "UnsignedIntegral");
-                break;
-        }
-
-        node.appendChild(sampleFormat);
-
-        IIOMetadataNode bitsPerSample = new IIOMetadataNode("BitsPerSample");
-        bitsPerSample.setAttribute("value", createListValue(header.getChannels(), Integer.toString(header.getBitsPerPixel())));
-        node.appendChild(bitsPerSample);
-
-        IIOMetadataNode significantBitsPerSample = new IIOMetadataNode("SignificantBitsPerSample");
-        significantBitsPerSample.setAttribute("value", createListValue(header.getChannels(), Integer.toString(header.getBitsPerPixel())));
-        node.appendChild(significantBitsPerSample);
-
-        IIOMetadataNode sampleMSB = new IIOMetadataNode("SampleMSB");
-        sampleMSB.setAttribute("value", createListValue(header.getChannels(), "0"));
-
-        return node;
-    }
-
-    private String createListValue(final int itemCount, final String... values) {
-        StringBuilder buffer = new StringBuilder();
-
-        for (int i = 0; i < itemCount; i++) {
-            if (buffer.length() > 0) {
-                buffer.append(' ');
-            }
-
-            buffer.append(values[i % values.length]);
-        }
-
-        return buffer.toString();
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDimensionNode() {
-        IIOMetadataNode dimension = new IIOMetadataNode("Dimension");
-
-        IIOMetadataNode imageOrientation = new IIOMetadataNode("ImageOrientation");
-        imageOrientation.setAttribute("value", "Normal");
-        dimension.appendChild(imageOrientation);
-
-        return dimension;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDocumentNode() {
-        IIOMetadataNode dimension = new IIOMetadataNode("Document");
-
-        IIOMetadataNode imageOrientation = new IIOMetadataNode("FormatVersion");
-        imageOrientation.setAttribute("value", String.valueOf(header.getVersion()));
-        dimension.appendChild(imageOrientation);
-
-        return dimension;
-    }
-
-    // No text node
-
-    // No tiling
-
-    @Override
-    protected IIOMetadataNode getStandardTransparencyNode() {
-        // NOTE: There doesn't seem to be any god way to determine transparency, other than by convention
-        // 1 channel: Gray, 2 channel: Gray + Alpha, 3 channel: RGB, 4 channel: RGBA (hopefully never CMYK...)
-
-        IIOMetadataNode transparency = new IIOMetadataNode("Transparency");
-
-        IIOMetadataNode alpha = new IIOMetadataNode("Alpha");
-        alpha.setAttribute("value", header.getChannels() == 1 || header.getChannels() == 3 ? "none" : "nonpremultiplied");
-        transparency.appendChild(alpha);
-
-        return transparency;
+        return "Unknown";
    }
 }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-pdf</artifactId>
    <name>TwelveMonkeys :: ImageIO :: PDF plugin</name>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-pict</artifactId>
    <name>TwelveMonkeys :: ImageIO :: PICT plugin</name>
@@ -67,18 +67,28 @@ import com.twelvemonkeys.io.enc.Decoder;
 import com.twelvemonkeys.io.enc.DecoderStream;
 import com.twelvemonkeys.io.enc.PackBitsDecoder;

-import javax.imageio.*;
+import javax.imageio.IIOException;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.*;
-import java.awt.color.ColorSpace;
-import java.awt.geom.AffineTransform;
-import java.awt.geom.Area;
+import java.awt.color.*;
+import java.awt.geom.*;
 import java.awt.image.*;
-import java.io.*;
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.EOFException;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
-import java.util.*;

 /**
 * Reader for Apple Mac Paint Picture (PICT) format.
@@ -2611,7 +2621,9 @@ public final class PICTImageReader extends ImageReaderBase {
        return getYPtCoord(getPICTFrame().height);
    }

-    public Iterator<ImageTypeSpecifier> getImageTypes(int pIndex) {
+    public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) throws IOException {
+        checkBounds(imageIndex);
+
        // TODO: The images look slightly different in Preview.. Could indicate the color space is wrong...
        return Collections.singletonList(
                ImageTypeSpecifiers.createPacked(
@@ -2623,10 +2635,10 @@ public final class PICTImageReader extends ImageReaderBase {

    @Override
    public IIOMetadata getImageMetadata(final int imageIndex) throws IOException {
-        checkBounds(imageIndex);
+        ImageTypeSpecifier rawType = getRawImageType(imageIndex);
        getPICTFrame(); // TODO: Would probably be better to use readPictHeader here, but it isn't cached

-        return new PICTMetadata(version, screenImageXRatio, screenImageYRatio);
+        return new PICTMetadata(rawType, version, screenImageXRatio, screenImageYRatio);
    }

    protected static void showIt(final BufferedImage pImage, final String pTitle) {
@@ -1,8 +1,38 @@
+/*
+ * Copyright (c) 2022, 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 of the copyright holder 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 HOLDER 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.pict;

-import com.twelvemonkeys.imageio.AbstractMetadata;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport;

-import javax.imageio.metadata.IIOMetadataNode;
+import javax.imageio.ImageTypeSpecifier;

 /**
 * PICTMetadata.
@@ -11,82 +41,13 @@ import javax.imageio.metadata.IIOMetadataNode;
 * @author last modified by $Author: haraldk$
 * @version $Id: PICTMetadata.java,v 1.0 23/03/2021 haraldk Exp$
 */
-public class PICTMetadata extends AbstractMetadata {
-
-    private final int version;
-    private final double screenImageXRatio;
-    private final double screenImageYRatio;
-
-    PICTMetadata(final int version, final double screenImageXRatio, final double screenImageYRatio) {
-        this.version = version;
-        this.screenImageXRatio = screenImageXRatio;
-        this.screenImageYRatio = screenImageYRatio;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardChromaNode() {
-        IIOMetadataNode chroma = new IIOMetadataNode("Chroma");
-
-        IIOMetadataNode csType = new IIOMetadataNode("ColorSpaceType");
-        chroma.appendChild(csType);
-        csType.setAttribute("name", "RGB");
-
-        // NOTE: Channels in chroma node reflects channels in color model (see data node, for channels in data)
-        IIOMetadataNode numChannels = new IIOMetadataNode("NumChannels");
-        chroma.appendChild(numChannels);
-        numChannels.setAttribute("value", "3");
-
-        IIOMetadataNode blackIsZero = new IIOMetadataNode("BlackIsZero");
-        chroma.appendChild(blackIsZero);
-        blackIsZero.setAttribute("value", "TRUE");
-
-        return chroma;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDimensionNode() {
-        if (screenImageXRatio > 0.0d && screenImageYRatio > 0.0d) {
-            IIOMetadataNode node = new IIOMetadataNode("Dimension");
-            double ratio = screenImageXRatio / screenImageYRatio;
-            IIOMetadataNode subNode = new IIOMetadataNode("PixelAspectRatio");
-            subNode.setAttribute("value", "" + ratio);
-            node.appendChild(subNode);
-
-            return node;
-        }
-        return null;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDataNode() {
-        IIOMetadataNode data = new IIOMetadataNode("Data");
-
-        // As this is a vector-ish format, with possibly multiple regions of pixel data, this makes no sense... :-P
-        // This is, however, consistent with the getRawImageTyp/getImageTypes
-
-        IIOMetadataNode planarConfiguration = new IIOMetadataNode("PlanarConfiguration");
-        planarConfiguration.setAttribute("value", "PixelInterleaved");
-        data.appendChild(planarConfiguration);
-
-        IIOMetadataNode sampleFormat = new IIOMetadataNode("SampleFormat");
-        sampleFormat.setAttribute("value", "UnsignedIntegral");
-        data.appendChild(sampleFormat);
-
-        IIOMetadataNode bitsPerSample = new IIOMetadataNode("BitsPerSample");
-        bitsPerSample.setAttribute("value", "32");
-        data.appendChild(bitsPerSample);
-
-        return data;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDocumentNode() {
-        IIOMetadataNode document = new IIOMetadataNode("Document");
-
-        IIOMetadataNode formatVersion = new IIOMetadataNode("FormatVersion");
-        document.appendChild(formatVersion);
-        formatVersion.setAttribute("value", Integer.toString(version));
-
-        return document;
+final class PICTMetadata extends StandardImageMetadataSupport {
+    PICTMetadata(final ImageTypeSpecifier type, final int version, final double screenImageXRatio, final double screenImageYRatio) {
+        super(builder(type)
+                      .withPixelAspectRatio(screenImageXRatio > 0.0d && screenImageYRatio > 0.0d ? screenImageXRatio / screenImageYRatio : 1)
+                      .withFormatVersion(Integer.toString(version))
+        );
+        // As this is a vector-ish format, some of the data makes no sense... :-P
+        // It is, however, consistent with the getRawImageTyp/getImageTypes
    }
 }
@@ -1,3 +1,33 @@
+/*
+ * Copyright (c) 2021, 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 of the copyright holder 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 HOLDER 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.pntg;

 import com.twelvemonkeys.imageio.ImageReaderBase;
@@ -34,7 +64,7 @@ public final class PNTGImageReader extends ImageReaderBase {
    private static final Set<ImageTypeSpecifier> IMAGE_TYPES =
            Collections.singleton(ImageTypeSpecifiers.createIndexed(new int[] {-1, 0}, false, -1, 1, DataBuffer.TYPE_BYTE));

-    protected PNTGImageReader(final ImageReaderSpi provider) {
+    PNTGImageReader(final ImageReaderSpi provider) {
        super(provider);
    }

@@ -123,9 +153,7 @@ public final class PNTGImageReader extends ImageReaderBase {

    @Override
    public IIOMetadata getImageMetadata(final int imageIndex) throws IOException {
-        checkBounds(imageIndex);
-
-        return new PNTGMetadata();
+        return new PNTGMetadata(getRawImageType(imageIndex));
    }

    private void readHeader() throws IOException {
@@ -1,3 +1,33 @@
+/*
+ * Copyright (c) 2021, 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 of the copyright holder 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 HOLDER 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.pntg;

 import com.twelvemonkeys.imageio.spi.ImageReaderSpiBase;
@@ -1,8 +1,38 @@
+/*
+ * Copyright (c) 2022, 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 of the copyright holder 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 HOLDER 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.pntg;

-import com.twelvemonkeys.imageio.AbstractMetadata;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport;

-import javax.imageio.metadata.IIOMetadataNode;
+import javax.imageio.ImageTypeSpecifier;

 /**
 * PNTGMetadata.
@@ -11,76 +41,11 @@ import javax.imageio.metadata.IIOMetadataNode;
 * @author last modified by $Author: haraldk$
 * @version $Id: PNTGMetadata.java,v 1.0 23/03/2021 haraldk Exp$
 */
-public class PNTGMetadata extends AbstractMetadata {
-    @Override
-    protected IIOMetadataNode getStandardChromaNode() {
-        IIOMetadataNode chroma = new IIOMetadataNode("Chroma");
-
-        IIOMetadataNode csType = new IIOMetadataNode("ColorSpaceType");
-        chroma.appendChild(csType);
-        csType.setAttribute("name", "GRAY");
-
-        // NOTE: Channels in chroma node reflects channels in color model (see data node, for channels in data)
-        IIOMetadataNode numChannels = new IIOMetadataNode("NumChannels");
-        chroma.appendChild(numChannels);
-        numChannels.setAttribute("value", "1");
-
-        IIOMetadataNode blackIsZero = new IIOMetadataNode("BlackIsZero");
-        chroma.appendChild(blackIsZero);
-        blackIsZero.setAttribute("value", "FALSE");
-
-        return chroma;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardCompressionNode() {
-        IIOMetadataNode compressionNode = new IIOMetadataNode("Compression");
-
-        IIOMetadataNode compressionTypeName = new IIOMetadataNode("CompressionTypeName");
-        compressionTypeName.setAttribute("value", "PackBits"); // RLE?
-        compressionNode.appendChild(compressionTypeName);
-        compressionNode.appendChild(new IIOMetadataNode("Lossless"));
-        // "value" defaults to TRUE
-
-        return compressionNode;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDataNode() {
-        IIOMetadataNode data = new IIOMetadataNode("Data");
-
-        // PlanarConfiguration
-        IIOMetadataNode planarConfiguration = new IIOMetadataNode("PlanarConfiguration");
-        planarConfiguration.setAttribute("value", "PixelInterleaved");
-        data.appendChild(planarConfiguration);
-
-        IIOMetadataNode sampleFormat = new IIOMetadataNode("SampleFormat");
-        sampleFormat.setAttribute("value", "UnsignedIntegral");
-        data.appendChild(sampleFormat);
-
-        IIOMetadataNode bitsPerSample = new IIOMetadataNode("BitsPerSample");
-        bitsPerSample.setAttribute("value", "1");
-        data.appendChild(bitsPerSample);
-
-        return data;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardDocumentNode() {
-        IIOMetadataNode document = new IIOMetadataNode("Document");
-
-        IIOMetadataNode formatVersion = new IIOMetadataNode("FormatVersion");
-        document.appendChild(formatVersion);
-        formatVersion.setAttribute("value",  "1.0");
-
-        // TODO: We could get the file creation time from MacBinary header here...
-
-        return document;
-    }
-
-    @Override
-    protected IIOMetadataNode getStandardTextNode() {
-        // TODO: We could get the file name from MacBinary header here...
-        return super.getStandardTextNode();
+final class PNTGMetadata extends StandardImageMetadataSupport {
+    public PNTGMetadata(ImageTypeSpecifier type) {
+        super(builder(type)
+                      .withBlackIsZero(false)
+                      .withCompressionTypeName("PackBits")
+                      .withFormatVersion("1.0"));
    }
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Harald Kuhr
+ * Copyright (c) 2021, Harald Kuhr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -1,7 +1,11 @@
 package com.twelvemonkeys.imageio.plugins.pntg;

+import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
+
 import org.junit.Test;

+import java.awt.image.*;
+
 /**
 * PNTGMetadataTest.
 *
@@ -12,6 +16,6 @@ import org.junit.Test;
 public class PNTGMetadataTest {
    @Test
    public void testCreate() {
-        new PNTGMetadata();
+        new PNTGMetadata(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_BINARY));
    }
 }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-pnm</artifactId>
    <name>TwelveMonkeys :: ImageIO :: PNM plugin</name>
@@ -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 {
            }
        }
    }
-
 }
@@ -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;
+    }
 }
@@ -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);
    }

@@ -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('#');
@@ -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;
+    }
 }
@@ -43,7 +43,7 @@ import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.*;
-import java.awt.color.ColorSpace;
+import java.awt.color.*;
 import java.awt.image.*;
 import java.io.DataInput;
 import java.io.DataInputStream;
@@ -468,10 +468,7 @@ public final class PNMImageReader extends ImageReaderBase {

    @Override
    public IIOMetadata getImageMetadata(final int imageIndex) throws IOException {
-        checkBounds(imageIndex);
-        readHeader();
-
-        return new PNMMetadata(header);
+        return new PNMMetadata(getRawImageType(imageIndex), header);
    }

    public static void main(String[] args) throws IOException {
@@ -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();
@@ -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);
    }

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Harald Kuhr
+ * Copyright (c) 2022, Harald Kuhr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -30,92 +30,35 @@

 package com.twelvemonkeys.imageio.plugins.pnm;

-import com.twelvemonkeys.imageio.AbstractMetadata;
+import com.twelvemonkeys.imageio.StandardImageMetadataSupport;

+import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.metadata.IIOMetadataNode;
-import java.awt.*;
-import java.awt.image.DataBuffer;
+import java.awt.image.*;
 import java.nio.ByteOrder;

-final class PNMMetadata extends AbstractMetadata {
+/**
+ * PNMMetadata.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ */
+final class PNMMetadata extends StandardImageMetadataSupport {
    private final PNMHeader header;

-    PNMMetadata(final PNMHeader header) {
+    PNMMetadata(ImageTypeSpecifier type, PNMHeader header) {
+        super(builder(type)
+                      .withColorSpaceType(colorSpace(header))
+                      // TODO: Might make sense to set gamma?
+                      .withBlackIsZero(header.getTupleType() != TupleType.BLACKANDWHITE_WHITE_IS_ZERO)
+                      .withSignificantBitsPerSample(significantBits(header))
+                      .withSampleMSB(header.getByteOrder() == ByteOrder.BIG_ENDIAN ? 0 : header.getBitsPerSample() - 1)
+                      .withOrientation(orientation(header))
+        );
+
        this.header = header;
    }

-    @Override
-    protected IIOMetadataNode getStandardChromaNode() {
-        IIOMetadataNode chroma = new IIOMetadataNode("Chroma");
-
-        IIOMetadataNode csType = new IIOMetadataNode("ColorSpaceType");
-        switch (header.getTupleType()) {
-            case BLACKANDWHITE:
-            case BLACKANDWHITE_ALPHA:
-            case BLACKANDWHITE_WHITE_IS_ZERO:
-            case GRAYSCALE:
-            case GRAYSCALE_ALPHA:
-                csType.setAttribute("name", "GRAY");
-                break;
-            case RGB:
-            case RGB_ALPHA:
-                csType.setAttribute("name", "RGB");
-                break;
-            case CMYK:
-            case CMYK_ALPHA:
-                csType.setAttribute("name", "CMYK");
-                break;
-        }
-
-        if (csType.getAttribute("name") != null) {
-            chroma.appendChild(csType);
-        }
-
-        IIOMetadataNode numChannels = new IIOMetadataNode("NumChannels");
-        numChannels.setAttribute("value", Integer.toString(header.getSamplesPerPixel()));
-        chroma.appendChild(numChannels);
-
-        // TODO: Might make sense to set gamma?
-
-        IIOMetadataNode blackIsZero = new IIOMetadataNode("BlackIsZero");
-        blackIsZero.setAttribute("value", header.getTupleType() == TupleType.BLACKANDWHITE_WHITE_IS_ZERO
-                                          ? "FALSE"
-                                          : "TRUE");
-        chroma.appendChild(blackIsZero);
-
-        return chroma;
-    }
-
-    // No compression
-
-    @Override
-    protected IIOMetadataNode getStandardDataNode() {
-        IIOMetadataNode node = new IIOMetadataNode("Data");
-
-        IIOMetadataNode sampleFormat = new IIOMetadataNode("SampleFormat");
-        sampleFormat.setAttribute("value", header.getTransferType() == DataBuffer.TYPE_FLOAT
-                                           ? "Real"
-                                           : "UnsignedIntegral");
-        node.appendChild(sampleFormat);
-
-        IIOMetadataNode bitsPerSample = new IIOMetadataNode("BitsPerSample");
-        bitsPerSample.setAttribute("value", createListValue(header.getSamplesPerPixel(), Integer.toString(header.getBitsPerSample())));
-        node.appendChild(bitsPerSample);
-
-        IIOMetadataNode significantBitsPerSample = new IIOMetadataNode("SignificantBitsPerSample");
-        significantBitsPerSample.setAttribute("value", createListValue(header.getSamplesPerPixel(), Integer.toString(computeSignificantBits())));
-        node.appendChild(significantBitsPerSample);
-
-        String msb = header.getByteOrder() == ByteOrder.BIG_ENDIAN
-                     ? "0"
-                     : Integer.toString(header.getBitsPerSample() - 1);
-        IIOMetadataNode sampleMSB = new IIOMetadataNode("SampleMSB");
-        sampleMSB.setAttribute("value", createListValue(header.getSamplesPerPixel(), msb));
-
-        return node;
-    }
-
-    private int computeSignificantBits() {
+    private static int significantBits(PNMHeader header) {
        if (header.getTransferType() == DataBuffer.TYPE_FLOAT) {
            return header.getBitsPerSample();
        }
@@ -132,38 +75,30 @@ final class PNMMetadata extends AbstractMetadata {
        return significantBits;
    }

-    private String createListValue(final int itemCount, final String... values) {
-        StringBuilder buffer = new StringBuilder();
-
-        for (int i = 0; i < itemCount; i++) {
-            if (buffer.length() > 0) {
-                buffer.append(' ');
-            }
-
-            buffer.append(values[i % values.length]);
+    private static ColorSpaceType colorSpace(PNMHeader header) {
+        switch (header.getTupleType()) {
+            case BLACKANDWHITE:
+            case BLACKANDWHITE_ALPHA:
+            case BLACKANDWHITE_WHITE_IS_ZERO:
+            case GRAYSCALE:
+            case GRAYSCALE_ALPHA:
+                return ColorSpaceType.GRAY;
+            default:
+                return null; // Fall back to color model's type
        }
-
-        return buffer.toString();
    }

-    @Override
-    protected IIOMetadataNode getStandardDimensionNode() {
-        IIOMetadataNode dimension = new IIOMetadataNode("Dimension");
-
-        IIOMetadataNode imageOrientation = new IIOMetadataNode("ImageOrientation");
-        imageOrientation.setAttribute("value",
-                header.getFileType() == PNM.PFM_GRAY || header.getFileType() == PNM.PFM_RGB
-                ? "FlipH"
-                : "Normal");
-        dimension.appendChild(imageOrientation);
-
-        return dimension;
+    private static ImageOrientation orientation(PNMHeader header) {
+        // For some reason, the float values are stored bottom-up
+        return header.getFileType() == PNM.PFM_GRAY || header.getFileType() == PNM.PFM_RGB
+               ? ImageOrientation.FlipH
+               : ImageOrientation.Normal;
    }

-    // No document node
-
    @Override
    protected IIOMetadataNode getStandardTextNode() {
+        // TODO: Could avoid this override, by changing the StandardImageMetadataSupport to
+        //  use List<Entry<String, String>> instead of Map<String, String> (we use duplicate "comment"s).
        if (!header.getComments().isEmpty()) {
            IIOMetadataNode text = new IIOMetadataNode("Text");

@@ -179,17 +114,4 @@ final class PNMMetadata extends AbstractMetadata {

        return null;
    }
-
-    // No tiling
-
-    @Override
-    protected IIOMetadataNode getStandardTransparencyNode() {
-        IIOMetadataNode transparency = new IIOMetadataNode("Transparency");
-
-        IIOMetadataNode alpha = new IIOMetadataNode("Alpha");
-        alpha.setAttribute("value", header.getTransparency() == Transparency.OPAQUE ? "none" : "nonpremultiplied");
-        transparency.appendChild(alpha);
-
-        return transparency;
-    }
 }
@@ -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;
+    }
 }
@@ -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))));
+    }
 }
@@ -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)
+        );
+    }
+}
@@ -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))));
+    }
 }
@@ -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)
        );
    }
 }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-psd</artifactId>
    <name>TwelveMonkeys :: ImageIO :: PSD plugin</name>
@@ -709,4 +709,6 @@ interface PSD extends com.twelvemonkeys.imageio.metadata.psd.PSD {
    int luni = 'l' << 24 | 'u' << 16 | 'n' << 8 | 'i';
    int lyid = 'l' << 24 | 'y' << 16 | 'i' << 8 | 'd';
    int lsct = 'l' << 24 | 's' << 16 | 'c' << 8 | 't';
+    // Undocumented: Nested section divider setting
+    int lsdk = 'l' << 24 | 's' << 16 | 'd' << 8 | 'k';
 }
@@ -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;
                        }
@@ -155,6 +155,7 @@ final class PSDLayerInfo {
                    layerId = pInput.readInt();
                    break;

+                case PSD.lsdk:
                case PSD.lsct:
                    if (resourceLength < 4) {
                        throw new IIOException(String.format("Expected sectionDividerSetting length >= 4: %d", resourceLength));
@@ -203,6 +203,7 @@ public final class PSDMetadata extends AbstractMetadata {
                    IIOMetadataNode guideNode = new IIOMetadataNode("Guide");
                    guideNode.setAttribute("location", Integer.toString(guide.location));
                    guideNode.setAttribute("orientation", GUIDE_ORIENTATIONS[guide.direction]);
+                    node.appendChild(guideNode);
                }
            }
            else if (imageResource instanceof PSDPixelAspectRatio) {
@@ -32,6 +32,7 @@ package com.twelvemonkeys.imageio.plugins.psd;

 import com.twelvemonkeys.imageio.stream.DirectImageInputStream;
 import com.twelvemonkeys.imageio.stream.SubImageInputStream;
+import com.twelvemonkeys.io.SubStream;
 import com.twelvemonkeys.io.enc.DecoderStream;
 import com.twelvemonkeys.io.enc.PackBitsDecoder;
 import com.twelvemonkeys.lang.StringUtil;
@@ -103,10 +104,12 @@ 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)));
+                int rowLength = (columns * bitsPerSample + 7) / 8;
+                return new DirectImageInputStream(new SequenceInputStream(new LazyPackBitsStreamEnumeration(stream, byteCounts, rowLength)));

            case PSD.COMPRESSION_ZIP:
                return new DirectImageInputStream(new InflaterInputStream(createStreamAdapter(stream, compressedLength)));
@@ -123,11 +126,13 @@ final class PSDUtil {
    private static class LazyPackBitsStreamEnumeration implements Enumeration<InputStream> {
        private final ImageInputStream stream;
        private final int[] byteCounts;
+        private final int rowLength;
        private int index;

-        public LazyPackBitsStreamEnumeration(int[] byteCounts, ImageInputStream stream) {
-            this.byteCounts = byteCounts;
+        public LazyPackBitsStreamEnumeration(ImageInputStream stream, int[] byteCounts, int rowLength) {
            this.stream = stream;
+            this.byteCounts = byteCounts;
+            this.rowLength = rowLength;
        }

        @Override
@@ -137,7 +142,7 @@ final class PSDUtil {

        @Override
        public InputStream nextElement() {
-            return new DecoderStream(createStreamAdapter(stream, byteCounts[index++]), new PackBitsDecoder());
+            return new SubStream(new DecoderStream(createStreamAdapter(stream, byteCounts[index++]), new PackBitsDecoder(), rowLength), rowLength);
        }
    }
 }
@@ -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
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-reference</artifactId>
    <name>TwelveMonkeys :: ImageIO :: JDK Reference Tests</name>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.4-SNAPSHOT</version>
+        <version>3.9.5-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-sgi</artifactId>
    <name>TwelveMonkeys :: ImageIO :: SGI plugin</name>
@@ -33,7 +33,7 @@ package com.twelvemonkeys.imageio.plugins.sgi;
 import javax.imageio.IIOException;
 import javax.imageio.stream.ImageInputStream;
 import java.io.IOException;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;

 final class SGIHeader {
    private int compression;
@@ -157,6 +157,6 @@ final class SGIHeader {
            }
        }

-        return new String(bytes, 0, len, Charset.forName("ASCII"));
+        return new String(bytes, 0, len, StandardCharsets.US_ASCII);
    }
 }
--- a/Show More
+++ b/Show More