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

#712 Core: Fix possible OOM situation in new stream implementation
(cherry picked from commit 8f5c1b409f)
2026-05-01 00:00:02 -04:00 · 2022-11-21 18:51:26 +01:00 · 2022-11-21 18:49:06 +01:00 · 2022-11-21 18:49:06 +01:00 · 2022-11-21 18:44:44 +01:00 · 2022-11-21 18:43:40 +01:00
458 changed files with 13257 additions and 45931 deletions
@@ -7,14 +7,14 @@ assignees: ''

 ---

-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem or use case is. 
+**Is your feature request related to a use case or a problem you are working on? Please describe.**
+A clear and concise description of what the problem or use case is. Understanding the rationale is key, to be able to implemeent the right solution. 

 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.

 **Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
+A clear and concise description of any alternative solutions or features you've already considered, and why they won't work.

 **Additional context**
 Add any other context or screenshots about the feature request here, like links to specifications or sample files.
@@ -0,0 +1,90 @@
+name: CI
+
+on: [ push, pull_request ]
+
+jobs:
+  test:
+    name: Test OpenJDK ${{ matrix.java }} on ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest, windows-latest, macos-latest ]
+        java: [ 8, 11, 17, 18 ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: ${{ matrix.java }}
+          java-package: jdk
+          cache: 'maven'
+      - name: Run Tests
+        run: mvn test
+      - name: Publish Test Report
+        uses: mikepenz/action-junit-report@v3
+        if: ${{ !cancelled() }}
+        with:
+          report_paths: "**/target/surefire-reports/TEST*.xml"
+          check_name: Unit Test Results for OpenJDK ${{ matrix.java }} on ${{ matrix.os }}
+
+  test_oracle:
+    name: Test Oracle JDK 8 with KCMS=${{ matrix.kcms }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        kcms: [ true, false ]
+    steps:
+      - uses: actions/checkout@v3
+      - 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@v3
+        with:
+          distribution: 'jdkfile'
+          jdkFile: ${{ runner.temp }}/java_package.tar.gz
+          java-version: '8'
+          cache: 'maven'
+      - name: Set MAVEN_OPTS
+        if: ${{ matrix.kcms }}
+        run: |
+          echo "MAVEN_OPTS=-Dsun.java2d.cmm=sun.java2d.cmm.kcms.KcmsServiceProvider" >> $GITHUB_ENV
+      - name: Display Java version
+        run: java -version
+      - name: Run Tests
+        run: mvn test
+      - name: Publish Test Report
+        uses: mikepenz/action-junit-report@v3
+        if: ${{ !cancelled() }}
+        with:
+          report_paths: "**/target/surefire-reports/TEST*.xml"
+          check_name: Unit Test Results for Oracle JDK 8 with KCMS=${{ matrix.kcms }}
+
+  release:
+    name: Deploy
+    needs: [ test, test_oracle ]
+    if: github.ref == 'refs/heads/master' # only perform on latest master
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Maven Central
+        uses: actions/setup-java@v3
+        with: # running setup-java again overwrites the settings.xml
+          distribution: 'temurin'
+          java-version: '8'
+          java-package: jdk
+          server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml
+          server-username: MAVEN_CENTRAL_USERNAME # env variable for username in deploy (1)
+          server-password: MAVEN_CENTRAL_PASSWORD # env variable for token in deploy (2)
+          gpg-private-key: ${{ secrets.GPG_KEY }} # Value of the GPG private key to import
+          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
+      - name: Publish to Maven Central
+        if: ${{ endsWith(env.PROJECT_VERSION, '-SNAPSHOT') }}
+        run: mvn 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)
@@ -1,16 +0,0 @@
-dist: trusty
-language: java
-jdk:
-  - oraclejdk8  # LTS until Mar 2022
-  - oraclejdk11 # LTS until Sep 2023
-  - oraclejdk15 # out of support
-  - oraclejdk16 # out of support
-  - oraclejdk17 # LTS until Sep 2026
-jobs:
-  include:
-    # Extra job, testing legacy CMM option
-    - jdk: oraclejdk8
-      env: MAVEN_OPTS=-Dsun.java2d.cmm=sun.java2d.cmm.kcms.KcmsServiceProvider
-cache:
-  directories:
-  - $HOME/.m2
@@ -1,5 +1,6 @@
-[![Build Status](https://travis-ci.com/haraldk/TwelveMonkeys.svg?branch=master)](https://travis-ci.com/github/haraldk/TwelveMonkeys) 
-[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.twelvemonkeys.imageio/imageio/badge.svg?color=slateblue)](https://maven-badges.herokuapp.com/maven-central/com.twelvemonkeys.imageio/imageio)
+[![CI](https://github.com/haraldk/TwelveMonkeys/actions/workflows/ci.yml/badge.svg)](https://github.com/haraldk/TwelveMonkeys/actions/workflows/ci.yml)
+[![Maven Central](https://img.shields.io/maven-central/v/com.twelvemonkeys.imageio/imageio?color=slateblue)](https://search.maven.org/search?q=g:com.twelvemonkeys.imageio)
+[![Maven Snapshot](https://img.shields.io/nexus/s/com.twelvemonkeys.imageio/imageio?label=development&server=https%3A%2F%2Foss.sonatype.org&color=slateblue)](https://oss.sonatype.org/content/repositories/snapshots/com/twelvemonkeys/)
 [![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)

@@ -16,40 +17,40 @@ As there is lots of legacy data out there, we see the need for open implementati

 ## File formats supported

-| Plugin | Format   | Description           | Read | Write | Metadata | Notes |
-| ------ | -------- | -----------           |:----:|:-----:| -------- | ----- |
-| Batik  | **SVG**  | Scalable Vector Graphics | ✔ |  -  | - | Requires [Batik](https://xmlgraphics.apache.org/batik/)
-|        | WMF      | MS Windows Metafile      | ✔ |  -  | - | Requires [Batik](https://xmlgraphics.apache.org/batik/)
-| [BMP](https://github.com/haraldk/TwelveMonkeys/wiki/BMP-Plugin)    | **BMP**  | MS Windows and IBM OS/2 Device Independent Bitmap | ✔  | ✔   | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/bmp_metadata.html) & [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |
-|        | CUR      | MS Windows Cursor Format  | ✔  | -   | - |
-|        | ICO      | MS Windows Icon Format    | ✔  | ✔   | - | 
-| [HDR](https://github.com/haraldk/TwelveMonkeys/wiki/HDR-Plugin)    | HDR      | Radiance High Dynamic Range RGBE Format | ✔  | - | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-| [ICNS](https://github.com/haraldk/TwelveMonkeys/wiki/ICNS-Plugin)   | ICNS     | Apple Icon Image | ✔  | ✔   | -  | 
-| [IFF](https://github.com/haraldk/TwelveMonkeys/wiki/IFF-Plugin)    | IFF      | Commodore Amiga/Electronic Arts Interchange File Format | ✔  | ✔   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-| [JPEG](https://github.com/haraldk/TwelveMonkeys/wiki/JPEG-Plugin)   | **JPEG** | Joint Photographers Expert Group | ✔  | ✔   | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/jpeg_metadata.html#image) & [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|   | JPEG Lossless |   | ✔  |  -  | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/jpeg_metadata.html#image) & [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-| [PCX](https://github.com/haraldk/TwelveMonkeys/wiki/PCX-Plugin)    | PCX      | ZSoft Paintbrush Format | ✔  | -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|        | DCX      | Multi-page PCX fax document | ✔  | -   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-| [PICT](https://github.com/haraldk/TwelveMonkeys/wiki/PICT-Plugin)   | PICT     | Apple QuickTime Picture Format | ✔  | ✔   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|        | PNTG     | Apple MacPaint Picture Format | ✔  |     | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-| [PNM](https://github.com/haraldk/TwelveMonkeys/wiki/PNM-Plugin)    | PAM      | NetPBM Portable Any Map | ✔  | ✔   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|        | PBM      | NetPBM Portable Bit Map | ✔  | -     | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|        | PGM      | NetPBM Portable Grey Map | ✔  | -   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|        | PPM      | NetPBM Portable Pix Map | ✔  | ✔   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|        | PFM      | Portable Float Map | ✔  | -   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-| [PSD](https://github.com/haraldk/TwelveMonkeys/wiki/PSD-Plugin)    | **PSD**  | Adobe Photoshop Document | ✔  | - | Native & [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |  
-|        |  PSB     | Adobe Photoshop Large Document | ✔  | - | Native & [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-| [SGI](https://github.com/haraldk/TwelveMonkeys/wiki/SGI-Plugin)    | SGI      | Silicon Graphics Image Format  | ✔  | -   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-| [TGA](https://github.com/haraldk/TwelveMonkeys/wiki/TGA-Plugin)    | TGA      | Truevision TGA Image Format  | ✔  | ✔   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|ThumbsDB| Thumbs.db| MS Windows Thumbs DB | ✔  | -   | - | OLE2 Compound Document based format only
-| [TIFF](https://github.com/haraldk/TwelveMonkeys/wiki/TIFF-Plugin)   | **TIFF** | Aldus/Adobe Tagged Image File Format | ✔  | ✔ | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/tiff_metadata.html#ImageMetadata) & [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
-|        | BigTIFF  |  | ✔  | - | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/tiff_metadata.html#ImageMetadata) & [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |  
-| [WebP](https://github.com/haraldk/TwelveMonkeys/wiki/WebP-Plugin)   | **WebP** | Google WebP Format | ✔  | - | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |  
-| XWD    | XWD      | X11 Window Dump Format | ✔  | -   | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| Plugin | Format   | Description                                             | R |  W  | Metadata | Notes |
+| ------ | -------- |---------------------------------------------------------|:---:|:---:| -------- | ----- |
+| Batik  | **SVG**  | Scalable Vector Graphics                                | ✔ |  -  | - | Requires [Batik](https://xmlgraphics.apache.org/batik/) |
+|        | WMF      | MS Windows Metafile                                     | ✔ |  -  | - | Requires [Batik](https://xmlgraphics.apache.org/batik/) |
+| [BMP](https://github.com/haraldk/TwelveMonkeys/wiki/BMP-Plugin)    | **BMP**  | MS Windows and IBM OS/2 Device Independent Bitmap       | ✔  |  ✔  | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/bmp_metadata.html), [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |
+|        | CUR      | MS Windows Cursor Format                                | ✔  |  -  | - |
+|        | ICO      | MS Windows Icon Format                                  | ✔  |  ✔  | - | 
+| [HDR](https://github.com/haraldk/TwelveMonkeys/wiki/HDR-Plugin)    | HDR      | Radiance High Dynamic Range RGBE Format                 | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| [ICNS](https://github.com/haraldk/TwelveMonkeys/wiki/ICNS-Plugin)   | ICNS     | Apple Icon Image                                        | ✔  |  ✔  | -  | 
+| [IFF](https://github.com/haraldk/TwelveMonkeys/wiki/IFF-Plugin)    | IFF      | Commodore Amiga/Electronic Arts Interchange File Format | ✔  |  ✔  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| [JPEG](https://github.com/haraldk/TwelveMonkeys/wiki/JPEG-Plugin)   | **JPEG** | Joint Photographers Expert Group                        | ✔  |  ✔  | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/jpeg_metadata.html#image), [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|   | JPEG Lossless |                                                         | ✔  |  -  | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/jpeg_metadata.html#image), [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| [PCX](https://github.com/haraldk/TwelveMonkeys/wiki/PCX-Plugin)    | PCX      | ZSoft Paintbrush Format                                 | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|        | DCX      | Multi-page PCX fax document                             | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| [PICT](https://github.com/haraldk/TwelveMonkeys/wiki/PICT-Plugin)   | PICT     | Apple QuickTime Picture Format                          | ✔  |  ✔  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|        | PNTG     | Apple MacPaint Picture Format                           | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| [PNM](https://github.com/haraldk/TwelveMonkeys/wiki/PNM-Plugin)    | PAM      | NetPBM Portable Any Map                                 | ✔  |  ✔  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|        | PBM      | NetPBM Portable Bit Map                                 | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|        | PGM      | NetPBM Portable Grey Map                                | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|        | PPM      | NetPBM Portable Pix Map                                 | ✔  |  ✔  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|        | PFM      | Portable Float Map                                      | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| [PSD](https://github.com/haraldk/TwelveMonkeys/wiki/PSD-Plugin)    | **PSD**  | Adobe Photoshop Document                                | ✔  | (✔) | Native, [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |  
+|        |  PSB     | Adobe Photoshop Large Document                          | ✔  |  -  | Native, [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| [SGI](https://github.com/haraldk/TwelveMonkeys/wiki/SGI-Plugin)    | SGI      | Silicon Graphics Image Format                           | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+| [TGA](https://github.com/haraldk/TwelveMonkeys/wiki/TGA-Plugin)    | TGA      | Truevision TGA Image Format                             | ✔  |  ✔  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|ThumbsDB| Thumbs.db| MS Windows Thumbs DB                                    | ✔  |  -  | - | OLE2 Compound Document based format only |
+| [TIFF](https://github.com/haraldk/TwelveMonkeys/wiki/TIFF-Plugin)   | **TIFF** | Aldus/Adobe Tagged Image File Format                    | ✔  |  ✔  | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/tiff_metadata.html#ImageMetadata), [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
+|        | BigTIFF  |                                                         | ✔  |  ✔  | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/tiff_metadata.html#ImageMetadata), [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |  
+| [WebP](https://github.com/haraldk/TwelveMonkeys/wiki/WebP-Plugin)   | **WebP** | Google WebP Format                                      | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |  
+| XWD    | XWD      | X11 Window Dump Format                                  | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 


 **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).
@@ -271,12 +272,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.7.0</version>
+        <version>3.8.1</version>
    </dependency>
    <dependency>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio-tiff</artifactId>
-        <version>3.7.0</version>
+        <version>3.8.1</version>
    </dependency>

    <!--
@@ -286,7 +287,17 @@ 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.7.0</version>
+        <version>3.8.1</version>
+    </dependency>
+
+    <!--
+    Or Jakarta version, for Servlet API 5.0
+    -->
+    <dependency>
+        <groupId>com.twelvemonkeys.servlet</groupId>
+        <artifactId>servlet</artifactId>
+        <version>3.8.1</version>
+        <classifier>jakarta</classifier>
    </dependency>
 </dependencies>
 ```
@@ -295,13 +306,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.7.0.jar
-    twelvemonkeys-common-io-3.7.0.jar
-    twelvemonkeys-common-image-3.7.0.jar
-    twelvemonkeys-imageio-core-3.7.0.jar
-    twelvemonkeys-imageio-metadata-3.7.0.jar
-    twelvemonkeys-imageio-jpeg-3.7.0.jar
-    twelvemonkeys-imageio-tiff-3.7.0.jar
+    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

 #### Deploying the plugins in a web app

@@ -367,44 +378,44 @@ Other "fat" JAR bundlers will probably have similar mechanisms to merge entries

 ### Links to prebuilt binaries

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

 Requires Java 7 or later.
 
 Common dependencies
-* [common-lang-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.7.0/common-lang-3.7.0.jar)
-* [common-io-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.7.0/common-io-3.7.0.jar)
-* [common-image-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.7.0/common-image-3.7.0.jar)
+* [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)

 ImageIO dependencies
-* [imageio-core-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.7.0/imageio-core-3.7.0.jar)
-* [imageio-metadata-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.7.0/imageio-metadata-3.7.0.jar)
+* [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 plugins
-* [imageio-bmp-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-bmp/3.7.0/imageio-bmp-3.7.0.jar)
-* [imageio-hdr-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-hdr/3.7.0/imageio-hdr-3.7.0.jar)
-* [imageio-icns-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.7.0/imageio-icns-3.7.0.jar)
-* [imageio-iff-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.7.0/imageio-iff-3.7.0.jar)
-* [imageio-jpeg-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.7.0/imageio-jpeg-3.7.0.jar)
-* [imageio-pcx-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pcx/3.7.0/imageio-pcx-3.7.0.jar)
-* [imageio-pict-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.7.0/imageio-pict-3.7.0.jar)
-* [imageio-pnm-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pnm/3.7.0/imageio-pnm-3.7.0.jar)
-* [imageio-psd-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.7.0/imageio-psd-3.7.0.jar)
-* [imageio-sgi-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-sgi/3.7.0/imageio-sgi-3.7.0.jar)
-* [imageio-tga-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tga/3.7.0/imageio-tga-3.7.0.jar)
-* [imageio-thumbsdb-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.7.0/imageio-thumbsdb-3.7.0.jar)
-* [imageio-tiff-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.7.0/imageio-tiff-3.7.0.jar)
-* [imageio-webp-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-webp/3.7.0/imageio-webp-3.7.0.jar)
-* [imageio-xwd-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-xwd/3.7.0/imageio-xwd-3.7.0.jar)
+* [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 plugins requiring 3rd party libs
-* [imageio-batik-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.7.0/imageio-batik-3.7.0.jar)
+* [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)

 Photoshop Path support for ImageIO
-* [imageio-clippath-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-clippath/3.7.0/imageio-clippath-3.7.0.jar)
+* [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)

 Servlet support
-* [servlet-3.7.0.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.7.0/servlet-3.7.0.jar)
+* [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)

@@ -512,7 +523,7 @@ 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.
@@ -5,7 +5,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</version>
    </parent>

    <groupId>com.twelvemonkeys.bom</groupId>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</version>
    </parent>
    <artifactId>common-image</artifactId>
    <packaging>jar</packaging>
@@ -31,7 +31,7 @@
        <dependency>
            <groupId>jmagick</groupId>
            <artifactId>jmagick</artifactId>
-            <version>6.2.4</version>
+            <version>6.6.9</version>
            <optional>true</optional>
            <scope>provided</scope>
        </dependency>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</version>
    </parent>
    <artifactId>common-io</artifactId>
    <packaging>jar</packaging>
@@ -34,6 +34,7 @@ import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.Arrays;

 /**
 * An unsynchronized {@code ByteArrayOutputStream} implementation. This version
@@ -42,11 +43,8 @@ import java.io.OutputStream;
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @version $Id: FastByteArrayOutputStream.java#2 $
 */
-// TODO: Performance test of a stream impl that uses list of fixed size blocks, rather than contiguous block 
+// TODO: Performance test of a stream impl that uses list of fixed size blocks, rather than contiguous block
 public final class FastByteArrayOutputStream extends ByteArrayOutputStream {
-    /** Max grow size (unless if writing more than this amount of bytes) */
-    protected int maxGrowSize = 1024 * 1024; // 1 MB
-
    /**
     * Creates a {@code ByteArrayOutputStream} with the given initial buffer
     * size.
@@ -97,10 +95,8 @@ public final class FastByteArrayOutputStream extends ByteArrayOutputStream {

    private void growIfNeeded(int pNewCount) {
        if (pNewCount > buf.length) {
-            int newSize = Math.max(Math.min(buf.length << 1, buf.length + maxGrowSize), pNewCount);
-            byte[] newBuf = new byte[newSize];
-            System.arraycopy(buf, 0, newBuf, 0, count);
-            buf = newBuf;
+            int newSize = Math.max(buf.length << 1, pNewCount);
+            buf = Arrays.copyOf(buf, newSize);
        }
    }

@@ -113,10 +109,7 @@ public final class FastByteArrayOutputStream extends ByteArrayOutputStream {
    // Non-synchronized version of toByteArray
    @Override
    public byte[] toByteArray() {
-        byte[] newBuf = new byte[count];
-        System.arraycopy(buf, 0, newBuf, 0, count);
-
-        return newBuf;
+        return Arrays.copyOf(buf, count);
    }

    /**
@@ -45,39 +45,39 @@ import java.nio.ByteBuffer;
 * @version $Id: //depot/branches/personal/haraldk/twelvemonkeys/release-2/twelvemonkeys-core/src/main/java/com/twelvemonkeys/io/enc/DecoderStream.java#2 $
 */
 public final class DecoderStream extends FilterInputStream {
-    protected final ByteBuffer buffer;
-    protected final Decoder decoder;
+    private final ByteBuffer buffer;
+    private final Decoder decoder;

    /**
     * Creates a new decoder stream and chains it to the
-     * input stream specified by the {@code pStream} argument.
+     * input stream specified by the {@code stream} argument.
     * The stream will use a default decode buffer size.
     *
-     * @param pStream the underlying input stream.
-     * @param pDecoder the decoder that will be used to decode the underlying stream
+     * @param stream the underlying input stream.
+     * @param decoder the decoder that will be used to decode the underlying stream
     *
     * @see java.io.FilterInputStream#in
     */
-    public DecoderStream(final InputStream pStream, final Decoder pDecoder) {
+    public DecoderStream(final InputStream stream, final Decoder decoder) {
        // TODO: Let the decoder decide preferred buffer size 
-        this(pStream, pDecoder, 1024);
+        this(stream, decoder, 1024);
    }

    /**
     * Creates a new decoder stream and chains it to the
-     * input stream specified by the {@code pStream} argument.
+     * input stream specified by the {@code stream} argument.
     *
-     * @param pStream the underlying input stream.
-     * @param pDecoder the decoder that will be used to decode the underlying stream
-     * @param pBufferSize the size of the decode buffer
+     * @param stream the underlying input stream.
+     * @param decoder the decoder that will be used to decode the underlying stream
+     * @param bufferSize the size of the decode buffer
     *
     * @see java.io.FilterInputStream#in
     */
-    public DecoderStream(final InputStream pStream, final Decoder pDecoder, final int pBufferSize) {
-        super(pStream);
+    public DecoderStream(final InputStream stream, final Decoder decoder, final int bufferSize) {
+        super(stream);

-        decoder = pDecoder;
-        buffer = ByteBuffer.allocate(pBufferSize);
+        this.decoder = decoder;
+        buffer = ByteBuffer.allocate(bufferSize);
        buffer.flip();
    }

@@ -95,15 +95,15 @@ public final class DecoderStream extends FilterInputStream {
        return buffer.get() & 0xff;
    }

-    public int read(final byte pBytes[], final int pOffset, final int pLength) throws IOException {
-        if (pBytes == null) {
+    public int read(final byte[] bytes, final int offset, final int length) throws IOException {
+        if (bytes == null) {
            throw new NullPointerException();
        }
-        else if ((pOffset < 0) || (pOffset > pBytes.length) || (pLength < 0) ||
-                ((pOffset + pLength) > pBytes.length) || ((pOffset + pLength) < 0)) {
-            throw new IndexOutOfBoundsException("bytes.length=" + pBytes.length + " offset=" + pOffset + " length=" + pLength);
+        else if ((offset < 0) || (offset > bytes.length) || (length < 0) ||
+                ((offset + length) > bytes.length) || ((offset + length) < 0)) {
+            throw new IndexOutOfBoundsException("bytes.length=" + bytes.length + " offset=" + offset + " length=" + length);
        }
-        else if (pLength == 0) {
+        else if (length == 0) {
            return 0;
        }

@@ -114,11 +114,11 @@ public final class DecoderStream extends FilterInputStream {
            }
        }

-        // Read until we have read pLength bytes, or have reached EOF
+        // Read until we have read length bytes, or have reached EOF
        int count = 0;
-        int off = pOffset;
+        int off = offset;

-        while (pLength > count) {
+        while (length > count) {
            if (!buffer.hasRemaining()) {
                if (fill() < 0) {
                    break;
@@ -126,8 +126,8 @@ public final class DecoderStream extends FilterInputStream {
            }

            // Copy as many bytes as possible
-            int dstLen = Math.min(pLength - count, buffer.remaining());
-            buffer.get(pBytes, off, dstLen);
+            int dstLen = Math.min(length - count, buffer.remaining());
+            buffer.get(bytes, off, dstLen);

            // Update offset (rest)
            off += dstLen;
@@ -139,7 +139,7 @@ public final class DecoderStream extends FilterInputStream {
        return count;
    }

-    public long skip(final long pLength) throws IOException {
+    public long skip(final long length) throws IOException {
        // End of file?
        if (!buffer.hasRemaining()) {
            if (fill() < 0) {
@@ -147,10 +147,10 @@ public final class DecoderStream extends FilterInputStream {
            }
        }

-        // Skip until we have skipped pLength bytes, or have reached EOF
+        // Skip until we have skipped length bytes, or have reached EOF
        long total = 0;

-        while (total < pLength) {
+        while (total < length) {
            if (!buffer.hasRemaining()) {
                if (fill() < 0) {
                    break;
@@ -158,7 +158,7 @@ public final class DecoderStream extends FilterInputStream {
            }

            // NOTE: Skipped can never be more than avail, which is an int, so the cast is safe
-            int skipped = (int) Math.min(pLength - total, buffer.remaining());
+            int skipped = (int) Math.min(length - total, buffer.remaining());
            buffer.position(buffer.position() + skipped);
            total += skipped;
        }
@@ -174,7 +174,7 @@ public final class DecoderStream extends FilterInputStream {
     *
     * @throws IOException if an I/O error occurs
     */
-    protected int fill() throws IOException {
+    private int fill() throws IOException {
        buffer.clear();
        int read = decoder.decode(in, buffer);

@@ -45,41 +45,39 @@ import java.nio.ByteBuffer;
 * @version $Id: //depot/branches/personal/haraldk/twelvemonkeys/release-2/twelvemonkeys-core/src/main/java/com/twelvemonkeys/io/enc/EncoderStream.java#2 $
 */
 public final class EncoderStream extends FilterOutputStream {
-    // TODO: This class need a test case ASAP!!!

-    protected final Encoder encoder;
+    private final Encoder encoder;
    private final boolean flushOnWrite;

-    protected final ByteBuffer buffer;
+    private final ByteBuffer buffer;

    /**
     * Creates an output stream filter built on top of the specified
     * underlying output stream.
     *
-     * @param pStream the underlying output stream
-     * @param pEncoder the encoder to use
+     * @param stream the underlying output stream
+     * @param encoder the encoder to use
     */
-    public EncoderStream(final OutputStream pStream, final Encoder pEncoder) {
-        this(pStream, pEncoder, false);
+    public EncoderStream(final OutputStream stream, final Encoder encoder) {
+        this(stream, encoder, false);
    }

    /**
     * Creates an output stream filter built on top of the specified
     * underlying output stream.
     *
-     * @param pStream the underlying output stream
-     * @param pEncoder the encoder to use
-     * @param pFlushOnWrite if {@code true}, calls to the byte-array
+     * @param stream the underlying output stream
+     * @param encoder the encoder to use
+     * @param flushOnWrite if {@code true}, calls to the byte-array
     * {@code write} methods will automatically flush the buffer.
     */
-    public EncoderStream(final OutputStream pStream, final Encoder pEncoder, final boolean pFlushOnWrite) {
-        super(pStream);
+    public EncoderStream(final OutputStream stream, final Encoder encoder, final boolean flushOnWrite) {
+        super(stream);

-        encoder = pEncoder;
-        flushOnWrite = pFlushOnWrite;
+        this.encoder = encoder;
+        this.flushOnWrite = flushOnWrite;

        buffer = ByteBuffer.allocate(1024);
-        buffer.flip();
    }

    public void close() throws IOException {
@@ -104,33 +102,33 @@ public final class EncoderStream extends FilterOutputStream {
        }
    }

-    public final void write(final byte[] pBytes) throws IOException {
-        write(pBytes, 0, pBytes.length);
+    public void write(final byte[] bytes) throws IOException {
+        write(bytes, 0, bytes.length);
    }

    // TODO: Verify that this works for the general case (it probably won't)...
    // TODO: We might need a way to explicitly flush the encoder, or specify
    // that the encoder can't buffer. In that case, the encoder should probably
-    // tell the EncoderStream how large buffer it prefers... 
-    public void write(final byte[] pBytes, final int pOffset, final int pLength) throws IOException {
-        if (!flushOnWrite && pLength < buffer.remaining()) {
+    // tell the EncoderStream how large buffer it prefers...
+    public void write(final byte[] values, final int offset, final int length) throws IOException {
+        if (!flushOnWrite && length < buffer.remaining()) {
            // Buffer data
-            buffer.put(pBytes, pOffset, pLength);
+            buffer.put(values, offset, length);
        }
        else {
            // Encode data already in the buffer
            encodeBuffer();

            // Encode rest without buffering
-            encoder.encode(out, ByteBuffer.wrap(pBytes, pOffset, pLength));
+            encoder.encode(out, ByteBuffer.wrap(values, offset, length));
        }
    }

-    public void write(final int pByte) throws IOException {
+    public void write(final int value) throws IOException {
        if (!buffer.hasRemaining()) {
            encodeBuffer(); // Resets bufferPos to 0
        }

-        buffer.put((byte) pByte);
+        buffer.put((byte) value);
    }
 }
@@ -0,0 +1,130 @@
+/*
+ * 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.io.enc;
+
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Random;
+
+import static org.junit.Assert.*;
+
+public class DecoderStreamTest {
+
+    private final Random rng = new Random(5467809876546L);
+
+    private byte[] createData(final int length) {
+        byte[] data = new byte[length];
+        rng.nextBytes(data);
+        return data;
+    }
+
+    @Test
+    public void testDecodeSingleBytes() throws IOException {
+        byte[] data = createData(1327);
+
+        InputStream source = new ByteArrayInputStream(data);
+        try (InputStream stream = new DecoderStream(source, new NullDecoder())) {
+            for (byte datum : data) {
+                int read = stream.read();
+                assertNotEquals(-1, read);
+                assertEquals(datum, (byte) read);
+            }
+
+            assertEquals(-1, stream.read());
+        }
+    }
+
+    @Test
+    public void testDecodeArray() throws IOException {
+        int length = 793;
+        byte[] data = createData(length * 10);
+
+        InputStream source = new ByteArrayInputStream(data);
+        byte[] result = new byte[477];
+
+        try (InputStream stream = new DecoderStream(source, new NullDecoder())) {
+            int dataOffset = 0;
+            while (dataOffset < data.length) {
+                int count = stream.read(result);
+
+                assertFalse(count <= 0);
+                assertArrayEquals(Arrays.copyOfRange(data, dataOffset, dataOffset + count), Arrays.copyOfRange(result, 0, count));
+
+                dataOffset += count;
+            }
+
+            assertEquals(-1, stream.read());
+        }
+    }
+
+    @Test
+    public void testDecodeArrayOffset() throws IOException {
+        int length = 793;
+        byte[] data = createData(length * 10);
+
+        InputStream source = new ByteArrayInputStream(data);
+        byte[] result = new byte[477];
+
+        try (InputStream stream = new DecoderStream(source, new NullDecoder())) {
+            int dataOffset = 0;
+            while (dataOffset < data.length) {
+                int resultOffset = dataOffset % result.length;
+                int count = stream.read(result, resultOffset, result.length - resultOffset);
+
+                assertFalse(count <= 0);
+                assertArrayEquals(Arrays.copyOfRange(data, dataOffset + resultOffset, dataOffset + count), Arrays.copyOfRange(result, resultOffset, count));
+
+                dataOffset += count;
+            }
+
+            assertEquals(-1, stream.read());
+        }
+    }
+
+    private static final class NullDecoder implements Decoder {
+        @Override
+        public int decode(InputStream stream, ByteBuffer buffer) throws IOException {
+            int read = stream.read(buffer.array(), buffer.arrayOffset(), buffer.remaining());
+
+            if (read > 0) {
+                // Set position, should be equivalent to using buffer.put(stream.read()) until EOF or buffer full
+                buffer.position(read);
+            }
+
+            return read;
+        }
+    }
+}
@@ -0,0 +1,111 @@
+/*
+ * 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.io.enc;
+
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Random;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class EncoderStreamTest {
+
+    private final Random rng = new Random(5467809876546L);
+
+    private byte[] createData(final int length) {
+        byte[] data = new byte[length];
+        rng.nextBytes(data);
+        return data;
+    }
+
+    @Test
+    public void testEncodeSingleBytes() throws IOException {
+        byte[] data = createData(1327);
+
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+        try (OutputStream stream = new EncoderStream(result, new NullEncoder())) {
+            for (byte datum : data) {
+                stream.write(datum);
+            }
+        }
+
+        assertArrayEquals(data, result.toByteArray());
+    }
+
+    @Test
+    public void testEncodeArray() throws IOException {
+        byte[] data = createData(1793);
+
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+        try (OutputStream stream = new EncoderStream(result, new NullEncoder())) {
+            for (int i = 0; i < 10; i++) {
+                stream.write(data);
+            }
+        }
+
+        byte[] encoded = result.toByteArray();
+
+        for (int i = 0; i < 10; i++) {
+            assertArrayEquals(data, Arrays.copyOfRange(encoded, i * data.length, (i + 1) * data.length));
+        }
+    }
+
+    @Test
+    public void testEncodeArrayOffset() throws IOException {
+        byte[] data = createData(87);
+
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+        try (OutputStream stream = new EncoderStream(result, new NullEncoder())) {
+            for (int i = 0; i < 10; i++) {
+                stream.write(data, 13, 59);
+            }
+        }
+
+        byte[] original = Arrays.copyOfRange(data, 13, 13 + 59);
+        byte[] encoded = result.toByteArray();
+
+        for (int i = 0; i < 10; i++) {
+            assertArrayEquals(original, Arrays.copyOfRange(encoded, i * original.length, (i + 1) * original.length));
+        }
+    }
+
+    private static final class NullEncoder implements Encoder {
+        @Override
+        public void encode(OutputStream stream, ByteBuffer buffer) throws IOException {
+            stream.write(buffer.array(), buffer.arrayOffset(), buffer.remaining());
+        }
+    }
+}
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</version>
    </parent>
    <artifactId>common-lang</artifactId>
    <packaging>jar</packaging>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</version>
    </parent>
    <groupId>com.twelvemonkeys.common</groupId>
    <artifactId>common</artifactId>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</version>
    </parent>
    <groupId>com.twelvemonkeys.contrib</groupId>
    <artifactId>contrib</artifactId>
@@ -30,9 +30,14 @@ import static com.twelvemonkeys.contrib.tiff.TIFFUtilities.applyOrientation;
 public class EXIFUtilities {
    /**
     * Reads image and metadata, applies Exif orientation to image, and returns everything as an {@code IIOImage}.
+     * The returned {@code IIOImage} will always contain an image and no raster, and
+     * the {@code RenderedImage} may be safely cast to a {@code BufferedImage}.
+     *
+     * If no registered {@code ImageReader} claims to be able to read the input, {@code null} is returned.
     *
     * @param input a {@code URL}
-     * @return an {@code IIOImage} containing the correctly oriented image and metadata including rotation info.
+     * @return an {@code IIOImage} containing the correctly oriented image and metadata including rotation info, or
+     * {@code null}.
     * @throws IOException if an error occurs during reading.
     */
    public static IIOImage readWithOrientation(final URL input) throws IOException {
@@ -43,9 +48,14 @@ public class EXIFUtilities {

    /**
     * Reads image and metadata, applies Exif orientation to image, and returns everything as an {@code IIOImage}.
+     * The returned {@code IIOImage} will always contain an image and no raster, and
+     * the {@code RenderedImage} may be safely cast to a {@code BufferedImage}.
+     *
+     * If no registered {@code ImageReader} claims to be able to read the input, {@code null} is returned.
     *
     * @param input an {@code InputStream}
-     * @return an {@code IIOImage} containing the correctly oriented image and metadata including rotation info.
+     * @return an {@code IIOImage} containing the correctly oriented image and metadata including rotation info, or
+     * {@code null}.
     * @throws IOException if an error occurs during reading.
     */
    public static IIOImage readWithOrientation(final InputStream input) throws IOException {
@@ -56,9 +66,14 @@ public class EXIFUtilities {

    /**
     * Reads image and metadata, applies Exif orientation to image, and returns everything as an {@code IIOImage}.
+     * The returned {@code IIOImage} will always contain an image and no raster, and
+     * the {@code RenderedImage} may be safely cast to a {@code BufferedImage}.
+     *
+     * If no registered {@code ImageReader} claims to be able to read the input, {@code null} is returned.
     *
     * @param input a {@code File}
-     * @return an {@code IIOImage} containing the correctly oriented image and metadata including rotation info.
+     * @return an {@code IIOImage} containing the correctly oriented image and metadata including rotation info or
+     * {@code null}.
     * @throws IOException if an error occurs during reading.
     */
    public static IIOImage readWithOrientation(final File input) throws IOException {
@@ -69,9 +84,14 @@ public class EXIFUtilities {

    /**
     * Reads image and metadata, applies Exif orientation to image, and returns everything as an {@code IIOImage}.
+     * The returned {@code IIOImage} will always contain an image and no raster, and
+     * the {@code RenderedImage} may be safely cast to a {@code BufferedImage}.
+     *
+     * If no registered {@code ImageReader} claims to be able to read the input, {@code null} is returned.
     *
     * @param input an {@code ImageInputStream}
-     * @return an {@code IIOImage} containing the correctly oriented image and metadata including rotation info.
+     * @return an {@code IIOImage} containing the correctly oriented image and metadata including rotation info, or
+     * {@code null}.
     * @throws IOException if an error occurs during reading.
     */
    public static IIOImage readWithOrientation(final ImageInputStream input) throws IOException {
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</version>
    </parent>
    <artifactId>imageio-batik</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Batik Plugin</name>
@@ -17,7 +17,7 @@

    <properties>
        <project.jpms.module.name>com.twelvemonkeys.imageio.batik</project.jpms.module.name>
-        <batik.version>1.14</batik.version>
+        <batik.version>1.16</batik.version>
    </properties>

    <build>
@@ -27,9 +27,9 @@
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <systemPropertyVariables>
-                        <com.twelvemonkeys.imageio.plugins.svg.allowexternalresources>
+                        <com.twelvemonkeys.imageio.plugins.svg.allowExternalResources>
                            true
-                        </com.twelvemonkeys.imageio.plugins.svg.allowexternalresources>
+                        </com.twelvemonkeys.imageio.plugins.svg.allowExternalResources>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
@@ -48,6 +48,13 @@
            <scope>test</scope>
        </dependency>

+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.11.0</version>
+            <scope>provided</scope>
+        </dependency>
+
        <dependency>
            <groupId>org.apache.xmlgraphics</groupId>
            <artifactId>batik-rasterizer-ext</artifactId>
@@ -30,21 +30,10 @@

 package com.twelvemonkeys.imageio.plugins.svg;

-import java.awt.*;
-import java.awt.geom.AffineTransform;
-import java.awt.geom.Rectangle2D;
-import java.awt.image.BufferedImage;
-import java.io.IOException;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.Map;
-
-import javax.imageio.IIOException;
-import javax.imageio.ImageReadParam;
-import javax.imageio.ImageTypeSpecifier;
-import javax.imageio.spi.ImageReaderSpi;
+import com.twelvemonkeys.image.ImageUtil;
+import com.twelvemonkeys.imageio.ImageReaderBase;
+import com.twelvemonkeys.imageio.util.IIOUtil;
+import com.twelvemonkeys.lang.StringUtil;

 import org.apache.batik.anim.dom.SVGDOMImplementation;
 import org.apache.batik.anim.dom.SVGOMDocument;
@@ -68,10 +57,19 @@ import org.w3c.dom.DOMImplementation;
 import org.w3c.dom.Document;
 import org.w3c.dom.svg.SVGSVGElement;

-import com.twelvemonkeys.image.ImageUtil;
-import com.twelvemonkeys.imageio.ImageReaderBase;
-import com.twelvemonkeys.imageio.util.IIOUtil;
-import com.twelvemonkeys.lang.StringUtil;
+import javax.imageio.IIOException;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.spi.ImageReaderSpi;
+import java.awt.*;
+import java.awt.geom.*;
+import java.awt.image.*;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;

 /**
 * Image reader for SVG document fragments.
@@ -79,12 +77,13 @@ import com.twelvemonkeys.lang.StringUtil;
 * @author Harald Kuhr
 * @author Inpspired by code from the Batik Team
 * @version $Id: $
- * @see <A href="http://www.mail-archive.com/batik-dev@xml.apache.org/msg00992.html">batik-dev</A>
+ * @see <a href="http://www.mail-archive.com/batik-dev@xml.apache.org/msg00992.html">batik-dev</a>
 */
 public class SVGImageReader extends ImageReaderBase {

    final static boolean DEFAULT_ALLOW_EXTERNAL_RESOURCES =
-            "true".equalsIgnoreCase(System.getProperty("com.twelvemonkeys.imageio.plugins.svg.allowexternalresources"));
+            "true".equalsIgnoreCase(System.getProperty("com.twelvemonkeys.imageio.plugins.svg.allowExternalResources",
+                    System.getProperty("com.twelvemonkeys.imageio.plugins.svg.allowexternalresources")));

    private Rasterizer rasterizer;
    private boolean allowExternalResources = DEFAULT_ALLOW_EXTERNAL_RESOURCES;
@@ -150,29 +149,23 @@ public class SVGImageReader extends ImageReaderBase {
        BufferedImage destination = getDestination(pParam, getImageTypes(pIndex), size.width, size.height);

        // Read in the image, using the Batik Transcoder
+        processImageStarted(pIndex);
+
+        BufferedImage image = rasterizer.getImage();
+
+        Graphics2D g = destination.createGraphics();
        try {
-            processImageStarted(pIndex);
-
-            BufferedImage image = rasterizer.getImage();
-
-            Graphics2D g = destination.createGraphics();
-            try {
-                g.setComposite(AlphaComposite.Src);
-                g.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
-                g.drawImage(image, 0, 0, null); // TODO: Dest offset?
-            }
-            finally {
-                g.dispose();
-            }
-
-            processImageComplete();
-
-            return destination;
+            g.setComposite(AlphaComposite.Src);
+            g.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
+            g.drawImage(image, 0, 0, null); // TODO: Dest offset?
        }
-        catch (TranscoderException e) {
-            Throwable cause = unwrapException(e);
-            throw new IIOException(cause.getMessage(), cause);
+        finally {
+            g.dispose();
        }
+
+        processImageComplete();
+
+        return destination;
    }

    private static Throwable unwrapException(TranscoderException ex) {
@@ -187,11 +180,11 @@ public class SVGImageReader extends ImageReaderBase {

        // Set dimensions
        Dimension size = pParam.getSourceRenderSize();
-        Dimension origSize = new Dimension(getWidth(0), getHeight(0));
+        Rectangle viewBox = rasterizer.getViewBox();
        if (size == null) {
            // SVG is not a pixel based format, but we'll scale it, according to
            // the subsampling for compatibility
-            size = getSourceRenderSizeFromSubsamping(pParam, origSize);
+            size = getSourceRenderSizeFromSubsamping(pParam, viewBox.getSize());
        }

        if (size != null) {
@@ -211,8 +204,8 @@ public class SVGImageReader extends ImageReaderBase {
            }
            else {
                // Need to resize here...
-                double xScale = size.getWidth() / origSize.getWidth();
-                double yScale =  size.getHeight() / origSize.getHeight();
+                double xScale = size.getWidth() / viewBox.getWidth();
+                double yScale =  size.getHeight() / viewBox.getHeight();

                hints.put(ImageTranscoder.KEY_WIDTH, (float) (region.getWidth() * xScale));
                hints.put(ImageTranscoder.KEY_HEIGHT, (float) (region.getHeight() * yScale));
@@ -220,7 +213,7 @@ public class SVGImageReader extends ImageReaderBase {
        }
        else if (size != null) {
            // Allow non-uniform scaling
-            hints.put(ImageTranscoder.KEY_AOI, new Rectangle(origSize));
+            hints.put(ImageTranscoder.KEY_AOI, viewBox);
        }

        // Background color
@@ -235,7 +228,7 @@ public class SVGImageReader extends ImageReaderBase {
    private Dimension getSourceRenderSizeFromSubsamping(ImageReadParam pParam, Dimension pOrigSize) {
        if (pParam.getSourceXSubsampling() > 1 || pParam.getSourceYSubsampling() > 1) {
            return new Dimension((int) (pOrigSize.width / (float) pParam.getSourceXSubsampling()),
-                                 (int) (pOrigSize.height / (float) pParam.getSourceYSubsampling()));
+                    (int) (pOrigSize.height / (float) pParam.getSourceYSubsampling()));
        }
        return null;
    }
@@ -246,22 +239,13 @@ public class SVGImageReader extends ImageReaderBase {

    public int getWidth(int pIndex) throws IOException {
        checkBounds(pIndex);
-        try {
-            return rasterizer.getDefaultWidth();
-        }
-        catch (TranscoderException e) {
-            throw new IIOException(e.getMessage(), e);
-        }
+
+        return rasterizer.getDefaultWidth();
    }

    public int getHeight(int pIndex) throws IOException {
        checkBounds(pIndex);
-        try {
-            return rasterizer.getDefaultHeight();
-        }
-        catch (TranscoderException e) {
-            throw new IIOException(e.getMessage(), e);
-        }
+        return rasterizer.getDefaultHeight();
    }

    public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) {
@@ -275,12 +259,11 @@ public class SVGImageReader extends ImageReaderBase {
     * and needs major refactoring!
     * </p>
     */
-    private class Rasterizer extends SVGAbstractTranscoder /*ImageTranscoder*/ {
-
+    private class Rasterizer extends SVGAbstractTranscoder {
        private BufferedImage image;
        private TranscoderInput transcoderInput;
-        private float defaultWidth;
-        private float defaultHeight;
+        private final Rectangle2D viewBox = new Rectangle2D.Float();
+        private final Dimension defaultSize = new Dimension();
        private boolean initialized = false;
        private SVGOMDocument document;
        private String uri;
@@ -341,54 +324,66 @@ public class SVGImageReader extends ImageReaderBase {
            // ----
            SVGSVGElement rootElement = svgDoc.getRootElement();

-            // get the 'width' and 'height' attributes of the SVG document
-            UnitProcessor.Context uctx
-                    = UnitProcessor.createContext(ctx, rootElement);
+            // Get the viewBox
+            String viewBoxStr = rootElement.getAttributeNS(null, SVGConstants.SVG_VIEW_BOX_ATTRIBUTE);
+            if (viewBoxStr.length() != 0) {
+                float[] rect = ViewBox.parseViewBoxAttribute(rootElement, viewBoxStr, null);
+                viewBox.setFrame(rect[0], rect[1], rect[2], rect[3]);
+            }
+
+            // Get the 'width' and 'height' attributes of the SVG document
+            double width = 0;
+            double height = 0;
+            UnitProcessor.Context uctx = UnitProcessor.createContext(ctx, rootElement);
            String widthStr = rootElement.getAttributeNS(null, SVGConstants.SVG_WIDTH_ATTRIBUTE);
            String heightStr = rootElement.getAttributeNS(null, SVGConstants.SVG_HEIGHT_ATTRIBUTE);
            if (!StringUtil.isEmpty(widthStr)) {
-                defaultWidth = UnitProcessor.svgToUserSpace(widthStr, SVGConstants.SVG_WIDTH_ATTRIBUTE, UnitProcessor.HORIZONTAL_LENGTH, uctx);
+                width = UnitProcessor.svgToUserSpace(widthStr, SVGConstants.SVG_WIDTH_ATTRIBUTE, UnitProcessor.HORIZONTAL_LENGTH, uctx);
            }
-            if(!StringUtil.isEmpty(heightStr)){
-                defaultHeight = UnitProcessor.svgToUserSpace(heightStr, SVGConstants.SVG_HEIGHT_ATTRIBUTE, UnitProcessor.VERTICAL_LENGTH, uctx);
+            if (!StringUtil.isEmpty(heightStr)) {
+                height = UnitProcessor.svgToUserSpace(heightStr, SVGConstants.SVG_HEIGHT_ATTRIBUTE, UnitProcessor.VERTICAL_LENGTH, uctx);
            }

-            boolean hasWidth = defaultWidth > 0.0;
-            boolean hasHeight = defaultHeight > 0.0;
+            boolean hasWidth = width > 0.0;
+            boolean hasHeight = height > 0.0;

            if (!hasWidth || !hasHeight) {
-                String viewBoxStr = rootElement.getAttributeNS
-                        (null, SVGConstants.SVG_VIEW_BOX_ATTRIBUTE);
-                if (viewBoxStr.length() != 0) {
-                    float[] rect = ViewBox.parseViewBoxAttribute(rootElement, viewBoxStr, null);
-                    // if one dimension is given, calculate other by aspect ratio in viewBox
-                    // or use viewBox if no dimension is given
+                if (!viewBox.isEmpty()) {
+                    // If one dimension is given, calculate other by aspect ratio in viewBox
                    if (hasWidth) {
-                        defaultHeight = defaultWidth * rect[3] / rect[2];
+                        height = width * viewBox.getHeight() / viewBox.getWidth();
                    }
                    else if (hasHeight) {
-                        defaultWidth = defaultHeight * rect[2] / rect[3];
+                        width = height * viewBox.getWidth() / viewBox.getHeight();
                    }
                    else {
-                        defaultWidth = rect[2];
-                        defaultHeight = rect[3];
+                        // ...or use viewBox if no dimension is given
+                        width = viewBox.getWidth();
+                        height = viewBox.getHeight();
                    }
                }
                else {
+                    // No viewBox, just assume square size
                    if (hasHeight) {
-                        defaultWidth = defaultHeight;
+                        width = height;
                    }
                    else if (hasWidth) {
-                        defaultHeight = defaultWidth;
+                        height = width;
                    }
                    else {
-                        // fallback to batik default sizes
-                        defaultWidth = 400;
-                        defaultHeight = 400;
+                        // ...or finally fall back to Batik default sizes
+                        width = 400;
+                        height = 400;
                    }
                }
            }

+            // We now have a size, in the rare case we don't have a viewBox; set it to this size
+            defaultSize.setSize(width, height);
+            if (viewBox.isEmpty()) {
+                viewBox.setRect(0, 0, width, height);
+            }
+
            // Hack to work around exception above
            if (root != null) {
                gvtRoot = root;
@@ -401,7 +396,7 @@ public class SVGImageReader extends ImageReaderBase {
            ctx = null;
        }

-        private BufferedImage readImage() throws TranscoderException {
+        private BufferedImage readImage() throws IOException {
            init();

            if (abortRequested()) {
@@ -426,7 +421,8 @@ public class SVGImageReader extends ImageReaderBase {
                }

                if (gvtRoot == null) {
-                    throw exception;
+                    Throwable cause = unwrapException(exception);
+                    throw new IIOException(cause.getMessage(), cause);
                }
            }
            ctx = context;
@@ -444,7 +440,7 @@ public class SVGImageReader extends ImageReaderBase {


            // ----
-            setImageSize(defaultWidth, defaultHeight);
+            setImageSize(defaultSize.width, defaultSize.height);

            if (abortRequested()) {
                processReadAborted();
@@ -458,18 +454,17 @@ public class SVGImageReader extends ImageReaderBase {

            try {
                Px = ViewBox.getViewTransform(ref, root, width, height, null);
-
            }
            catch (BridgeException ex) {
-                throw new TranscoderException(ex);
+                throw new IIOException(ex.getMessage(), ex);
            }

-            if (Px.isIdentity() && (width != defaultWidth || height != defaultHeight)) {
+            if (Px.isIdentity() && (width != defaultSize.width || height != defaultSize.height)) {
                // The document has no viewBox, we need to resize it by hand.
                // we want to keep the document size ratio
                float xscale, yscale;
-                xscale = width / defaultWidth;
-                yscale = height / defaultHeight;
+                xscale = width / defaultSize.width;
+                yscale = height / defaultSize.height;
                float scale = Math.min(xscale, yscale);
                Px = AffineTransform.getScaleInstance(scale, scale);
            }
@@ -519,7 +514,7 @@ public class SVGImageReader extends ImageReaderBase {
                }
            }
            catch (BridgeException ex) {
-                throw new TranscoderException(ex);
+                throw new IIOException(ex.getMessage(), ex);
            }

            this.root = gvtRoot;
@@ -588,7 +583,7 @@ public class SVGImageReader extends ImageReaderBase {
                return dest;
            }
            catch (Exception ex) {
-                throw new TranscoderException(ex.getMessage(), ex);
+                throw new IIOException(ex.getMessage(), ex);
            }
            finally {
                if (context != null) {
@@ -597,7 +592,7 @@ public class SVGImageReader extends ImageReaderBase {
            }
        }

-        private synchronized void init() throws TranscoderException {
+        private synchronized void init() throws IIOException {
            if (!initialized) {
                if (transcoderInput == null) {
                    throw new IllegalStateException("input == null");
@@ -605,11 +600,17 @@ public class SVGImageReader extends ImageReaderBase {

                initialized = true;

-                super.transcode(transcoderInput, null);
+                try {
+                    super.transcode(transcoderInput, null);
+                }
+                catch (TranscoderException e) {
+                    Throwable cause = unwrapException(e);
+                    throw new IIOException(cause.getMessage(), cause);
+                }
            }
        }

-        private BufferedImage getImage() throws TranscoderException {
+        private BufferedImage getImage() throws IOException {
            if (image == null) {
                image = readImage();
            }
@@ -617,14 +618,19 @@ public class SVGImageReader extends ImageReaderBase {
            return image;
        }

-        int getDefaultWidth() throws TranscoderException {
+        int getDefaultWidth() throws IOException {
            init();
-            return (int) Math.ceil(defaultWidth);
+            return defaultSize.width;
        }

-        int getDefaultHeight() throws TranscoderException {
+        int getDefaultHeight() throws IOException {
            init();
-            return (int) Math.ceil(defaultHeight);
+            return defaultSize.height;
+        }
+
+        Rectangle getViewBox() throws IOException {
+            init();
+            return viewBox.getBounds();
        }

        void setInput(final TranscoderInput pInput) {
@@ -1,141 +1,143 @@
-/*
- * Copyright (c) 2008, 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.wmf;
-
-import com.twelvemonkeys.imageio.ImageReaderBase;
-import com.twelvemonkeys.imageio.plugins.svg.SVGImageReader;
-import com.twelvemonkeys.imageio.plugins.svg.SVGReadParam;
-import com.twelvemonkeys.imageio.util.IIOUtil;
-import org.apache.batik.transcoder.TranscoderException;
-import org.apache.batik.transcoder.TranscoderInput;
-import org.apache.batik.transcoder.TranscoderOutput;
-import org.apache.batik.transcoder.wmf.tosvg.WMFTranscoder;
-
-import javax.imageio.IIOException;
-import javax.imageio.ImageIO;
-import javax.imageio.ImageReadParam;
-import javax.imageio.ImageTypeSpecifier;
-import javax.imageio.spi.ImageReaderSpi;
-import java.awt.image.BufferedImage;
-import java.io.*;
-import java.util.Iterator;
-
-/**
- * WMFImageReader class description.
- * 
- * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
- * @author last modified by $Author: haku $
- * @version $Id: WMFImageReader.java,v 1.0 29.jul.2004 13:00:59 haku Exp $
- */
-// TODO: Probably possible to do less wrapping/unwrapping of data...
-// TODO: Consider using temp file instead of in-memory stream
-public final class WMFImageReader extends ImageReaderBase {
-
-    private SVGImageReader reader = null;
-
-    public WMFImageReader(final ImageReaderSpi pProvider) {
-        super(pProvider);
-    }
-
-    protected void resetMembers() {
-        if (reader != null) {
-            reader.dispose();
-        }
-
-        reader = null;
-    }
-
-    public BufferedImage read(int pIndex, ImageReadParam pParam) throws IOException {
-        init();
-
-        processImageStarted(pIndex);
-
-        BufferedImage image = reader.read(pIndex, pParam);
-        if (abortRequested()) {
-            processReadAborted();
-            return image;
-        }
-        processImageProgress(100f);
-
-        processImageComplete();
-
-        return image;
-    }
-
-    private synchronized void init() throws IOException {
-        // Need the extra test, to avoid throwing an IOException from the Transcoder
-        if (imageInput == null) {
-            throw new IllegalStateException("input == null");
-        }
-
-        if (reader == null) {
-            WMFTranscoder transcoder = new WMFTranscoder();
-
-            ByteArrayOutputStream output = new ByteArrayOutputStream();
-            Writer writer = new OutputStreamWriter(output, "UTF8");
-            try {
-                TranscoderInput in = new TranscoderInput(IIOUtil.createStreamAdapter(imageInput));
-                TranscoderOutput out = new TranscoderOutput(writer);
-
-                // TODO: Transcodinghints?
-
-                transcoder.transcode(in, out);
-            }
-            catch (TranscoderException e) {
-                throw new IIOException(e.getMessage(), e);
-            }
-
-            reader = new SVGImageReader(getOriginatingProvider());
-            reader.setInput(ImageIO.createImageInputStream(new ByteArrayInputStream(output.toByteArray())));
-        }
-    }
-
-    @Override
-    public ImageReadParam getDefaultReadParam() {
-        return new SVGReadParam();
-    }
-
-    public int getWidth(int pIndex) throws IOException {
-        init();
-        return reader.getWidth(pIndex);
-    }
-
-    public int getHeight(int pIndex) throws IOException {
-        init();
-        return reader.getHeight(pIndex);
-    }
-
-    public Iterator<ImageTypeSpecifier> getImageTypes(final int pImageIndex) throws IOException {
-        init();
-        return reader.getImageTypes(pImageIndex);
-    }
-
-}
+/*
+ * Copyright (c) 2008, 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.wmf;
+
+import com.twelvemonkeys.imageio.ImageReaderBase;
+import com.twelvemonkeys.imageio.plugins.svg.SVGImageReader;
+import com.twelvemonkeys.imageio.plugins.svg.SVGReadParam;
+import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
+import com.twelvemonkeys.imageio.util.IIOUtil;
+
+import org.apache.batik.transcoder.TranscoderException;
+import org.apache.batik.transcoder.TranscoderInput;
+import org.apache.batik.transcoder.TranscoderOutput;
+import org.apache.batik.transcoder.wmf.tosvg.WMFTranscoder;
+
+import javax.imageio.IIOException;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.spi.ImageReaderSpi;
+import java.awt.image.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.Iterator;
+
+/**
+ * WMFImageReader class description.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haku $
+ * @version $Id: WMFImageReader.java,v 1.0 29.jul.2004 13:00:59 haku Exp $
+ */
+// TODO: Probably possible to do less wrapping/unwrapping of data...
+public final class WMFImageReader extends ImageReaderBase {
+
+    private SVGImageReader reader = null;
+
+    public WMFImageReader(final ImageReaderSpi pProvider) {
+        super(pProvider);
+    }
+
+    protected void resetMembers() {
+        if (reader != null) {
+            reader.dispose();
+        }
+
+        reader = null;
+    }
+
+    public BufferedImage read(int pIndex, ImageReadParam pParam) throws IOException {
+        init();
+
+        processImageStarted(pIndex);
+
+        BufferedImage image = reader.read(pIndex, pParam);
+        if (abortRequested()) {
+            processReadAborted();
+            return image;
+        }
+        processImageProgress(100f);
+
+        processImageComplete();
+
+        return image;
+    }
+
+    private void init() throws IOException {
+        // Need the extra test, to avoid throwing an IOException from the Transcoder
+        if (imageInput == null) {
+            throw new IllegalStateException("input == null");
+        }
+
+        if (reader == null) {
+            WMFTranscoder transcoder = new WMFTranscoder();
+            ByteArrayOutputStream output = new ByteArrayOutputStream(8192);
+
+            try (Writer writer = new OutputStreamWriter(output, StandardCharsets.UTF_8)) {
+                TranscoderInput in = new TranscoderInput(IIOUtil.createStreamAdapter(imageInput));
+                TranscoderOutput out = new TranscoderOutput(writer);
+
+                // TODO: Transcodinghints?
+
+                transcoder.transcode(in, out);
+            }
+            catch (TranscoderException e) {
+                throw new IIOException(e.getMessage(), e);
+            }
+
+            reader = new SVGImageReader(getOriginatingProvider());
+            reader.setInput(new ByteArrayImageInputStream(output.toByteArray()));
+        }
+    }
+
+    @Override
+    public ImageReadParam getDefaultReadParam() {
+        return new SVGReadParam();
+    }
+
+    public int getWidth(int pIndex) throws IOException {
+        init();
+        return reader.getWidth(pIndex);
+    }
+
+    public int getHeight(int pIndex) throws IOException {
+        init();
+        return reader.getHeight(pIndex);
+    }
+
+    public Iterator<ImageTypeSpecifier> getImageTypes(final int pImageIndex) throws IOException {
+        init();
+        return reader.getImageTypes(pImageIndex);
+    }
+}
@@ -43,8 +43,7 @@ import javax.imageio.event.IIOReadWarningListener;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.awt.image.ImagingOpException;
+import java.awt.image.*;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URISyntaxException;
@@ -53,7 +52,10 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

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

 /**
@@ -192,12 +194,12 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
        TestData redSquare = new TestData(getClassLoaderResource("/svg/red-square.svg"), dim);
        reader.setInput(redSquare.getInputStream());
        BufferedImage imageRed = reader.read(0, param);
-        assertEquals(0xFF0000, imageRed.getRGB(50, 50) & 0xFFFFFF);
+        assertRGBEquals("Expected all red", 0xFF0000, imageRed.getRGB(50, 50) & 0xFFFFFF, 0);

        TestData blueSquare = new TestData(getClassLoaderResource("/svg/blue-square.svg"), dim);
        reader.setInput(blueSquare.getInputStream());
        BufferedImage imageBlue = reader.read(0, param);
-        assertEquals(0x0000FF, imageBlue.getRGB(50, 50) & 0xFFFFFF);
+        assertRGBEquals("Expected all blue", 0x0000FF, imageBlue.getRGB(50, 50) & 0xFFFFFF, 0);
    }

    @Test
@@ -337,4 +339,69 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
            reader.dispose();
        }
    }
+
+    @Test
+    public void testReadWitSourceRenderSize() throws IOException {
+        URL resource = getClassLoaderResource("/svg/circle.svg");
+
+        SVGImageReader reader = createReader();
+
+        TestData data = new TestData(resource, (Dimension) null);
+        try (ImageInputStream stream = data.getInputStream()) {
+            reader.setInput(stream);
+
+            SVGReadParam param = reader.getDefaultReadParam();
+            param.setSourceRenderSize(new Dimension(100, 100));
+            BufferedImage image = reader.read(0, param);
+
+            assertNotNull(image);
+            assertEquals(100, image.getWidth());
+            assertEquals(100, image.getHeight());
+
+            // Some quick samples
+            assertRGBEquals("Expected transparent corner", 0, image.getRGB(0, 0), 0);
+            assertRGBEquals("Expected transparent corner", 0, image.getRGB(99, 0), 0);
+            assertRGBEquals("Expected transparent corner", 0, image.getRGB(0, 99), 0);
+            assertRGBEquals("Expected transparent corner", 0, image.getRGB(99, 99), 0);
+            assertRGBEquals("Expected red center", 0xffff0000, image.getRGB(50, 50), 0);
+        }
+        finally {
+            reader.dispose();
+        }
+    }
+
+    @Test
+    public void testReadWitSourceRenderSizeViewBoxNegativeXY() throws IOException {
+        URL resource = getClassLoaderResource("/svg/Android_robot.svg");
+
+        SVGImageReader reader = createReader();
+
+        TestData data = new TestData(resource, (Dimension) null);
+        try (ImageInputStream stream = data.getInputStream()) {
+            reader.setInput(stream);
+
+            SVGReadParam param = reader.getDefaultReadParam();
+            param.setSourceRenderSize(new Dimension(219, 256)); // Aspect scaled to 256 boxed
+            BufferedImage image = reader.read(0, param);
+
+            assertNotNull(image);
+            assertEquals(219, image.getWidth());
+            assertEquals(256, image.getHeight());
+
+            // Some quick samples
+            assertRGBEquals("Expected transparent corner", 0, image.getRGB(0, 0), 0);
+            assertRGBEquals("Expected transparent corner", 0, image.getRGB(218, 0), 0);
+            assertRGBEquals("Expected transparent corner", 0, image.getRGB(0, 255), 0);
+            assertRGBEquals("Expected transparent corner", 0, image.getRGB(218, 255), 0);
+            assertRGBEquals("Expected green head", 0xffa4c639, image.getRGB(109, 20), 25);
+            assertRGBEquals("Expected green center", 0xffa4c639, image.getRGB(109, 128), 25);
+            assertRGBEquals("Expected green feet", 0xffa4c639, image.getRGB(80, 246), 25);
+            assertRGBEquals("Expected green feet", 0xffa4c639, image.getRGB(130, 246), 25);
+            assertRGBEquals("Expected white edge", 0xffffffff, image.getRGB(0, 128), 0);
+            assertRGBEquals("Expected white edge", 0xffffffff, image.getRGB(218, 128), 0);
+        }
+        finally {
+            reader.dispose();
+        }
+    }
 }
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+    "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 50 50" version="1.1" xmlns="http://www.w3.org/2000/svg"
+     xml:space="preserve"
+     style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2">
+    <circle cx="25" cy="25" r="25" fill="red"/></svg>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</version>
    </parent>
    <artifactId>imageio-bmp</artifactId>
    <name>TwelveMonkeys :: ImageIO :: BMP plugin</name>
@@ -39,7 +39,11 @@ import com.twelvemonkeys.io.LittleEndianDataInputStream;
 import com.twelvemonkeys.io.enc.DecoderStream;
 import com.twelvemonkeys.xml.XMLSerializer;

-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.event.IIOReadUpdateListener;
 import javax.imageio.event.IIOReadWarningListener;
 import javax.imageio.metadata.IIOMetadata;
@@ -47,7 +51,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.File;
@@ -77,7 +81,7 @@ public final class BMPImageReader extends ImageReaderBase {
        super(new BMPImageReaderSpi());
    }

-    protected BMPImageReader(final ImageReaderSpi pProvider) {
+    BMPImageReader(final ImageReaderSpi pProvider) {
        super(pProvider);
    }

@@ -358,14 +362,18 @@ public final class BMPImageReader extends ImageReaderBase {

        processImageStarted(imageIndex);
        for (int y = 0; y < height; y++) {
-            switch (header.getBitCount()) {
+            int bitCount = header.getBitCount();
+            switch (bitCount) {
                case 1:
                case 2:
                case 4:
                case 8:
                case 24:
                    byte[] rowDataByte = ((DataBufferByte) rowRaster.getDataBuffer()).getData();
-                    readRowByte(input, height, srcRegion, xSub, ySub, rowDataByte, destRaster, clippedRow, y);
+                    int bitsPerSample = bitCount == 24 ? 8 : bitCount;
+                    int samplesPerPixel = bitCount == 24 ? 3 : 1;
+
+                    readRowByte(input, height, srcRegion, xSub, ySub, bitsPerSample, samplesPerPixel, rowDataByte, destRaster, clippedRow, y);
                    break;

                case 16:
@@ -379,7 +387,7 @@ public final class BMPImageReader extends ImageReaderBase {
                    break;

                default:
-                    throw new AssertionError("Unsupported pixel depth: " + header.getBitCount());
+                    throw new AssertionError("Unsupported pixel depth: " + bitCount);
            }

            processImageProgress(100f * y / height);
@@ -476,6 +484,7 @@ public final class BMPImageReader extends ImageReaderBase {
    }

    private void readRowByte(final DataInput input, final int height, final Rectangle srcRegion, final int xSub, final int ySub,
+                             int bitsPerSample, int samplesPerPixel,
                             final byte[] rowDataByte, final WritableRaster destChannel, final Raster srcChannel, final int y) throws IOException {
        // Flip into position?
        int srcY = !header.topDown ? height - 1 - y : y;
@@ -492,9 +501,7 @@ public final class BMPImageReader extends ImageReaderBase {

        // Subsample horizontal
        if (xSub != 1) {
-            for (int x = 0; x < srcRegion.width / xSub; x++) {
-                rowDataByte[srcRegion.x + x] = rowDataByte[srcRegion.x + x * xSub];
-            }
+            IIOUtil.subsampleRow(rowDataByte, srcRegion.x, srcRegion.width, rowDataByte, 0, samplesPerPixel, bitsPerSample, xSub);
        }

        destChannel.setDataElements(0, dstY, srcChannel);
@@ -116,7 +116,7 @@ public final class BMPImageReaderSpi extends ImageReaderSpiBase {
        }
    }

-    public ImageReader createReaderInstance(final Object pExtension) throws IOException {
+    public ImageReader createReaderInstance(final Object pExtension) {
        return new BMPImageReader(this);
    }

@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.8.0</version>
+        <version>3.9.4</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.0</version>
+        <version>3.9.4</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;
+    }
+}
@@ -54,8 +54,8 @@ public final class DiscreteAlphaIndexColorModel extends ColorModel {
    // Our IndexColorModel delegate
    private final IndexColorModel icm;

+    private final int extraSamples;
    private final int samples;
-    private final boolean hasAlpha;

    /**
     * Creates a {@code DiscreteAlphaIndexColorModel}, delegating color map look-ups
@@ -86,33 +86,33 @@ public final class DiscreteAlphaIndexColorModel extends ColorModel {
        );

        this.icm = icm;
+        this.extraSamples = extraSamples;
        this.samples = 1 + extraSamples;
-        this.hasAlpha = hasAlpha;
    }

    @Override
    public int getNumComponents() {
-        return samples;
+        return getNumColorComponents() + extraSamples;
    }

    @Override
-    public final int getRed(final int pixel) {
+    public int getRed(final int pixel) {
        return icm.getRed(pixel);
    }

    @Override
-    public final int getGreen(final int pixel) {
+    public int getGreen(final int pixel) {
        return icm.getGreen(pixel);
    }

    @Override
-    public final int getBlue(final int pixel) {
+    public int getBlue(final int pixel) {
        return icm.getBlue(pixel);
    }

    @Override
-    public final int getAlpha(final int pixel) {
-        return hasAlpha ? (int) ((((float) pixel) / ((1 << getComponentSize(3))-1)) * 255.0f + 0.5f) : 0xff;
+    public int getAlpha(final int pixel) {
+        return hasAlpha() ? (int) ((((float) pixel) / ((1 << getComponentSize(3)) - 1)) * 255.0f + 0.5f) : 0xff;
    }

    private int getSample(final Object inData, final int index) {
@@ -120,15 +120,15 @@ public final class DiscreteAlphaIndexColorModel extends ColorModel {

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
-                byte bdata[] = (byte[]) inData;
+                byte[] bdata = (byte[]) inData;
                pixel = bdata[index] & 0xff;
                break;
            case DataBuffer.TYPE_USHORT:
-                short sdata[] = (short[]) inData;
+                short[] sdata = (short[]) inData;
                pixel = sdata[index] & 0xffff;
                break;
            case DataBuffer.TYPE_INT:
-                int idata[] = (int[]) inData;
+                int[] idata = (int[]) inData;
                pixel = idata[index];
                break;
            default:
@@ -139,27 +139,27 @@ public final class DiscreteAlphaIndexColorModel extends ColorModel {
    }

    @Override
-    public final int getRed(final Object inData) {
+    public int getRed(final Object inData) {
        return getRed(getSample(inData, 0));
    }

    @Override
-    public final int getGreen(final Object inData) {
+    public int getGreen(final Object inData) {
        return getGreen(getSample(inData, 0));
    }

    @Override
-    public final int getBlue(final Object inData) {
+    public int getBlue(final Object inData) {
        return getBlue(getSample(inData, 0));
    }

    @Override
-    public final int getAlpha(final Object inData) {
-        return hasAlpha ? getAlpha(getSample(inData, 1)) : 0xff;
+    public int getAlpha(final Object inData) {
+        return hasAlpha() ? getAlpha(getSample(inData, 1)) : 0xff;
    }

    @Override
-    public final SampleModel createCompatibleSampleModel(final int w, final int h) {
+    public SampleModel createCompatibleSampleModel(final int w, final int h) {
        return new PixelInterleavedSampleModel(transferType, w, h, samples, w * samples, createOffsets(samples));
    }

@@ -174,17 +174,17 @@ public final class DiscreteAlphaIndexColorModel extends ColorModel {
    }

    @Override
-    public final boolean isCompatibleSampleModel(final SampleModel sm) {
+    public boolean isCompatibleSampleModel(final SampleModel sm) {
        return sm instanceof PixelInterleavedSampleModel && sm.getNumBands() == samples;
    }

    @Override
-    public final WritableRaster createCompatibleWritableRaster(final int w, final int h) {
+    public WritableRaster createCompatibleWritableRaster(final int w, final int h) {
        return Raster.createWritableRaster(createCompatibleSampleModel(w, h), new Point(0, 0));
    }

    @Override
-    public final boolean isCompatibleRaster(final Raster raster) {
+    public boolean isCompatibleRaster(final Raster raster) {
        int size = raster.getSampleModel().getSampleSize(0);
        return ((raster.getTransferType() == transferType) &&
                (raster.getNumBands() == samples) && ((1 << size) >= icm.getMapSize()));
@@ -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);
+}
@@ -0,0 +1,133 @@
+/*
+ * 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.IOException;
+import java.io.InputStream;
+
+import static com.twelvemonkeys.lang.Validate.isTrue;
+import static com.twelvemonkeys.lang.Validate.notNull;
+
+/**
+ * An {@code ImageInputStream} that adapts an {@code InputSteam},
+ * by reading directly from the stream without and form of caching or buffering.
+ * <p>
+ * Note: This is <em>not</em> a general-purpose {@code ImageInputStream}, and is designed for reading large chunks,
+ * typically of pixel data, from an {@code InputStream}.
+ * It does <em>not</em> support backwards seeking, or reading bits.
+ * </p>
+ */
+public final class DirectImageInputStream extends ImageInputStreamImpl {
+    private final InputStream stream;
+    private final long length;
+
+    public DirectImageInputStream(final InputStream stream) {
+        this(stream, -1L);
+    }
+
+    public DirectImageInputStream(final InputStream stream, long length) {
+        this.stream = notNull(stream, "stream");
+        this.length = isTrue(length >= 0L || length == -1L, length, "negative length: %d");
+    }
+
+    @Override
+    public int read() throws IOException {
+        bitOffset = 0;
+        streamPos++;
+        return stream.read();
+    }
+
+    @Override
+    public int read(final byte[] bytes, int off, int len) throws IOException {
+        bitOffset = 0;
+
+        int read = stream.read(bytes, off, len);
+        if (read > 0) {
+            streamPos += read;
+        }
+
+        return read;
+    }
+
+    @Override
+    public void seek(long pos) throws IOException {
+        checkClosed();
+
+        if (pos < streamPos) {
+            // Handle as if flushedPos == streamPos at any time
+            throw new IndexOutOfBoundsException("pos < flushedPos");
+        }
+
+        bitOffset = 0;
+
+        while (streamPos < pos) {
+            long skipped = stream.skip(pos - streamPos);
+
+            if (skipped <= 0) {
+                break;
+            }
+
+            streamPos += skipped;
+        }
+    }
+
+    @Override
+    public long getFlushedPosition() {
+        // Handle as if flushedPos == streamPos at any time
+        return streamPos;
+    }
+
+    @Override
+    public long length() {
+        return length;
+    }
+
+    @SuppressWarnings("RedundantThrows")
+    @Override
+    public int readBit() throws IOException {
+        throw new UnsupportedOperationException("Bit reading not supported");
+    }
+
+    @SuppressWarnings("RedundantThrows")
+    @Override
+    public long readBits(int numBits) throws IOException {
+        throw new UnsupportedOperationException("Bit reading not supported");
+    }
+
+    @Override
+    public void close() throws IOException {
+        // 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";
    }
 }
@@ -81,7 +81,7 @@ class IIOInputStreamAdapter extends InputStream {

    private IIOInputStreamAdapter(ImageInputStream pInput, long pLength, boolean pHasLength) {
        Validate.notNull(pInput, "stream");
-        Validate.isTrue(!pHasLength || pLength >= 0, pLength, "length < 0: %f");
+        Validate.isTrue(!pHasLength || pLength >= 0, pLength, "length < 0: %d");

        input = pInput;
        left = pLength;
@@ -45,6 +45,7 @@ import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.Iterator;
 import java.util.SortedSet;
 import java.util.TreeSet;

@@ -175,15 +176,22 @@ public final class IIOUtil {
     * @param providerClassName name of the provider class.
     * @param category provider category
     *
-     * @return the provider instance, or {@code null}.
+     * @return the provider instance, or {@code null} if not found
     */
    public static <T> T lookupProviderByName(final ServiceRegistry registry, final String providerClassName, Class<T> category) {
-        try {
-            return category.cast(registry.getServiceProviderByClass(Class.forName(providerClassName)));
-        }
-        catch (ClassNotFoundException ignore) {
-            return null;
+        // NOTE: While more verbose, this is more OSGi-friendly than using
+        // registry.getServiceProviderByClass(Class.forName(providerClassName))
+        Iterator<T> providers = registry.getServiceProviders(category, true);
+
+        while (providers.hasNext()) {
+            T provider = providers.next();
+
+            if (provider.getClass().getName().equals(providerClassName)) {
+                return provider;
+            }
        }
+
+        return null;
    }

    /**
@@ -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()));
+        }
+    }
+}
@@ -37,7 +37,9 @@ import java.awt.image.*;

 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;

 public class DiscreteAlphaIndexColorModelTest {

@@ -204,6 +206,25 @@ public class DiscreteAlphaIndexColorModelTest {
        assertThat(raster.getTransferType(), CoreMatchers.equalTo(DataBuffer.TYPE_BYTE));
    }

+    @Test
+    public void testNumComponents() {
+        int[] colors = createIntLut(1 << 8);
+        IndexColorModel icm = new IndexColorModel(8, colors.length, colors, 0, false, -1, DataBuffer.TYPE_BYTE);
+
+        ColorModel colorModelDiscreteAlpha = new DiscreteAlphaIndexColorModel(icm, 1, true);
+        ColorModel colorModelDiscreteAlphaExtra = new DiscreteAlphaIndexColorModel(icm, 2, true);
+        ColorModel colorModelNoAlphaExtra = new DiscreteAlphaIndexColorModel(icm, 42, false);
+
+        assertEquals(3, colorModelDiscreteAlpha.getNumColorComponents());
+        assertEquals(4, colorModelDiscreteAlpha.getNumComponents());
+
+        assertEquals(3, colorModelDiscreteAlphaExtra.getNumColorComponents());
+        assertEquals(5, colorModelDiscreteAlphaExtra.getNumComponents()); // Questionable
+
+        assertEquals(3, colorModelNoAlphaExtra.getNumColorComponents());
+        assertEquals(45, colorModelNoAlphaExtra.getNumComponents()); // Questionable
+    }
+
    private static int[] createIntLut(final int count) {
        int[] lut = new int[count];

@@ -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());
+    }
+}
@@ -53,6 +53,7 @@ import static org.mockito.Mockito.*;
 * @author last modified by $Author: haraldk$
 * @version $Id: BufferedImageInputStreamTest.java,v 1.0 Jun 30, 2008 3:07:42 PM haraldk Exp$
 */
+@SuppressWarnings("deprecation")
 public class BufferedImageInputStreamTest {
    private final Random random = new Random(3450972865211L);

@@ -433,7 +434,7 @@ public class BufferedImageInputStreamTest {
     * and {@code pFirstOffset == pSecondOffset}.
     * Otherwise {@code false}.
     */
-    static boolean rangeEquals(byte[] pFirst, int pFirstOffset, byte[] pSecond, int pSecondOffset, int pLength) {
+    public static boolean rangeEquals(byte[] pFirst, int pFirstOffset, byte[] pSecond, int pSecondOffset, int pLength) {
        if (pFirst == pSecond && pFirstOffset == pSecondOffset) {
            return true;
        }
@@ -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]);
+    }
+}
@@ -0,0 +1,380 @@
+/*
+ * 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 org.junit.Ignore;
+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.util.Random;
+
+import static com.twelvemonkeys.imageio.stream.BufferedImageInputStreamTest.rangeEquals;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * NonSeekableImageInputStreamTest
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: NonSeekableImageInputStreamTest.java,v 1.0 Apr 21, 2009 10:58:48 AM haraldk Exp$
+ */
+public class DirectImageInputStreamTest {
+    private final Random random = new Random(170984354357234566L);
+
+    private InputStream randomData(byte[] data) {
+        random.nextBytes(data);
+
+        return new ByteArrayInputStream(data);
+    }
+
+    @Test
+    public void testCreate() throws IOException {
+        try (DirectImageInputStream stream = new DirectImageInputStream(new ByteArrayInputStream(new byte[0]), 0)) {
+            assertEquals("Data length should be same as stream length", 0, stream.length());
+        }
+    }
+
+    @Test
+    public void testCreateNullFile() throws IOException {
+        try (@SuppressWarnings("unused") DirectImageInputStream stream = new DirectImageInputStream(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 testRead() throws IOException {
+        byte[] data = new byte[1024 * 1024];
+        InputStream input = randomData(data);
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(input)) {
+            for (byte value : data) {
+                assertEquals("Wrong data read", value & 0xff, stream.read());
+            }
+        }
+    }
+
+    @Test
+    public void testReadArray() throws IOException {
+        byte[] data = new byte[1024 * 10];
+        InputStream input = randomData(data);
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(input)) {
+            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];
+        InputStream input = randomData(data);
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(input)) {
+            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[24 * 18];
+        InputStream input = randomData(data);
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(input)) {
+            byte[] result = new byte[9];
+
+            for (int i = 0; i < data.length / (2 * result.length); i++) {
+                long newPos = i * 2 * 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));
+            }
+        }
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Ignore("Bit reading requires backwards seek or buffer...")
+    @Test
+    public void testReadBitRandom() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomData(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (DirectImageInputStream stream = new DirectImageInputStream(input)) {
+            for (int i = 1; i <= 64; i++) {
+                assertEquals(String.format("bit %d differ", i), (value << (i - 1L)) >>> 63L, stream.readBit());
+            }
+        }
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Ignore("Bit reading requires backwards seek or buffer...")
+    @Test
+    public void testReadBitsRandom() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomData(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (DirectImageInputStream stream = new DirectImageInputStream(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());
+            }
+        }
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Ignore("Bit reading requires backwards seek or buffer...")
+    @Test
+    public void testReadBitsRandomOffset() throws IOException {
+        byte[] bytes = new byte[8];
+        InputStream input = randomData(bytes);
+        long value = ByteBuffer.wrap(bytes).getLong();
+
+        // Create stream
+        try (DirectImageInputStream stream = new DirectImageInputStream(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 * 2L % 8, stream.getBitOffset());
+            }
+        }
+    }
+
+    @Test
+    public void testReadShort() throws IOException {
+        byte[] bytes = new byte[31];
+        InputStream input = randomData(bytes);
+
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(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();
+                }
+            });
+        }
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(new ByteArrayInputStream(bytes))) {
+            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[31];
+        InputStream input = randomData(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        // Create stream
+        try (DirectImageInputStream stream = new DirectImageInputStream(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();
+                }
+            });
+        }
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(new ByteArrayInputStream(bytes))) {
+            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 = randomData(bytes);
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(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();
+                }
+            });
+        }
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(new ByteArrayInputStream(bytes))) {
+            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 = randomData(bytes);
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(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();
+                }
+            });
+        }
+
+        try (DirectImageInputStream stream = new DirectImageInputStream(new ByteArrayInputStream(bytes))) {
+            for (byte value : bytes) {
+                assertEquals(value, stream.readByte());
+            }
+
+            assertEquals(-1, stream.read());
+        }
+    }
+
+    @Test
+    public void testClose() throws IOException {
+        // Create wrapper stream
+        InputStream input = mock(InputStream.class);
+        ImageInputStream stream = new DirectImageInputStream(input);
+
+        stream.close();
+        verify(input, only()).close();
+    }
+}
@@ -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.0</version>
+        <version>3.9.4</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.0</version>
+        <version>3.9.4</version>
    </parent>
    <artifactId>imageio-icns</artifactId>
    <name>TwelveMonkeys :: ImageIO :: ICNS plugin</name>
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, Harald Kuhr
+ * Copyright (c) 2022, Harald Kuhr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -28,18 +28,14 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-package com.twelvemonkeys.servlet.cache;
+package com.twelvemonkeys.imageio.plugins.icns;

-/**
- * CacheException
- *
- * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
- * @author last modified by $Author: haku $
- * @version $Id: CacheException.java#1 $
- */
-@Deprecated
-public class CacheException extends Exception {
-    public CacheException(Throwable pCause) {
-        super(pCause);
+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.0</version>
+        <version>3.9.4</version>
    </parent>
    <artifactId>imageio-iff</artifactId>
    <name>TwelveMonkeys :: ImageIO :: IFF plugin</name>
@@ -69,14 +69,14 @@ abstract class AbstractMultiPaletteChunk extends IFFChunk implements MultiPalett
    protected WeakReference<IndexColorModel> originalPalette;
    protected MutableIndexColorModel mutablePalette;

-    public AbstractMultiPaletteChunk(int pChunkId, int pChunkLength) {
-        super(pChunkId, pChunkLength);
+    public AbstractMultiPaletteChunk(int chunkId, int chunkLength) {
+        super(chunkId, chunkLength);
    }

    @Override
-    void readChunk(final DataInput pInput) throws IOException {
+    void readChunk(final DataInput input) throws IOException {
        if (chunkId == IFF.CHUNK_SHAM) {
-            pInput.readUnsignedShort(); // Version, typically 0, skipped
+            input.readUnsignedShort(); // Version, typically 0, skipped
        }

        int rows = chunkLength / 32;    /* sizeof(word) * 16 */
@@ -91,7 +91,7 @@ abstract class AbstractMultiPaletteChunk extends IFFChunk implements MultiPalett
            }

            for (int i = 0; i < 16; i++ ) {
-                int data = pInput.readUnsignedShort();
+                int data = input.readUnsignedShort();

                changes[row][i].index = i;
                changes[row][i].r = (byte) (((data & 0x0f00) >> 8) * FACTOR_4BIT);
@@ -102,7 +102,7 @@ abstract class AbstractMultiPaletteChunk extends IFFChunk implements MultiPalett
    }

    @Override
-    void writeChunk(DataOutput pOutput) {
+    void writeChunk(DataOutput output) {
        throw new UnsupportedOperationException("Method writeChunk not implemented");
    }

@@ -30,12 +30,11 @@

 package com.twelvemonkeys.imageio.plugins.iff;

+import javax.imageio.IIOException;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;

-import javax.imageio.IIOException;
-
 /**
 * BMHDChunk
 *
@@ -110,64 +109,65 @@ final class BMHDChunk extends IFFChunk {
    int pageWidth;
    int pageHeight;

-    protected BMHDChunk(int pChunkLength) {
-        super(IFF.CHUNK_BMHD, pChunkLength);
+    BMHDChunk(int chunkLength) {
+        super(IFF.CHUNK_BMHD, chunkLength);
    }

-    protected BMHDChunk(int pWidth, int pHeight, int pBitplanes, int pMaskType, int pCompressionType, int pTransparentIndex) {
+    BMHDChunk(int width, int height, int bitplanes, int maskType, int compressionType, int transparentIndex) {
        super(IFF.CHUNK_BMHD, 20);
-        width = pWidth;
-        height = pHeight;
+        this.width = width;
+        this.height = height;
        xPos = 0;
        yPos = 0;
-        bitplanes = pBitplanes;
-        maskType = pMaskType;
-        compressionType = pCompressionType;
-        transparentIndex = pTransparentIndex;
+        this.bitplanes = bitplanes;
+        this.maskType = maskType;
+        this.compressionType = compressionType;
+        this.transparentIndex = transparentIndex;
        xAspect = 1;
        yAspect = 1;
-        pageWidth = Math.min(pWidth, Short.MAX_VALUE); // For some reason, these are signed?
-        pageHeight = Math.min(pHeight, Short.MAX_VALUE);
+        pageWidth = Math.min(width, Short.MAX_VALUE); // For some reason, these are signed?
+        pageHeight = Math.min(height, Short.MAX_VALUE);
    }

    @Override
-    void readChunk(final DataInput pInput) throws IOException {
+    void readChunk(final DataInput input) throws IOException {
        if (chunkLength != 20) {
            throw new IIOException("Unknown BMHD chunk length: " + chunkLength);
        }
-        width = pInput.readUnsignedShort();
-        height = pInput.readUnsignedShort();
-        xPos = pInput.readShort();
-        yPos = pInput.readShort();
-        bitplanes = pInput.readUnsignedByte();
-        maskType = pInput.readUnsignedByte();
-        compressionType = pInput.readUnsignedByte();
-        pInput.readByte(); // PAD
-        transparentIndex = pInput.readUnsignedShort();
-        xAspect = pInput.readUnsignedByte();
-        yAspect = pInput.readUnsignedByte();
-        pageWidth = pInput.readShort();
-        pageHeight = pInput.readShort();
+
+        width = input.readUnsignedShort();
+        height = input.readUnsignedShort();
+        xPos = input.readShort();
+        yPos = input.readShort();
+        bitplanes = input.readUnsignedByte();
+        maskType = input.readUnsignedByte();
+        compressionType = input.readUnsignedByte();
+        input.readByte(); // PAD
+        transparentIndex = input.readUnsignedShort();
+        xAspect = input.readUnsignedByte();
+        yAspect = input.readUnsignedByte();
+        pageWidth = input.readShort();
+        pageHeight = input.readShort();
    }

    @Override
-    void writeChunk(final DataOutput pOutput) throws IOException {
-        pOutput.writeInt(chunkId);
-        pOutput.writeInt(chunkLength);
+    void writeChunk(final DataOutput output) throws IOException {
+        output.writeInt(chunkId);
+        output.writeInt(chunkLength);

-        pOutput.writeShort(width);
-        pOutput.writeShort(height);
-        pOutput.writeShort(xPos);
-        pOutput.writeShort(yPos);
-        pOutput.writeByte(bitplanes);
-        pOutput.writeByte(maskType);
-        pOutput.writeByte(compressionType);
-        pOutput.writeByte(0); // PAD
-        pOutput.writeShort(transparentIndex);
-        pOutput.writeByte(xAspect);
-        pOutput.writeByte(yAspect);
-        pOutput.writeShort(pageWidth);
-        pOutput.writeShort(pageHeight);
+        output.writeShort(width);
+        output.writeShort(height);
+        output.writeShort(xPos);
+        output.writeShort(yPos);
+        output.writeByte(bitplanes);
+        output.writeByte(maskType);
+        output.writeByte(compressionType);
+        output.writeByte(0); // PAD
+        output.writeShort(transparentIndex);
+        output.writeByte(xAspect);
+        output.writeByte(yAspect);
+        output.writeShort(pageWidth);
+        output.writeShort(pageHeight);
    }

    @Override
@@ -33,6 +33,8 @@ package com.twelvemonkeys.imageio.plugins.iff;
 import java.io.DataInput;
 import java.io.DataOutput;

+import static com.twelvemonkeys.lang.Validate.isTrue;
+
 /**
 * BODYChunk
 *
@@ -40,17 +42,20 @@ import java.io.DataOutput;
 * @version $Id: BODYChunk.java,v 1.0 28.feb.2006 01:25:49 haku Exp$
 */
 final class BODYChunk extends IFFChunk {
-    protected BODYChunk(int pChunkLength) {
-        super(IFF.CHUNK_BODY, pChunkLength);
+    final long chunkOffset;
+
+    BODYChunk(int chunkId, int chunkLength, long chunkOffset) {
+        super(isTrue(chunkId == IFF.CHUNK_BODY || chunkId == IFF.CHUNK_DBOD, chunkId, "Illegal body chunk: '%s'"), chunkLength);
+        this.chunkOffset = chunkOffset;
    }

    @Override
-    void readChunk(final DataInput pInput) {
+    void readChunk(final DataInput input) {
        throw new InternalError("BODY chunk should only be read from IFFImageReader");
    }

    @Override
-    void writeChunk(final DataOutput pOutput)  {
+    void writeChunk(final DataOutput output)  {
        throw new InternalError("BODY chunk should only be written from IFFImageWriter");
    }
 }
@@ -30,12 +30,11 @@

 package com.twelvemonkeys.imageio.plugins.iff;

+import javax.imageio.IIOException;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;

-import javax.imageio.IIOException;
-
 /**
 * CAMGChunk
 *
@@ -49,21 +48,21 @@ final class CAMGChunk extends IFFChunk {

    int camg;

-    public CAMGChunk(int pLength) {
-        super(IFF.CHUNK_CAMG, pLength);
+    CAMGChunk(int chunkLength) {
+        super(IFF.CHUNK_CAMG, chunkLength);
    }

    @Override
-    void readChunk(final DataInput pInput) throws IOException {
+    void readChunk(final DataInput input) throws IOException {
        if (chunkLength != 4) {
            throw new IIOException("Unknown CAMG chunk length: " + chunkLength);
        }

-        camg = pInput.readInt();
+        camg = input.readInt();
    }

    @Override
-    void writeChunk(final DataOutput pOutput) {
+    void writeChunk(final DataOutput output) {
        throw new InternalError("Not implemented: writeChunk()");
    }

@@ -30,16 +30,13 @@

 package com.twelvemonkeys.imageio.plugins.iff;

-import java.awt.image.BufferedImage;
+import javax.imageio.IIOException;
 import java.awt.image.IndexColorModel;
-import java.awt.image.WritableRaster;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import java.util.Arrays;

-import javax.imageio.IIOException;
-
 /**
 * CMAPChunk
 *
@@ -60,7 +57,7 @@ final class CMAPChunk extends IFFChunk {

    private IndexColorModel model;

-    protected CMAPChunk(final int pChunkLength) {
+    CMAPChunk(final int pChunkLength) {
        super(IFF.CHUNK_CMAP, pChunkLength);
    }

@@ -70,7 +67,7 @@ final class CMAPChunk extends IFFChunk {
    }

    @Override
-    void readChunk(final DataInput pInput) throws IOException {
+    void readChunk(final DataInput input) throws IOException {
        int numColors = chunkLength / 3;

        reds = new byte[numColors];
@@ -78,9 +75,9 @@ final class CMAPChunk extends IFFChunk {
        blues = reds.clone();

        for (int i = 0; i < numColors; i++) {
-            reds[i] = pInput.readByte();
-            greens[i] = pInput.readByte();
-            blues[i] = pInput.readByte();
+            reds[i] = input.readByte();
+            greens[i] = input.readByte();
+            blues[i] = input.readByte();
        }

        // TODO: When reading in a CMAP for 8-bit-per-gun display or
@@ -93,25 +90,25 @@ final class CMAPChunk extends IFFChunk {

        // All chunks are WORD aligned (even sized), may need to read pad...
        if (chunkLength % 2 != 0) {
-            pInput.readByte();
+            input.readByte();
        }
    }

    @Override
-    void writeChunk(final DataOutput pOutput) throws IOException {
-        pOutput.writeInt(chunkId);
-        pOutput.writeInt(chunkLength);
+    void writeChunk(final DataOutput output) throws IOException {
+        output.writeInt(chunkId);
+        output.writeInt(chunkLength);

        final int length = model.getMapSize();

        for (int i = 0; i < length; i++) {
-            pOutput.writeByte(model.getRed(i));
-            pOutput.writeByte(model.getGreen(i));
-            pOutput.writeByte(model.getBlue(i));
+            output.writeByte(model.getRed(i));
+            output.writeByte(model.getGreen(i));
+            output.writeByte(model.getBlue(i));
        }

        if (chunkLength % 2 != 0) {
-            pOutput.writeByte(0); // PAD
+            output.writeByte(0); // PAD
        }
    }

@@ -120,25 +117,11 @@ final class CMAPChunk extends IFFChunk {
        return super.toString() + " {colorMap=" + model + "}";
    }

-    BufferedImage createPaletteImage(final BMHDChunk header, boolean isEHB) throws IIOException {
-        // Create a 1 x colors.length image
-        IndexColorModel cm = getIndexColorModel(header, isEHB);
-        WritableRaster raster = cm.createCompatibleWritableRaster(cm.getMapSize(), 1);
-        byte[] pixel = null;
-
-        for (int x = 0; x < cm.getMapSize(); x++) {
-            pixel = (byte[]) cm.getDataElements(cm.getRGB(x), pixel);
-            raster.setDataElements(x, 0, pixel);
-        }
-
-        return new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null);
-    }
-
-    public IndexColorModel getIndexColorModel(final BMHDChunk header, boolean isEHB) throws IIOException {
+    public IndexColorModel getIndexColorModel(final Form.ILBMForm header) throws IIOException {
        if (model == null) {
            int numColors = reds.length; // All arrays are same size

-            if (isEHB) {
+            if (header.isEHB()) {
                if (numColors == 32) {
                    reds = Arrays.copyOf(reds,  numColors * 2);
                    blues = Arrays.copyOf(blues,  numColors * 2);
@@ -161,8 +144,10 @@ final class CMAPChunk extends IFFChunk {
            // Would it work to double to numbers of colors, and create an indexcolormodel,
            // with alpha, where all colors above the original color is all transparent?
            // This is a waste of time and space, of course...
-            int transparent = header.maskType == BMHDChunk.MASK_TRANSPARENT_COLOR ? header.transparentIndex : -1;
-            model = new IndexColorModel(header.bitplanes, reds.length, reds, greens, blues, transparent); // https://github.com/haraldk/TwelveMonkeys/issues/15
+            int transparent = header.transparentIndex();
+            int bitplanes = header.bitplanes() == 25 ? 8 : header.bitplanes();
+
+            model = new IndexColorModel(bitplanes, reds.length, reds, greens, blues, transparent); // https://github.com/haraldk/TwelveMonkeys/issues/15
        }

        return model;
@@ -38,7 +38,7 @@ package com.twelvemonkeys.imageio.plugins.iff;
 * @version $Id: CTBLChunk.java,v 1.0 30.03.12 14:53 haraldk Exp$
 */
 final class CTBLChunk extends AbstractMultiPaletteChunk {
-    protected CTBLChunk(int pChunkLength) {
-        super(IFF.CHUNK_CTBL, pChunkLength);
+    CTBLChunk(int chunkLength) {
+        super(IFF.CHUNK_CTBL, chunkLength);
    }
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, Harald Kuhr
+ * Copyright (c) 2022, Harald Kuhr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -28,45 +28,75 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-package com.twelvemonkeys.servlet.cache;
+package com.twelvemonkeys.imageio.plugins.iff;

-import java.net.URI;
-
-import com.twelvemonkeys.lang.Validate;
+import javax.imageio.IIOException;
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;

 /**
- * AbstractCacheRequest
+ * DGBLChunk
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
- * @author last modified by $Author: haku $
- * @version $Id: AbstractCacheRequest.java#1 $
+ * @version $Id: DGBLChunk.java,v 1.0 28.feb.2006 02:10:07 haku Exp$
 */
-@Deprecated
-public abstract class AbstractCacheRequest implements CacheRequest {
-    private final URI requestURI;
-    private final String method;
+final class DGBLChunk extends IFFChunk {

-    protected AbstractCacheRequest(final URI pRequestURI, final String pMethod) {
-        requestURI = Validate.notNull(pRequestURI, "requestURI");
-        method = Validate.notNull(pMethod, "method");
+    /*
+    //
+    struct DGBL = {
+//
+// Size of source display
+//
+      UWORD  DisplayWidth,DisplayHeight;
+//
+// Type of compression
+//
+      UWORD  Compression;
+//
+// Pixel aspect, a ration w:h
+//
+      UBYTE  xAspect,yAspect;
+    };
+
+     */
+    int displayWidth;
+    int displayHeight;
+    int compressionType;
+    int xAspect;
+    int yAspect;
+
+    DGBLChunk(int chunkLength) {
+        super(IFF.CHUNK_DGBL, chunkLength);
    }

-    public URI getRequestURI() {
-        return requestURI;
+    @Override
+    void readChunk(final DataInput input) throws IOException {
+        if (chunkLength != 8) {
+            throw new IIOException("Unknown DBGL chunk length: " + chunkLength);
+        }
+
+        displayWidth = input.readUnsignedShort();
+        displayHeight = input.readUnsignedShort();
+        compressionType = input.readUnsignedShort();
+        xAspect = input.readUnsignedByte();
+        yAspect = input.readUnsignedByte();
    }

-    public String getMethod() {
-        return method;
+    @Override
+    void writeChunk(final DataOutput output) {
+        throw new InternalError("Not implemented: writeChunk()");
    }

-    // TODO: Consider overriding equals/hashcode
-
    @Override
    public String toString() {
-        return new StringBuilder(getClass().getSimpleName())
-                .append("[URI=").append(requestURI)
-                .append(", parameters=").append(getParameters())
-                .append(", headers=").append(getHeaders())
-                .append("]").toString();
+        return super.toString() +
+                "{displayWidth=" + displayWidth +
+                ", displayHeight=" + displayHeight +
+                ", compression=" + compressionType +
+                ", xAspect=" + xAspect +
+                ", yAspect=" + yAspect +
+                '}';
    }
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, Harald Kuhr
+ * Copyright (c) 2022, Harald Kuhr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -28,51 +28,53 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-package com.twelvemonkeys.servlet.cache;
+package com.twelvemonkeys.imageio.plugins.iff;

+import javax.imageio.IIOException;
+import java.io.DataInput;
+import java.io.DataOutput;
 import java.io.IOException;
-import java.io.OutputStream;
-
-import javax.servlet.http.HttpServletResponse;

 /**
- * ServletCacheResponse
+ * DLOCChunk.
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
- * @author last modified by $Author: haku $
- * @version $Id: ServletCacheResponse.java#2 $
+ * @author last modified by $Author: haraldk$
+ * @version $Id: DLOCChunk.java,v 1.0 31/01/2022 haraldk Exp$
 */
-@Deprecated
-public final class ServletCacheResponse extends AbstractCacheResponse {
-    private HttpServletResponse response;
+final class DLOCChunk extends IFFChunk {
+    int width;
+    int height;
+    int x;
+    int y;

-    public ServletCacheResponse(HttpServletResponse pResponse) {
-        response = pResponse;
-    }
-
-    public OutputStream getOutputStream() throws IOException {
-        return response.getOutputStream();
+     DLOCChunk(final int chunkLength) {
+        super(IFF.CHUNK_DLOC, chunkLength);
    }

    @Override
-    public void setStatus(int pStatusCode) {
-        response.setStatus(pStatusCode);
-        super.setStatus(pStatusCode);
+    void readChunk(final DataInput input) throws IOException {
+        if (chunkLength != 8) {
+            throw new IIOException("Unknown DLOC chunk length: " + chunkLength);
+        }
+
+        width = input.readUnsignedShort();
+        height = input.readUnsignedShort();
+        x = input.readShort();
+        y = input.readShort();
    }

    @Override
-    public void addHeader(String pHeaderName, String pHeaderValue) {
-        response.addHeader(pHeaderName, pHeaderValue);
-        super.addHeader(pHeaderName, pHeaderValue);
+    void writeChunk(final DataOutput output) {
+        throw new InternalError("Not implemented: writeChunk()");
    }

    @Override
-    public void setHeader(String pHeaderName, String pHeaderValue) {
-        response.setHeader(pHeaderName, pHeaderValue);
-        super.setHeader(pHeaderName, pHeaderValue);
-    }
-
-    HttpServletResponse getResponse() {
-        return response;
+    public String toString() {
+        return super.toString() +
+                "{width=" + width +
+                ", height=" + height +
+                ", x=" + x +
+                ", y=" + y + '}';
    }
 }
@@ -0,0 +1,103 @@
+package com.twelvemonkeys.imageio.plugins.iff;
+
+import javax.imageio.IIOException;
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.Arrays;
+
+/**
+ * DPELChunk.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: DPELChunk.java,v 1.0 01/02/2022 haraldk Exp$
+ */
+final class DPELChunk extends IFFChunk {
+    /*
+//
+//   Chunk DPEL
+//   ----------
+    struct DPEL = {
+//
+// Number of pixel components
+//
+ULONG nElements;
+    //
+// The TypeDepth structure is repeated nElement times to identify
+// the content of every pixel.  Pixels will always be padded to
+// byte boundaries.  The DBOD chunk will be padded to an even
+// longword boundary.
+//
+    struct TypeDepth = {
+//
+// Type of data
+//
+UWORD cType;
+    //
+// Bit depth of this type
+//
+    UWORD cBitDepth;
+} typedepth[Nelements];
+        };
+     */
+    TypeDepth[] typeDepths;
+
+    DPELChunk(final int chunkLength) {
+        super(IFF.CHUNK_DPEL, chunkLength);
+    }
+
+    @Override
+    void readChunk(final DataInput input) throws IOException {
+        int components = input.readInt(); // Strictly, it's unsigned, but that many components is unlikely...
+
+        if (chunkLength != 4 + components * 4) {
+            throw new IIOException("Unsupported DPEL chunk length: " + chunkLength);
+        }
+
+        typeDepths = new TypeDepth[components];
+
+        for (int i = 0; i < components; i++) {
+            typeDepths[i] = new TypeDepth(input.readUnsignedShort(), input.readUnsignedShort());
+        }
+    }
+
+    @Override
+    void writeChunk(final DataOutput output) {
+        throw new InternalError("Not implemented: writeChunk()");
+    }
+
+    @Override
+    public String toString() {
+        return super.toString()
+                + "{typeDepths=" + Arrays.toString(typeDepths) + '}';
+    }
+
+    public int bitsPerPixel() {
+        int bitCount = 0;
+
+        for (TypeDepth typeDepth : typeDepths) {
+            bitCount += typeDepth.bitDepth;
+        }
+
+        return bitCount;
+    }
+
+    static class TypeDepth {
+        final int type;
+        final int bitDepth;
+
+        TypeDepth(final int type, final int bitDepth) {
+            this.type = type;
+            this.bitDepth = bitDepth;
+        }
+
+        @Override
+        public String toString() {
+            return "TypeDepth{" +
+                    "type=" + type +
+                    ", bits=" + bitDepth +
+                    '}';
+        }
+    }
+}
@@ -0,0 +1,443 @@
+package com.twelvemonkeys.imageio.plugins.iff;
+
+import javax.imageio.IIOException;
+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.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: Form.java,v 1.0 31/01/2022 haraldk Exp$
+ */
+abstract class Form {
+
+    final int formType;
+    final List<GenericChunk> meta = new ArrayList<>();
+
+    Form(int formType) {
+        this.formType = formType;
+    }
+
+    abstract int width();
+    abstract int height();
+    abstract double aspect();
+    abstract int bitplanes();
+    abstract int compressionType();
+
+    boolean isMultiPalette() {
+        return false;
+    }
+
+    boolean isHAM() {
+        return false;
+    }
+
+    public boolean premultiplied() {
+        return false;
+    }
+
+    public int sampleSize() {
+        return 1;
+    }
+
+    public int transparentIndex() {
+        return -1;
+    }
+
+    public IndexColorModel colorMap() throws IIOException {
+        return null;
+    }
+
+    public ColorModel colorMapForRow(IndexColorModel colorModel, int row) {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract boolean hasThumbnail();
+
+    public abstract int thumbnailWidth();
+
+    public abstract int thumbnailHeight();
+
+    public abstract BufferedImage thumbnail();
+
+    abstract long bodyOffset();
+    abstract long bodyLength();
+
+    @Override
+    public String toString() {
+        return toChunkStr(formType);
+    }
+
+    Form with(final IFFChunk chunk) throws IIOException {
+        if (chunk instanceof GenericChunk) {
+            // TODO: This feels kind of hackish, as it breaks the immutable design, perhaps we should just reconsider...
+            meta.add((GenericChunk) chunk);
+
+            return this;
+        }
+
+        throw new IllegalArgumentException(chunk + " not supported in FORM type " + toChunkStr(formType));
+    }
+
+    static Form ofType(int formType) {
+        switch (formType) {
+            case IFF.TYPE_ACBM:
+            case IFF.TYPE_ILBM:
+            case IFF.TYPE_PBM:
+            case IFF.TYPE_RGB8:
+                return new ILBMForm(formType);
+            case IFF.TYPE_DEEP:
+            case IFF.TYPE_TVPP:
+                return new DEEPForm(formType);
+            default:
+                throw new IllegalArgumentException("FORM type " + toChunkStr(formType) + " not supported");
+        }
+    }
+
+    /**
+     * The set of chunks used in the "original" ILBM,
+     * and also ACBM, PBM and RGB8 FORMs.
+     */
+    static final class ILBMForm extends Form {
+        private final BMHDChunk bitmapHeader;
+        private final CAMGChunk viewMode;
+        private final CMAPChunk colorMap;
+        private final AbstractMultiPaletteChunk multiPalette;
+        private final XS24Chunk thumbnail; // TVPaint puts these into normal IFF ILBM 24 bit files as well as DEEP/TVPP
+        private final BODYChunk body;
+
+        ILBMForm(int formType) {
+            this(formType, null, null, null, null, null, null);
+        }
+
+        private ILBMForm(final int formType, final BMHDChunk bitmapHeader, final CAMGChunk viewMode, final CMAPChunk colorMap, final AbstractMultiPaletteChunk multiPalette, final XS24Chunk thumbnail, final BODYChunk body) {
+            super(isTrue(validFormType(formType), formType, "Unknown IFF Form type: %s"));
+            this.bitmapHeader = bitmapHeader;
+            this.viewMode = viewMode;
+            this.colorMap = colorMap;
+            this.multiPalette = multiPalette;
+            this.thumbnail = thumbnail;
+            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;
+        }
+
+        @Override
+        int height() {
+            return bitmapHeader.height;
+        }
+
+        @Override
+        int bitplanes() {
+            return bitmapHeader.bitplanes;
+        }
+
+        @Override
+        int compressionType() {
+            return bitmapHeader.compressionType;
+        }
+
+        @Override
+        double aspect() {
+            return bitmapHeader.yAspect == 0 ? 0 : (bitmapHeader.xAspect / (double) bitmapHeader.yAspect);
+        }
+
+        @Override
+        boolean isMultiPalette() {
+            return multiPalette != null;
+        }
+
+        boolean isEHB() {
+            return viewMode != null && viewMode.isEHB();
+        }
+
+        @Override
+        boolean isHAM() {
+            return viewMode != null && viewMode.isHAM();
+        }
+
+        boolean isLaced() {
+            return viewMode != null && viewMode.isLaced();
+        }
+
+        @Override
+        public int transparentIndex() {
+            return bitmapHeader.maskType == BMHDChunk.MASK_TRANSPARENT_COLOR ? bitmapHeader.transparentIndex : -1;
+        }
+
+        @Override
+        public IndexColorModel colorMap() throws IIOException {
+            return colorMap != null ? colorMap.getIndexColorModel(this) : null;
+        }
+
+        @Override
+        public ColorModel colorMapForRow(final IndexColorModel colorModel, final int row) {
+            return multiPalette != null ? multiPalette.getColorModel(colorModel, row, isLaced()) : null;
+        }
+
+        @Override
+        public boolean hasThumbnail() {
+            return thumbnail != null;
+        }
+
+        @Override
+        public int thumbnailWidth() {
+            return thumbnail != null ? thumbnail.width : -1;
+        }
+
+        @Override
+        public int thumbnailHeight() {
+            return thumbnail != null ? thumbnail.height : -1;
+        }
+
+        @Override
+        public BufferedImage thumbnail() {
+            return thumbnail != null ? thumbnail.thumbnail() : null;
+        }
+
+        @Override
+        long bodyOffset() {
+            return body.chunkOffset;
+        }
+
+        @Override
+        long bodyLength() {
+            return body.chunkLength;
+        }
+
+        @Override
+        ILBMForm with(final IFFChunk chunk) throws IIOException {
+            if (chunk instanceof BMHDChunk) {
+                if (bitmapHeader != null) {
+                    throw new IIOException("Multiple BMHD chunks not allowed");
+                }
+
+                return new ILBMForm(formType, (BMHDChunk) chunk, null, colorMap, multiPalette, thumbnail, body);
+            }
+            else if (chunk instanceof CAMGChunk) {
+                if (viewMode != null) {
+                    throw new IIOException("Multiple CAMG chunks not allowed");
+                }
+
+                return new ILBMForm(formType, bitmapHeader, (CAMGChunk) chunk, colorMap, multiPalette, thumbnail, body);
+            }
+            else if (chunk instanceof CMAPChunk) {
+                if (colorMap != null) {
+                    throw new IIOException("Multiple CMAP chunks not allowed");
+                }
+
+                return new ILBMForm(formType, bitmapHeader, viewMode, (CMAPChunk) chunk, multiPalette, thumbnail, body);
+            }
+            else if (chunk instanceof AbstractMultiPaletteChunk) {
+                // NOTE: We prefer PHCG over SHAM/CTBL style palette changes, if both are present
+                if (multiPalette instanceof PCHGChunk) {
+                    if (chunk instanceof PCHGChunk) {
+                        throw new IIOException("Multiple PCHG/SHAM/CTBL chunks not allowed");
+                    }
+
+                    return this;
+                }
+
+                return new ILBMForm(formType, bitmapHeader, viewMode, colorMap, (AbstractMultiPaletteChunk) chunk, thumbnail, body);
+            }
+            else if (chunk instanceof XS24Chunk) {
+                if (thumbnail != null) {
+                    throw new IIOException("Multiple XS24 chunks not allowed");
+                }
+
+                return new ILBMForm(formType, bitmapHeader, viewMode, colorMap, multiPalette, (XS24Chunk) chunk, body);
+            }
+            else if (chunk instanceof BODYChunk) {
+                if (body != null) {
+                    throw new IIOException("Multiple " + toChunkStr(chunk.chunkId) + " chunks not allowed");
+                }
+
+                return new ILBMForm(formType, bitmapHeader, viewMode, colorMap, multiPalette, thumbnail, (BODYChunk) chunk);
+            }
+            else if (chunk instanceof GRABChunk) {
+                // Ignored for now
+                return this;
+            }
+
+            return (ILBMForm) super.with(chunk);
+        }
+
+        @Override
+        public String toString() {
+            return super.toString() + '{' + bitmapHeader +
+                    (viewMode != null ? ", " + viewMode : "" ) +
+                    (colorMap != null ? ", " + colorMap : "" ) +
+                    (multiPalette != null ? ", " + multiPalette : "" ) +
+                    '}';
+        }
+    }
+
+    /**
+     * The set of chunks used in DEEP and TVPP FORMs.
+     */
+    private static final class DEEPForm extends Form {
+        private final DGBLChunk deepGlobal;
+        private final DLOCChunk deepLocation;
+        private final DPELChunk deepPixel;
+        private final XS24Chunk thumbnail;
+        private final BODYChunk body;
+
+        DEEPForm(int formType) {
+            this(formType, null, null, null, null, null);
+        }
+
+        private DEEPForm(final int formType, final DGBLChunk deepGlobal, final DLOCChunk deepLocation, final DPELChunk deepPixel, final XS24Chunk thumbnail, final BODYChunk body) {
+            super(isTrue(validFormType(formType), formType, "Unknown IFF Form type: %s"));
+            this.deepGlobal = deepGlobal;
+            this.deepLocation = deepLocation;
+            this.deepPixel = deepPixel;
+            this.thumbnail = thumbnail;
+            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() {
+            return deepLocation.width;
+        }
+
+        @Override
+        int height() {
+            return deepLocation.height;
+        }
+
+        @Override
+        int bitplanes() {
+            return deepPixel.bitsPerPixel();
+        }
+
+        @Override
+        public int sampleSize() {
+            return bitplanes() / 8;
+        }
+
+        @Override
+        public boolean premultiplied() {
+            return true;
+        }
+
+        @Override
+        int compressionType() {
+            return deepGlobal.compressionType;
+        }
+
+        @Override
+        double aspect() {
+            return deepGlobal.yAspect == 0 ? 0 : deepGlobal.xAspect / (double) deepGlobal.yAspect;
+        }
+
+        @Override
+        public boolean hasThumbnail() {
+            return thumbnail != null;
+        }
+
+        @Override
+        public int thumbnailWidth() {
+            return thumbnail != null ? thumbnail.width : -1;
+        }
+
+        @Override
+        public int thumbnailHeight() {
+            return thumbnail != null ? thumbnail.height : -1;
+        }
+
+        @Override
+        public BufferedImage thumbnail() {
+            return thumbnail != null ? thumbnail.thumbnail() : null;
+        }
+
+        @Override
+        long bodyOffset() {
+            return body.chunkOffset;
+        }
+
+        @Override
+        long bodyLength() {
+            return body.chunkLength;
+        }
+
+        @Override
+        DEEPForm with(final IFFChunk chunk) throws IIOException {
+            if (chunk instanceof DGBLChunk) {
+                if (deepGlobal != null) {
+                    throw new IIOException("Multiple DGBL chunks not allowed");
+                }
+
+                return new DEEPForm(formType, (DGBLChunk) chunk, null, null, thumbnail, body);
+            }
+            else if (chunk instanceof DLOCChunk) {
+                if (deepLocation != null) {
+                    throw new IIOException("Multiple DLOC chunks not allowed");
+                }
+
+                return new DEEPForm(formType, deepGlobal, (DLOCChunk) chunk, deepPixel, thumbnail, body);
+            }
+            else if (chunk instanceof DPELChunk) {
+                if (deepPixel != null) {
+                    throw new IIOException("Multiple DPEL chunks not allowed");
+                }
+
+                return new DEEPForm(formType, deepGlobal, deepLocation, (DPELChunk) chunk, thumbnail, body);
+            }
+            else if (chunk instanceof XS24Chunk) {
+                if (thumbnail != null) {
+                    throw new IIOException("Multiple XS24 chunks not allowed");
+                }
+
+                return new DEEPForm(formType, deepGlobal, deepLocation, deepPixel, (XS24Chunk) chunk, body);
+            }
+            else if (chunk instanceof BODYChunk) {
+                // TODO: Make a better approach!
+//                 if (body != null) {
+//                     throw new IIOException("Multiple " + toChunkStr(chunk.chunkId) + " chunks not allowed");
+//                 }
+
+                return new DEEPForm(formType, deepGlobal, deepLocation, deepPixel, thumbnail, (BODYChunk) chunk);
+            }
+
+            return (DEEPForm) super.with(chunk);
+        }
+
+        @Override
+        public String toString() {
+            return super.toString() + '{' + deepGlobal + ", " + deepLocation + ", " + deepPixel + '}';
+        }
+    }
+}
@@ -50,25 +50,25 @@ final class GRABChunk extends IFFChunk {

    Point2D point;

-    protected GRABChunk(int pChunkLength) {
-        super(IFF.CHUNK_GRAB, pChunkLength);
+    GRABChunk(int chunkLength) {
+        super(IFF.CHUNK_GRAB, chunkLength);
    }

-    protected GRABChunk(Point2D pPoint) {
+    GRABChunk(Point2D point) {
        super(IFF.CHUNK_GRAB, 4);
-        point = pPoint;
+        this.point = point;
    }

-    void readChunk(DataInput pInput) throws IOException {
+    void readChunk(DataInput input) throws IOException {
        if (chunkLength != 4) {
            throw new IIOException("Unknown GRAB chunk size: " + chunkLength);
        }
-        point = new Point(pInput.readShort(), pInput.readShort());
+        point = new Point(input.readShort(), input.readShort());
    }

-    void writeChunk(DataOutput pOutput) throws IOException {
-        pOutput.writeShort((int) point.getX());
-        pOutput.writeShort((int) point.getY());
+    void writeChunk(DataOutput output) throws IOException {
+        output.writeShort((int) point.getX());
+        output.writeShort((int) point.getY());
    }

    public String toString() {
@@ -44,31 +44,31 @@ final class GenericChunk extends IFFChunk {

    byte[] data;

-    protected GenericChunk(int pChunkId, int pChunkLength) {
-        super(pChunkId, pChunkLength);
-        data = new byte[chunkLength];
+    GenericChunk(int chunkId, int chunkLength) {
+        super(chunkId, chunkLength);
+        data = new byte[this.chunkLength];
    }

-    protected GenericChunk(int pChunkId, byte[] pChunkData) {
-        super(pChunkId, pChunkData.length);
-        data = pChunkData;
+    GenericChunk(int chunkId, byte[] chunkData) {
+        super(chunkId, chunkData.length);
+        data = chunkData;
    }

    @Override
-    void readChunk(final DataInput pInput) throws IOException {
-        pInput.readFully(data, 0, data.length);
+    void readChunk(final DataInput input) throws IOException {
+        input.readFully(data, 0, data.length);

-        skipData(pInput, chunkLength, data.length);
+        skipData(input, chunkLength, data.length);
    }

    @Override
-    void writeChunk(final DataOutput pOutput) throws IOException {
-        pOutput.writeInt(chunkId);
-        pOutput.writeInt(chunkLength);
-        pOutput.write(data, 0, data.length);
+    void writeChunk(final DataOutput output) throws IOException {
+        output.writeInt(chunkId);
+        output.writeInt(chunkLength);
+        output.write(data, 0, data.length);

        if (data.length % 2 != 0) {
-            pOutput.writeByte(0); // PAD
+            output.writeByte(0); // PAD
        }
    }

@@ -49,6 +49,8 @@ interface IFF {
    // TODO:
    /** IFF DEEP form type (TVPaint) */
    int TYPE_DEEP  = ('D' << 24) + ('E' << 16) + ('E' << 8) + 'P';
+    /** IFF TVPP form type (TVPaint Project) */
+    int TYPE_TVPP =  ('T' << 24) + ('V' << 16) + ('P' << 8) + 'P';
    /** IFF RGB8 form type (TurboSilver) */
    int TYPE_RGB8  = ('R' << 24) + ('G' << 16) + ('B' << 8) + '8';
    /** IFF RGBN form type (TurboSilver) */
@@ -92,7 +94,7 @@ interface IFF {
    int CHUNK_COPY = ('(' << 24) + ('c' << 16) + (')' << 8) + ' ';

    /** EA IFF 85 Generic annotation chunk (usually used for Software) */
-    int CHUNK_ANNO = ('A' << 24) + ('N' << 16) + ('N' << 8) + 'O';;
+    int CHUNK_ANNO = ('A' << 24) + ('N' << 16) + ('N' << 8) + 'O';

    /** Third-party defined UTF-8 text. */
    int CHUNK_UTF8 = ('U' << 24) + ('T' << 16) + ('F' << 8) + '8';
@@ -129,6 +131,18 @@ interface IFF {
    int CHUNK_SHAM = ('S' << 24) + ('H' << 16) + ('A' << 8) + 'M';
    /** ACBM body chunk */
    int CHUNK_ABIT = ('A' << 24) + ('B' << 16) + ('I' << 8) + 'T';
-    /** unofficial direct color */
+    /** Unofficial direct color */
    int CHUNK_DCOL = ('D' << 24) + ('C' << 16) + ('O' << 8) + 'L';
+    /** TVPaint Deep GloBaL information */
+    int CHUNK_DGBL = ('D' << 24) + ('G' << 16) + ('B' << 8) + 'L';
+    /** TVPaint Deep Pixel ELements */
+    int CHUNK_DPEL = ('D' << 24) + ('P' << 16) + ('E' << 8) + 'L';
+    /** TVPaint Deep LOCation information */
+    int CHUNK_DLOC = ('D' << 24) + ('L' << 16) + ('O' << 8) + 'C';
+    /** TVPaint Deep BODy */
+    int CHUNK_DBOD = ('D' << 24) + ('B' << 16) + ('O' << 8) + 'D';
+    /** TVPaint Deep CHanGe buffer */
+    int CHUNK_DCHG = ('D' << 24) + ('C' << 16) + ('H' << 8) + 'G';
+    /** TVPaint 24 bit thumbnail */
+    int CHUNK_XS24 = ('X' << 24) + ('S' << 16) + ('2' << 8) + '4';
 }
@@ -44,25 +44,25 @@ abstract class IFFChunk {
    int chunkId;
    int chunkLength;

-    protected IFFChunk(int pChunkId, int pChunkLength) {
-        chunkId = pChunkId;
-        chunkLength = pChunkLength;
+    protected IFFChunk(int chunkId, int chunkLength) {
+        this.chunkId = chunkId;
+        this.chunkLength = chunkLength;
    }

-    abstract void readChunk(DataInput pInput) throws IOException;
+    abstract void readChunk(DataInput input) throws IOException;

-    abstract void writeChunk(DataOutput pOutput) throws IOException;
+    abstract void writeChunk(DataOutput output) throws IOException;

-    protected static void skipData(final DataInput pInput, final int chunkLength, final int dataReadSoFar) throws IOException {
+    protected static void skipData(final DataInput input, final int chunkLength, final int dataReadSoFar) throws IOException {
        int toSkip = chunkLength - dataReadSoFar;

        while (toSkip > 0) {
-            toSkip -= pInput.skipBytes(toSkip);
+            toSkip -= input.skipBytes(toSkip);
        }

        // Read pad
        if (chunkLength % 2 != 0) {
-            pInput.readByte();
+            input.readByte();
        }
    }

@@ -1,180 +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 int formType;
-    private final BMHDChunk header;
-    private final IndexColorModel colorMap;
-    private final CAMGChunk viewPort;
-    private final List<GenericChunk> meta;
-
-    IFFImageMetadata(int formType, BMHDChunk header, IndexColorModel colorMap, CAMGChunk viewPort, List<GenericChunk> meta) {
-        this.formType = isTrue(validFormType(formType), formType, "Unknown IFF Form type: %s");
-        this.header = notNull(header, "header");
-        this.colorMap = colorMap;
-        this.viewPort = viewPort;
-        this.meta = 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) {
-            case TYPE_ACBM:
-            case TYPE_DEEP:
-            case TYPE_ILBM:
-            case TYPE_PBM:
-            case TYPE_RGB8:
-            case TYPE_RGBN:
-                return true;
-            default:
-                return false;
-        }
+    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 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 == 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)));
-            }
-        }
-
-        // TODO: Background color is the color of the transparent index in the color model?
-//        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 (formType) {
-            case TYPE_PBM:
-                planarConfiguration.setAttribute("value", "PixelInterleaved");
-                break;
-            case TYPE_ILBM:
-                planarConfiguration.setAttribute("value", "PlaneInterleaved");
-                break;
-            default:
-                planarConfiguration.setAttribute("value", "Unknown " + IFFUtil.toChunkStr(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:
@@ -184,86 +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 new int[] {8, 8, 8, 1};
            case 32:
-                return "8 8 8 8";
+                return new int[] {8, 8, 8, 8};
            default:
-                throw new IllegalArgumentException("Ubknown bit count: " + bitplanes);
+                throw new IllegalArgumentException("Unknown bit count: " + bitplanes);
        }
    }

-    @Override
-    protected IIOMetadataNode getStandardDimensionNode() {
-        if (viewPort == null) {
-            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((viewPort.isHires() ? 2f : 1f) / (viewPort.isLaced() ? 2f : 1f)));
-        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) {
-            return null;
-        }
-
-        IIOMetadataNode transparency = new IIOMetadataNode("Transparency");
-
-        if (header.bitplanes == 32) {
-            IIOMetadataNode alpha = new IIOMetadataNode("Alpha");
-            alpha.setAttribute("value", "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;
    }
 }
@@ -30,13 +30,12 @@

 package com.twelvemonkeys.imageio.plugins.iff;

-import java.io.IOException;
-import java.util.Locale;
+import com.twelvemonkeys.imageio.spi.ImageReaderSpiBase;

 import javax.imageio.ImageReader;
 import javax.imageio.stream.ImageInputStream;
-
-import com.twelvemonkeys.imageio.spi.ImageReaderSpiBase;
+import java.io.IOException;
+import java.util.Locale;

 /**
 * IFFImageReaderSpi
@@ -54,41 +53,41 @@ public final class IFFImageReaderSpi extends ImageReaderSpiBase {
    }

    @Override
-    public boolean canDecodeInput(Object pSource) throws IOException {
-        return pSource instanceof ImageInputStream && canDecode((ImageInputStream) pSource);
+    public boolean canDecodeInput(final Object source) throws IOException {
+        return source instanceof ImageInputStream && canDecode((ImageInputStream) source);
    }

-    private static boolean canDecode(ImageInputStream pInput) throws IOException {
-        pInput.mark();
+    private static boolean canDecode(final ImageInputStream input) throws IOException {
+        input.mark();

        try {
            // Is it IFF
-            if (pInput.readInt() == IFF.CHUNK_FORM) {
-                pInput.readInt();// Skip length field
+            if (input.readInt() == IFF.CHUNK_FORM) {
+                input.readInt();// Skip length field

-                int type = pInput.readInt();
-
-                // Is it ILBM or PBM
-                if (type == IFF.TYPE_ILBM || type == IFF.TYPE_PBM) {
+                int type = input.readInt();
+                if (type == IFF.TYPE_ILBM || type == IFF.TYPE_PBM
+                        || type == IFF.TYPE_RGB8 // Impulse RGB8 format
+                        || type == IFF.TYPE_DEEP || type == IFF.TYPE_TVPP) { // TVPaint DEEP format
                    return true;
                }

            }
        }
        finally {
-            pInput.reset();
+            input.reset();
        }

        return false;
    }

    @Override
-    public ImageReader createReaderInstance(Object pExtension) throws IOException {
+    public ImageReader createReaderInstance(final Object extension) {
        return new IFFImageReader(this);
    }

    @Override
-    public String getDescription(Locale pLocale) {
+    public String getDescription(Locale locale) {
        return "Commodore Amiga/Electronic Arts Image Interchange Format (IFF) image reader";
    }
 }
@@ -30,31 +30,22 @@

 package com.twelvemonkeys.imageio.plugins.iff;

-import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.awt.image.ColorModel;
-import java.awt.image.IndexColorModel;
-import java.awt.image.Raster;
-import java.awt.image.RenderedImage;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.IOException;
-import java.io.OutputStream;
-
-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 com.twelvemonkeys.imageio.ImageWriterBase;
 import com.twelvemonkeys.imageio.util.IIOUtil;
 import com.twelvemonkeys.io.FastByteArrayOutputStream;
 import com.twelvemonkeys.io.enc.EncoderStream;
 import com.twelvemonkeys.io.enc.PackBitsEncoder;

+import javax.imageio.*;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.spi.ImageWriterSpi;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+
 /**
 * Writer for Commodore Amiga (Electronic Arts) IFF ILBM (InterLeaved BitMap) format.
 * The IFF format (Interchange File Format) is the standard file format
@@ -68,8 +59,8 @@ import com.twelvemonkeys.io.enc.PackBitsEncoder;
 */
 public final class IFFImageWriter extends ImageWriterBase {

-    IFFImageWriter(ImageWriterSpi pProvider) {
-        super(pProvider);
+    IFFImageWriter(ImageWriterSpi provider) {
+        super(provider);
    }

    @Override
@@ -83,23 +74,29 @@ public final class IFFImageWriter extends ImageWriterBase {
    }

    @Override
-    public void write(IIOMetadata pStreamMetadata, IIOImage pImage, ImageWriteParam pParam) throws IOException {
+    public ImageWriteParam getDefaultWriteParam() {
+        return new IFFWriteParam(getLocale());
+    }
+
+    @Override
+    public void write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) throws IOException {
        assertOutput();

-        if (pImage.hasRaster()) {
+        if (image.hasRaster()) {
            throw new UnsupportedOperationException("Cannot write raster");
        }

        processImageStarted(0);

+        RenderedImage renderedImage = image.getRenderedImage();
+        boolean compress = shouldCompress(renderedImage, param);
+
        // Prepare image data to be written
        ByteArrayOutputStream imageData = new FastByteArrayOutputStream(1024);
-        packImageData(imageData, pImage.getRenderedImage(), pParam);
-
-        //System.out.println("Image data: " + imageData.size());
+        packImageData(imageData, renderedImage, compress);

        // Write metadata
-        writeMeta(pImage.getRenderedImage(), imageData.size());
+        writeMeta(renderedImage, imageData.size(), compress);

        // Write image data
        writeBody(imageData);
@@ -107,34 +104,31 @@ public final class IFFImageWriter extends ImageWriterBase {
        processImageComplete();
    }

-    private void writeBody(ByteArrayOutputStream pImageData) throws IOException {
+    private void writeBody(ByteArrayOutputStream imageData) throws IOException {
        imageOutput.writeInt(IFF.CHUNK_BODY);
-        imageOutput.writeInt(pImageData.size());
+        imageOutput.writeInt(imageData.size());

-        // NOTE: This is much faster than imageOutput.write(pImageData.toByteArray())
+        // NOTE: This is much faster than imageOutput.write(imageData.toByteArray())
        // as the data array is not duplicated
        try (OutputStream adapter = IIOUtil.createStreamAdapter(imageOutput)) {
-            pImageData.writeTo(adapter);
+            imageData.writeTo(adapter);
        }

-        if (pImageData.size() % 2 == 0) {
+        if (imageData.size() % 2 == 0) {
            imageOutput.writeByte(0); // PAD
        }

        imageOutput.flush();
    }

-    private void packImageData(OutputStream pOutput, RenderedImage pImage, ImageWriteParam pParam) throws IOException {
-        // TODO: Allow param to dictate uncompressed
-        // TODO: Allow param to dictate type PBM?
+    private void packImageData(OutputStream outputStream, RenderedImage image, final boolean compress) throws IOException {
        // TODO: Subsample/AOI
-        final boolean compress = shouldCompress(pImage);
-        final OutputStream output = compress ? new EncoderStream(pOutput, new PackBitsEncoder(), true) : pOutput;
-        final ColorModel model = pImage.getColorModel();
-        final Raster raster = pImage.getData();
+        final OutputStream output = compress ? new EncoderStream(outputStream, new PackBitsEncoder(), true) : outputStream;
+        final ColorModel model = image.getColorModel();
+        final Raster raster = image.getData();

-        final int width = pImage.getWidth();
-        final int height = pImage.getHeight();
+        final int width = image.getWidth();
+        final int height = image.getHeight();

        // Store each row of pixels
        // 0. Loop pr channel
@@ -142,7 +136,6 @@ public final class IFFImageWriter extends ImageWriterBase {
        // 2. Perform byteRun1 compression for each plane separately
        // 3. Write the plane data for each plane

-        //final int planeWidth = (width + 7) / 8;
        final int planeWidth = 2 * ((width + 15) / 16);
        final byte[] planeData = new byte[8 * planeWidth];
        final int channels = (model.getPixelSize() + 7) / 8;
@@ -167,10 +160,6 @@ public final class IFFImageWriter extends ImageWriterBase {

                for (int p = 0; p < planesPerChannel; p++) {
                    output.write(planeData, p * planeWidth, planeWidth);
-
-                    if (!compress && planeWidth % 2 != 0) {
-                        output.write(0); // PAD
-                    }
                }
            }

@@ -182,17 +171,16 @@ public final class IFFImageWriter extends ImageWriterBase {
        output.flush();
    }

-    private void writeMeta(RenderedImage pImage, int pBodyLength) throws IOException {
+    private void writeMeta(RenderedImage image, int bodyLength, boolean compress) throws IOException {
        // Annotation ANNO chunk, 8 + annoData.length bytes
        String annotation = String.format("Written by %s IFFImageWriter %s", getOriginatingProvider().getVendorName(), getOriginatingProvider().getVersion());
        GenericChunk anno = new GenericChunk(IFFUtil.toInt("ANNO".getBytes()), annotation.getBytes());

-        ColorModel cm = pImage.getColorModel();
+        ColorModel cm = image.getColorModel();
        IndexColorModel icm = null;

        // Bitmap header BMHD chunk, 8 + 20 bytes
-        // By default, don't compress narrow images
-        int compression = shouldCompress(pImage) ? BMHDChunk.COMPRESSION_BYTE_RUN : BMHDChunk.COMPRESSION_NONE;
+        int compression = compress ? BMHDChunk.COMPRESSION_BYTE_RUN : BMHDChunk.COMPRESSION_NONE;

        BMHDChunk header;
        if (cm instanceof IndexColorModel) {
@@ -200,12 +188,12 @@ public final class IFFImageWriter extends ImageWriterBase {
            icm = (IndexColorModel) cm;
            int trans = icm.getTransparency() == Transparency.BITMASK ? BMHDChunk.MASK_TRANSPARENT_COLOR : BMHDChunk.MASK_NONE;
            int transPixel = icm.getTransparency() == Transparency.BITMASK ? icm.getTransparentPixel() : 0;
-            header = new BMHDChunk(pImage.getWidth(), pImage.getHeight(), icm.getPixelSize(),
+            header = new BMHDChunk(image.getWidth(), image.getHeight(), icm.getPixelSize(),
                                   trans, compression, transPixel);
        }
        else {
            //System.out.println(cm.getClass().getName());
-            header = new BMHDChunk(pImage.getWidth(), pImage.getHeight(), cm.getPixelSize(),
+            header = new BMHDChunk(image.getWidth(), image.getHeight(), cm.getPixelSize(),
                                   BMHDChunk.MASK_NONE, compression, 0);
        }

@@ -217,7 +205,7 @@ public final class IFFImageWriter extends ImageWriterBase {
        }

        // ILBM(4) + anno(8+len) + header(8+20) + cmap(8+len)? + body(8+len);
-        int size = 4 + 8 + anno.chunkLength + 28 + 8 + pBodyLength;
+        int size = 4 + 8 + anno.chunkLength + 28 + 8 + bodyLength;
        if (cmap != null) {
            size += 8 + cmap.chunkLength;
        }
@@ -231,21 +219,30 @@ public final class IFFImageWriter extends ImageWriterBase {
        header.writeChunk(imageOutput);

        if (cmap != null) {
-            //System.out.println("CMAP written");
            cmap.writeChunk(imageOutput);
        }
-
    }

-    private boolean shouldCompress(RenderedImage pImage) {
-        return pImage.getWidth() >= 32;
+    private boolean shouldCompress(final RenderedImage image, final ImageWriteParam param) {
+        if (param != null && param.canWriteCompressed()) {
+            switch (param.getCompressionMode()) {
+                case ImageWriteParam.MODE_DISABLED:
+                    return false;
+                case ImageWriteParam.MODE_EXPLICIT:
+                    return IFFWriteParam.COMPRESSION_TYPES[1].equals(param.getCompressionType());
+                default:
+                    // Fall through
+            }
+        }
+
+        return image.getWidth() >= 32;
    }

-    public static void main(String[] pArgs) throws IOException {
-        BufferedImage image = ImageIO.read(new File(pArgs[0]));
+    public static void main(String[] args) throws IOException {
+        BufferedImage image = ImageIO.read(new File(args[0]));

        ImageWriter writer = new IFFImageWriter(new IFFImageWriterSpi());
-        writer.setOutput(ImageIO.createImageOutputStream(new File(pArgs[1])));
+        writer.setOutput(ImageIO.createImageOutputStream(new File(args[1])));
        //writer.addIIOWriteProgressListener(new ProgressListenerBase() {
        //    int mCurrPct = 0;
        //
@@ -30,13 +30,11 @@

 package com.twelvemonkeys.imageio.plugins.iff;

-import java.io.IOException;
-import java.util.Locale;
+import com.twelvemonkeys.imageio.spi.ImageWriterSpiBase;

 import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.ImageWriter;
-
-import com.twelvemonkeys.imageio.spi.ImageWriterSpiBase;
+import java.util.Locale;

 /**
 * IFFImageWriterSpi
@@ -53,19 +51,19 @@ public class IFFImageWriterSpi extends ImageWriterSpiBase {
        super(new IFFProviderInfo());
    }

-    public boolean canEncodeImage(final ImageTypeSpecifier pType) {
+    public boolean canEncodeImage(final ImageTypeSpecifier type) {
        // TODO: Probably can't store 16 bit types etc...
        // TODO: Can't store CMYK (well.. it does, but they can't be read back) 
        return true;
    }

    @Override
-    public ImageWriter createWriterInstance(Object pExtension) throws IOException {
+    public ImageWriter createWriterInstance(Object extension) {
        return new IFFImageWriter(this);
    }

    @Override
-    public String getDescription(Locale pLocale) {
+    public String getDescription(Locale locale) {
        return "Commodore Amiga/Electronic Arts Image Interchange Format (IFF) image writer";
    }
 }
@@ -40,11 +40,11 @@ import com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfo;
 * @version $Id: IFFProviderInfo.java,v 1.0 20/03/15 harald.kuhr Exp$
 */
 final class IFFProviderInfo extends ReaderWriterProviderInfo {
-    protected IFFProviderInfo() {
+    IFFProviderInfo() {
        super(
                IFFProviderInfo.class,
                new String[] {"iff", "IFF"},
-                new String[] {"iff", "lbm", "ham", "ham8", "ilbm"},
+                new String[] {"iff", "lbm", "ham", "ham8", "ilbm", "rgb8", "deep"},
                new String[] {"image/iff", "image/x-iff"},
                "com.twelvemonkeys.imageio.plugins.iff.IFFImageReader",
                new String[]{"com.twelvemonkeys.imageio.plugins.iff.IFFImageReaderSpi"},
@@ -56,11 +56,11 @@ final class IFFUtil {
     * @return the rotation table
     */
    static private long[] rtable(int n) {
-        return new long[]{
-                0x00000000l << n, 0x00000001l << n, 0x00000100l << n, 0x00000101l << n,
-                0x00010000l << n, 0x00010001l << n, 0x00010100l << n, 0x00010101l << n,
-                0x01000000l << n, 0x01000001l << n, 0x01000100l << n, 0x01000101l << n,
-                0x01010000l << n, 0x01010001l << n, 0x01010100l << n, 0x01010101l << n
+        return new long[] {
+                0x00000000L     , 0x00000001L << n, 0x00000100L << n, 0x00000101L << n,
+                0x00010000L << n, 0x00010001L << n, 0x00010100L << n, 0x00010101L << n,
+                0x01000000L << n, 0x01000001L << n, 0x01000100L << n, 0x01000101L << n,
+                0x01010000L << n, 0x01010001L << n, 0x01010100L << n, 0x01010101L << n
        };
    }

@@ -75,16 +75,16 @@ final class IFFUtil {
     * Bits from the source are rotated 90 degrees clockwise written to the
     * destination.
     *
-     * @param pSrc     source pixel data
-     * @param pSrcPos  starting index of 8 x 8 bit source tile
-     * @param pSrcStep byte offset between adjacent rows in source
-     * @param pDst     destination pixel data
-     * @param pDstPos  starting index of 8 x 8 bit destination tile
-     * @param pDstStep byte offset between adjacent rows in destination
+     * @param src     source pixel data
+     * @param srcPos  starting index of 8 x 8 bit source tile
+     * @param srcStep byte offset between adjacent rows in source
+     * @param dst     destination pixel data
+     * @param dstPos  starting index of 8 x 8 bit destination tile
+     * @param dstStep byte offset between adjacent rows in destination
     */
-    static void bitRotateCW(final byte[] pSrc, int pSrcPos, int pSrcStep,
-                            final byte[] pDst, int pDstPos, int pDstStep) {
-        int idx = pSrcPos;
+    static void bitRotateCW(final byte[] src, int srcPos, int srcStep,
+                            final byte[] dst, int dstPos, int dstStep) {
+        int idx = srcPos;

        int lonyb;
        int hinyb;
@@ -92,41 +92,41 @@ final class IFFUtil {
        long hi = 0;

        for (int i = 0; i < 8; i++) {
-            lonyb = pSrc[idx] & 0xF;
-            hinyb = (pSrc[idx] >> 4) & 0xF;
+            lonyb = src[idx] & 0xF;
+            hinyb = (src[idx] >> 4) & 0xF;
            lo |= RTABLE[i][lonyb];
            hi |= RTABLE[i][hinyb];
-            idx += pSrcStep;
+            idx += srcStep;
        }

-        idx = pDstPos;
+        idx = dstPos;

-        pDst[idx] = (byte)((hi >> 24) & 0xFF);
-        idx += pDstStep;
-        if (idx < pDst.length) {
-            pDst[idx] = (byte)((hi >> 16) & 0xFF);
-            idx += pDstStep;
-            if (idx < pDst.length) {
-                pDst[idx] = (byte)((hi >> 8) & 0xFF);
-                idx += pDstStep;
-                if (idx < pDst.length) {
-                    pDst[idx] = (byte)(hi & 0xFF);
-                    idx += pDstStep;
+        dst[idx] = (byte)((hi >> 24) & 0xFF);
+        idx += dstStep;
+        if (idx < dst.length) {
+            dst[idx] = (byte)((hi >> 16) & 0xFF);
+            idx += dstStep;
+            if (idx < dst.length) {
+                dst[idx] = (byte)((hi >> 8) & 0xFF);
+                idx += dstStep;
+                if (idx < dst.length) {
+                    dst[idx] = (byte)(hi & 0xFF);
+                    idx += dstStep;
                }
            }
        }

-        if (idx < pDst.length) {
-            pDst[idx] = (byte)((lo >> 24) & 0xFF);
-            idx += pDstStep;
-            if (idx < pDst.length) {
-                pDst[idx] = (byte)((lo >> 16) & 0xFF);
-                idx += pDstStep;
-                if (idx < pDst.length) {
-                    pDst[idx] = (byte)((lo >> 8) & 0xFF);
-                    idx += pDstStep;
-                    if (idx < pDst.length) {
-                        pDst[idx] = (byte)(lo & 0xFF);
+        if (idx < dst.length) {
+            dst[idx] = (byte)((lo >> 24) & 0xFF);
+            idx += dstStep;
+            if (idx < dst.length) {
+                dst[idx] = (byte)((lo >> 16) & 0xFF);
+                idx += dstStep;
+                if (idx < dst.length) {
+                    dst[idx] = (byte)((lo >> 8) & 0xFF);
+                    idx += dstStep;
+                    if (idx < dst.length) {
+                        dst[idx] = (byte)(lo & 0xFF);
                    }
                }
            }
@@ -137,16 +137,16 @@ final class IFFUtil {
     * Rotate bits counterclockwise.
     * The IFFImageWriter uses this to convert pixel bits from chunky to planar.
     *
-     * @param pSrc     source pixel data (only lower 8 bits used)
-     * @param pSrcPos  starting index of 8 x 8 bit source tile
-     * @param pSrcStep byte offset between adjacent rows in source
-     * @param pDst     destination pixel data
-     * @param pDstPos  starting index of 8 x 8 bit destination tile
-     * @param pDstStep byte offset between adjacent rows in destination
+     * @param src     source pixel data (only lower 8 bits used)
+     * @param srcPos  starting index of 8 x 8 bit source tile
+     * @param srcStep byte offset between adjacent rows in source
+     * @param dst     destination pixel data
+     * @param dstPos  starting index of 8 x 8 bit destination tile
+     * @param dstStep byte offset between adjacent rows in destination
     */
-    static void bitRotateCCW(final int[] pSrc, int pSrcPos, int pSrcStep,
-                             final byte[] pDst, int pDstPos, int pDstStep) {
-        int idx = pSrcPos;
+    static void bitRotateCCW(final int[] src, int srcPos, @SuppressWarnings("SameParameterValue") int srcStep,
+                             final byte[] dst, int dstPos, int dstStep) {
+        int idx = srcPos;

        int lonyb;
        int hinyb;
@@ -154,48 +154,49 @@ final class IFFUtil {
        long hi = 0;

        for (int i = 7; i >= 0; i--) {
-            lonyb = pSrc[idx] & 0xF;
-            hinyb = (pSrc[idx] >> 4) & 0xF;
+            lonyb = src[idx] & 0xF;
+            hinyb = (src[idx] >> 4) & 0xF;
            lo |= RTABLE[i][lonyb];
            hi |= RTABLE[i][hinyb];
-            idx += pSrcStep;
+            idx += srcStep;
        }

-        idx = pDstPos;
+        idx = dstPos;

-        pDst[idx] = (byte)(lo & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((lo >> 8) & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((lo >> 16) & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((lo >> 24) & 0xFF);
+        dst[idx] = (byte)(lo & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((lo >> 8) & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((lo >> 16) & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((lo >> 24) & 0xFF);

-        idx += pDstStep;
+        idx += dstStep;

-        pDst[idx] = (byte)(hi & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((hi >>  8) & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((hi >> 16) & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((hi >> 24) & 0xFF);
+        dst[idx] = (byte)(hi & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((hi >>  8) & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((hi >> 16) & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((hi >> 24) & 0xFF);
    }

    /**
     * Rotate bits counterclockwise.
     * The IFFImageWriter uses this to convert pixel bits from chunky to planar.
     *
-     * @param pSrc     source pixel data
-     * @param pSrcPos  starting index of 8 x 8 bit source tile
-     * @param pSrcStep byte offset between adjacent rows in source
-     * @param pDst     destination pixel data
-     * @param pDstPos  starting index of 8 x 8 bit destination tile
-     * @param pDstStep byte offset between adjacent rows in destination
+     * @param src     source pixel data
+     * @param srcPos  starting index of 8 x 8 bit source tile
+     * @param srcStep byte offset between adjacent rows in source
+     * @param dst     destination pixel data
+     * @param dstPos  starting index of 8 x 8 bit destination tile
+     * @param dstStep byte offset between adjacent rows in destination
     */
-    static void bitRotateCCW(final byte[] pSrc, int pSrcPos, int pSrcStep,
-                             final byte[] pDst, int pDstPos, int pDstStep) {
-        int idx = pSrcPos;
+    @SuppressWarnings("unused")
+    static void bitRotateCCW(final byte[] src, int srcPos, int srcStep,
+                             final byte[] dst, int dstPos, int dstStep) {
+        int idx = srcPos;

        int lonyb;
        int hinyb;
@@ -203,57 +204,57 @@ final class IFFUtil {
        long hi = 0;

        for (int i = 7; i >= 0; i--) {
-            lonyb = pSrc[idx] & 0xF;
-            hinyb = (pSrc[idx] >> 4) & 0xF;
+            lonyb = src[idx] & 0xF;
+            hinyb = (src[idx] >> 4) & 0xF;
            lo |= RTABLE[i][lonyb];
            hi |= IFFUtil.RTABLE[i][hinyb];
-            idx += pSrcStep;
+            idx += srcStep;
        }

-        idx = pDstPos;
+        idx = dstPos;

-        pDst[idx] = (byte)(lo & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((lo >> 8) & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((lo >> 16) & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((lo >> 24) & 0xFF);
+        dst[idx] = (byte)(lo & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((lo >> 8) & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((lo >> 16) & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((lo >> 24) & 0xFF);

-        idx += pDstStep;
+        idx += dstStep;

-        pDst[idx] = (byte)(hi & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((hi >>  8) & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((hi >> 16) & 0xFF);
-        idx += pDstStep;
-        pDst[idx] = (byte)((hi >> 24) & 0xFF);
+        dst[idx] = (byte)(hi & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((hi >>  8) & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((hi >> 16) & 0xFF);
+        idx += dstStep;
+        dst[idx] = (byte)((hi >> 24) & 0xFF);
    }

    /**
     * Converts a byte array to an int.
     *
-     * @param pBytes a byte array of length 4
+     * @param bytes a byte array of length 4
     * @return the bytes converted to an int
     *
     * @throws ArrayIndexOutOfBoundsException if length is < 4
     */
-    static int toInt(final byte[] pBytes) {
-        return (pBytes[0] & 0xff) << 24 | (pBytes[1] & 0xff) << 16
-                | (pBytes[2] & 0xff) << 8 | (pBytes[3] & 0xff);
+    static int toInt(final byte[] bytes) {
+        return (bytes[0] & 0xff) << 24 | (bytes[1] & 0xff) << 16
+                | (bytes[2] & 0xff) << 8 | (bytes[3] & 0xff);
    }

    /**
     * Converts an int to a four letter String.
     *
-     * @param pChunkId the chunk identifier
+     * @param chunkId the chunk identifier
     * @return a String
     */
-    static String toChunkStr(int pChunkId) {
-        return new String(new byte[] {(byte) ((pChunkId & 0xff000000) >> 24),
-                                      (byte) ((pChunkId & 0x00ff0000) >> 16),
-                                      (byte) ((pChunkId & 0x0000ff00) >>  8),
-                                      (byte) ((pChunkId & 0x000000ff))});
+    static String toChunkStr(int chunkId) {
+        return new String(new byte[] {(byte) ((chunkId & 0xff000000) >> 24),
+                                      (byte) ((chunkId & 0x00ff0000) >> 16),
+                                      (byte) ((chunkId & 0x0000ff00) >>  8),
+                                      (byte) ((chunkId & 0x000000ff))});
    }
 }
@@ -0,0 +1,25 @@
+package com.twelvemonkeys.imageio.plugins.iff;
+
+import javax.imageio.ImageWriteParam;
+import java.util.Locale;
+
+/**
+ * IFFWriteParam.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: IFFWriteParam.java,v 1.0 03/02/2022 haraldk Exp$
+ */
+public final class IFFWriteParam extends ImageWriteParam {
+
+    static final String[] COMPRESSION_TYPES = {"NONE", "RLE"};
+
+    public IFFWriteParam(final Locale locale) {
+        super(locale);
+
+        compressionTypes = COMPRESSION_TYPES;
+        compressionType = compressionTypes[1];
+
+        canWriteCompressed = true;
+    }
+}
@@ -80,9 +80,9 @@ final class MutableIndexColorModel extends ColorModel {
            // TODO: Move validation to chunk (when reading)
            if (index >= rgbs.length) {
                // TODO: Issue IIO warning
-                System.err.printf("warning - palette change register out of range\n");
+                System.err.println("warning - palette change register out of range");
                System.err.printf("    change structure %d  index=%d (max %d)\n", i, index, getMapSize() - 1);
-                System.err.printf("    ignoring it... colors might get messed up from here\n");
+                System.err.println("    ignoring it... colors might get messed up from here");
            }
            else if (index != MP_REG_IGNORE) {
                updateRGB(index, ((changes[i].r & 0xff) << 16) | ((changes[i].g & 0xff) << 8) | (changes[i].b & 0xff));
@@ -72,42 +72,43 @@ final class PCHGChunk extends AbstractMultiPaletteChunk {
    private int totalChanges;
    private int minReg;

-    public PCHGChunk(int pChunkLength) {
-        super(IFF.CHUNK_PCHG, pChunkLength);
+    PCHGChunk(int chunkLength) {
+        super(IFF.CHUNK_PCHG, chunkLength);
    }

    @Override
-    void readChunk(final DataInput pInput) throws IOException {
-        int compression = pInput.readUnsignedShort();
-        int flags = pInput.readUnsignedShort();
-        startLine = pInput.readShort();
-        lineCount = pInput.readUnsignedShort();
-        changedLines = pInput.readUnsignedShort();
-        minReg = pInput.readUnsignedShort();
-        int maxReg = pInput.readUnsignedShort();
-        /*int maxChangesPerLine = */pInput.readUnsignedShort(); // We don't really care, as we're not limited by the Amiga display hardware
-        totalChanges = pInput.readInt();
+    void readChunk(final DataInput input) throws IOException {
+        int compression = input.readUnsignedShort();
+        int flags = input.readUnsignedShort();
+        startLine = input.readShort();
+        lineCount = input.readUnsignedShort();
+        changedLines = input.readUnsignedShort();
+        minReg = input.readUnsignedShort();
+        int maxReg = input.readUnsignedShort();
+        /*int maxChangesPerLine = */
+        input.readUnsignedShort(); // We don't really care, as we're not limited by the Amiga display hardware
+        totalChanges = input.readInt();

        byte[] data;

        switch (compression) {
            case PCHG_COMP_NONE:
                data = new byte[chunkLength - 20];
-                pInput.readFully(data);
+                input.readFully(data);

                break;
            case PCHG_COMP_HUFFMAN:
                // NOTE: Huffman decompression is completely untested, due to lack of source data (read: Probably broken).
-                int compInfoSize = pInput.readInt();
-                int originalDataSize = pInput.readInt();
+                int compInfoSize = input.readInt();
+                int originalDataSize = input.readInt();

                short[] compTree = new short[compInfoSize / 2];
                for (int i = 0; i < compTree.length; i++) {
-                    compTree[i] = pInput.readShort();
+                    compTree[i] = input.readShort();
                }

                byte[] compData = new byte[chunkLength - 20 - 8 - compInfoSize];
-                pInput.readFully(compData);
+                input.readFully(compData);

                data = new byte[originalDataSize];

@@ -1,94 +1,87 @@
-/*
- * Copyright (c) 2008, 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.servlet.fileupload;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-
-import org.apache.commons.fileupload.FileItem;
-import org.apache.commons.fileupload.FileUploadException;
-
-/**
- * An {@code UploadedFile} implementation, based on
- * <a href="http://jakarta.apache.org/commons/fileupload/">Jakarta Commons FileUpload</a>.
- *
- * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
- * @version $Id: UploadedFileImpl.java#1 $
- */
-@Deprecated
-class UploadedFileImpl implements UploadedFile {
-    private final FileItem item;
-
-    public UploadedFileImpl(FileItem pItem) {
-        if (pItem == null) {
-            throw new IllegalArgumentException("fileitem == null");
-        }
-
-        item = pItem;
-    }
-
-    public String getContentType() {
-        return item.getContentType();
-    }
-
-    public InputStream getInputStream() throws IOException {
-        return item.getInputStream();
-    }
-
-    public String getName() {
-        return item.getName();
-    }
-
-    public long length() {
-        return item.getSize();
-    }
-
-    public void writeTo(File pFile) throws IOException {
-        try {
-            item.write(pFile);
-        }
-        catch(RuntimeException e) {
-            throw e;
-        }
-        catch (IOException e) {
-            throw e;
-        }
-        catch (FileUploadException e) {
-            // We deliberately change this exception to an IOException, as it really is
-            throw (IOException) new IOException(e.getMessage()).initCause(e);
-        }
-        catch (Exception e) {
-            // Should not really happen, ever
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-}
+/*
+ * 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.iff;
+
+import com.twelvemonkeys.io.enc.DecodeException;
+import com.twelvemonkeys.io.enc.Decoder;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+
+/**
+ * Decoder implementation for Impulse FORM RGB8 RLE compression (type 4).
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: RGB8RLEDecoder.java,v 1.0 28/01/2022 haraldk Exp$
+ *
+ * @see <a href="https://wiki.amigaos.net/wiki/RGBN_and_RGB8_IFF_Image_Data">RGBN and RGB8 IFF Image Data</a>
+ */
+final class RGB8RLEDecoder implements Decoder {
+    public int decode(final InputStream stream, final ByteBuffer buffer) throws IOException {
+        while (buffer.remaining() >= 127 * 4) {
+            int r = stream.read();
+            int g = stream.read();
+            int b = stream.read();
+            int a = stream.read();
+
+            if (a < 0) {
+                // Normal EOF
+                if (r == -1) {
+                    break;
+                }
+
+                // Partial pixel read...
+                throw new EOFException();
+            }
+
+            // Get "genlock" (transparency) bit + count
+            boolean alpha = (a & 0x80) != 0;
+            int count = a & 0x7f;
+            a = alpha ? 0 : (byte) 0xff; // convert to full transparent/opaque;
+
+            if (count == 0) {
+                throw new DecodeException("Multi-byte counts not supported");
+            }
+
+            for (int i = 0; i < count; i++) {
+                buffer.put((byte) r);
+                buffer.put((byte) g);
+                buffer.put((byte) b);
+                buffer.put((byte) a);
+            }
+        }
+
+        return buffer.position();
+    }
+}
@@ -38,8 +38,8 @@ package com.twelvemonkeys.imageio.plugins.iff;
 * @version $Id: SHAMChunk.java,v 1.0 30.03.12 14:53 haraldk Exp$
 */
 final class SHAMChunk extends AbstractMultiPaletteChunk {
-    protected SHAMChunk(int pChunkLength) {
-        super(IFF.CHUNK_SHAM, pChunkLength);
+    SHAMChunk(int chunkLength) {
+        super(IFF.CHUNK_SHAM, chunkLength);
    }

    @Override
@@ -0,0 +1,65 @@
+package com.twelvemonkeys.imageio.plugins.iff;
+
+import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
+
+import javax.imageio.IIOException;
+import java.awt.image.BufferedImage;
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+/**
+ * XS24Chunk.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: XS24Chunk.java,v 1.0 01/02/2022 haraldk Exp$
+ */
+final class XS24Chunk extends IFFChunk {
+    private byte[] data;
+    int width;
+    int height;
+
+    XS24Chunk(final int chunkLength) {
+        super(IFF.CHUNK_XS24, chunkLength);
+    }
+
+    @Override
+    void readChunk(final DataInput input) throws IOException {
+        width = input.readUnsignedShort();
+        height = input.readUnsignedShort();
+        input.readShort(); // Not sure what this is?
+
+        int dataLength = width * height * 3;
+        if (dataLength > chunkLength - 6) {
+            throw new IIOException("Bad XS24 chunk: " + width + " * " + height + " * 3 > chunk length (" + chunkLength + ")");
+        }
+
+        data = new byte[dataLength];
+
+        input.readFully(data);
+
+        // Skip pad
+        for (int i = 0; i < chunkLength - dataLength - 6; i++) {
+            input.readByte();
+        }
+    }
+
+    @Override
+    void writeChunk(final DataOutput output) {
+        throw new InternalError("Not implemented: writeChunk()");
+    }
+
+    @Override
+    public String toString() {
+        return super.toString()
+                + "{thumbnail=" + data.length + '}';
+    }
+
+    public BufferedImage thumbnail() {
+        BufferedImage thumbnail = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR)
+                                                     .createBufferedImage(width, height);
+        thumbnail.getRaster().setDataElements(0, 0, width, height, data);
+        return thumbnail;
+    }
+}
@@ -1,26 +1,37 @@
 package com.twelvemonkeys.imageio.plugins.iff;

-import static org.junit.Assert.*;
-
-import java.awt.image.IndexColorModel;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import javax.imageio.metadata.IIOMetadataFormatImpl;
-import javax.imageio.metadata.IIOMetadataNode;
+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.*;
+import java.nio.charset.StandardCharsets;
+
+import static java.awt.image.BufferedImage.*;
+import static org.junit.Assert.*;

 public class IFFImageMetadataTest {
-    @Test
-    public void testStandardFeatures() {
-        BMHDChunk header = new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);

-        final IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+    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(TYPE_24_BIT_RGB, header, header.colorMap());

        // Standard metadata format
        assertTrue(metadata.isStandardMetadataFormatSupported());
@@ -49,12 +60,13 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardChromaGray() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardChromaGray() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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());
@@ -75,12 +87,13 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardChromaRGB() {
-        BMHDChunk header = new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardChromaRGB() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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());
@@ -101,16 +114,18 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardChromaPalette() {
-        BMHDChunk header = new BMHDChunk(300, 200, 1, BMHDChunk.MASK_TRANSPARENT_COLOR, BMHDChunk.COMPRESSION_BYTE_RUN, 1);
+    public void testStandardChromaPalette() throws IIOException {
+        Form header = Form.ofType(IFF.TYPE_ILBM)
+                          .with(new BMHDChunk(300, 200, 1, BMHDChunk.MASK_TRANSPARENT_COLOR, BMHDChunk.COMPRESSION_BYTE_RUN, 1));

        byte[] bw = {0, (byte) 0xff};
-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, new IndexColorModel(header.bitplanes, bw.length, bw, bw, bw, header.transparentIndex), null, Collections.<GenericChunk>emptyList());
+        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(4, chroma.getLength());
+        assertEquals(5, chroma.getLength());

        IIOMetadataNode colorSpaceType = (IIOMetadataNode) chroma.getFirstChild();
        assertEquals("ColorSpaceType", colorSpaceType.getNodeName());
@@ -118,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());
@@ -138,16 +153,23 @@ public class IFFImageMetadataTest {
            assertEquals(rgb, item0.getAttribute("blue"));
        }

-        // TODO: BackgroundIndex == 1??
+        // BackgroundIndex == 1
+        IIOMetadataNode backgroundIndex = (IIOMetadataNode) palette.getNextSibling();
+        assertEquals("BackgroundIndex", backgroundIndex.getNodeName());
+        assertEquals("1", backgroundIndex.getAttribute("value"));
+
+        // No more elements
+        assertNull(backgroundIndex.getNextSibling());
    }

    @Test
-    public void testStandardCompressionRLE() {
-        BMHDChunk header = new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardCompressionRLE() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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());
@@ -164,21 +186,23 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardCompressionNone() {
-        BMHDChunk header = new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_NONE, 0);
+    public void testStandardCompressionNone() throws IIOException {
+        Form header = Form.ofType(IFF.TYPE_ILBM)
+                          .with(new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_NONE, 0));

-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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
-    public void testStandardDataILBM_Gray() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDataILBM_Gray() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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());
@@ -199,12 +223,13 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardDataILBM_RGB() {
-        BMHDChunk header = new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDataILBM_RGB() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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());
@@ -225,12 +250,13 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardDataILBM_RGBA() {
-        BMHDChunk header = new BMHDChunk(300, 200, 32, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDataILBM_RGBA() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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());
@@ -251,14 +277,16 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardDataILBM_Palette() {
+    public void testStandardDataILBM_Palette() throws IIOException {
        for (int i = 1; i <= 8; i++) {
-            BMHDChunk header = new BMHDChunk(300, 200, i, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+            Form header = Form.ofType(IFF.TYPE_ILBM)
+                              .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(IFF.TYPE_ILBM, header, new IndexColorModel(header.bitplanes, rgb.length, rgb, rgb, rgb, 0), null, Collections.<GenericChunk>emptyList());
+            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());
@@ -280,12 +308,13 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardDataPBM_Gray() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDataPBM_Gray() throws IIOException {
+        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(IFF.TYPE_PBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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());
@@ -306,12 +335,13 @@ public class IFFImageMetadataTest {
    }

    @Test
-    public void testStandardDataPBM_RGB() {
-        BMHDChunk header = new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDataPBM_RGB() throws IIOException {
+        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(IFF.TYPE_PBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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());
@@ -333,123 +363,177 @@ public class IFFImageMetadataTest {


    @Test
-    public void testStandardDimensionNoViewport() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDimensionNoViewport() throws IIOException {
+        BMHDChunk bitmapHeader = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+        bitmapHeader.xAspect = 0;
+        bitmapHeader.yAspect = 0;

-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        Form header = Form.ofType(IFF.TYPE_ILBM)
+                          .with(bitmapHeader);

-        IIOMetadataNode dimension = metadata.getStandardDimensionNode();
-        assertNull(dimension);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());
+
+        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
-    public void testStandardDimensionNormal() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDimensionNormal() throws IIOException {
+        Form header = Form.ofType(IFF.TYPE_ILBM)
+                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0))
+                          .with(new CAMGChunk(4));

-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, null, new CAMGChunk(4), Collections.<GenericChunk>emptyList());
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());

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

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

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

    @Test
-    public void testStandardDimensionHires() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDimensionHires() throws IIOException {
+        BMHDChunk bitmapHeader = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+        bitmapHeader.xAspect = 2;
+        bitmapHeader.yAspect = 1;
+
        CAMGChunk viewPort = new CAMGChunk(4);
        viewPort.camg = 0x8000;

-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, null, viewPort, Collections.<GenericChunk>emptyList());
+        Form header = Form.ofType(IFF.TYPE_ILBM)
+                          .with(bitmapHeader)
+                          .with(viewPort);

-        IIOMetadataNode dimension = metadata.getStandardDimensionNode();
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());
+
+        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
-    public void testStandardDimensionInterlaced() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDimensionInterlaced() throws IIOException {
+        BMHDChunk bitmapHeader = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+        bitmapHeader.xAspect = 1;
+        bitmapHeader.yAspect = 2;

        CAMGChunk viewPort = new CAMGChunk(4);
        viewPort.camg = 0x4;

-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, null, viewPort, Collections.<GenericChunk>emptyList());
+        Form header = Form.ofType(IFF.TYPE_ILBM)
+                          .with(bitmapHeader)
+                          .with(viewPort);

-        IIOMetadataNode dimension = metadata.getStandardDimensionNode();
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_8_BIT_PALETTE, header, header.colorMap());
+
+        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
-    public void testStandardDimensionHiresInterlaced() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
-
+    public void testStandardDimensionHiresInterlaced() throws IIOException {
        CAMGChunk viewPort = new CAMGChunk(4);
        viewPort.camg = 0x8004;
+        Form header = Form.ofType(IFF.TYPE_ILBM)
+                          .with(new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0))
+                          .with(viewPort);

-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, null, viewPort, Collections.<GenericChunk>emptyList());
+        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
-    public void testStandardDocument() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardDocument() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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() {
-        BMHDChunk header = new BMHDChunk(300, 200, 8, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardText() throws IIOException {
+        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.US_ASCII)))
+                .with(new GenericChunk(chunks[2], texts[2].getBytes(StandardCharsets.UTF_8)));

-        String[] texts = {"annotation", "äñnótâtïøñ"};
-        List<GenericChunk> meta = Arrays.asList(new GenericChunk(IFF.CHUNK_ANNO, texts[0].getBytes(StandardCharsets.US_ASCII)),
-                                                new GenericChunk(IFF.CHUNK_UTF8, texts[1].getBytes(StandardCharsets.UTF_8)));
-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, null, null, meta);
+        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());
@@ -457,55 +541,210 @@ public class IFFImageMetadataTest {
        for (int i = 0; i < texts.length; i++) {
            IIOMetadataNode textEntry = (IIOMetadataNode) text.item(i);
            assertEquals("TextEntry", textEntry.getNodeName());
-            assertEquals(IFFUtil.toChunkStr(meta.get(i).chunkId), textEntry.getAttribute("keyword"));
+            assertEquals(IFFUtil.toChunkStr(chunks[i]), textEntry.getAttribute("keyword"));
            assertEquals(texts[i], textEntry.getAttribute("value"));
        }
    }

    @Test
-    public void testStandardTransparencyRGB() {
-        BMHDChunk header = new BMHDChunk(300, 200, 24, BMHDChunk.MASK_NONE, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardTransparencyRGB() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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
-    public void testStandardTransparencyRGBA() {
-        BMHDChunk header = new BMHDChunk(300, 200, 32, BMHDChunk.MASK_HAS_MASK, BMHDChunk.COMPRESSION_BYTE_RUN, 0);
+    public void testStandardTransparencyRGBA() throws IIOException {
+        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(IFF.TYPE_ILBM, header, null, null, Collections.<GenericChunk>emptyList());
+        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
-    public void testStandardTransparencyPalette() {
-        BMHDChunk header = new BMHDChunk(300, 200, 1, BMHDChunk.MASK_TRANSPARENT_COLOR, BMHDChunk.COMPRESSION_BYTE_RUN, 1);
+    public void testStandardTransparencyPalette() throws IIOException {
+        Form header = Form.ofType(IFF.TYPE_ILBM)
+                          .with(new BMHDChunk(300, 200, 1, BMHDChunk.MASK_TRANSPARENT_COLOR, BMHDChunk.COMPRESSION_BYTE_RUN, 1));

        byte[] bw = {0, (byte) 0xff};
-        IFFImageMetadata metadata = new IFFImageMetadata(IFF.TYPE_ILBM, header, new IndexColorModel(header.bitplanes, bw.length, bw, bw, bw, header.transparentIndex), null, Collections.<GenericChunk>emptyList());
+        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(2, transparency.getLength());
+
+        IIOMetadataNode alpha = (IIOMetadataNode) transparency.getFirstChild();
+        assertEquals("Alpha", alpha.getNodeName());
+        assertEquals("nonpremultiplied", alpha.getAttribute("value"));
+
+        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(TYPE_32_BIT_ARGB, header, header.colorMap());
+
+        // Chroma
+        IIOMetadataNode chroma = getStandardNode(metadata, "Chroma");
+        assertNotNull(chroma);
+        assertEquals("Chroma", chroma.getNodeName());
+        assertEquals(3, chroma.getLength());
+
+        IIOMetadataNode colorSpaceType = (IIOMetadataNode) chroma.getFirstChild();
+        assertEquals("ColorSpaceType", colorSpaceType.getNodeName());
+        assertEquals("RGB", colorSpaceType.getAttribute("name"));
+
+        IIOMetadataNode numChannels = (IIOMetadataNode) colorSpaceType.getNextSibling();
+        assertEquals("NumChannels", numChannels.getNodeName());
+        assertEquals("4", numChannels.getAttribute("value"));
+
+        IIOMetadataNode blackIsZero = (IIOMetadataNode) numChannels.getNextSibling();
+        assertEquals("BlackIsZero", blackIsZero.getNodeName());
+        assertEquals("TRUE", blackIsZero.getAttribute("value"));
+
+        assertNull(blackIsZero.getNextSibling()); // No more children
+
+        // Data
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
+        assertNotNull(data);
+        assertEquals("Data", data.getNodeName());
+        assertEquals(3, data.getLength());
+
+        IIOMetadataNode planarConfiguration = (IIOMetadataNode) data.getFirstChild();
+        assertEquals("PlanarConfiguration", planarConfiguration.getNodeName());
+        assertEquals("PixelInterleaved", planarConfiguration.getAttribute("value"));
+
+        IIOMetadataNode sampleFormat = (IIOMetadataNode) planarConfiguration.getNextSibling();
+        assertEquals("SampleFormat", sampleFormat.getNodeName());
+        assertEquals("UnsignedIntegral", sampleFormat.getAttribute("value"));
+
+        IIOMetadataNode bitsPerSample = (IIOMetadataNode) sampleFormat.getNextSibling();
+        assertEquals("BitsPerSample", bitsPerSample.getNodeName());
+        assertEquals("8 8 8 1", bitsPerSample.getAttribute("value"));
+
+        assertNull(bitsPerSample.getNextSibling()); // No more children
+
+        // Transparency
+        IIOMetadataNode transparency = getStandardNode(metadata, "Transparency");
        assertNotNull(transparency);
        assertEquals("Transparency", transparency.getNodeName());
        assertEquals(1, 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
+        assertNull(alpha.getNextSibling()); // No more children
+    }
+
+    @Test
+    public void testStandardDEEP() throws IIOException {
+        DPELChunk dpel = new DPELChunk(20);
+        dpel.typeDepths = new DPELChunk.TypeDepth[4];
+        for (int i = 0; i < dpel.typeDepths.length; i++) {
+            dpel.typeDepths[i] = new DPELChunk.TypeDepth(i == 0 ? 11 : i, 8);
+        }
+
+        Form header = Form.ofType(IFF.TYPE_DEEP)
+                          .with(new DGBLChunk(8))
+                          .with(dpel);
+        IFFImageMetadata metadata = new IFFImageMetadata(TYPE_32_BIT_ARGB_DEEP, header, header.colorMap());
+
+        // Chroma
+        IIOMetadataNode chroma = getStandardNode(metadata, "Chroma");
+        assertNotNull(chroma);
+        assertEquals("Chroma", chroma.getNodeName());
+        assertEquals(3, chroma.getLength());
+
+        IIOMetadataNode colorSpaceType = (IIOMetadataNode) chroma.getFirstChild();
+        assertEquals("ColorSpaceType", colorSpaceType.getNodeName());
+        assertEquals("RGB", colorSpaceType.getAttribute("name"));
+
+        IIOMetadataNode numChannels = (IIOMetadataNode) colorSpaceType.getNextSibling();
+        assertEquals("NumChannels", numChannels.getNodeName());
+        assertEquals("4", numChannels.getAttribute("value"));
+
+        IIOMetadataNode blackIsZero = (IIOMetadataNode) numChannels.getNextSibling();
+        assertEquals("BlackIsZero", blackIsZero.getNodeName());
+        assertEquals("TRUE", blackIsZero.getAttribute("value"));
+
+        // TODO: BackgroundColor = 0x666666
+
+        assertNull(blackIsZero.getNextSibling()); // No more children
+
+        // Data
+        IIOMetadataNode data = getStandardNode(metadata, "Data");
+        assertNotNull(data);
+        assertEquals("Data", data.getNodeName());
+        assertEquals(3, data.getLength());
+
+        IIOMetadataNode planarConfiguration = (IIOMetadataNode) data.getFirstChild();
+        assertEquals("PlanarConfiguration", planarConfiguration.getNodeName());
+        assertEquals("PixelInterleaved", planarConfiguration.getAttribute("value"));
+
+        IIOMetadataNode sampleFormat = (IIOMetadataNode) planarConfiguration.getNextSibling();
+        assertEquals("SampleFormat", sampleFormat.getNodeName());
+        assertEquals("UnsignedIntegral", sampleFormat.getAttribute("value"));
+
+        IIOMetadataNode bitsPerSample = (IIOMetadataNode) sampleFormat.getNextSibling();
+        assertEquals("BitsPerSample", bitsPerSample.getNodeName());
+        assertEquals("8 8 8 8", bitsPerSample.getAttribute("value"));
+
+        assertNull(bitsPerSample.getNextSibling()); // No more children
+
+        // Transparency
+        IIOMetadataNode transparency = getStandardNode(metadata, "Transparency");
+        assertNotNull(transparency);
+        assertEquals("Transparency", transparency.getNodeName());
+        assertEquals(1, transparency.getLength());
+
+        IIOMetadataNode alpha = (IIOMetadataNode) transparency.getFirstChild();
+        assertEquals("Alpha", alpha.getNodeName());
+        assertEquals("premultiplied", alpha.getAttribute("value"));
+
+        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;
    }
 }
@@ -88,7 +88,16 @@ public class IFFImageReaderTest extends ImageReaderAbstractTest<IFFImageReader>
                // 16 color indexed, multi palette (PCHG) - Ok
                new TestData(getClassLoaderResource("/iff/Manhattan.PCHG"), new Dimension(704, 440)),
                // 16 color indexed, multi palette (PCHG + SHAM) - Ok
-                new TestData(getClassLoaderResource("/iff/Somnambulist-2.SHAM"), new Dimension(704, 440))
+                new TestData(getClassLoaderResource("/iff/Somnambulist-2.SHAM"), new Dimension(704, 440)),
+                // Impulse RGB8 format straight from Imagine 2.0
+                new TestData(getClassLoaderResource("/iff/glowsphere2.rgb8"), new Dimension(640, 480)),
+                // Impulse RGB8 format written by ASDG ADPro, with cross boundary runs, which is probably not as per spec...
+                new TestData(getClassLoaderResource("/iff/tunnel04-adpro-cross-boundary-runs.rgb8"), new Dimension(640, 480)),
+                // TVPaint (TecSoft) DEEP format
+                new TestData(getClassLoaderResource("/iff/arch.deep"), new Dimension(800, 600)),
+                // TVPaint Project (TVPP is effectively same as the DEEP format, but multiple layers, background color etc.)
+                // TODO: This file contains one more image/layer, second DBOD chunk @1868908, len: 1199144!
+                new TestData(getClassLoaderResource("/iff/warm-and-bright.pro"), new Dimension(800, 600))
        );
    }

@@ -99,7 +108,7 @@ public class IFFImageReaderTest extends ImageReaderAbstractTest<IFFImageReader>

    @Override
    protected List<String> getSuffixes() {
-        return Arrays.asList("iff", "ilbm", "ham", "ham8", "lbm");
+        return Arrays.asList("iff", "ilbm", "ham", "ham8", "lbm", "rgb8", "deep");
    }

    @Override
@@ -134,9 +143,14 @@ public class IFFImageReaderTest extends ImageReaderAbstractTest<IFFImageReader>

        for (int i = 0; i < 32; i++) {
            // Make sure the color model is really EHB
-            assertEquals("red", (reds[i] & 0xff) / 2, reds[i + 32] & 0xff);
-            assertEquals("blue", (blues[i] & 0xff) / 2, blues[i + 32] & 0xff);
-            assertEquals("green", (greens[i] & 0xff) / 2, greens[i + 32] & 0xff);
+            try {
+                assertEquals("red", (reds[i] & 0xff) / 2, reds[i + 32] & 0xff);
+                assertEquals("blue", (blues[i] & 0xff) / 2, blues[i + 32] & 0xff);
+                assertEquals("green", (greens[i] & 0xff) / 2, greens[i + 32] & 0xff);
+            }
+            catch (AssertionError err) {
+                throw new AssertionError("Color " + i + " " + err.getMessage(), err);
+            }
        }
    }
 }
@@ -0,0 +1,114 @@
+package com.twelvemonkeys.imageio.plugins.iff;
+
+import com.twelvemonkeys.io.enc.DecodeException;
+import com.twelvemonkeys.io.enc.Decoder;
+import com.twelvemonkeys.io.enc.DecoderAbstractTest;
+import com.twelvemonkeys.io.enc.Encoder;
+
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+/**
+ * RGB8RLEDecoderTest.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: RGB8RLEDecoderTest.java,v 1.0 28/01/2022 haraldk Exp$
+ */
+public class RGB8RLEDecoderTest extends DecoderAbstractTest {
+
+    public static final int BUFFER_SIZE = 1024;
+
+    @Override
+    public Decoder createDecoder() {
+        return new RGB8RLEDecoder();
+    }
+
+    @Override
+    public Encoder createCompatibleEncoder() {
+        return null;
+    }
+
+    @Test
+    public final void testDecodeEmpty() throws IOException {
+        Decoder decoder = createDecoder();
+        ByteArrayInputStream bytes = new ByteArrayInputStream(new byte[0]);
+
+        int count = decoder.decode(bytes, ByteBuffer.allocate(BUFFER_SIZE));
+        assertEquals("Should not be able to read any bytes", 0, count);
+    }
+
+    @Test(expected = EOFException.class)
+    public final void testDecodePartial() throws IOException {
+        Decoder decoder = createDecoder();
+        ByteArrayInputStream bytes = new ByteArrayInputStream(new byte[] {0});
+
+        decoder.decode(bytes, ByteBuffer.allocate(BUFFER_SIZE));
+        fail("Should not be able to read any bytes");
+    }
+
+    @Test(expected = EOFException.class)
+    public final void testDecodePartialToo() throws IOException {
+        Decoder decoder = createDecoder();
+        ByteArrayInputStream bytes = new ByteArrayInputStream(new byte[] {0, 0, 0, 1, 0, 0});
+
+        decoder.decode(bytes, ByteBuffer.allocate(BUFFER_SIZE));
+        fail("Should not be able to read any bytes");
+    }
+
+    @Test(expected = DecodeException.class)
+    public final void testDecodeZeroRun() throws IOException {
+        // The spec says that 0-runs should be used to signal that the run is > 127,
+        // and contained in the next byte, however, this is not used in practise and not supported.
+        Decoder decoder = createDecoder();
+        ByteArrayInputStream bytes = new ByteArrayInputStream(new byte[] {0, 0, 0, 0});
+
+        decoder.decode(bytes, ByteBuffer.allocate(BUFFER_SIZE));
+        fail("Should not be able to read any bytes");
+    }
+
+    @Test
+    public final void testDecodeSingleOpaque() throws IOException {
+        Decoder decoder = createDecoder();
+        ByteArrayInputStream bytes = new ByteArrayInputStream(new byte[] {0, 0, 0, 1});
+        ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
+
+        int count = decoder.decode(bytes, buffer);
+
+        assertEquals(4, count);
+        assertEquals(0x000000FF, buffer.getInt(0));
+    }
+
+    @Test
+    public final void testDecodeSingleTransparent() throws IOException {
+        Decoder decoder = createDecoder();
+        ByteArrayInputStream bytes = new ByteArrayInputStream(new byte[] {0, 0, 0, (byte) 0x81});
+        ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
+
+        int count = decoder.decode(bytes, buffer);
+
+        assertEquals(4, count);
+        assertEquals(0x00000000, buffer.getInt(0));
+    }
+
+    @Test
+    public final void testDecodeMaxRun() throws IOException {
+        Decoder decoder = createDecoder();
+        ByteArrayInputStream bytes = new ByteArrayInputStream(new byte[] {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x7F});
+        ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
+
+        int count = decoder.decode(bytes, buffer);
+
+        assertEquals(127 * 4, count);
+        for (int i = 0; i < 127; i++) {
+            assertEquals(0xFFFFFFFF, buffer.getInt(i));
+        }
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Harald Kuhr	dbb7c07695	[maven-release-plugin] prepare release twelvemonkeys-3.9.4	2022-11-21 18:51:26 +01:00
Harald Kuhr	6840f31fa3	#712 Core: Fix possible OOM situation in new stream implementation (cherry picked from commit `8f5c1b409f`)	2022-11-21 18:49:06 +01:00
Harald Kuhr	debf7d0207	#714 PNM: Add support for writing TYPE_INT_* images + implementation of WriterSpi.canEncode (cherry picked from commit `26981513d8`)	2022-11-21 18:49:06 +01:00
Harald Kuhr	0538db7103	#713 PSD: Broken uncompressed reading from stream w/unknown length (cherry picked from commit `da800be8c8`)	2022-11-21 18:44:44 +01:00
snyk-bot	1e981242ad	fix: imageio/imageio-batik/pom.xml to reduce vulnerabilities The following vulnerabilities are fixed with an upgrade: - https://snyk.io/vuln/SNYK-JAVA-ORGAPACHEXMLGRAPHICS-3063442 - https://snyk.io/vuln/SNYK-JAVA-ORGAPACHEXMLGRAPHICS-3063691 (cherry picked from commit `304d050bc3`)	2022-11-21 18:43:40 +01:00
Harald Kuhr	135a631bcc	#708 PSD: No longer emit warning for '8B64' (64 bit/long) resources. (cherry picked from commit `0443172666`)	2022-11-21 18:43:40 +01:00
Harald Kuhr	f2624d5193	[maven-release-plugin] prepare for next development iteration	2022-10-20 16:22:15 +02:00
Harald Kuhr	ada3a84bec	[maven-release-plugin] prepare release twelvemonkeys-3.9.3	2022-10-20 16:22:10 +02:00
Harald Kuhr	7e7aaa293e	#707 WebP: Fix Alpha support the correct way... (cherry picked from commit `cee2663f06`)	2022-10-20 16:10:05 +02:00
Harald Kuhr	5d623cce9f	#707 WebP: Fix Alpha support (cherry picked from commit `8f44cfc43c`)	2022-10-20 16:00:45 +02:00
Harald Kuhr	055838aaaf	[maven-release-plugin] prepare for next development iteration	2022-10-20 14:08:11 +02:00
Harald Kuhr	a8327c3c67	[maven-release-plugin] prepare release twelvemonkeys-3.9.2	2022-10-20 14:08:06 +02:00
Harald Kuhr	36c91f67e4	#704 Fix LSBBitReader to avoid back/forth seeking that invalidates buffer (cherry picked from commit `8a240aac68`)	2022-10-20 14:06:19 +02:00
Harald Kuhr	4cc53d822f	[maven-release-plugin] prepare for next development iteration	2022-10-19 20:56:12 +02:00
Harald Kuhr	9875de0383	[maven-release-plugin] prepare release twelvemonkeys-3.9.1	2022-10-19 20:56:08 +02:00
Harald Kuhr	6ed858a4ca	#704 Tiny performance improvement + code clean-up (cherry picked from commit `61424f33b6`)	2022-10-19 20:46:45 +02:00
Harald Kuhr	38192ae835	Code clean-up. (cherry picked from commit `c7b9b1fadd`)	2022-10-19 20:46:45 +02:00
Harald Kuhr	b5e8853e6b	Set versions for 3.9 bugfix branch.	2022-10-18 20:49:43 +02:00
Harald Kuhr	a98224e652	#705 No longer closes streams we didn't open (cherry picked from commit `ab08ec1e0d`)	2022-10-18 20:34:27 +02:00
Harald Kuhr	73a58266be	...and removed System.out.. Ouch... (cherry picked from commit `cbe78dc67f`)	2022-10-18 20:34:26 +02:00
Harald Kuhr	edd523534c	Fixed typo... (cherry picked from commit `c9e11f171f`)	2022-10-18 20:34:26 +02:00
Harald Kuhr	6581e2e2a1	[maven-release-plugin] prepare release twelvemonkeys-3.9.0	2022-10-15 12:12:49 +02:00
Harald Kuhr	c2873b1f27	Minor test optimization...	2022-10-15 12:05:33 +02:00
Harald Kuhr	35f2f0be9f	Revert "Replace Java 18 with 19 in build matrix." This reverts commit `a77b62b6ba`.	2022-10-15 11:55:34 +02:00
Harald Kuhr	b5856fd110	Revert "Update test to pass on JDK 19." This reverts commit `081f2efea2`.	2022-10-15 11:55:34 +02:00
Harald Kuhr	1919d77a45	Revert "Update test to pass on JDK 19." This reverts commit `37afe24aac`.	2022-10-15 11:55:34 +02:00
Harald Kuhr	37afe24aac	Update test to pass on JDK 19.	2022-10-14 18:51:40 +02:00
Harald Kuhr	081f2efea2	Update test to pass on JDK 19.	2022-10-14 18:44:54 +02:00
Harald Kuhr	627bb1bf1f	Update action versions.	2022-10-14 18:27:29 +02:00
Harald Kuhr	a77b62b6ba	Replace Java 18 with 19 in build matrix.	2022-10-14 18:22:50 +02:00
Harald Kuhr	2500d8cc15	#687 #691 Stream performance regressions... and JDK 17+ support :-P	2022-10-14 18:20:47 +02:00
Harald Kuhr	c01336fb8a	#687 #691 Stream performance regressions, now with JDK 11 support...	2022-10-14 18:16:18 +02:00
Harald Kuhr	6f9b9bee01	#687 #691 Stream performance regressions	2022-10-14 18:00:43 +02:00
Harald Kuhr	b9b1a35408	Replaced Map.Entry with StandardImageMetadataSupport.TextEntry	2022-10-10 14:15:57 +02:00
Harald Kuhr	7ed5663633	More tests of StandardImageMetadataSupport + minor API changes	2022-10-08 14:28:10 +02:00
Harald Kuhr	6458fcdcbd	Major ImageMetadata refactor for more consistent standard metadata support. Fixes a few related bugs as a bonus.	2022-10-08 13:43:26 +02:00
Harald Kuhr	9375bfda9a	#703 : Workaround for 32 bit issue in ImageTypeSpecifier	2022-10-06 16:00:43 +02:00
Harald Kuhr	0160fb70f8	#702 Fix NPE while reading an WebP animation without alpha + bonus cleanup	2022-10-06 15:24:40 +02:00
Harald Kuhr	29dca0f124	Removed explicit version number for Apache Batik	2022-09-29 14:36:57 +02:00
Harald Kuhr	c21f14efe1	Merge pull request #698 from KoenDG/batik_upgrade115 Batik has released version 1.15	2022-09-23 15:24:45 +02:00
Koen De Groote	81ba43e1e8	Batik has released version 1.15 Tickets fixed in this release: https://issues.apache.org/jira/browse/BATIK-1334?jql=project%20%3D%20BATIK%20AND%20status%20in%20(Resolved%2C%20Closed)%20AND%20fixVersion%20%3D%201.15%20ORDER%20BY%20affectedVersion%20DESC%2C%20priority%20DESC	2022-09-22 14:51:57 +02:00
Harald Kuhr	a1fcfc3958	Fix WebP visibility issues.	2022-09-09 14:09:58 +02:00
Harald Kuhr	c60116a611	Inserted license header + author tags for contributed WebP files.	2022-09-09 14:06:41 +02:00
Harald Kuhr	15e6ddc1fd	Fix typo. :-)	2022-09-09 14:05:51 +02:00
Harald Kuhr	49f4e5401e	Add JDK 18 to the build matrix.	2022-09-09 12:35:22 +02:00
Harald Kuhr	e333c7d1b2	Merge pull request #696 from Simon04090/webp-lossless WebP lossless	2022-09-09 08:43:48 +02:00
Simon Kammermeier	cda34b704b	Indicate support for lossless to ImageIO	2022-09-09 01:18:53 +02:00
Simon Kammermeier	7c4487be04	Add tests for lossless decoder	2022-09-09 01:18:53 +02:00
Simon Kammermeier	5a4525aaa1	Remove debug prints	2022-09-09 01:18:53 +02:00
Simon Kammermeier	b766420e3e	Parse ANIM metadata Still need to expose them in image metadata	2022-09-09 01:18:53 +02:00
Simon Kammermeier	c858454c5a	Support ImageReadParam Settings limiting Raster size On animation frames dimension has to be passed as it is not guaranteed the same as in the file header.	2022-09-09 01:18:53 +02:00
Simon Kammermeier	67b48ce1e3	Implement decoding of compressed alpha chunks, alpha filtering	2022-09-09 01:18:53 +02:00
Simon Kammermeier	6608f61353	Fix starting to read at wrong offset, now skips header	2022-09-09 01:18:53 +02:00
Simon Kammermeier	326b98d5e5	Implement applying of the inverse transforms	2022-09-09 01:18:53 +02:00
Simon Kammermeier	fafa58b718	Implement actual decoding including resolving backward refs and cache	2022-09-09 01:18:45 +02:00
Simon Kammermeier	0ed0246762	Implement Huffman Table parsing and decoding Uses a 2 level table approach inspired by libwebp	2022-09-09 01:15:04 +02:00
Simon Kammermeier	b3004a1227	Implement buffering in LSBBitReader This optimizes away the constant re-reading of bytes. Also allows peeking at coming bits without consuming them.	2022-09-09 01:15:04 +02:00
Simon Kammermeier	7ab627a754	Setup Huffman Table framework, decode meta groups	2022-09-09 01:14:36 +02:00
Simon Kammermeier	008e57a7ce	Move helper methods to transforms needing them	2022-09-09 01:09:28 +02:00
Simon Kammermeier	28270b4d5b	Objectify Transforms Deduplicate code for parsing predictor and color transforms. Add missing subtraction code removal on indexing transform.	2022-09-09 00:46:48 +02:00
Simon Kammermeier	7382151db8	Convert transforms list and colorCache to local variables This is needed because on recursion new (empty) ones are necessary.	2022-09-09 00:10:33 +02:00
Simon Kammermeier	b856ce07af	Fix not using LSBBitReader	2022-09-09 00:04:41 +02:00
Harald Kuhr	190fe87ee9	DiscreteAlphaIndexColorModel num components fix	2022-08-19 16:38:45 +02:00
Harald Kuhr	d1872ce94f	#694 : Fixed import order	2022-08-19 14:08:26 +02:00
Harald Kuhr	a5c52a99b4	#694 BMP: Fixed subsampling for 24 bit/pixel case	2022-08-16 13:56:51 +02:00
Harald Kuhr	4170b393fa	#684 Add some tolerance for JDK 8...	2022-06-10 17:48:20 +02:00
Harald Kuhr	53f9ba91e0	#684 Remove TODO as it's now fixed	2022-06-10 17:44:53 +02:00
Harald Kuhr	be2d7d5f10	#684 Fix some render size issues in SVGImageReader Bonus: Minor code clean-up.	2022-06-10 17:24:47 +02:00
Harald Kuhr	00aec2c90e	Minor code clean-up for WMFImageReader	2022-06-10 17:01:55 +02:00
Harald Kuhr	2b04f7205c	Minor optimizations.	2022-06-10 16:58:23 +02:00
Harald Kuhr	7d401d0194	#675 PSD 16/32 bit layer support pt2: Cross-platform test	2022-06-10 15:19:14 +02:00
Harald Kuhr	48691139a3	#675 PSD 16/32 bit layer support	2022-06-10 10:14:41 +02:00
Harald Kuhr	bcb87c09d2	#681 : Fix for little-endian "packed" USHORT types + rewritten stream handling	2022-06-03 19:23:50 +02:00
Harald Kuhr	84a8ceeb93	#683 : Fix TIFF stripByteCounts computation for uncompressed data	2022-06-03 16:04:43 +02:00
Harald Kuhr	0cb99feedf	A new ImageInputStream adapter for InputStream.	2022-06-01 22:00:37 +02:00
Harald Kuhr	91493c5145	#682 TIFF Lab w/alpha support	2022-06-01 19:30:01 +02:00
Harald Kuhr	6ddb799a95	Fix bad format in validator message.	2022-05-29 14:55:17 +02:00
Harald Kuhr	8a187f6657	TGAImageReader no longer reads single byte 0-terminator as Image Identification	2022-05-18 22:47:45 +02:00
Harald Kuhr	b7d865f2cf	#680 TGAImageReader now reads attribute bits with no extension area as alpha	2022-05-18 22:18:20 +02:00
Harald Kuhr	d50fb1a51e	Fix bug in 0-terminated ASCII string parsing + test.	2022-05-18 21:01:17 +02:00
Harald Kuhr	8992406f50	Documentation & details.	2022-05-18 20:31:28 +02:00
Harald Kuhr	44eebff62f	#678 , #679 : TIFF read support for YCbCr Planar with or without subsampling	2022-05-12 23:01:12 +02:00
Harald Kuhr	8c85c4ca96	Simplified TIFF writing.	2022-05-06 19:49:06 +02:00
Harald Kuhr	fa5c77bff0	Added test cases for EncoderStream/DecoderStream and fixed a bug + code clean-up to make IntelliJ happy :-)	2022-05-06 19:31:16 +02:00
Harald Kuhr	d87b80deea	PCX: Minor clean up	2022-05-06 19:27:44 +02:00
Harald Kuhr	ae138c3b4e	Write LONG8 offsets for BigTIFF	2022-05-05 15:53:20 +02:00
Harald Kuhr	ab13fdd09d	#677 Fixed integer overflow + added tests	2022-05-04 18:23:25 +02:00
Harald Kuhr	aab5b062bd	Fixed test typo.	2022-05-04 18:22:14 +02:00
Harald Kuhr	00d6acd1bf	[skip ci] Fixed some typos in comments. :-)	2022-04-26 19:25:52 +02:00
Harald Kuhr	0f8a7ea482	Update feature_request.md	2022-04-25 16:58:39 +02:00
Harald Kuhr	9fe87fe10d	#672 : WebPImageReader now supports unknown stream lengths	2022-04-22 14:41:57 +02:00
Harald Kuhr	a33dbaf897	Merge pull request #669 from haraldk/snyk-upgrade-a0c5c60996f8b405ed1deadc1666ddc0 [Snyk] Upgrade jmagick:jmagick from 6.2.4 to 6.6.9	2022-04-11 17:01:44 +02:00
Harald Kuhr	9e2f369459	#666 Clean-up: No alpha for RGB 3/components	2022-03-11 19:58:38 +01:00
Harald Kuhr	d34b0b7fcf	#666 Support for TIFF RGB 2/4 bit per sample.	2022-03-11 19:54:33 +01:00
snyk-bot	5effcb1344	fix: upgrade jmagick:jmagick from 6.2.4 to 6.6.9 Snyk has created this PR to upgrade jmagick:jmagick from 6.2.4 to 6.6.9. See this package in Maven Repository: https://mvnrepository.com/artifact/jmagick/jmagick/ See this project in Snyk: https://app.snyk.io/org/haraldk/project/eca06326-94ac-456d-a029-f411089e7f16?utm_source=github&utm_medium=referral&page=upgrade-pr	2022-03-04 21:50:39 +00:00
Oliver Schmidtmer	b67d687761	TIFFImageMetadata: ImageOrientation in mergeTree (#667 ) TIFFImageMetadata: ImageOrientation in mergeTree	2022-02-28 15:53:49 +01:00
Harald Kuhr	d0881c8b5c	Attempt at adding JavaDocs + use "release" profile for release-plugin [skip ci]	2022-02-22 14:46:14 +01:00
Harald Kuhr	976928f48c	Adding description to top-level POM [skip ci]	2022-02-22 13:19:49 +01:00
Harald Kuhr	e1c2f2ee73	Thank you, Travis [skip ci]	2022-02-21 09:34:34 +01:00
Harald Kuhr	92632fa2a3	#661 : JUnit test results take 4	2022-02-17 19:09:26 +01:00
Harald Kuhr	5a563e315f	#661 : JUnit test results take 3	2022-02-17 18:42:54 +01:00
Harald Kuhr	c06d47d123	#661 : JUnit test results take 2	2022-02-17 18:33:20 +01:00
Harald Kuhr	fea6beb364	#661 : JUnit test results	2022-02-17 18:32:18 +01:00
Harald Kuhr	4b951c06cc	PNM: New attempt at making the new header parser work on Windows.	2022-02-14 22:00:04 +01:00
Harald Kuhr	a3e6e52c95	PNM Windows issue. Temporary roll-back to working version.	2022-02-14 19:33:28 +01:00
Harald Kuhr	5347015cbd	PNM clean-up: Avoid leading/trailing whitespace in comments.	2022-02-14 19:27:55 +01:00
Harald Kuhr	4d190892df	PNM clean-up.	2022-02-09 20:13:49 +01:00
Harald Kuhr	60eab81709	#660 : Attempt at making the comment parsing more Windows-friendly...	2022-02-08 11:19:38 +01:00
Harald Kuhr	b400b6b157	#660 : Make sure region is within bounds of new test image...	2022-02-08 10:38:53 +01:00
Harald Kuhr	499b3ef120	#660 : Farewell, Lena	2022-02-08 10:16:42 +01:00
Harald Kuhr	92bc9c73f6	IFF: Simplified aspect.	2022-02-08 08:43:21 +01:00
Harald Kuhr	2a77558cac	IFF: XS24 clean-up (again...)	2022-02-04 12:33:28 +01:00
Harald Kuhr	816cad60a8	IFF: XS24 clean-up	2022-02-04 12:23:44 +01:00
Harald Kuhr	7167f81c69	IFF: Thumbnail support for XS24 chunk (now without stderr output)	2022-02-04 12:13:53 +01:00
Harald Kuhr	f5cfa0e619	IFF: Thumbnail support for XS24 chunk.	2022-02-04 11:46:32 +01:00
Harald Kuhr	73ad024833	IFF: Read support for TVPaint DEEP and TVPP + Bonus: Massive code clean-up/refactor.	2022-02-03 17:26:41 +01:00
Harald Kuhr	379449b621	IFF: More clean-up	2022-01-29 14:41:49 +01:00
Harald Kuhr	e17faad6fb	IFF: Read support for Impulse (Imagine, Turbo Silver) RGB8 format.	2022-01-28 16:36:34 +01:00
Harald Kuhr	1271a3d55e	IFF clean-up.	2022-01-28 16:07:15 +01:00
Harald Kuhr	1cd594d113	RIP: Sandbox	2022-01-24 09:01:53 +01:00
Harald Kuhr	b76f74e79a	A little safer way to skip 6 bytes...	2022-01-19 09:00:13 +01:00
Harald Kuhr	78817a489b	#658 : TGAImageReader now allows extension area of size 0	2022-01-19 09:00:13 +01:00
Harald Kuhr	b8f2a80ca6	#658 : TGAImageReaderSpi now recognizes "true color" images with valid palette depth != 0	2022-01-19 09:00:13 +01:00
Oliver Schmidtmer	ac8a36db1c	findCompressionType always uses RLE if leading EOL is missing (#657 ) Update of the last read byte is missing since the last update. So if only the first EOL is missing, further EOLs after the lines are not detected.	2022-01-15 00:21:47 +01:00
Harald Kuhr	7e0d8922da	#655 Experimental force raster conversion switch.	2022-01-12 19:51:56 +01:00
Harald Kuhr	9a6b8c9bfe	Fix for IIOInvalidTreeException: Invalid DHT node #559	2022-01-12 19:33:21 +01:00
Harald Kuhr	eced5b8efd	#656 Code clean-up + minor refactorings.	2022-01-12 19:11:52 +01:00
Oliver Schmidtmer	74611e4e52	Support writing ASCII array in TIFF metadata (#656 ) * Support writing ASCII array in TIFF metadata * corrected formatting and extracted string writing to method	2022-01-12 18:56:22 +01:00
Harald Kuhr	b8614eca4d	New CI badge + new maven badges, replaces #653	2022-01-12 18:45:14 +01:00
Harald Kuhr	efd24456ac	#636 : Correct name for shaded artifact.	2022-01-05 15:47:16 +01:00
Gauthier	191b2371c8	add support for Github Actions, publish snapshots to OSSRH automatically (#633 ) * remove oss-parent * add github workflow * use java 16 for now * disable fail fast * add java 15 * use only java 8 and 11 for now * snapshot deploy * snapshot deploy * oracle jdk * oracle jdk * oracle jdk * kcms matrix * kcms job name * only deploy for snapshots * try not operator * prepare PR * restore groupId * Fixed Travis link + bonus project summary updates * Readme improvements * #629: Preliminary WebP animation (ANIM/ANMF) support * #629: Fixed build * Make tests pass on JDK 16 and 17 (#635) * make tests pass on JDK 16 and 17 replace deprecated mockito-all by mockito-core, and updated to latest 3.x replace deprecated org.mockito.Matchers * code cleanup from IDE suggestions * add oracle jdk 16 and 17 to Travis * test on java 17 * try to fix warning about maven-source-plugin Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>	2022-01-05 12:34:52 +01:00
Harald Kuhr	33419ef291	#652 : Avoid OOME for large values outside TIFF, even if length is unknown	2022-01-03 12:51:52 +01:00
Harald Kuhr	123f0bb7fc	#648 : (Re-)Added support for nested layer groups	2021-12-29 16:20:02 +01:00
Harald Kuhr	99b5f28a49	#648 : Removed unnecessary parentheses.	2021-12-29 12:38:04 +01:00
Harald Kuhr	b30fb4f8c3	#648 : Simplified logic, code style fixes and clean up.	2021-12-28 16:49:41 +01:00
Jack Yun	dc0bdcbd5b	Support Group Layer in psd (#648 )	2021-12-27 13:39:39 +01:00
Harald Kuhr	0cf29c167d	Updated with latest versions.	2021-12-27 12:59:24 +01:00
Harald Kuhr	98e4b76206	#651 : Fix ExtraSamplesColorModel equals + hashcode to behave nicely with ImageTypeSpecifier comparison.	2021-12-24 12:57:24 +01:00
Harald Kuhr	aa4b5db054	Minor clean-up.	2021-12-24 12:27:10 +01:00
Harald Kuhr	433311c10d	#651 : Fix ExtraSamplesColorModel to create correct length elements array.	2021-12-24 12:25:31 +01:00
Harald Kuhr	f50178bc78	Alternative fix for #650 : Allow usage in OSGi environment.	2021-12-23 11:02:27 +01:00
Snyk bot	e016e970e5	fix: upgrade commons-io:commons-io from 2.9.0 to 2.11.0 (#647 ) Snyk has created this PR to upgrade commons-io:commons-io from 2.9.0 to 2.11.0. See this package in Maven Repository: https://mvnrepository.com/artifact/commons-io/commons-io/ See this project in Snyk: https://app.snyk.io/org/haraldk/project/9a1f6304-68e0-49c5-af4f-db1f87bd4f90?utm_source=github&utm_medium=referral&page=upgrade-pr	2021-12-16 08:46:44 +01:00
Harald Kuhr	4223d13898	Update jakarta servlet dependency classifier.	2021-12-15 18:34:03 +01:00
Harald Kuhr	444aeabf21	Overriding transitive dependency.	2021-12-15 16:58:27 +01:00
Harald Kuhr	05507a59d6	Getting rid of the dependencies too.	2021-12-15 16:29:38 +01:00
Harald Kuhr	c4c89a0a25	Delete deprecated servlet classes	2021-12-15 16:23:08 +01:00
Harald Kuhr	b0ad6b2a4b	Delete deprecated Servlet classes	2021-12-14 19:35:13 +01:00
Harald Kuhr	25c703f4b2	#646 : Spi now recognizes VP8 encoded images in VP8X ("extended format").	2021-12-14 19:30:08 +01:00
Oleh Astappiev	529c59f93f	Create jakartified package on build (#636 ) * feat(servlet): create jakartified package on build * feat(servlet): update README to include Jakarta classifier	2021-12-14 19:25:02 +01:00
Harald Kuhr	584b1d9b21	Updated with the latest versions.	2021-12-14 09:18:36 +01:00
Harald Kuhr	312ce364cc	[maven-release-plugin] prepare for next development iteration	2021-12-12 13:17:20 +01:00