[maven-release-plugin] prepare for next development iteration

[maven-release-plugin] prepare release twelvemonkeys-3.8.3
DiscreteAlphaIndexColorModel num components fix
2026-05-01 00:00:02 -04:00 · 2022-08-19 17:43:15 +02:00 · 2022-08-19 17:43:11 +02:00 · 2022-08-19 17:39:27 +02:00 · 2022-08-19 17:39:27 +02:00 · 2022-08-19 17:39:25 +02:00
707 changed files with 28765 additions and 47944 deletions
@@ -0,0 +1 @@
+github: haraldk
@@ -0,0 +1,53 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: Reported bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Version information**
+1. The version of the TwelveMonkeys ImageIO library in use.
+For example:  4.0.0
+
+2. The *exact* output of `java --version` (or `java -version` for older Java releases). 
+For example: 
+
+    java version "1.8.0_271"
+    Java(TM) SE Runtime Environment (build 1.8.0_271-b09)
+    Java HotSpot(TM) 64-Bit Server VM (build 25.271-b09, mixed mode)
+
+3. Extra information about OS version, server version, standalone program or web application packaging, executable wrapper, etc. Please state exact version numbers where applicable.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+1. Compile the below sample code
+2. Download the sample image file
+3. Run the code with the sample file
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Example code**
+Preferably as a failing JUnit test, or a standalone program with a `main` method that showcases the problem. 
+
+Less is more. Don't add your entire project, only the code required to reproduce the problem. 😀 
+
+**Sample file(s)**
+Attach any sample files needed to reproduce the problem. Use a ZIP-file if the format is not directly supported by GitHub.
+
+**Stak trace**
+Always include the stack trace you experience.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+Do not add screenshots of code or stack traces. 😀 
+
+**Additional context**
+Add any other context about the problem here.
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: New feature
+assignees: ''
+
+---
+
+**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 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,13 @@
+---
+name: Trouble shooting and programming help
+about: "General programming issues will reach a wider audience at StackOverflow. Tag
+  questions with javax-imageio and/or twelvemonkeys \U0001F600 "
+title: ''
+labels: Trouble-shooting
+assignees: ''
+
+---
+
+General programming issues and problems will reach a much wider audience at StackOverflow, we suggest you ask them there. This will offload our work with maintaining the library, and make sure you get better help sooner.
+
+Tag the question with `javax-imageio` and/or `twelvemonkeys` and we'll find them there.
@@ -0,0 +1,11 @@
+**What is fixed** Add link to the issue this PR fixes. 
+
+Example: Fixes #42. 
+
+**Why is this change proposed** If this change does *not* fix an open issue, briefly describe the rationale for this PR.
+
+**What is changed** Briefly describe the changes proposed in this pull request: 
+
+* Fixed rare exception happening in `x >= 42` case
+* Small optimization of `decompress()` method
+* Corrected API doc for `compress()` method to reflect current implementation 
@@ -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 ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v2
+        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@v2
+        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@v2
+      - run: |
+          download_url="https://javadl.oracle.com/webapps/download/AutoDL?BundleId=245038_d3c52aa6bfa54d3ca74e617f18309292"
+          wget -O $RUNNER_TEMP/java_package.tar.gz $download_url
+      - uses: actions/setup-java@v2
+        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@v2
+        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@v2
+      - name: Set up Maven Central
+        uses: actions/setup-java@v2
+        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,14 +0,0 @@
-dist: trusty
-language: java
-jdk:
-  - oraclejdk8
-# Oracle JDK 7 no longer supported, we use env matrix to test various CMM providers
-#  - oraclejdk7
-# Some JPEGImageReader tests fail on OpenJDK, need to investigate/fix before enabling
-#  - openjdk7
-env:
-  - MAVEN_OPTS=-Dsun.java2d.cmm=sun.java2d.cmm.kcms.KcmsServiceProvider
-  - MAVEN_OPTS=""
-cache:
-  directories:
-  - $HOME/.m2
@@ -1,264 +1,78 @@
-## Latest
-
-Master branch build status: [![Build Status](https://travis-ci.org/haraldk/TwelveMonkeys.svg?branch=master)](https://travis-ci.org/haraldk/TwelveMonkeys)
-
-Latest release is TwelveMonkeys ImageIO [3.4.3](https://search.maven.org/search?q=g:com.twelvemonkeys.imageio%20AND%20v:3.4.3) (Jan. 9th, 2020).
-[Release notes](https://github.com/haraldk/TwelveMonkeys/releases/latest).
+[![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)

 ## About

-TwelveMonkeys ImageIO is a collection of plugins and extensions for Java's ImageIO.
+TwelveMonkeys ImageIO provides extended image file format support for the Java platform, through plugins for the `javax.imageio.*` package.

-These plugins extends the number of image file formats supported in Java, using the javax.imageio.* package.
-The main purpose of this project is to provide support for formats not covered by the JRE itself.
-
-Support for formats is important, both to be able to read data found
+The main goal of this project is to provide support for formats not covered by the JRE itself. 
+Support for these formats is important, to be able to read data found
 "in the wild", as well as to maintain access to data in legacy formats.
-Because there is lots of legacy data out there, we see the need for open implementations of readers for popular formats.
-The goal is to create a set of efficient and robust ImageIO plug-ins, that can be distributed independently.
+As there is lots of legacy data out there, we see the need for open implementations of readers for popular formats.

 ----

-## Features
+## File formats supported

-Mainstream format support
+| 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) | 

-#### BMP - MS Windows/IBM OS/2 Device Independent Bitmap
- 
-* Read support for all known versions of the DIB/BMP format
-  * Indexed color, 1, 4 and 8 bit, including 4 and 8 bit RLE
-  * RGB, 16, 24 and 32 bit
-  * Embedded PNG and JPEG data
-  * Windows and OS/2 versions
-* Native and standard metadata format

-#### JPEG
-
-* Read support for the following JPEG "flavors":
-  * All JFIF compliant JPEGs
-  * All Exif compliant JPEGs
-  * YCbCr JPEGs without JFIF segment (converted to RGB, using embedded ICC profile)
-  * CMYK JPEGs (converted to RGB by default or as CMYK, using embedded ICC profile)
-  * Adobe YCCK JPEGs (converted to RGB by default or as CMYK, using embedded ICC profile)
-  * JPEGs containing ICC profiles with interpretation other than 'Perceptual' or class other than 'Display'
-  * JPEGs containing ICC profiles that are incompatible with stream data, corrupted ICC profiles or corrupted `ICC_PROFILE` segments
-  * JPEGs using non-standard color spaces, unsupported by Java 2D
-  * JPEGs with APP14/Adobe segments with length other than 14 bytes
-  * 8 bit JPEGs with 16 bit DQT segments
-  * Issues warnings instead of throwing exceptions in cases of corrupted or non-conformant data where ever the image 
-  data can still be read in a reasonable way
-* Thumbnail support:
-  * JFIF thumbnails (even if stream contains "inconsistent metadata")
-  * JFXX thumbnails (JPEG, Indexed and RGB)
-  * EXIF thumbnails (JPEG, RGB and YCbCr)
-* Metadata support:
-  * JPEG metadata in both standard and native formats (even if stream contains "inconsistent metadata")
-  * `javax_imageio_jpeg_image_1.0` format (currently as native format, may change in the future)
-  * Non-conforming combinations of JFIF, Exif and Adobe markers, using "unknown" segments in the
-   "MarkerSequence" tag for the unsupported segments (for `javax_imageio_jpeg_image_1.0` format)
-* Extended write support:
-  * CMYK JPEGs
-  * YCCK JPEGs in progress
-
-#### JPEG-2000
-
-* Possibly coming in the future, pending some license issues.
-
-If you are one of the authors, or know one of the authors and/or the current license holders of either the original
-jj2000 package or the JAI ImageIO project, please contact me (I've tried to get in touch in various ways, 
-without success so far).
-
-Alternatively, if you have or know of a JPEG-2000 implementation in Java with a suitable license, get in touch. :-)
-
-#### PNM - NetPBM Portable Any Map
-
-* Read support for the following file types:
-  * PBM in 'P1' (ASCII) and 'P4' (binary) formats, 1 bit per pixel
-  * PGM in 'P2' (ASCII) and 'P5' (binary) formats, up to 16/32 bits per pixel
-  * PPM in 'P3' (ASCII) and 'P6' (binary) formats, up to 16/32 bits per pixel component
-  * PAM in 'P7' (binary) format up to 32 bits per pixel component
-  * Limited support for PFM in 'Pf' (gray) and 'PF' (RGB) formats, 32 bits floating point
-* Write support for the following formats:
-  * PPM in 'P6' (binary) format
-  * PAM in 'P7' (binary) format
-* Standard metadata support
-
-#### PSD - Adobe Photoshop Document
-
-* Read support for the following file types:
-  * Monochrome, 1 channel, 1 bit
-  * Indexed, 1 channel, 8 bit
-  * Gray, 1 channel, 8, 16 and 32 bit
-  * Duotone, 1 channel, 8, 16 and 32 bit
-  * RGB, 3-4 channels, 8, 16 and 32 bit
-  * CMYK, 4-5 channels, 8, 16 and 32 bit
-* Read support for the following compression types:
-  * Uncompressed
-  * RLE (PackBits)
-* Layer support
-  * Image layers only, in all of the above types
-* Thumbnail support
-  * JPEG
-  * RAW (RGB)
-* Support for "Large Document Format" (PSB)
-* Native and Standard metadata support
-
-#### TIFF - Aldus/Adobe Tagged Image File Format
-
-* Read support for the following "Baseline" TIFF file types:
-  * Class B (Bi-level), all relevant compression types, 1 bit per sample
-  * Class G (Gray), all relevant compression types, 2, 4, 8, 16 or 32 bits per sample, unsigned integer
-  * Class P (Palette/indexed color), all relevant compression types, 1, 2, 4, 8 or 16 bits per sample, unsigned integer
-  * Class R (RGB), all relevant compression types, 8 or 16 bits per sample, unsigned integer
-* Read support for the following TIFF extensions:
-  * Tiling
-  * Class F (Facsimile), CCITT Modified Huffman RLE, T4 and T6 (type 2, 3 and 4) compressions.
-  * LZW Compression (type 5)
-  * "Old-style" JPEG Compression (type 6), as a best effort, as the spec is not well-defined
-  * JPEG Compression (type 7)
-  * ZLib (aka Adobe-style Deflate) Compression (type 8)
-  * Deflate Compression (type 32946)
-  * Horizontal differencing Predictor (type 2) for LZW, ZLib, Deflate and PackBits compression
-  * Alpha channel (ExtraSamples type 1/Associated Alpha and type 2/Unassociated Alpha)
-  * CMYK data (PhotometricInterpretation type 5/Separated)
-  * YCbCr data (PhotometricInterpretation type 6/YCbCr) for JPEG
-  * CIELab data in TIFF, ITU and ICC variants (PhotometricInterpretation type 9, 10 and 11)
-  * Planar data (PlanarConfiguration type 2/Planar)
-  * ICC profiles (ICCProfile)
-  * BitsPerSample values up to 16 for most PhotometricInterpretations
-  * Multiple images (pages) in one file
-* Write support for most "Baseline" TIFF options
-  * Uncompressed, PackBits, ZLib and Deflate 
-  * Additional support for CCITT T4 and and T6 compressions.
-  * Additional support for LZW and JPEG (type 7) compressions
-  * Horizontal differencing Predictor (type 2) for LZW, ZLib, Deflate
-* Native and Standard metadata support
-
-Legacy formats
-
-#### HDR - Radiance High Dynamic Range RGBE Format
-
-* Read support for the most common RGBE (.hdr) format
-* Samples are converted to 32 bit floating point (`float`) and normalized using a global tone mapper by default.
-  * Support for custom global tone mappers
-  * Alternatively, use a "null-tone mapper", for unnormalized data (allows local tone mapping)
-* Unconverted RGBE samples accessible using `readRaster`
-* Standard metadata support
-
-#### IFF - Commodore Amiga/Electronic Arts Interchange File Format
-
-* Legacy format, allows reading popular image format from the Commodore Amiga computer.
-* Read support for the following file types:
-  * ILBM Indexed color, 1-8 interleaved bit planes, including 6 bit EHB
-  * ILBM  Gray, 8 bit interleaved bit planes
-  * ILBM RGB, 24 and 32 bit interleaved bit planes
-  * ILBM HAM6 and HAM8
-  * PBM Indexed color, 1-8 bit,
-  * PBM Gray, 8 bit
-  * PBM RGB, 24 and 32 bit
-  * PBM HAM6 and HAM8
-* Write support
-  * ILBM Indexed color, 1-8 bits per sample, 8 bit gray, 24 and 32 bit true color.
-* Support for the following compression types (read/write):
-  * Uncompressed
-  * RLE (PackBits)
-
-#### PCX - ZSoft Paintbrush Format
-
-* Read support for the following file types:
-  * Indexed color, 1, 2, 4 or 8 bits per pixel, bit planes or interleaved
-  * Grayscale, 8 bits per pixel
-  * Color (RGB), 8 bits per pixel component
-* Read support for DCX (multi-page) fax format, containing any of the above types
-* Support for the following compression types:
-  * Uncompressed (experimental)
-  * RLE compressed
-* Standard metadata support
-
-#### PICT - Apple Mac Paint Picture Format
-
-* Legacy format, especially useful for reading OS X clipboard data.
-* Read support for the following file types:
-  * QuickDraw (format support is not complete, but supports most OS X clipboard data as well as RGB pixel data)
-  * QuickDraw bitmap
-  * QuickDraw pixmap
-  * QuickTime stills
-* Write support for RGB pixel data:
-  * QuickDraw pixmap
-
-#### SGI - Silicon Graphics Image Format
-
-* Read support for the following file types:
-  * 1, 2, 3 or 4 channel image data
-  * 8 or 16 bits per pixel component
-* Support for the following compression types:
-  * Uncompressed
-  * RLE compressed
-* Standard metadata support
-
-#### TGA - Truevision TGA Image Format
-
-* Read support for the following file types:
-  * ColorMapped
-  * Monochrome
-  * TrueColor
-* Support for the following compression types:
-  * Uncompressed
-  * RLE compressed
-* Standard metadata support
-* Write support
-
-Icon/other formats
-
-#### ICNS - Apple Icon Image
-
-* Read support for the following icon types:
-  * All known "native" icon types
-  * Large PNG encoded icons
-  * Large JPEG 2000 encoded icons (requires JPEG 2000 ImageIO plugin or fallback to `sips` command line tool)
-* Write support for PNG encoded icons
-
-#### ICO & CUR - MS Windows Icon and Cursor Formats
-
-* Read support for the following file types:
-  * ICO Indexed color, 1, 4 and 8 bit
-  * ICO RGB, 16, 24 and 32 bit
-  * CUR Indexed color, 1, 4 and 8 bit
-  * CUR RGB, 16, 24 and 32 bit
-* Write support
-* *3.1* Note: These formats are now part of the BMP plugin
-
-#### Thumbs.db - MS Windows Thumbs DB
-
-* Read support
-
-Other formats, using 3rd party libraries
-
-#### SVG - Scalable Vector Graphics
-
-* Read-only support using Batik
-
-#### WMF - MS Windows MetaFile
-
-* Limited read-only support using Batik
-
-**Important note on using Batik:** *Please read [The Apache™ XML Graphics Project - Security](http://xmlgraphics.apache.org/security.html), and make sure you use
-either version 1.6.1, 1.7.1 or 1.8+.*
+**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.*

+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).
+For BMP, JPEG, and TIFF formats the TwelveMonkeys plugins provides extended format support and additional features.

 ## Basic usage

 Most of the time, all you need to do is simply include the plugins in your project and write:

-    BufferedImage image = ImageIO.read(file);
+```java
+BufferedImage image = ImageIO.read(file);
+```

 This will load the first image of the file, entirely into memory.

 The basic and simplest form of writing is:

-    if (!ImageIO.write(image, format, file)) {
-       // Handle image not written case
-    }
+```java
+if (!ImageIO.write(image, format, file)) {
+   // Handle image not written case
+}
+```

 This will write the entire image into a single file, using the default settings for the given format.

@@ -269,50 +83,44 @@ The plugins are discovered automatically at run time. See the [FAQ](#faq) for mo
 If you need more control of read parameters and the reading process, the common idiom for reading is something like:

 ```java
-    // Create input stream
-    ImageInputStream input = ImageIO.createImageInputStream(file);
+// Create input stream (in try-with-resource block to avoid leaks)
+try (ImageInputStream input = ImageIO.createImageInputStream(file)) {
+    // Get the reader
+    Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
+
+    if (!readers.hasNext()) {
+        throw new IllegalArgumentException("No reader for: " + file);
+    }
+
+    ImageReader reader = readers.next();

    try {
-        // Get the reader
-        Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
+        reader.setInput(input);

-        if (!readers.hasNext()) {
-            throw new IllegalArgumentException("No reader for: " + file);
-        }
+        // Optionally, listen for read warnings, progress, etc.
+        reader.addIIOReadWarningListener(...);
+        reader.addIIOReadProgressListener(...);

-        ImageReader reader = readers.next();
+        ImageReadParam param = reader.getDefaultReadParam();

-        try {
-            reader.setInput(input);
+        // Optionally, control read settings like sub sampling, source region or destination etc.
+        param.setSourceSubsampling(...);
+        param.setSourceRegion(...);
+        param.setDestination(...);
+        // ...

-            // Optionally, listen for read warnings, progress, etc.
-            reader.addIIOReadWarningListener(...);
-            reader.addIIOReadProgressListener(...);
+        // Finally read the image, using settings from param
+        BufferedImage image = reader.read(0, param);

-            ImageReadParam param = reader.getDefaultReadParam();
-
-            // Optionally, control read settings like sub sampling, source region or destination etc.
-            param.setSourceSubsampling(...);
-            param.setSourceRegion(...);
-            param.setDestination(...);
-            // ...
-
-            // Finally read the image, using settings from param
-            BufferedImage image = reader.read(0, param);
-
-            // Optionally, read thumbnails, meta data, etc...
-            int numThumbs = reader.getNumThumbnails(0);
-            // ...
-        }
-        finally {
-            // Dispose reader in finally block to avoid memory leaks
-            reader.dispose();
-        }
+        // Optionally, read thumbnails, meta data, etc...
+        int numThumbs = reader.getNumThumbnails(0);
+        // ...
    }
    finally {
-        // Close stream in finally block to avoid resource leaks
-        input.close();
+        // Dispose reader in finally block to avoid memory leaks
+        reader.dispose();
    }
+}
 ```

 Query the reader for source image dimensions using `reader.getWidth(n)` and `reader.getHeight(n)` without reading the
@@ -324,86 +132,56 @@ It's also possible to read multiple images from the same file in a loop, using `
 If you need more control of write parameters and the writing process, the common idiom for writing is something like:

 ```java
-    // Get the writer
-    Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(format);
+// Get the writer
+Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(format);

-    if (!writers.hasNext()) {
-        throw new IllegalArgumentException("No writer for: " + format);
-    }
-
-    ImageWriter writer = writers.next();
-
-    try {
-        // Create output stream
-        ImageOutputStream output = ImageIO.createImageOutputStream(file);
-
-        try {
-            writer.setOutput(output);
-
-            // Optionally, listen to progress, warnings, etc.
-
-            ImageWriteParam param = writer.getDefaultWriteParam();
-
-            // Optionally, control format specific settings of param (requires casting), or
-            // control generic write settings like sub sampling, source region, output type etc.
-
-            // Optionally, provide thumbnails and image/stream metadata
-            writer.write(..., new IIOImage(..., image, ...), param);
-        }
-        finally {
-            // Close stream in finally block to avoid resource leaks
-            output.close();
-        }
-    }
-    finally {
-        // Dispose writer in finally block to avoid memory leaks
-        writer.dispose();
+if (!writers.hasNext()) {
+    throw new IllegalArgumentException("No writer for: " + format);
+}
+
+ImageWriter writer = writers.next();
+
+try {
+    // Create output stream (in try-with-resource block to avoid leaks)
+    try (ImageOutputStream output = ImageIO.createImageOutputStream(file)) {
+        writer.setOutput(output);
+
+        // Optionally, listen to progress, warnings, etc.
+
+        ImageWriteParam param = writer.getDefaultWriteParam();
+
+        // Optionally, control format specific settings of param (requires casting), or
+        // control generic write settings like sub sampling, source region, output type etc.
+
+        // Optionally, provide thumbnails and image/stream metadata
+        writer.write(..., new IIOImage(..., image, ...), param);
    }
+}
+finally {
+    // Dispose writer in finally block to avoid memory leaks
+    writer.dispose();
+}
 ```

 For more advanced usage, and information on how to use the ImageIO API, I suggest you read the
-[Java Image I/O API Guide](http://docs.oracle.com/javase/7/docs/technotes/guides/imageio/spec/imageio_guideTOC.fm.html)
+[Java Image I/O API Guide](https://docs.oracle.com/javase/7/docs/technotes/guides/imageio/spec/imageio_guideTOC.fm.html)
 from Oracle.

+#### Adobe Clipping Path support

-#### Deploying the plugins in a web app
+```java
+import com.twelvemonkeys.imageio.path.Paths;

-Because the `ImageIO` plugin registry (the `IIORegistry`) is "VM global", it doesn't by default work well with
-servlet contexts. This is especially evident if you load plugins from the `WEB-INF/lib` or `classes` folder.
-Unless you add `ImageIO.scanForPlugins()` somewhere in your code, the plugins might never be available at all.
+...

-In addition, servlet contexts dynamically loads and unloads classes (using a new class loader per context).
-If you restart your application, old classes will by default remain in memory forever (because the next time
-`scanForPlugins` is called, it's another `ClassLoader` that scans/loads classes, and thus they will be new instances
-in the registry). If a read is attempted using one of the remaining "old" readers, weird exceptions
-(like `NullPointerException`s when accessing `static final` initialized fields or `NoClassDefFoundError`s 
-for uninitialized inner classes) may occur.
+try (ImageInputStream stream = ImageIO.createImageInputStream(new File("image_with_path.jpg")) {
+    BufferedImage image = Paths.readClipped(stream);

-To work around both the discovery problem and the resource leak,
-it is *strongly recommended* to use the `IIOProviderContextListener` that implements
-dynamic loading and unloading of ImageIO plugins for web applications.
-
-```xml
-    <web-app ...>
-
-    ...
-
-        <listener>
-            <display-name>ImageIO service provider loader/unloader</display-name>
-            <listener-class>com.twelvemonkeys.servlet.image.IIOProviderContextListener</listener-class>
-        </listener>
-
-    ...
-
-    </web-app>
+    // Do something with the clipped image...
+}
 ```
+See [Adobe Clipping Path support on the Wiki](https://github.com/haraldk/TwelveMonkeys/wiki/Photoshop-Clipping-Path-support) for more details and example code.

-Loading plugins from `WEB-INF/lib` without the context listener installed is unsupported and will not work correctly.
-
-The context listener has no dependencies to the TwelveMonkeys ImageIO plugins, and may be used with JAI ImageIO 
-or other ImageIO plugins as well.
-
-Another safe option, is to place the JAR files in the application server's shared or common lib folder. 

 #### Using the ResampleOp

@@ -411,15 +189,15 @@ The library comes with a resampling (image resizing) operation, that contains ma
 to provide excellent results at reasonable speed.

 ```java
-    import com.twelvemonkeys.image.ResampleOp;
+import com.twelvemonkeys.image.ResampleOp;

-    ...
+...

-    BufferedImage input = ...; // Image to resample
-    int width, height = ...; // new width/height
+BufferedImage input = ...; // Image to resample
+int width, height = ...; // new width/height

-    BufferedImageOp resampler = new ResampleOp(width, height, ResampleOp.FILTER_LANCZOS); // A good default filter, see class documentation for more info
-    BufferedImage output = resampler.filter(input, null);
+BufferedImageOp resampler = new ResampleOp(width, height, ResampleOp.FILTER_LANCZOS); // A good default filter, see class documentation for more info
+BufferedImage output = resampler.filter(input, null);
 ```

 #### Using the DiffusionDither
@@ -428,30 +206,30 @@ The library comes with a dithering operation, that can be used to convert `Buffe
 Floyd-Steinberg error-diffusion dither.

 ```java
-    import com.twelvemonkeys.image.DiffusionDither;
+import com.twelvemonkeys.image.DiffusionDither;

-    ...
+...

-    BufferedImage input = ...; // Image to dither
+BufferedImage input = ...; // Image to dither

-    BufferedImageOp ditherer = new DiffusionDither();
-    BufferedImage output = ditherer.filter(input, null);
+BufferedImageOp ditherer = new DiffusionDither();
+BufferedImage output = ditherer.filter(input, null);
 ```

 ## Building

-Download the project (using [Git](http://git-scm.com/downloads)):
+Download the project (using [Git](https://git-scm.com/downloads)):

    $ git clone git@github.com:haraldk/TwelveMonkeys.git

 This should create a folder named `TwelveMonkeys` in your current directory. Change directory to the `TwelveMonkeys`
 folder, and issue the command below to build.

-Build the project (using [Maven](http://maven.apache.org/download.cgi)):
+Build the project (using [Maven](https://maven.apache.org/download.cgi)):

    $ mvn package

-Currently, the recommended JDK for making a build is Oracle JDK 7.x or 8.x. 
+Currently, the recommended JDK for making a build is Oracle JDK 8.x. 

 It's possible to build using OpenJDK, but some tests might fail due to some minor differences between the color management systems used. You will need to either disable the tests in question, or build without tests altogether.

@@ -473,10 +251,10 @@ The ImageIO registry and service lookup mechanism will make sure the plugins are
 To verify that the JPEG plugin is installed and used at run-time, you could use the following code:

 ```java
-    Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("JPEG");
-    while (readers.hasNext()) {
-        System.out.println("reader: " + readers.next());
-    }
+Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("JPEG");
+while (readers.hasNext()) {
+    System.out.println("reader: " + readers.next());
+}
 ```

 The first line should print:
@@ -488,119 +266,193 @@ The first line should print:
 To depend on the JPEG and TIFF plugin using Maven, add the following to your POM:

 ```xml
+...
+<dependencies>
    ...
-    <dependencies>
-        ...
-        <dependency>
-            <groupId>com.twelvemonkeys.imageio</groupId>
-            <artifactId>imageio-jpeg</artifactId>
-            <version>3.4.3</version>
-        </dependency>
-        <dependency>
-            <groupId>com.twelvemonkeys.imageio</groupId>
-            <artifactId>imageio-tiff</artifactId>
-            <version>3.4.3</version>
-        </dependency>
+    <dependency>
+        <groupId>com.twelvemonkeys.imageio</groupId>
+        <artifactId>imageio-jpeg</artifactId>
+        <version>3.8.1</version>
+    </dependency>
+    <dependency>
+        <groupId>com.twelvemonkeys.imageio</groupId>
+        <artifactId>imageio-tiff</artifactId>
+        <version>3.8.1</version>
+    </dependency>

-        <!--
-        Optional dependency. Needed only if you deploy `ImageIO` plugins as part of a web app.
-        Make sure you add the `IIOProviderContextListener` to your `web.xml`, see above.
-        -->
-        <dependency>
-            <groupId>com.twelvemonkeys.servlet</groupId>
-            <artifactId>servlet</artifactId>
-            <version>3.4.3</version>
-        </dependency>
-    </dependencies>
+    <!--
+    Optional dependency. Needed only if you deploy ImageIO plugins as part of a web app.
+    Make sure you add the IIOProviderContextListener to your web.xml, see above.
+    -->
+    <dependency>
+        <groupId>com.twelvemonkeys.servlet</groupId>
+        <artifactId>servlet</artifactId>
+        <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>
 ```

 #### Manual dependency example

 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.4.3.jar
-    twelvemonkeys-common-io-3.4.3.jar
-    twelvemonkeys-common-image-3.4.3.jar
-    twelvemonkeys-imageio-core-3.4.3.jar
-    twelvemonkeys-imageio-metadata-3.4.3.jar
-    twelvemonkeys-imageio-jpeg-3.4.3.jar
-    twelvemonkeys-imageio-tiff-3.4.3.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
+
+Because the `ImageIO` plugin registry (the `IIORegistry`) is "VM global", it doesn't by default work well with
+servlet contexts. This is especially evident if you load plugins from the `WEB-INF/lib` or `classes` folder.
+Unless you add `ImageIO.scanForPlugins()` somewhere in your code, the plugins might never be available at all.
+
+In addition, servlet contexts dynamically loads and unloads classes (using a new class loader per context).
+If you restart your application, old classes will by default remain in memory forever (because the next time
+`scanForPlugins` is called, it's another `ClassLoader` that scans/loads classes, and thus they will be new instances
+in the registry). If a read is attempted using one of the remaining "old" readers, weird exceptions
+(like `NullPointerException`s when accessing `static final` initialized fields or `NoClassDefFoundError`s 
+for uninitialized inner classes) may occur.
+
+To work around both the discovery problem and the resource leak,
+it is *strongly recommended* to use the `IIOProviderContextListener` that implements
+dynamic loading and unloading of ImageIO plugins for web applications.
+
+```xml
+<web-app ...>
+
+...
+
+    <listener>
+        <display-name>ImageIO service provider loader/unloader</display-name>
+        <listener-class>com.twelvemonkeys.servlet.image.IIOProviderContextListener</listener-class>
+    </listener>
+
+...
+
+</web-app>
+```
+
+Loading plugins from `WEB-INF/lib` without the context listener installed is unsupported and will not work correctly.
+
+The context listener has no dependencies to the TwelveMonkeys ImageIO plugins, and may be used with JAI ImageIO 
+or other ImageIO plugins as well.
+
+Another safe option, is to place the JAR files in the application server's shared or common lib folder. 
+
+#### Including the plugins in a "fat" JAR
+
+The recommended way to use the plugins, is just to include the JARs as-is in your project, through a Maven dependency or similar. 
+Re-packaging is not necessary to use the library, and not recommended. 
+ 
+However, if you like to create a "fat" 
+JAR, or otherwise like to re-package the JARs for some reason, it's important to remember that automatic discovery of 
+the plugins by ImageIO depends on the 
+[Service Provider Interface (SPI)](https://docs.oracle.com/javase/tutorial/sound/SPI-intro.html) mechanism. 
+In short, each JAR contains a special folder, named `META-INF/services` containing one or more files, 
+typically `javax.imageio.spi.ImageReaderSpi` and `javax.imageio.spi.ImageWriterSpi`. 
+These files exist *with the same name in every JAR*, 
+so if you simply unpack everything to a single folder or create a JAR, files will be overwritten and behavior be 
+unspecified (most likely you will end up with a single plugin being installed). 
+
+The solution is to make sure all files with the same name, are merged to a single file, 
+containing all the SPI information of each type. If using the Maven Shade plugin, you should use the 
+[ServicesResourceTransformer](https://maven.apache.org/plugins/maven-shade-plugin/examples/resource-transformers.html#ServicesResourceTransformer)
+to properly merge these files. You may also want to use the 
+[ManifestResourceTransforme](https://maven.apache.org/plugins/maven-shade-plugin/examples/resource-transformers.html#ManifestResourceTransformer) 
+to get the correct vendor name, version info etc. 
+Other "fat" JAR bundlers will probably have similar mechanisms to merge entries with the same name.

 ### Links to prebuilt binaries

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

 Requires Java 7 or later.
 
 Common dependencies
-* [common-lang-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.4.3/common-lang-3.4.3.jar)
-* [common-io-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.4.3/common-io-3.4.3.jar)
-* [common-image-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.4.3/common-image-3.4.3.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.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.4.3/imageio-core-3.4.3.jar)
-* [imageio-metadata-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.4.3/imageio-metadata-3.4.3.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.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-bmp/3.4.3/imageio-bmp-3.4.3.jar)
-* [imageio-jpeg-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.4.3/imageio-jpeg-3.4.3.jar)
-* [imageio-tiff-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.4.3/imageio-tiff-3.4.3.jar)
-* [imageio-pnm-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pnm/3.4.3/imageio-pnm-3.4.3.jar)
-* [imageio-psd-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.4.3/imageio-psd-3.4.3.jar)
-* [imageio-hdr-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-hdr/3.4.3/imageio-hdr-3.4.3.jar)
-* [imageio-iff-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.4.3/imageio-iff-3.4.3.jar)
-* [imageio-pcx-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pcx/3.4.3/imageio-pcx-3.4.3.jar)
-* [imageio-pict-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.4.3/imageio-pict-3.4.3.jar)
-* [imageio-sgi-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-sgi/3.4.3/imageio-sgi-3.4.3.jar)
-* [imageio-tga-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tga/3.4.3/imageio-tga-3.4.3.jar)
-* [imageio-icns-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.4.3/imageio-icns-3.4.3.jar)
-* [imageio-thumbsdb-3.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.4.3/imageio-thumbsdb-3.4.3.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.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.4.3/imageio-batik-3.4.3.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.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-clippath/3.4.3/imageio-clippath-3.4.3.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.4.3.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.4.3/servlet-3.4.3.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)

 Use this version for projects that requires Java 6 or need the JMagick support. *Does not support Java 8 or later*.

 Common dependencies
-* [common-lang-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.0.2/common-lang-3.0.2.jar)
-* [common-io-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.0.2/common-io-3.0.2.jar)
-* [common-image-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.0.2/common-image-3.0.2.jar)
+* [common-lang-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.0.2/common-lang-3.0.2.jar)
+* [common-io-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.0.2/common-io-3.0.2.jar)
+* [common-image-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.0.2/common-image-3.0.2.jar)
 
 ImageIO dependencies
-* [imageio-core-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.0.2/imageio-core-3.0.2.jar)
-* [imageio-metadata-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.0.2/imageio-metadata-3.0.2.jar)
+* [imageio-core-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.0.2/imageio-core-3.0.2.jar)
+* [imageio-metadata-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.0.2/imageio-metadata-3.0.2.jar)
 
 ImageIO plugins
-* [imageio-jpeg-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.0.2/imageio-jpeg-3.0.2.jar)
-* [imageio-tiff-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.0.2/imageio-tiff-3.0.2.jar)
-* [imageio-psd-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.0.2/imageio-psd-3.0.2.jar)
-* [imageio-pict-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.0.2/imageio-pict-3.0.2.jar)
-* [imageio-iff-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.0.2/imageio-iff-3.0.2.jar)
-* [imageio-icns-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.0.2/imageio-icns-3.0.2.jar)
-* [imageio-ico-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-ico/3.0.2/imageio-ico-3.0.2.jar)
-* [imageio-thumbsdb-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.0.2/imageio-thumbsdb-3.0.2.jar)
+* [imageio-jpeg-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.0.2/imageio-jpeg-3.0.2.jar)
+* [imageio-tiff-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.0.2/imageio-tiff-3.0.2.jar)
+* [imageio-psd-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.0.2/imageio-psd-3.0.2.jar)
+* [imageio-pict-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.0.2/imageio-pict-3.0.2.jar)
+* [imageio-iff-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.0.2/imageio-iff-3.0.2.jar)
+* [imageio-icns-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.0.2/imageio-icns-3.0.2.jar)
+* [imageio-ico-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-ico/3.0.2/imageio-ico-3.0.2.jar)
+* [imageio-thumbsdb-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.0.2/imageio-thumbsdb-3.0.2.jar)
 
 ImageIO plugins requiring 3rd party libs
-* [imageio-batik-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.0.2/imageio-batik-3.0.2.jar)
-* [imageio-jmagick-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jmagick/3.0.2/imageio-jmagick-3.0.2.jar)
+* [imageio-batik-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.0.2/imageio-batik-3.0.2.jar)
+* [imageio-jmagick-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jmagick/3.0.2/imageio-jmagick-3.0.2.jar)
 
 Servlet support
-* [servlet-3.0.2.jar](http://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.0.2/servlet-3.0.2.jar)
+* [servlet-3.0.2.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.0.2/servlet-3.0.2.jar)


 ## License

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

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

    Redistribution and use in source and binary forms, with or without
@@ -653,7 +505,7 @@ a: The TwelveMonkeys ImageIO project contains plug-ins for ImageIO. ImageIO uses

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

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

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

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

 q: 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 formats, JAI has some major issues.
+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.
 - To get full format support, you need native libs.
@@ -5,7 +5,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>

    <groupId>com.twelvemonkeys.bom</groupId>
@@ -123,6 +123,16 @@
                <artifactId>imageio-tiff</artifactId>
                <version>${project.version}</version>
            </dependency>
+            <dependency>
+                <groupId>com.twelvemonkeys.imageio</groupId>
+                <artifactId>imageio-webp</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>com.twelvemonkeys.imageio</groupId>
+                <artifactId>imageio-xwd</artifactId>
+                <version>${project.version}</version>
+            </dependency>

            <!-- ImageIO 3rd party dependent plugins -->
            <dependency>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <artifactId>common-image</artifactId>
    <packaging>jar</packaging>
@@ -13,6 +13,10 @@
        The TwelveMonkeys Common Image support
    </description>

+    <properties>
+        <project.jpms.module.name>com.twelvemonkeys.common.image</project.jpms.module.name>
+    </properties>
+
    <dependencies>
        <dependency>
            <groupId>${project.groupId}</groupId>
@@ -27,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>
@@ -34,7 +34,13 @@ import java.awt.*;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
-import java.awt.image.*;
+import java.awt.image.BufferedImage;
+import java.awt.image.BufferedImageOp;
+import java.awt.image.ColorModel;
+import java.awt.image.ImagingOpException;
+import java.awt.image.Raster;
+import java.awt.image.RasterOp;
+import java.awt.image.WritableRaster;

 /**
 * This is a drop-in replacement for {@link java.awt.image.AffineTransformOp}.
@@ -70,6 +76,7 @@ public class AffineTransformOp implements BufferedImageOp, RasterOp {
        delegate = new java.awt.image.AffineTransformOp(xform, interpolationType);
    }

+    @SuppressWarnings("ConstantConditions")
    @Override
    public BufferedImage filter(final BufferedImage src, BufferedImage dst) {
        try {
@@ -80,10 +87,9 @@ public class AffineTransformOp implements BufferedImageOp, RasterOp {
                dst = createCompatibleDestImage(src, src.getColorModel());
            }

-            Graphics2D g2d = null;
+            Graphics2D g2d = dst.createGraphics();

            try {
-                g2d = dst.createGraphics();
                int interpolationType = delegate.getInterpolationType();

                if (interpolationType > 0) {
@@ -109,9 +115,7 @@ public class AffineTransformOp implements BufferedImageOp, RasterOp {
                return dst;
            }
            finally {
-                if (g2d != null) {
-                    g2d.dispose();
-                }
+                g2d.dispose();
            }
        }
    }
@@ -45,8 +45,8 @@ import java.awt.image.BufferedImage;
 */
 public class BufferedImageIcon implements Icon {
    private final BufferedImage image;
-    private int width;
-    private int height;
+    private final int width;
+    private final int height;
    private final boolean fast;

    public BufferedImageIcon(BufferedImage pImage) {
@@ -81,11 +81,10 @@ public class BufferedImageIcon implements Icon {
        else {
            //System.out.println("Scaling using interpolation");
            Graphics2D g2 = (Graphics2D) g;
-            AffineTransform xform = AffineTransform.getTranslateInstance(x, y);
-            xform.scale(width / (double) image.getWidth(), height / (double) image.getHeight());
-            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                                RenderingHints.VALUE_INTERPOLATION_BILINEAR);
-            g2.drawImage(image, xform, null);
+            AffineTransform transform = AffineTransform.getTranslateInstance(x, y);
+            transform.scale(width / (double) image.getWidth(), height / (double) image.getHeight());
+            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+            g2.drawImage(image, transform, null);
        }
    }
 }
@@ -587,6 +587,7 @@ class IndexImage {
     * @deprecated Use {@link #getIndexColorModel(Image,int,int)} instead!
     *             This version will be removed in a later version of the API.
     */
+    @Deprecated
    public static IndexColorModel getIndexColorModel(Image pImage, int pNumberOfColors, boolean pFast) {
        return getIndexColorModel(pImage, pNumberOfColors, pFast ? COLOR_SELECTION_FAST : COLOR_SELECTION_QUALITY);
    }
@@ -30,17 +30,26 @@

 package com.twelvemonkeys.image;

-import org.junit.Test;
+import static java.lang.Math.min;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;

-import javax.imageio.ImageTypeSpecifier;
 import java.awt.color.ColorSpace;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
-import java.awt.image.*;
+import java.awt.image.BufferedImage;
+import java.awt.image.BufferedImageOp;
+import java.awt.image.DataBuffer;
+import java.awt.image.ImagingOpException;
+import java.awt.image.Raster;
+import java.awt.image.RasterOp;
 import java.util.Arrays;
 import java.util.List;

-import static org.junit.Assert.*;
+import javax.imageio.ImageTypeSpecifier;
+
+import org.junit.Test;

 /**
 * AffineTransformOpTest.
@@ -101,6 +110,7 @@ public class AffineTransformOpTest {

    private final int width = 30;
    private final int height = 20;
+    private final double anchor = min(width, height) / 2.0;

    @Test
    public void testGetPoint2D() {
@@ -128,8 +138,8 @@ public class AffineTransformOpTest {

    @Test
    public void testFilterRotateBIStandard() {
-        BufferedImageOp jreOp = new java.awt.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, Math.min(width, height) / 2, Math.min(width, height) / 2), null);
-        BufferedImageOp tmOp = new com.twelvemonkeys.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, Math.min(width, height) / 2, Math.min(width, height) / 2), null);
+        BufferedImageOp jreOp = new java.awt.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, anchor, anchor), null);
+        BufferedImageOp tmOp = new com.twelvemonkeys.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, anchor, anchor), null);

        for (Integer type : TYPES) {
            BufferedImage image = new BufferedImage(width, height, type);
@@ -147,8 +157,8 @@ public class AffineTransformOpTest {

    @Test
    public void testFilterRotateBICustom() {
-        BufferedImageOp jreOp = new java.awt.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, Math.min(width, height) / 2, Math.min(width, height) / 2), null);
-        BufferedImageOp tmOp = new com.twelvemonkeys.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, Math.min(width, height) / 2, Math.min(width, height) / 2), null);
+        BufferedImageOp jreOp = new java.awt.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, anchor, anchor), null);
+        BufferedImageOp tmOp = new com.twelvemonkeys.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, anchor, anchor), null);

        for (ImageTypeSpecifier spec : SPECS) {
            BufferedImage image = spec.createBufferedImage(width, height);
@@ -197,8 +207,8 @@ public class AffineTransformOpTest {

    @Test
    public void testFilterRotateRasterStandard() {
-        RasterOp jreOp = new java.awt.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, Math.min(width, height) / 2, Math.min(width, height) / 2), null);
-        RasterOp tmOp = new com.twelvemonkeys.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, Math.min(width, height) / 2, Math.min(width, height) / 2), null);
+        RasterOp jreOp = new java.awt.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, anchor, anchor), null);
+        RasterOp tmOp = new com.twelvemonkeys.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, anchor, anchor), null);

        for (Integer type : TYPES) {
            Raster raster = new BufferedImage(width, height, type).getRaster();
@@ -221,8 +231,6 @@ public class AffineTransformOpTest {
                    fail("No result!");
                }
                else {
-                    System.err.println("AffineTransformOpTest.testFilterRotateRasterStandard");
-                    System.err.println("type: " + type);
                    continue;
                }
            }
@@ -240,8 +248,8 @@ public class AffineTransformOpTest {

    @Test
    public void testFilterRotateRasterCustom() {
-        RasterOp jreOp = new java.awt.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, Math.min(width, height) / 2, Math.min(width, height) / 2), null);
-        RasterOp tmOp = new com.twelvemonkeys.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, Math.min(width, height) / 2, Math.min(width, height) / 2), null);
+        RasterOp jreOp = new java.awt.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, anchor, anchor), null);
+        RasterOp tmOp = new com.twelvemonkeys.image.AffineTransformOp(AffineTransform.getQuadrantRotateInstance(1, anchor, anchor), null);

        for (ImageTypeSpecifier spec : SPECS) {
            Raster raster = spec.createBufferedImage(width, height).getRaster();
@@ -264,8 +272,6 @@ public class AffineTransformOpTest {
                    fail("No result!");
                }
                else {
-                    System.err.println("AffineTransformOpTest.testFilterRotateRasterCustom");
-                    System.err.println("spec: " + spec);
                    continue;
                }
            }
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <artifactId>common-io</artifactId>
    <packaging>jar</packaging>
@@ -13,6 +13,10 @@
        The TwelveMonkeys Common IO support
    </description>

+    <properties>
+        <project.jpms.module.name>com.twelvemonkeys.common.io</project.jpms.module.name>
+    </properties>
+
    <dependencies>
        <dependency>
            <groupId>${project.groupId}</groupId>
@@ -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.
@@ -72,7 +70,7 @@ public final class FastByteArrayOutputStream extends ByteArrayOutputStream {
    }

    @Override
-    public void write(byte pBytes[], int pOffset, int pLength) {
+    public void write(byte[] pBytes, int pOffset, int pLength) {
        if ((pOffset < 0) || (pOffset > pBytes.length) || (pLength < 0) ||
                ((pOffset + pLength) > pBytes.length) || ((pOffset + pLength) < 0)) {
            throw new IndexOutOfBoundsException();
@@ -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);
    }

    /**
@@ -346,7 +346,7 @@ public final class FileUtil {

    /**
     * Gets the file (type) extension of the given file.
-     * A file extension is the part of the filename, after the last occurence
+     * A file extension is the part of the filename, after the last occurrence
     * of a period {@code '.'}.
     * If the filename contains no period, {@code null} is returned.
     *
@@ -65,6 +65,7 @@ import java.io.FilenameFilter;
 * @see WildcardStringParser
 * @deprecated
 */
+@Deprecated
 public class FilenameMaskFilter implements FilenameFilter {

     // TODO: Rewrite to use regexp, or create new class
@@ -442,6 +442,7 @@ public class LittleEndianDataInputStream extends FilterInputStream implements Da
     * @see        java.io.BufferedReader#readLine()
     * @see        java.io.DataInputStream#readLine()
     */
+    @Deprecated
    public String readLine() throws IOException {
        DataInputStream ds = new DataInputStream(in);
        return ds.readLine();
@@ -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);
    }
 }
@@ -29,6 +29,9 @@

 package com.twelvemonkeys.xml;

+import java.io.OutputStream;
+import java.io.Writer;
+
 import org.w3c.dom.DOMConfiguration;
 import org.w3c.dom.DOMImplementationList;
 import org.w3c.dom.Document;
@@ -38,9 +41,6 @@ import org.w3c.dom.ls.DOMImplementationLS;
 import org.w3c.dom.ls.LSOutput;
 import org.w3c.dom.ls.LSSerializer;

-import java.io.OutputStream;
-import java.io.Writer;
-
 /**
 * {@code DOMImplementationLS} backed implementation.
 *
@@ -88,17 +88,6 @@ public final class DOMSerializer {
        output.setCharacterStream(pStream);
    }

-    /*
-    // TODO: Is it useful?
-    public void setNewLine(final String pNewLine) {
-        serializer.setNewLine(pNewLine);
-    }
-
-    public String getNewLine() {
-        return serializer.getNewLine();
-    }
-    */
-
    /**
     * Specifies wether the serializer should use indentation and optimize for
     * readability.
@@ -169,13 +158,7 @@ public final class DOMSerializer {
            try {
                return DOMImplementationRegistry.newInstance();
            }
-            catch (ClassNotFoundException e) {
-                throw new IllegalStateException(e);
-            }
-            catch (InstantiationException e) {
-                throw new IllegalStateException(e);
-            }
-            catch (IllegalAccessException e) {
+            catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
                throw new IllegalStateException(e);
            }
        }
@@ -30,16 +30,23 @@

 package com.twelvemonkeys.xml;

-import com.twelvemonkeys.lang.StringUtil;
-import org.w3c.dom.*;
-import org.xml.sax.SAXException;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.nio.charset.Charset;
+import java.util.Date;

 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
-import java.io.*;
-import java.nio.charset.Charset;
-import java.util.Date;
+
+import org.w3c.dom.*;
+import org.xml.sax.SAXException;
+
+import com.twelvemonkeys.lang.StringUtil;

 /**
 * XMLSerializer
@@ -290,7 +297,7 @@ public class XMLSerializer {
    }

    private static int appendAndEscape(final String pString, int pStart, final int pEnd, final StringBuilder pBuilder, final String pEntity) {
-        pBuilder.append(pString.substring(pStart, pEnd));
+        pBuilder.append(pString, pStart, pEnd);
        pBuilder.append(pEntity);
        return pEnd + 1;
    }
@@ -527,8 +534,7 @@ public class XMLSerializer {
            builder = factory.newDocumentBuilder();
        }
        catch (ParserConfigurationException e) {
-            //noinspection ThrowableInstanceNeverThrown BOGUS
-            throw (IOException) new IOException(e.getMessage()).initCause(e);
+            throw new IOException(e);
        }

        DOMImplementation dom = builder.getDOMImplementation();
@@ -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;
+        }
+    }
+}
@@ -32,13 +32,13 @@ package com.twelvemonkeys.io.enc;

 import com.twelvemonkeys.io.FileUtil;
 import com.twelvemonkeys.lang.ObjectAbstractTest;
+
 import org.junit.Test;

 import java.io.*;
-import java.util.Arrays;
 import java.util.Random;

-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.fail;

 /**
@@ -73,7 +73,7 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
        }
    }

-    private byte[] createData(final int pLength) throws Exception {
+    private byte[] createData(final int pLength) {
        byte[] bytes = new byte[pLength];
        RANDOM.nextBytes(bytes);
        return bytes;
@@ -82,9 +82,8 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
    private void runStreamTest(final int pLength) throws Exception {
        byte[] data = createData(pLength);
        ByteArrayOutputStream outBytes = new ByteArrayOutputStream();
-        OutputStream out = new EncoderStream(outBytes, createEncoder(), true);

-        try {
+        try (OutputStream out = new EncoderStream(outBytes, createEncoder(), true)) {
            // Provoke failure for encoders that doesn't take array offset properly into account
            int off = (data.length + 1) / 2;
            out.write(data, 0, off);
@@ -92,9 +91,6 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
                out.write(data, off, data.length - off);
            }
        }
-        finally {
-            out.close();
-        }

        byte[] encoded = outBytes.toByteArray();

@@ -102,7 +98,7 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
 //        System.err.println("encoded: " + Arrays.toString(encoded));

        byte[] decoded = FileUtil.read(new DecoderStream(new ByteArrayInputStream(encoded), createCompatibleDecoder()));
-        assertTrue(Arrays.equals(data, decoded));
+        assertArrayEquals(data, decoded);

        InputStream in = new DecoderStream(new ByteArrayInputStream(encoded), createCompatibleDecoder());
        outBytes = new ByteArrayOutputStream();
@@ -116,7 +112,7 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
        }

        decoded = outBytes.toByteArray();
-        assertTrue(Arrays.equals(data, decoded));
+        assertArrayEquals(data, decoded);
    }

    @Test
@@ -129,10 +125,6 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
                e.printStackTrace();
                fail(e.getMessage() + ": " + i);
            }
-            catch (Exception e) {
-                e.printStackTrace();
-                fail(e.getMessage() + ": " + i);
-            }
        }

        for (int i = 100; i < 2000; i += 250) {
@@ -143,10 +135,6 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
                e.printStackTrace();
                fail(e.getMessage() + ": " + i);
            }
-            catch (Exception e) {
-                e.printStackTrace();
-                fail(e.getMessage() + ": " + i);
-            }
        }

        for (int i = 2000; i < 80000; i += 1000) {
@@ -157,14 +145,8 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
                e.printStackTrace();
                fail(e.getMessage() + ": " + i);
            }
-            catch (Exception e) {
-                e.printStackTrace();
-                fail(e.getMessage() + ": " + i);
-            }
        }
    }

-    // TODO: Test that the transition from byte[] to ByteBuffer didn't introduce bugs when writing to a wrapped array with offset.
-
-
+    // TODO: Test that the transition from byte[] to ByteBuffer didn't introduce bugs when writing to a wrapped array with offset.
 }
@@ -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.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <artifactId>common-lang</artifactId>
    <packaging>jar</packaging>
@@ -13,4 +13,8 @@
        The TwelveMonkeys Common Language support
    </description>

+    <properties>
+        <project.jpms.module.name>com.twelvemonkeys.common.lang</project.jpms.module.name>
+    </properties>
+
 </project>
@@ -770,6 +770,7 @@ public final class StringUtil {
     */

    /*public*/
+    @Deprecated
    static String formatNumber(long pNum, int pLen) throws IllegalArgumentException {
        StringBuilder result = new StringBuilder();

@@ -1464,6 +1465,7 @@ public final class StringUtil {
     */

    /*public*/
+    @Deprecated
    static String removeSubstring(final String pSource, final char pBeginBoundaryChar, final char pEndBoundaryChar, final int pOffset) {
        StringBuilder filteredString = new StringBuilder();
        boolean insideDemarcatedArea = false;
@@ -330,7 +330,7 @@ abstract class AbstractDecoratedMap<K, V> extends AbstractMap<K, V> implements M
    }

    /**
-     * A simple Map.Entry implementaton.
+     * A simple Map.Entry implementation.
     */
    static class BasicEntry<K, V> implements Entry<K, V>, Serializable {
        K mKey;
@@ -129,8 +129,7 @@ public class Time {
     * @see #toString(String)
     */
    public String toString() {
-        return "" + getMinutes() + ":"
-                + (getSeconds() < 10 ? "0" : "") + getSeconds();
+        return getMinutes() + ":" + (getSeconds() < 10 ? "0" : "") + getSeconds();
    }

    /**
@@ -158,6 +157,7 @@ public class Time {
     * @see #parseTime(String)
     * @deprecated
     */
+    @Deprecated
    public String toString(String pFormatStr) {
        TimeFormat tf = new TimeFormat(pFormatStr);

@@ -175,6 +175,7 @@ public class Time {
     * @see #toString(String)
     * @deprecated
     */
+    @Deprecated
    public static Time parseTime(String pStr) {
        TimeFormat tf = TimeFormat.getInstance();

@@ -44,12 +44,12 @@ import java.util.Vector;
 * The format is expressed in a string as follows:
 * <DL>
 * <DD>m (or any multiple of m's)
- * <DT>the minutes part (padded with 0's, if number has less digits than 
+ * <DT>the minutes part (padded with 0's, if number has less digits than
 *     the number of m's)
 *     m -&gt; 0,1,...,59,60,61,...
 *     mm -&gt; 00,01,...,59,60,61,...
 * <DD>s or ss
- * <DT>the seconds part (padded with 0's, if number has less digits than 
+ * <DT>the seconds part (padded with 0's, if number has less digits than
 *     the number of s's)
 *     s -&gt; 0,1,...,59
 *     ss -&gt; 00,01,...,59
@@ -62,7 +62,7 @@ import java.util.Vector;
 * <P>
 * Known bugs:
 * <P>
- * The last character in the formatString is not escaped, while it should be. 
+ * The last character in the formatString is not escaped, while it should be.
 * The first character after an escaped character is escaped while is shouldn't
 * be.
 * <P>
@@ -81,15 +81,15 @@ public class TimeFormat extends Format {
    final static String SECOND = "s";
    final static String TIME = "S";
    final static String ESCAPE = "\\";
-    
+
    /**
-     * The default time format 
+     * The default time format
     */

    private final static TimeFormat DEFAULT_FORMAT = new TimeFormat("m:ss");
    protected String formatString = null;
-    
-    /** 
+
+    /**
     * Main method for testing ONLY
     */

@@ -122,7 +122,7 @@ public class TimeFormat extends Format {
 	}
 	else
 	    time = new Time();
-	
+
 	System.out.println("Time is \"" +  out.format(time) +
 			   "\" according to format \"" + out.formatString + "\"");
    }
@@ -147,18 +147,18 @@ public class TimeFormat extends Format {
 	String previous = null;
 	String current = null;
 	int previousCount = 0;
-	
+
 	while (tok.hasMoreElements()) {
 	    current = tok.nextToken();

 	    if (previous != null && previous.equals(ESCAPE)) {
 		// Handle escaping of s, S or m
-		current = ((current != null) ? current : "") 
+		current = ((current != null) ? current : "")
 		    + (tok.hasMoreElements() ? tok.nextToken() : "");
 		previous = null;
 		previousCount = 0;
 	    }
-	    
+
 	    // Skip over first,
 	    // or if current is the same, increase count, and try again
 	    if (previous == null || previous.equals(current)) {
@@ -173,12 +173,12 @@ public class TimeFormat extends Format {
 		    formatter.add(new SecondsFormatter(previousCount));
 		else if (previous.equals(TIME))
 		    formatter.add(new SecondsFormatter(-1));
-		else 
+		else
 		    formatter.add(new TextFormatter(previous));

 		previousCount = 1;
 		previous = current;
-		
+
 	    }
 	}

@@ -197,7 +197,7 @@ public class TimeFormat extends Format {
 	// Debug
 	/*
 	for (int i = 0; i < formatter.size(); i++) {
-	    System.out.println("Formatter " + formatter.get(i).getClass() 
+	    System.out.println("Formatter " + formatter.get(i).getClass()
 			       + ": length=" + ((TimeFormatter) formatter.get(i)).digits);
 	}
 	*/
@@ -206,7 +206,7 @@ public class TimeFormat extends Format {

    }

-    /** 
+    /**
     * DUMMY IMPLEMENTATION!!
     * Not locale specific.
     */
@@ -259,9 +259,9 @@ public class TimeFormat extends Format {
    /** DUMMY IMPLEMENTATION!! */
    public Object parseObject(String pStr, ParsePosition pStatus) {
 	Time t = parse(pStr);
-	
+
 	pStatus.setIndex(pStr.length()); // Not 100%
-	
+
 	return t;
    }

@@ -270,7 +270,7 @@ public class TimeFormat extends Format {
     * <p>
     * Will bug on some formats. It's safest to always use delimiters between
     * the minutes (m) and seconds (s) part.
-     * 
+     *
     */
    public Time parse(String pStr) {
 	Time time = new Time();
@@ -286,7 +286,7 @@ public class TimeFormat extends Format {
 		 && (pos + skip < pStr.length()) ; i++) {
 	    // Go to next offset
 	    pos += skip;
-	    
+
 	    if (formatter[i] instanceof MinutesFormatter) {
 		// Parse MINUTES
 		if ((i + 1) < formatter.length
@@ -327,9 +327,9 @@ public class TimeFormat extends Format {
 		    else {
 			// Cannot possibly know how long?
 			skip = 0;
-			continue;					    
+			continue;
 		    }
-		    
+
 		    // Get seconds
 		    sec = Integer.parseInt(pStr.substring(pos, skip));
 		    //		    System.out.println("Only seconds: " + sec);
@@ -343,7 +343,7 @@ public class TimeFormat extends Format {
 			&& formatter[i + 1] instanceof TextFormatter) {
 			// Skip until next format element
 			skip = pStr.indexOf(((TextFormatter) formatter[i + 1]).text, pos);
-			
+
 		    }
 		    else if ((i + 1) >= formatter.length) {
 			// Skip until end of string
@@ -359,7 +359,7 @@ public class TimeFormat extends Format {
 	    else if (formatter[i] instanceof TextFormatter) {
 		skip = formatter[i].digits;
 	    }
-	    
+
 	}

 	// Set the minutes part if we should
@@ -390,7 +390,7 @@ class SecondsFormatter extends TimeFormatter {
    SecondsFormatter(int pDigits) {
 	digits = pDigits;
    }
-    
+
    String format(Time t) {
 	// Negative number of digits, means all seconds, no padding
 	if (digits < 0) {
@@ -404,7 +404,7 @@ class SecondsFormatter extends TimeFormatter {

        // Else return it with leading 0's
 	//return StringUtil.formatNumber(t.getSeconds(), digits);
-        return StringUtil.pad("" + t.getSeconds(), digits, "0", true);
+        return StringUtil.pad(String.valueOf(t.getSeconds()), digits, "0", true);
    }
 }

@@ -425,7 +425,7 @@ class MinutesFormatter extends TimeFormatter {

        // Else return it with leading 0's
 	//return StringUtil.formatNumber(t.getMinutes(), digits);
-        return StringUtil.pad("" + t.getMinutes(), digits, "0", true);
+        return StringUtil.pad(String.valueOf(t.getMinutes()), digits, "0", true);
    }
 }

@@ -34,7 +34,7 @@ import java.io.Serializable;
 import java.util.*;

 /**
- * A {@code Map} implementation that removes (exipres) its elements after
+ * A {@code Map} implementation that removes (expires) its elements after
 * a given period. The map is by default backed by a {@link java.util.HashMap},
 * or can be instantiated with any given {@code Map} as backing.
 * <p>
@@ -67,7 +67,7 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi
    protected long expiryTime = 60000L;  // 1 minute

    //////////////////////
-    private volatile long nextExpiryTime;
+    private volatile long nextExpiryTime = Long.MAX_VALUE;
    //////////////////////

    /**
@@ -178,7 +178,7 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi
     * @return {@code true} if this map contains no key-value mappings.
     */
    public boolean isEmpty() {
-        return (size() <= 0);
+        return size() <= 0;
    }

    /**
@@ -208,7 +208,7 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi
     * @see #containsKey(java.lang.Object)
     */
    public V get(Object pKey) {
-        TimedEntry<K, V> entry = (TimedEntry<K, V>) entries.get(pKey);
+        TimedEntry entry = (TimedEntry) entries.get(pKey);

        if (entry == null) {
            return null;
@@ -236,7 +236,7 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi
     *         {@code null} values.
     */
    public V put(K pKey, V pValue) {
-        TimedEntry<K, V> entry = (TimedEntry<K, V>) entries.get(pKey);
+        TimedEntry entry = (TimedEntry) entries.get(pKey);
        V oldValue;

        if (entry == null) {
@@ -272,7 +272,7 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi
     *         {@code null} values.
     */
    public V remove(Object pKey) {
-        TimedEntry<K, V> entry = (TimedEntry<K, V>) entries.remove(pKey);
+        TimedEntry entry = (TimedEntry) entries.remove(pKey);
        return (entry != null) ? entry.getValue() : null;
    }

@@ -284,13 +284,12 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi
        init();
    }

-    /*protected*/ TimedEntry<K, V> createEntry(K pKey, V pValue) {
-        return new TimedEntry<K, V>(pKey, pValue);
+    /*protected*/ TimedEntry createEntry(K pKey, V pValue) {
+        return new TimedEntry(pKey, pValue);
    }

    /**
     * Removes any expired mappings.
-     *
     */
    protected void removeExpiredEntries() {
        // Remove any expired elements
@@ -312,7 +311,7 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi
            long next = Long.MAX_VALUE;
            nextExpiryTime = next; // Avoid multiple runs...
            for (Iterator<Entry<K, V>> iterator = new EntryIterator(); iterator.hasNext();) {
-                TimedEntry<K, V> entry = (TimedEntry<K, V>) iterator.next();
+                TimedEntry entry = (TimedEntry) iterator.next();
                ////
                long expires = entry.expires();
                if (expires < next) {
@@ -376,7 +375,7 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi

            while (mNext == null && mIterator.hasNext()) {
                Entry<K, Entry<K, V>> entry = mIterator.next();
-                TimedEntry<K, V> timed = (TimedEntry<K, V>) entry.getValue();
+                TimedEntry timed = (TimedEntry) entry.getValue();

                if (timed.isExpiredBy(mNow)) {
                    // Remove from map, and continue
@@ -425,19 +424,28 @@ public class TimeoutMap<K, V> extends AbstractDecoratedMap<K, V> implements Expi
    /**
     * Keeps track of timed objects
     */
-    private class TimedEntry<K, V> extends BasicEntry<K, V> {
+    private class TimedEntry extends BasicEntry<K, V> {
        private long mTimestamp;

        TimedEntry(K pKey, V pValue) {
            super(pKey, pValue);
-            mTimestamp = System.currentTimeMillis();
+            updateTimestamp();
        }

        public V setValue(V pValue) {
-            mTimestamp = System.currentTimeMillis();
+            updateTimestamp();
            return super.setValue(pValue);
        }

+        private void updateTimestamp() {
+            mTimestamp = System.currentTimeMillis();
+
+            long expires = expires();
+            if (expires < nextExpiryTime) {
+                nextExpiryTime = expires;
+            }
+        }
+
        final boolean isExpired() {
            return isExpiredBy(System.currentTimeMillis());
        }
@@ -111,6 +111,7 @@ import java.io.PrintStream;
 * @author <a href="mailto:eirik.torske@iconmedialab.no">Eirik Torske</a>
 * @deprecated Will probably be removed in the near future
 */
+@Deprecated
 public class WildcardStringParser {
    // TODO: Get rid of this class

@@ -30,7 +30,7 @@

 package com.twelvemonkeys.lang;

-import org.junit.Test;
+import static org.junit.Assert.*;

 import java.awt.*;
 import java.sql.Timestamp;
@@ -41,7 +41,7 @@ import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.Locale;

-import static org.junit.Assert.*;
+import org.junit.Test;

 /**
 * StringUtilTestCase
@@ -76,24 +76,24 @@ public class StringUtilTest {
        assertNull(StringUtil.valueOf(null));
    }

+    @SuppressWarnings("ConstantConditions")
    @Test
    public void testToUpperCase() {
        String str = StringUtil.toUpperCase(TEST_STRING);
        assertNotNull(str);
        assertEquals(TEST_STRING.toUpperCase(), str);

-        str = StringUtil.toUpperCase(null);
-        assertNull(str);
+        assertNull(StringUtil.toUpperCase(null));
    }

+    @SuppressWarnings("ConstantConditions")
    @Test
    public void testToLowerCase() {
        String str = StringUtil.toLowerCase(TEST_STRING);
        assertNotNull(str);
        assertEquals(TEST_STRING.toLowerCase(), str);

-        str = StringUtil.toLowerCase(null);
-        assertNull(str);
+        assertNull(StringUtil.toLowerCase(null));
    }

    @Test
@@ -113,6 +113,7 @@ public class StringUtilTest {
        assertFalse(StringUtil.isEmpty(new String[]{WHITESPACE_STRING, TEST_STRING}));
    }

+    @SuppressWarnings("ConstantConditions")
    @Test
    public void testContains() {
        assertTrue(StringUtil.contains(TEST_STRING, TEST_STRING));
@@ -145,6 +146,7 @@ public class StringUtilTest {
        assertFalse(StringUtil.containsIgnoreCase(null, null));
    }

+    @SuppressWarnings("ConstantConditions")
    @Test
    public void testContainsChar() {
        for (int i = 0; i < TEST_STRING.length(); i++) {
@@ -466,7 +468,7 @@ public class StringUtilTest {
        assertEquals(TEST_STRING, StringUtil.ltrim(TEST_STRING));
        assertEquals(TEST_STRING, StringUtil.ltrim("  " + TEST_STRING));
        assertEquals(TEST_STRING, StringUtil.ltrim(WHITESPACE_STRING + TEST_STRING));
-        assertFalse(TEST_STRING.equals(StringUtil.ltrim(TEST_STRING + WHITESPACE_STRING)));
+        assertNotEquals(TEST_STRING, StringUtil.ltrim(TEST_STRING + WHITESPACE_STRING));
        // TODO: Test is not complete
    }

@@ -475,7 +477,7 @@ public class StringUtilTest {
        assertEquals(TEST_STRING, StringUtil.rtrim(TEST_STRING));
        assertEquals(TEST_STRING, StringUtil.rtrim(TEST_STRING + "  "));
        assertEquals(TEST_STRING, StringUtil.rtrim(TEST_STRING + WHITESPACE_STRING));
-        assertFalse(TEST_STRING.equals(StringUtil.rtrim(WHITESPACE_STRING + TEST_STRING)));
+        assertNotEquals(TEST_STRING, StringUtil.rtrim(WHITESPACE_STRING + TEST_STRING));
        // TODO: Test is not complete
    }

@@ -516,7 +518,7 @@ public class StringUtilTest {
    public void testCaptialize() {
        assertNull(StringUtil.capitalize(null));
        assertEquals(TEST_STRING.toUpperCase(), StringUtil.capitalize(TEST_STRING.toUpperCase()));
-        assertTrue(StringUtil.capitalize("abc").charAt(0) == 'A');
+        assertEquals('A', StringUtil.capitalize("abc").charAt(0));
    }

    @Test
@@ -552,13 +554,13 @@ public class StringUtilTest {
    public void testToDateWithFormatString() {
        Calendar cal = new GregorianCalendar();
        cal.clear();
-        cal.set(1976, 2, 16); // Month is 0-based
+        cal.set(1976, Calendar.MARCH, 16); // Month is 0-based
        Date date = StringUtil.toDate("16.03.1976", "dd.MM.yyyy");
        assertNotNull(date);
        assertEquals(cal.getTime(), date);

        cal.clear();
-        cal.set(2004, 4, 13, 23, 51, 3);
+        cal.set(2004, Calendar.MAY, 13, 23, 51, 3);
        date = StringUtil.toDate("2004-5-13 23:51 (03)", "yyyy-MM-dd hh:mm (ss)");
        assertNotNull(date);
        assertEquals(cal.getTime(), date);
@@ -576,15 +578,15 @@ public class StringUtilTest {
    public void testToDateWithFormat() {
        Calendar cal = new GregorianCalendar();
        cal.clear();
-        cal.set(1976, 2, 16); // Month is 0-based
+        cal.set(1976, Calendar.MARCH, 16); // Month is 0-based
        Date date = StringUtil.toDate("16.03.1976", new SimpleDateFormat("dd.MM.yyyy"));
        assertNotNull(date);
        assertEquals(cal.getTime(), date);

        cal.clear();
-        cal.set(2004, 4, 13, 23, 51);
-        date = StringUtil.toDate("13.5.04 23:51",
-                                 DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, new Locale("no", "NO")));
+        cal.set(2004, Calendar.MAY, 13, 23, 51);
+        DateFormat format = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, new Locale("no", "NO"));
+        date = StringUtil.toDate(format.format(cal.getTime()), format);
        assertNotNull(date);
        assertEquals(cal.getTime(), date);

@@ -601,10 +603,9 @@ public class StringUtilTest {
    public void testToTimestamp() {
        Calendar cal = new GregorianCalendar();
        cal.clear();
-        cal.set(1976, 2, 16, 21, 28, 4); // Month is 0-based
-        Date date = StringUtil.toTimestamp("1976-03-16 21:28:04");
+        cal.set(1976, Calendar.MARCH, 16, 21, 28, 4); // Month is 0-based
+        Timestamp date = StringUtil.toTimestamp("1976-03-16 21:28:04");
        assertNotNull(date);
-        assertTrue(date instanceof Timestamp);
        assertEquals(cal.getTime(), date);
    }

@@ -821,7 +822,7 @@ public class StringUtilTest {
        assertTrue(StringUtil.isNumber("12345"));
        assertTrue(StringUtil.isNumber(TEST_INTEGER.toString()));
        assertTrue(StringUtil.isNumber("1234567890123456789012345678901234567890"));
-        assertTrue(StringUtil.isNumber(String.valueOf(Long.MAX_VALUE) + String.valueOf(Long.MAX_VALUE)));
+        assertTrue(StringUtil.isNumber(String.valueOf(Long.MAX_VALUE) + Long.MAX_VALUE));
        assertFalse(StringUtil.isNumber("abc"));
        assertFalse(StringUtil.isNumber(TEST_STRING));
    }
@@ -831,7 +832,7 @@ public class StringUtilTest {
        assertTrue(StringUtil.isNumber("-12345"));
        assertTrue(StringUtil.isNumber('-' + TEST_INTEGER.toString()));
        assertTrue(StringUtil.isNumber("-1234567890123456789012345678901234567890"));
-        assertTrue(StringUtil.isNumber('-' + String.valueOf(Long.MAX_VALUE) + String.valueOf(Long.MAX_VALUE)));
+        assertTrue(StringUtil.isNumber('-' + String.valueOf(Long.MAX_VALUE) + Long.MAX_VALUE));
        assertFalse(StringUtil.isNumber("-abc"));
        assertFalse(StringUtil.isNumber('-' + TEST_STRING));
    }
@@ -1117,18 +1117,19 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
    /**
     *  Tests {@link Collection#toArray(Object[])}.
     */
+    @SuppressWarnings({"SuspiciousToArrayCall", "RedundantCast"})
    @Test
    public void testCollectionToArray2() {
        resetEmpty();
        Object[] a = new Object[] { new Object(), null, null };
        Object[] array = collection.toArray(a);
        assertArrayEquals("Given array shouldn't shrink", array, a);
-        assertEquals("Last element should be set to null", a[0], null);
+        assertNull("Last element should be set to null", a[0]);
        verifyAll();

        resetFull();
        try {
-            array = collection.toArray(new Void[0]);
+            collection.toArray(new Void[0]);
            fail("toArray(new Void[0]) should raise ArrayStore");
        } catch (ArrayStoreException e) {
            // expected
@@ -1136,7 +1137,7 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        verifyAll();

        try {
-            array = collection.toArray(null);
+            collection.toArray((Object[]) null);
            fail("toArray(null) should raise NPE");
        } catch (NullPointerException e) {
            // expected
@@ -1150,13 +1151,13 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {

        // Figure out if they're all the same class
        // TODO: It'd be nicer to detect a common superclass
-        HashSet classes = new HashSet();
+        HashSet<Class<?>> classes = new HashSet<>();
        for (int i = 0; i < array.length; i++) {
            classes.add((array[i] == null) ? null : array[i].getClass());
        }
        if (classes.size() > 1) return;

-        Class cl = (Class)classes.iterator().next();
+        Class<?> cl = (Class<?>)classes.iterator().next();
        if (Map.Entry.class.isAssignableFrom(cl)) {  // check needed for protective cases like Predicated/Unmod map entrySet
            cl = Map.Entry.class;
        }
@@ -250,12 +250,12 @@ public class CollectionUtilTest {
        assertCorrectListIterator(new ArrayList<String>(Arrays.asList(new String[] {"foo", "bar", "baz", "boo"})).subList(1, 3).listIterator(0), new String[] {"bar", "baz"}, true, true);
    }

-    private void assertCorrectListIterator(ListIterator<String> iterator, final Object[] elements) {
+    private static void assertCorrectListIterator(ListIterator<String> iterator, final Object[] elements) {
        assertCorrectListIterator(iterator, elements, false, false);
    }

    // NOTE: The test is can only test list iterators with a starting index == 0
-    private void assertCorrectListIterator(ListIterator<String> iterator, final Object[] elements, boolean skipRemove, boolean skipAdd) {
+    private static void assertCorrectListIterator(ListIterator<String> iterator, final Object[] elements, boolean skipRemove, boolean skipAdd) {
        // Index is now "before 0"
        assertEquals(-1, iterator.previousIndex());
        assertEquals(0, iterator.nextIndex());
@@ -557,7 +557,7 @@ public class TimeoutMapTest extends MapAbstractTest {
                // NOTE: Only wait fist time, to avoid slooow tests
                synchronized (this) {
                    try {
-                        wait(60l);
+                        wait(60L);
                    }
                    catch (InterruptedException e) {
                    }
@@ -591,7 +591,7 @@ public class TimeoutMapTest extends MapAbstractTest {
                    try {
                        wait(60l);
                    }
-                    catch (InterruptedException e) {
+                    catch (InterruptedException ignore) {
                    }
                }
            }
@@ -651,5 +651,24 @@ public class TimeoutMapTest extends MapAbstractTest {
        assertTrue("Wrong entry removed, keySet().iterator() is broken.", !map.containsKey(removedKey));
        assertTrue("Wrong entry removed, keySet().iterator() is broken.", map.containsKey(otherKey));
    }
+
+
+    @Test
+    public void testContainsKeyOnEmptyMap() {
+        // See #600
+        Map<String, String> timeoutMap = new TimeoutMap<>(30);
+        assertFalse(timeoutMap.containsKey("xyz"));
+        timeoutMap.put("xyz", "xyz");
+        assertTrue(timeoutMap.containsKey("xyz"));
+
+        try {
+            Thread.sleep(50); // Let the item expire
+        }
+        catch (InterruptedException ignore) {
+        }
+
+        assertFalse(timeoutMap.containsKey("xyz"));
+        assertNull(timeoutMap.get("xyz"));
+    }
 }

@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <groupId>com.twelvemonkeys.common</groupId>
    <artifactId>common</artifactId>
@@ -47,7 +47,7 @@
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
-            <version>4.7</version>
+            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <groupId>com.twelvemonkeys.contrib</groupId>
    <artifactId>contrib</artifactId>
@@ -65,7 +65,7 @@
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
-            <version>4.7</version>
+            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
@@ -0,0 +1,178 @@
+package com.twelvemonkeys.contrib.exif;
+
+import com.twelvemonkeys.image.ImageUtil;
+import com.twelvemonkeys.imageio.ImageReaderBase;
+
+import org.w3c.dom.NodeList;
+
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataFormatImpl;
+import javax.imageio.metadata.IIOMetadataNode;
+import javax.imageio.stream.ImageInputStream;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Iterator;
+
+import static com.twelvemonkeys.contrib.tiff.TIFFUtilities.applyOrientation;
+
+/**
+ * EXIFUtilities.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @version : EXIFUtilities.java,v 1.0 23/06/2020
+ */
+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, or
+     * {@code null}.
+     * @throws IOException if an error occurs during reading.
+     */
+    public static IIOImage readWithOrientation(final URL input) throws IOException {
+        try (ImageInputStream stream = ImageIO.createImageInputStream(input)) {
+            return readWithOrientation(stream);
+        }
+    }
+
+    /**
+     * 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, or
+     * {@code null}.
+     * @throws IOException if an error occurs during reading.
+     */
+    public static IIOImage readWithOrientation(final InputStream input) throws IOException {
+        try (ImageInputStream stream = ImageIO.createImageInputStream(input)) {
+            return readWithOrientation(stream);
+        }
+    }
+
+    /**
+     * 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 or
+     * {@code null}.
+     * @throws IOException if an error occurs during reading.
+     */
+    public static IIOImage readWithOrientation(final File input) throws IOException {
+        try (ImageInputStream stream = ImageIO.createImageInputStream(input)) {
+            return readWithOrientation(stream);
+        }
+    }
+
+    /**
+     * 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, or
+     * {@code null}.
+     * @throws IOException if an error occurs during reading.
+     */
+    public static IIOImage readWithOrientation(final ImageInputStream input) throws IOException {
+        Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
+        if (!readers.hasNext()) {
+            return null;
+        }
+
+        ImageReader reader = readers.next();
+        try {
+            reader.setInput(input, true, false);
+
+            IIOMetadata metadata = reader.getImageMetadata(0);
+            BufferedImage bufferedImage = applyOrientation(reader.read(0), findImageOrientation(metadata).value());
+
+            return new IIOImage(bufferedImage, null, metadata);
+        }
+        finally {
+            reader.dispose();
+        }
+    }
+
+    /**
+     * Finds the {@code ImageOrientation} tag, if any, and returns an {@link Orientation} based on its
+     * {@code value} attribute.
+     * If no match is found or the tag is not present, {@code Normal} (the default orientation) is returned.
+     *
+     * @param metadata an {@code IIOMetadata} object
+     * @return the {@code Orientation} matching the {@code value} attribute of the {@code ImageOrientation} tag,
+     * or {@code Normal}, never {@code null}.
+     * @see Orientation
+     * @see <a href="https://docs.oracle.com/javase/7/docs/api/javax/imageio/metadata/doc-files/standard_metadata.html">Standard (Plug-in Neutral) Metadata Format Specification</a>
+     */
+    public static Orientation findImageOrientation(final IIOMetadata metadata) {
+        if (metadata != null) {
+            IIOMetadataNode root = (IIOMetadataNode) metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);
+            NodeList imageOrientations = root.getElementsByTagName("ImageOrientation");
+
+            if (imageOrientations != null && imageOrientations.getLength() > 0) {
+                IIOMetadataNode imageOrientation = (IIOMetadataNode) imageOrientations.item(0);
+                return Orientation.fromMetadataOrientation(imageOrientation.getAttribute("value"));
+            }
+        }
+
+        return Orientation.Normal;
+    }
+
+    public static void main(String[] args) throws IOException {
+        for (String arg : args) {
+            File input = new File(arg);
+
+            // Read everything but thumbnails (similar to ImageReader.readAll(0, null)),
+            // and applies the correct image orientation
+            IIOImage image = readWithOrientation(input);
+
+            if (image == null) {
+                System.err.printf("No reader for %s%n", input);
+                continue;
+            }
+
+            // Finds the orientation as defined by the javax_imageio_1.0 format
+            Orientation orientation = findImageOrientation(image.getMetadata());
+
+            // Retrieve the image as a BufferedImage. The image is already rotated by the readWithOrientation method
+            // In this case it will already be a BufferedImage, so using a cast will also do
+            // (i.e.: BufferedImage bufferedImage = (BufferedImage) image.getRenderedImage())
+            BufferedImage bufferedImage = ImageUtil.toBuffered(image.getRenderedImage());
+
+            // Demo purpose only, show image with orientation details in title
+            DisplayHelper.showIt(bufferedImage, input.getName() + ": " + orientation.name() + "/" + orientation.value());
+        }
+    }
+
+    // Don't do this... :-) Provided for convenience/demo only!
+    static abstract class DisplayHelper extends ImageReaderBase {
+        private DisplayHelper() {
+            super(null);
+        }
+
+        protected static void showIt(BufferedImage image, String title) {
+            ImageReaderBase.showIt(image, title);
+        }
+    }
+}
@@ -0,0 +1,63 @@
+package com.twelvemonkeys.contrib.exif;
+
+import com.twelvemonkeys.contrib.tiff.TIFFUtilities;
+
+/**
+ * Orientation.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @version : Orientation.java,v 1.0 10/07/2020 harald.kuhr
+ */
+public enum Orientation {
+    Normal(TIFFUtilities.TIFFBaseline.ORIENTATION_TOPLEFT),
+    FlipH(TIFFUtilities.TIFFExtension.ORIENTATION_TOPRIGHT),
+    Rotate180(TIFFUtilities.TIFFExtension.ORIENTATION_BOTRIGHT),
+    FlipV(TIFFUtilities.TIFFExtension.ORIENTATION_BOTLEFT),
+    FlipVRotate90(TIFFUtilities.TIFFExtension.ORIENTATION_LEFTTOP),
+    Rotate270(TIFFUtilities.TIFFExtension.ORIENTATION_RIGHTTOP),
+    FlipHRotate90(TIFFUtilities.TIFFExtension.ORIENTATION_RIGHTBOT),
+    Rotate90(TIFFUtilities.TIFFExtension.ORIENTATION_LEFTBOT);
+
+                             // name as defined in javax.imageio metadata
+    private final int value; // value as defined in TIFF spec
+
+    Orientation(int value) {
+        this.value = value;
+    }
+
+    public int value() {
+        return value;
+    }
+
+    public static Orientation fromMetadataOrientation(final String orientationName) {
+        if (orientationName != null) {
+            try {
+                return valueOf(orientationName);
+            }
+            catch (IllegalArgumentException e) {
+                // Not found, try ignore case match, as some metadata implementations are known to return "normal" etc.
+                String lowerCaseName = orientationName.toLowerCase();
+
+                for (Orientation orientation : values()) {
+                    if (orientation.name().toLowerCase().equals(lowerCaseName)) {
+                        return orientation;
+                    }
+                }
+            }
+        }
+
+        // Metadata does not have other orientations, default to Normal
+        return Normal;
+    }
+
+    public static Orientation fromTIFFOrientation(final int tiffOrientation) {
+        for (Orientation orientation : values()) {
+            if (orientation.value() == tiffOrientation) {
+                return orientation;
+            }
+        }
+
+        // No other TIFF orientations possible, default to Normal
+        return Normal;
+    }
+}
@@ -200,11 +200,10 @@ public final class TIFFUtilities {
    }

    public static List<TIFFPage> getPages(ImageInputStream imageInput) throws IOException {
-        ArrayList<TIFFPage> pages = new ArrayList<TIFFPage>();
-
        CompoundDirectory IFDs = (CompoundDirectory) new TIFFReader().read(imageInput);

-        int pageCount = IFDs.directoryCount();
+        final int pageCount = IFDs.directoryCount();
+        List<TIFFPage> pages = new ArrayList<>(pageCount);
        for (int pageIndex = 0; pageIndex < pageCount; pageIndex++) {
            pages.add(new TIFFPage(IFDs.getDirectory(pageIndex), imageInput));
        }
@@ -0,0 +1,75 @@
+package com.twelvemonkeys.contrib.exif;
+
+import org.junit.Test;
+
+import static com.twelvemonkeys.contrib.exif.Orientation.*;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * OrientationTest.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by : harald.kuhr$
+ * @version : OrientationTest.java,v 1.0 10/07/2020 harald.kuhr Exp$
+ */
+public class OrientationTest {
+    @Test
+    public void testFromMetadataOrientationNull() {
+        assertEquals(Normal, Orientation.fromMetadataOrientation(null));
+    }
+
+    @Test
+    public void testFromMetadataOrientation() {
+        assertEquals(Normal, Orientation.fromMetadataOrientation("Normal"));
+        assertEquals(Rotate90, Orientation.fromMetadataOrientation("Rotate90"));
+        assertEquals(Rotate180, Orientation.fromMetadataOrientation("Rotate180"));
+        assertEquals(Rotate270, Orientation.fromMetadataOrientation("Rotate270"));
+        assertEquals(FlipH, Orientation.fromMetadataOrientation("FlipH"));
+        assertEquals(FlipV, Orientation.fromMetadataOrientation("FlipV"));
+        assertEquals(FlipHRotate90, Orientation.fromMetadataOrientation("FlipHRotate90"));
+        assertEquals(FlipVRotate90, Orientation.fromMetadataOrientation("FlipVRotate90"));
+    }
+
+    @Test
+    public void testFromMetadataOrientationIgnoreCase() {
+        assertEquals(Normal, Orientation.fromMetadataOrientation("normal"));
+        assertEquals(Rotate90, Orientation.fromMetadataOrientation("rotate90"));
+        assertEquals(Rotate180, Orientation.fromMetadataOrientation("ROTATE180"));
+        assertEquals(Rotate270, Orientation.fromMetadataOrientation("ROTATE270"));
+        assertEquals(FlipH, Orientation.fromMetadataOrientation("FLIPH"));
+        assertEquals(FlipV, Orientation.fromMetadataOrientation("flipv"));
+        assertEquals(FlipHRotate90, Orientation.fromMetadataOrientation("FLIPhrotate90"));
+        assertEquals(FlipVRotate90, Orientation.fromMetadataOrientation("fLiPVRotAte90"));
+    }
+
+    @Test
+    public void testFromMetadataOrientationUnknown() {
+        assertEquals(Normal, Orientation.fromMetadataOrientation("foo"));
+        assertEquals(Normal, Orientation.fromMetadataOrientation("90"));
+        assertEquals(Normal, Orientation.fromMetadataOrientation("randomStringWithNumbers180"));
+    }
+
+    @Test
+    public void testFromTIFFOrientation() {
+        assertEquals(Normal, Orientation.fromTIFFOrientation(1));
+        assertEquals(FlipH, Orientation.fromTIFFOrientation(2));
+        assertEquals(Rotate180, Orientation.fromTIFFOrientation(3));
+        assertEquals(FlipV, Orientation.fromTIFFOrientation(4));
+        assertEquals(FlipVRotate90, Orientation.fromTIFFOrientation(5));
+        assertEquals(Rotate270, Orientation.fromTIFFOrientation(6));
+        assertEquals(FlipHRotate90, Orientation.fromTIFFOrientation(7));
+        assertEquals(Rotate90, Orientation.fromTIFFOrientation(8));
+    }
+
+    @Test
+    public void testFromTIFFOrientationUnknown() {
+        assertEquals(Normal, Orientation.fromTIFFOrientation(-1));
+        assertEquals(Normal, Orientation.fromTIFFOrientation(0));
+        assertEquals(Normal, Orientation.fromTIFFOrientation(9));
+        for (int i = 10; i < 1024; i++) {
+            assertEquals(Normal, Orientation.fromTIFFOrientation(i));
+        }
+        assertEquals(Normal, Orientation.fromTIFFOrientation(Integer.MAX_VALUE));
+        assertEquals(Normal, Orientation.fromTIFFOrientation(Integer.MIN_VALUE));
+    }
+}
@@ -31,8 +31,9 @@
 package com.twelvemonkeys.contrib.tiff;

 import com.twelvemonkeys.contrib.tiff.TIFFUtilities.TIFFExtension;
-import com.twelvemonkeys.imageio.plugins.tiff.TIFFMedataFormat;
+import com.twelvemonkeys.imageio.plugins.tiff.TIFFImageMetadataFormat;
 import com.twelvemonkeys.io.FileUtil;
+
 import org.junit.Assert;
 import org.junit.Test;
 import org.w3c.dom.Node;
@@ -154,7 +155,7 @@ public class TIFFUtilitiesTest {
        reader.setInput(checkTest1);
        for (int i = 0; i < 3; i++) {
            Node metaData = reader.getImageMetadata(i)
-                    .getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
+                    .getAsTree(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
            short orientation = ((Number) expression.evaluate(metaData, XPathConstants.NUMBER)).shortValue();
            Assert.assertEquals(orientation, TIFFExtension.ORIENTATION_RIGHTTOP);
        }
@@ -171,7 +172,7 @@ public class TIFFUtilitiesTest {
        reader.setInput(checkTest2);
        for (int i = 0; i < 3; i++) {
            Node metaData = reader.getImageMetadata(i)
-                    .getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
+                    .getAsTree(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
            short orientation = ((Number) expression.evaluate(metaData, XPathConstants.NUMBER)).shortValue();
            Assert.assertEquals(orientation, i == 1
                                             ? TIFFExtension.ORIENTATION_BOTRIGHT
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-batik</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Batik Plugin</name>
@@ -15,6 +15,27 @@
        for more information.]]>
    </description>

+    <properties>
+        <project.jpms.module.name>com.twelvemonkeys.imageio.batik</project.jpms.module.name>
+        <batik.version>1.14</batik.version>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <systemPropertyVariables>
+                        <com.twelvemonkeys.imageio.plugins.svg.allowExternalResources>
+                            true
+                        </com.twelvemonkeys.imageio.plugins.svg.allowExternalResources>
+                    </systemPropertyVariables>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
    <dependencies>
        <dependency>
            <groupId>com.twelvemonkeys.imageio</groupId>
@@ -24,6 +45,14 @@
            <groupId>com.twelvemonkeys.imageio</groupId>
            <artifactId>imageio-core</artifactId>
            <type>test-jar</type>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.11.0</version>
+            <scope>provided</scope>
        </dependency>

        <dependency>
@@ -46,13 +75,6 @@
            <scope>provided</scope>
        </dependency>

-        <dependency>
-            <groupId>org.apache.xmlgraphics</groupId>
-            <artifactId>xmlgraphics-commons</artifactId>
-            <version>2.2</version>
-            <scope>provided</scope>
-        </dependency>
-
        <dependency>
            <groupId>org.apache.xmlgraphics</groupId>
            <artifactId>batik-anim</artifactId>
@@ -76,7 +98,7 @@
            <!--
            There seems to be some weirdness in the
            Batik/FOP poms (Batik depends on FOP 0.20-5) that screws things up,
-            making everything end up depending on Batik 1.5, not 1.6
+            making everything end up depending on Batik 1.5, not the specified version
            -->
            <exclusions>
                <exclusion>
@@ -86,8 +108,4 @@
            </exclusions>
        </dependency>
    </dependencies>
-
-    <properties>
-        <batik.version>1.9</batik.version>
-    </properties>
 </project>
@@ -33,6 +33,8 @@ package com.twelvemonkeys.imageio.plugins.svg;
 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;
 import org.apache.batik.bridge.*;
@@ -43,7 +45,11 @@ import org.apache.batik.gvt.GraphicsNode;
 import org.apache.batik.gvt.renderer.ConcreteImageRendererFactory;
 import org.apache.batik.gvt.renderer.ImageRenderer;
 import org.apache.batik.gvt.renderer.ImageRendererFactory;
-import org.apache.batik.transcoder.*;
+import org.apache.batik.transcoder.SVGAbstractTranscoder;
+import org.apache.batik.transcoder.TranscoderException;
+import org.apache.batik.transcoder.TranscoderInput;
+import org.apache.batik.transcoder.TranscoderOutput;
+import org.apache.batik.transcoder.TranscodingHints;
 import org.apache.batik.transcoder.image.ImageTranscoder;
 import org.apache.batik.util.ParsedURL;
 import org.apache.batik.util.SVGConstants;
@@ -56,10 +62,8 @@ import javax.imageio.ImageReadParam;
 import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.spi.ImageReaderSpi;
 import java.awt.*;
-import java.awt.geom.AffineTransform;
-import java.awt.geom.Dimension2D;
-import java.awt.geom.Rectangle2D;
-import java.awt.image.BufferedImage;
+import java.awt.geom.*;
+import java.awt.image.*;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -73,10 +77,16 @@ import java.util.Map;
 * @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",
+                    System.getProperty("com.twelvemonkeys.imageio.plugins.svg.allowexternalresources")));
+
    private Rasterizer rasterizer;
+    private boolean allowExternalResources = DEFAULT_ALLOW_EXTERNAL_RESOURCES;

    /**
     * Creates an {@code SVGImageReader}.
@@ -113,6 +123,9 @@ public class SVGImageReader extends ImageReaderBase {
        if (pParam instanceof SVGReadParam) {
            SVGReadParam svgParam = (SVGReadParam) pParam;

+            // set the external-resource-resolution preference
+            allowExternalResources = svgParam.isAllowExternalResources();
+
            // Get the base URI
            // This must be done before converting the params to hints
            String baseURI = svgParam.getBaseURI();
@@ -121,6 +134,7 @@ public class SVGImageReader extends ImageReaderBase {
            // Set ImageReadParams as hints
            // Note: The cast to Map invokes a different method that preserves
            // unset defaults, DO NOT REMOVE!
+            //noinspection rawtypes
            rasterizer.setTranscodingHints((Map) paramsToHints(svgParam));
        }

@@ -135,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) {
@@ -172,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) {
@@ -196,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));
@@ -205,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
@@ -220,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;
    }
@@ -231,25 +239,16 @@ 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) throws IOException {
+    public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) {
        return Collections.singleton(ImageTypeSpecifier.createFromRenderedImage(rasterizer.createImage(1, 1))).iterator();
    }

@@ -260,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;
@@ -278,7 +276,7 @@ public class SVGImageReader extends ImageReaderBase {
        }

        //  This is cheating... We don't fully transcode after all
-        protected void transcode(Document document, final String uri, final TranscoderOutput output) throws TranscoderException {
+        protected void transcode(Document document, final String uri, final TranscoderOutput output) {
            // Sets up root, curTxf & curAoi
            // ----
            if (document != null) {
@@ -324,24 +322,66 @@ public class SVGImageReader extends ImageReaderBase {
            }

            // ----
-
-            // get the 'width' and 'height' attributes of the SVG document
-            Dimension2D docSize = ctx.getDocumentSize();
-            if (docSize != null) {
-                defaultWidth = (float) docSize.getWidth();
-                defaultHeight = (float) docSize.getHeight();
-            }
-            else {
-                defaultWidth = 200;
-                defaultHeight = 200;
-            }
            SVGSVGElement rootElement = svgDoc.getRootElement();
-            String viewBoxStr = rootElement.getAttributeNS
-                    (null, SVGConstants.SVG_VIEW_BOX_ATTRIBUTE);
+
+            // Get the viewBox
+            String viewBoxStr = rootElement.getAttributeNS(null, SVGConstants.SVG_VIEW_BOX_ATTRIBUTE);
            if (viewBoxStr.length() != 0) {
                float[] rect = ViewBox.parseViewBoxAttribute(rootElement, viewBoxStr, null);
-                defaultWidth = rect[2];
-                defaultHeight = rect[3];
+                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)) {
+                width = UnitProcessor.svgToUserSpace(widthStr, SVGConstants.SVG_WIDTH_ATTRIBUTE, UnitProcessor.HORIZONTAL_LENGTH, uctx);
+            }
+            if (!StringUtil.isEmpty(heightStr)) {
+                height = UnitProcessor.svgToUserSpace(heightStr, SVGConstants.SVG_HEIGHT_ATTRIBUTE, UnitProcessor.VERTICAL_LENGTH, uctx);
+            }
+
+            boolean hasWidth = width > 0.0;
+            boolean hasHeight = height > 0.0;
+
+            if (!hasWidth || !hasHeight) {
+                if (!viewBox.isEmpty()) {
+                    // If one dimension is given, calculate other by aspect ratio in viewBox
+                    if (hasWidth) {
+                        height = width * viewBox.getHeight() / viewBox.getWidth();
+                    }
+                    else if (hasHeight) {
+                        width = height * viewBox.getWidth() / viewBox.getHeight();
+                    }
+                    else {
+                        // ...or use viewBox if no dimension is given
+                        width = viewBox.getWidth();
+                        height = viewBox.getHeight();
+                    }
+                }
+                else {
+                    // No viewBox, just assume square size
+                    if (hasHeight) {
+                        width = height;
+                    }
+                    else if (hasWidth) {
+                        height = width;
+                    }
+                    else {
+                        // ...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
@@ -356,7 +396,7 @@ public class SVGImageReader extends ImageReaderBase {
            ctx = null;
        }

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

            if (abortRequested()) {
@@ -381,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;
@@ -399,7 +440,7 @@ public class SVGImageReader extends ImageReaderBase {


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

            if (abortRequested()) {
                processReadAborted();
@@ -413,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);
            }
@@ -474,7 +514,7 @@ public class SVGImageReader extends ImageReaderBase {
                }
            }
            catch (BridgeException ex) {
-                throw new TranscoderException(ex);
+                throw new IIOException(ex.getMessage(), ex);
            }

            this.root = gvtRoot;
@@ -543,9 +583,7 @@ public class SVGImageReader extends ImageReaderBase {
                return dest;
            }
            catch (Exception ex) {
-                TranscoderException exception = new TranscoderException(ex.getMessage());
-                exception.initCause(ex);
-                throw exception;
+                throw new IIOException(ex.getMessage(), ex);
            }
            finally {
                if (context != null) {
@@ -554,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");
@@ -562,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();
            }
@@ -574,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) {
@@ -608,6 +657,14 @@ public class SVGImageReader extends ImageReaderBase {
            public void displayMessage(String message) {
                processWarningOccurred(message.replaceAll("[\\r\\n]+", " "));
            }
+
+            @Override
+            public ExternalResourceSecurity getExternalResourceSecurity(ParsedURL resourceURL, ParsedURL docURL) {
+                if (allowExternalResources) {
+                    return super.getExternalResourceSecurity(resourceURL, docURL);
+                }
+                return new EmbededExternalResourceSecurity(resourceURL);
+            }
        }
    }
 }
@@ -41,6 +41,11 @@ import java.awt.*;
 public class SVGReadParam extends ImageReadParam {
    private Paint background;
    private String baseURI;
+    private boolean allowExternalResources = SVGImageReader.DEFAULT_ALLOW_EXTERNAL_RESOURCES;
+
+    public SVGReadParam() {
+        super();
+    }

    public Paint getBackgroundColor() {
        return background;
@@ -58,6 +63,14 @@ public class SVGReadParam extends ImageReadParam {
        baseURI = pBaseURI;
    }

+    public void setAllowExternalResources(boolean allow) {
+        allowExternalResources = allow;
+    }
+
+    public boolean isAllowExternalResources() {
+        return allowExternalResources;
+    }
+
    @Override
    public boolean canSetSourceRenderSize() {
        return true;
@@ -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);
+    }
+}
@@ -31,6 +31,7 @@
 package com.twelvemonkeys.imageio.plugins.svg;

 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
+
 import org.junit.Ignore;
 import org.junit.Test;

@@ -42,21 +43,19 @@ 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.io.File;
+import java.awt.image.*;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URISyntaxException;
 import java.net.URL;
-import java.nio.Buffer;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

-import static org.junit.Assert.*;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
+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.*;

 /**
@@ -67,30 +66,25 @@ import static org.mockito.Mockito.*;
 * @version $Id: SVGImageReaderTest.java,v 1.0 Apr 1, 2008 10:39:17 PM haraldk Exp$
 */
 public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader> {
-    private SVGImageReaderSpi provider = new SVGImageReaderSpi();
+
+    @Override
+    protected ImageReaderSpi createProvider() {
+        return new SVGImageReaderSpi();
+    }

    protected List<TestData> getTestData() {
        return Arrays.asList(
                new TestData(getClassLoaderResource("/svg/batikLogo.svg"), new Dimension(450, 500)),
                new TestData(getClassLoaderResource("/svg/red-square.svg"), new Dimension(100, 100)),
                new TestData(getClassLoaderResource("/svg/blue-square.svg"), new Dimension(100, 100)),
-                new TestData(getClassLoaderResource("/svg/Android_robot.svg"), new Dimension(294, 345))
+                new TestData(getClassLoaderResource("/svg/Android_robot.svg"), new Dimension(294, 345)),
+                new TestData(getClassLoaderResource("/svg/sizes/w50h50.svg"), new Dimension(50, 50)),
+                new TestData(getClassLoaderResource("/svg/sizes/w50_1to2.svg"), new Dimension(25, 50)),
+                new TestData(getClassLoaderResource("/svg/sizes/h50_1to2.svg"), new Dimension(50, 100)),
+                new TestData(getClassLoaderResource("/svg/sizes/w50noview.svg"), new Dimension(50, 50))
        );
    }

-    protected ImageReaderSpi createProvider() {
-        return provider;
-    }
-
-    @Override
-    protected SVGImageReader createReader() {
-        return new SVGImageReader(createProvider());
-    }
-
-    protected Class<SVGImageReader> getReaderClass() {
-        return SVGImageReader.class;
-    }
-
    protected List<String> getFormatNames() {
        return Collections.singletonList("svg");
    }
@@ -107,8 +101,6 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
    public void testScaleViewBox() throws IOException {
        URL svgUrl = getClassLoaderResource("/svg/quadrants.svg");

-        File tmpDir = new File(System.getProperty("java.io.tmpdir"));
-
        SVGImageReader reader = createReader();
        SVGReadParam param = new SVGReadParam();

@@ -156,11 +148,11 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>

    @Test
    @Override
-    public void testReadWithSizeParam() {
+    public void testReadWithSizeParam() throws IOException {
        try {
            super.testReadWithSizeParam();
        }
-        catch (AssertionError failure) {
+        catch (AssertionError | IOException failure) {
            Throwable cause = failure;

            while (cause.getCause() != null) {
@@ -202,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
@@ -224,6 +216,7 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
            reader.addIIOReadWarningListener(listener);

            SVGReadParam param = reader.getDefaultReadParam();
+            param.setAllowExternalResources(true);
            param.setBaseURI(resource.toURI().toASCIIString());
            BufferedImage image = reader.read(0, param);

@@ -232,7 +225,7 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
            assertEquals(500, image.getHeight());

            // CSS and embedded resources all go!
-            verifyZeroInteractions(listener);
+            verifyNoInteractions(listener);
        }
        finally {
            reader.dispose();
@@ -244,6 +237,8 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
        // Asking for metadata, width, height etc, before attempting to read using a param,
        // will cause the document to be parsed without a base URI.
        // This will work, but may not use the CSS...
+        // since the param is not available before the read operation is invoked,
+        // this test-case MUST use the system-property for backwards compatibility
        URL resource = getClassLoaderResource("/svg/barChart.svg");

        SVGImageReader reader = createReader();
@@ -271,7 +266,7 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
            assertEquals(500, image.getHeight());

            // No more warnings now that the base URI is set
-            verifyZeroInteractions(listener);
+            verifyNoInteractions(listener);
        }
        finally {
            reader.dispose();
@@ -282,18 +277,17 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
    public void testEmbeddedNoBaseURI() throws IOException {
        // With no base URI, we will throw an exception, about the missing embedded resource
        URL resource = getClassLoaderResource("/svg/barChart.svg");
-
        SVGImageReader reader = createReader();

        TestData data = new TestData(resource, (Dimension) null);
        try (ImageInputStream stream = data.getInputStream()) {
            reader.setInput(stream);

-            BufferedImage image = reader.read(0);
+            SVGReadParam params = reader.getDefaultReadParam();
+            params.setAllowExternalResources(true);
+            reader.read(0, params);

-            assertNotNull(image);
-            assertEquals(450, image.getWidth());
-            assertEquals(500, image.getHeight());
+            fail("reader.read should've thrown an exception, but didn't");
        }
        catch (IIOException allowed) {
            assertTrue(allowed.getMessage().contains("batikLogo.svg")); // The embedded resource we don't find
@@ -302,4 +296,112 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
            reader.dispose();
        }
    }
-}
+
+    @Test
+    public void testReadEmbeddedWithDisallowExternalResources() throws IOException{
+        // File using "data:" URLs for embedded resources
+        URL resource = getClassLoaderResource("/svg/embedded-data-resource.svg");
+        SVGImageReader reader = createReader();
+
+        TestData data = new TestData(resource, (Dimension) null);
+        try (ImageInputStream stream = data.getInputStream()) {
+            reader.setInput(stream);
+
+            SVGReadParam param = reader.getDefaultReadParam();
+            param.setAllowExternalResources(false);
+            reader.read(0, param);
+        }
+        finally {
+            reader.dispose();
+        }
+    }
+
+    @Test(expected = SecurityException.class)
+    public void testDisallowedExternalResources() throws URISyntaxException, IOException {
+        // system-property set to true in surefire-plugin-settings in the pom
+        URL resource = getClassLoaderResource("/svg/barChart.svg");
+        SVGImageReader reader = createReader();
+
+        TestData data = new TestData(resource, (Dimension) null);
+        try (ImageInputStream stream = data.getInputStream()) {
+            reader.setInput(stream);
+
+            SVGReadParam param = reader.getDefaultReadParam();
+            param.setBaseURI(resource.toURI().toASCIIString());
+            param.setAllowExternalResources(false);
+            // even when the system-property is set to true,
+            // `reader.read` for `/svg/barChart.svg` should raise
+            // a SecurityException when External Resources are blocked
+            // because the API invocation gets preference
+            reader.read(0, param);
+        }
+        finally {
+            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();
+        }
+    }
+}
@@ -31,6 +31,7 @@
 package com.twelvemonkeys.imageio.plugins.wmf;

 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
+
 import org.junit.Ignore;
 import org.junit.Test;

@@ -49,7 +50,10 @@ import java.util.List;
 * @version $Id: WMFImageReaderTest.java,v 1.0 Apr 1, 2008 10:39:17 PM haraldk Exp$
 */
 public class WMFImageReaderTest extends ImageReaderAbstractTest<WMFImageReader> {
-    private WMFImageReaderSpi provider = new WMFImageReaderSpi();
+    @Override
+    protected ImageReaderSpi createProvider() {
+        return new WMFImageReaderSpi();
+    }

    protected List<TestData> getTestData() {
        return Collections.singletonList(
@@ -57,27 +61,17 @@ public class WMFImageReaderTest extends ImageReaderAbstractTest<WMFImageReader>
        );
    }

-    protected ImageReaderSpi createProvider() {
-        return provider;
-    }
-
    @Override
-    protected WMFImageReader createReader() {
-        return new WMFImageReader(createProvider());
-    }
-
-    protected Class<WMFImageReader> getReaderClass() {
-        return WMFImageReader.class;
-    }
-
    protected List<String> getFormatNames() {
        return Collections.singletonList("wmf");
    }

+    @Override
    protected List<String> getSuffixes() {
        return Arrays.asList("wmf", "emf");
    }

+    @Override
    protected List<String> getMIMETypes() {
        return Arrays.asList("image/x-wmf", "application/x-msmetafile");
    }
@@ -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>
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="50" viewBox="0 0 100 200" version="1.1">
+  <g id="layer1">
+    <rect id="rect2985" width="50" height="50" x="0" y="0"
+	   style="color:#000000;fill:#0000ff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" />
+  </g>
+</svg>
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg xmlns="http://www.w3.org/2000/svg" height="50" viewBox="0 0 100 200" version="1.1">
+  <g id="layer1">
+    <rect id="rect2985" width="50" height="50" x="0" y="0"
+	   style="color:#000000;fill:#0000ff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" />
+  </g>
+</svg>
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="50" height="50" viewBox="0 0 100 200" version="1.1">
+  <g id="layer1">
+    <rect id="rect2985" width="50" height="50" x="0" y="0"
+	   style="color:#000000;fill:#0000ff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" />
+  </g>
+</svg>
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="50" version="1.1">
+  <g id="layer1">
+    <rect id="rect2985" width="50" height="50" x="0" y="0"
+	   style="color:#000000;fill:#0000ff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" />
+  </g>
+</svg>
@@ -4,12 +4,16 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-bmp</artifactId>
    <name>TwelveMonkeys :: ImageIO :: BMP plugin</name>
    <description>ImageIO plugin for Microsoft Device Independent Bitmap (BMP/DIB) format.</description>

+    <properties>
+        <project.jpms.module.name>com.twelvemonkeys.imageio.bmp</project.jpms.module.name>
+    </properties>
+
    <dependencies>
        <dependency>
            <groupId>com.twelvemonkeys.imageio</groupId>
@@ -19,6 +23,7 @@
            <groupId>com.twelvemonkeys.imageio</groupId>
            <artifactId>imageio-core</artifactId>
            <type>test-jar</type>
+            <scope>test</scope>
        </dependency>
    </dependencies>
 </project>
@@ -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,13 +51,13 @@ 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;
 import java.io.IOException;
 import java.nio.ByteOrder;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.Iterator;

 /**
@@ -77,7 +81,7 @@ public final class BMPImageReader extends ImageReaderBase {
        super(new BMPImageReaderSpi());
    }

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

@@ -125,6 +129,10 @@ public final class BMPImageReader extends ImageReaderBase {

            // Read DIB header
            header = DIBHeader.read(imageInput);
+
+            if (pixelOffset < header.size + DIB.BMP_FILE_HEADER_SIZE) {
+                throw new IIOException("Invalid pixel offset: " + pixelOffset);
+            }
        }
    }

@@ -196,7 +204,7 @@ public final class BMPImageReader extends ImageReaderBase {
        checkBounds(pImageIndex);

        // TODO: Better implementation, include INT_RGB types for 3BYTE_BGR and 4BYTE_ABGR for INT_ARGB
-        return Arrays.asList(getRawImageType(pImageIndex)).iterator();
+        return Collections.singletonList(getRawImageType(pImageIndex)).iterator();
    }

    @Override
@@ -207,50 +215,55 @@ public final class BMPImageReader extends ImageReaderBase {
            throw new IIOException("Multiple planes not supported");
        }

-        switch (header.getBitCount()) {
-            case 1:
-            case 2:
-            case 4:
-            case 8:
-                return ImageTypeSpecifiers.createFromIndexColorModel(readColorMap());
+        try {
+            switch (header.getBitCount()) {
+                case 1:
+                case 2:
+                case 4:
+                case 8:
+                    return ImageTypeSpecifiers.createFromIndexColorModel(readColorMap());

-            case 16:
-                if (header.hasMasks()) {
-                    return ImageTypeSpecifiers.createPacked(
-                            ColorSpace.getInstance(ColorSpace.CS_sRGB),
-                            header.masks[0], header.masks[1], header.masks[2], header.masks[3],
-                            DataBuffer.TYPE_USHORT, false
-                    );
-                }
+                case 16:
+                    if (header.hasMasks()) {
+                        return ImageTypeSpecifiers.createPacked(
+                                ColorSpace.getInstance(ColorSpace.CS_sRGB),
+                                header.masks[0], header.masks[1], header.masks[2], header.masks[3],
+                                DataBuffer.TYPE_USHORT, false
+                        );
+                    }

-                // Default if no mask is 555
-                return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_USHORT_555_RGB);
+                    // Default if no mask is 555
+                    return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_USHORT_555_RGB);

-            case 24:
-                if (header.getCompression() != DIB.COMPRESSION_RGB) {
-                    throw new IIOException("Unsupported compression for RGB: " + header.getCompression());
-                }
+                case 24:
+                    if (header.getCompression() != DIB.COMPRESSION_RGB) {
+                        throw new IIOException("Unsupported compression for RGB: " + header.getCompression());
+                    }

-                return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR);
+                    return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR);

-            case 32:
-                if (header.hasMasks()) {
-                    return ImageTypeSpecifiers.createPacked(
-                            ColorSpace.getInstance(ColorSpace.CS_sRGB),
-                            header.masks[0], header.masks[1], header.masks[2], header.masks[3],
-                            DataBuffer.TYPE_INT, false
-                    );
-                }
+                case 32:
+                    if (header.hasMasks()) {
+                        return ImageTypeSpecifiers.createPacked(
+                                ColorSpace.getInstance(ColorSpace.CS_sRGB),
+                                header.masks[0], header.masks[1], header.masks[2], header.masks[3],
+                                DataBuffer.TYPE_INT, false
+                        );
+                    }

-                // Default if no mask
-                return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
+                    // Default if no mask
+                    return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);

-            case 0:
-                if (header.getCompression() == DIB.COMPRESSION_JPEG || header.getCompression() == DIB.COMPRESSION_PNG) {
-                    return initReaderDelegate(header.getCompression()).getRawImageType(0);
-                }
-            default:
-                throw new IIOException("Unsupported bit count: " + header.getBitCount());
+                case 0:
+                    if (header.getCompression() == DIB.COMPRESSION_JPEG || header.getCompression() == DIB.COMPRESSION_PNG) {
+                        return initReaderDelegate(header.getCompression()).getRawImageType(0);
+                    }
+                default:
+                    throw new IIOException("Unsupported bit count: " + header.getBitCount());
+            }
+        }
+        catch (IllegalArgumentException e) {
+            throw new IIOException(e.getMessage(), e);
        }
    }

@@ -349,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:
@@ -370,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);
@@ -396,6 +413,13 @@ public final class BMPImageReader extends ImageReaderBase {

    private ImageReader initReaderDelegate(int compression) throws IOException {
        ImageReader reader = getImageReaderDelegate(compression);
+        reader.reset();
+
+        // Install listener
+        ListenerDelegator listenerDelegator = new ListenerDelegator();
+        reader.addIIOReadWarningListener(listenerDelegator);
+        reader.addIIOReadProgressListener(listenerDelegator);
+        reader.addIIOReadUpdateListener(listenerDelegator);

        imageInput.seek(pixelOffset);
        reader.setInput(new SubImageInputStream(imageInput, header.getImageSize()));
@@ -436,12 +460,6 @@ public final class BMPImageReader extends ImageReaderBase {

        ImageReader reader = readers.next();

-        // Install listener
-        ListenerDelegator listenerDelegator = new ListenerDelegator();
-        reader.addIIOReadWarningListener(listenerDelegator);
-        reader.addIIOReadProgressListener(listenerDelegator);
-        reader.addIIOReadUpdateListener(listenerDelegator);
-
        // Cache for later use
        switch (compression) {
            case DIB.COMPRESSION_JPEG:
@@ -466,9 +484,14 @@ 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;
+        int dstY = (srcY - srcRegion.y) / ySub;
+
        // If subsampled or outside source region, skip entire row
-        if (y % ySub != 0 || height - 1 - y < srcRegion.y || height - 1 - y >= srcRegion.y + srcRegion.height) {
+        if (srcY % ySub != 0 || srcY < srcRegion.y || srcY >= srcRegion.y + srcRegion.height) {
            input.skipBytes(rowDataByte.length);

            return;
@@ -478,24 +501,20 @@ 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);
        }

-        if (header.topDown) {
-            destChannel.setDataElements(0, y, srcChannel);
-        } else {
-            // Flip into position
-            int dstY = (height - 1 - y - srcRegion.y) / ySub;
-            destChannel.setDataElements(0, dstY, srcChannel);
-        }
+        destChannel.setDataElements(0, dstY, srcChannel);
    }

    private void readRowUShort(final DataInput input, final int height, final Rectangle srcRegion, final int xSub, final int ySub,
                               final short[] rowDataUShort, final WritableRaster destChannel, final Raster srcChannel, final int y) throws IOException {
+        // Flip into position?
+        int srcY = !header.topDown ? height - 1 - y : y;
+        int dstY = (srcY - srcRegion.y) / ySub;
+
        // If subsampled or outside source region, skip entire row
-        if (y % ySub != 0 || height - 1 - y < srcRegion.y || height - 1 - y >= srcRegion.y + srcRegion.height) {
+        if (srcY % ySub != 0 || srcY < srcRegion.y || srcY >= srcRegion.y + srcRegion.height) {
            input.skipBytes(rowDataUShort.length * 2 + (rowDataUShort.length % 2) * 2);

            return;
@@ -515,19 +534,17 @@ public final class BMPImageReader extends ImageReaderBase {
            }
        }

-        if (header.topDown) {
-            destChannel.setDataElements(0, y, srcChannel);
-        } else {
-            // Flip into position
-            int dstY = (height - 1 - y - srcRegion.y) / ySub;
-            destChannel.setDataElements(0, dstY, srcChannel);
-        }
+        destChannel.setDataElements(0, dstY, srcChannel);
    }

    private void readRowInt(final DataInput input, final int height, final Rectangle srcRegion, final int xSub, final int ySub,
                            final int[] rowDataInt, final WritableRaster destChannel, final Raster srcChannel, final int y) throws IOException {
+        // Flip into position?
+        int srcY = !header.topDown ? height - 1 - y : y;
+        int dstY = (srcY - srcRegion.y) / ySub;
+
        // If subsampled or outside source region, skip entire row
-        if (y % ySub != 0 || height - 1 - y < srcRegion.y || height - 1 - y >= srcRegion.y + srcRegion.height) {
+        if (srcY % ySub != 0 || srcY < srcRegion.y || srcY >= srcRegion.y + srcRegion.height) {
            input.skipBytes(rowDataInt.length * 4);

            return;
@@ -542,13 +559,7 @@ public final class BMPImageReader extends ImageReaderBase {
            }
        }

-        if (header.topDown) {
-            destChannel.setDataElements(0, y, srcChannel);
-        } else {
-            // Flip into position
-            int dstY = (height - 1 - y - srcRegion.y) / ySub;
-            destChannel.setDataElements(0, dstY, srcChannel);
-        }
+        destChannel.setDataElements(0, dstY, srcChannel);
    }

    // TODO: Candidate util method
@@ -619,7 +630,8 @@ public final class BMPImageReader extends ImageReaderBase {
        return new BMPMetadata(header, colors);
    }

-    public static void main(String[] args) throws IOException {
+    @SuppressWarnings("ConstantConditions")
+    public static void main(String[] args) {
        BMPImageReaderSpi provider = new BMPImageReaderSpi();
        BMPImageReader reader = new BMPImageReader(provider);

@@ -672,7 +684,7 @@ public final class BMPImageReader extends ImageReaderBase {
        }
    }

-    @SuppressWarnings({"unchecked", "UnusedDeclaration"})
+    @SuppressWarnings({ "unchecked", "UnusedDeclaration", "SameParameterValue" })
    static <T extends Throwable> void throwAs(final Class<T> pType, final Throwable pThrowable) throws T {
        throw (T) pThrowable;
    }
@@ -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);
    }

@@ -33,9 +33,13 @@ package com.twelvemonkeys.imageio.plugins.bmp;
 import com.twelvemonkeys.imageio.spi.ImageWriterSpiBase;

 import javax.imageio.ImageTypeSpecifier;
-import java.io.IOException;
+import javax.imageio.spi.ImageWriterSpi;
+import javax.imageio.spi.ServiceRegistry;
+import java.awt.image.BufferedImage;
 import java.util.Locale;

+import static com.twelvemonkeys.imageio.util.IIOUtil.lookupProviderByName;
+
 /**
 * BMPImageWriterSpi
 */
@@ -45,17 +49,28 @@ public final class BMPImageWriterSpi extends ImageWriterSpiBase {
    }

    @Override
-    public boolean canEncodeImage(final ImageTypeSpecifier type) {
-        return true;
+    public void onRegistration(ServiceRegistry registry, Class<?> category) {
+        // Make sure we register BEHIND the built-in BMP writer
+        ImageWriterSpi sunSpi = lookupProviderByName(registry, "com.sun.imageio.plugins.bmp.BMPImageWriterSpi", ImageWriterSpi.class);
+
+        if (sunSpi != null && sunSpi.getVendorName() != null) {
+            registry.setOrdering((Class<ImageWriterSpi>) category, sunSpi, this);
+        }
    }

    @Override
-    public BMPImageWriter createWriterInstance(final Object extension) throws IOException {
+    public boolean canEncodeImage(final ImageTypeSpecifier type) {
+        // TODO: Support more types, as time permits.
+        return type.getBufferedImageType() == BufferedImage.TYPE_4BYTE_ABGR;
+    }
+
+    @Override
+    public BMPImageWriter createWriterInstance(final Object extension) {
        return new BMPImageWriter(this);
    }

    @Override
    public String getDescription(final Locale locale) {
-        return "Windows Device Independent Bitmap Format (BMP) Reader";
+        return "Windows Device Independent Bitmap Format (BMP) Writer";
    }
 }
@@ -40,7 +40,7 @@ import javax.imageio.metadata.IIOMetadataNode;
 * BMPMetadata.
 */
 final class BMPMetadata extends AbstractMetadata {
-    /** We return metadata in the exact same form as the JRE built-in, to be compatible with the DIBImageWriter. */
+    /** We return metadata in the exact same form as the JRE built-in, to be compatible with the BMPImageWriter. */
    public static final String nativeMetadataFormatName = "javax_imageio_bmp_1.0";

    private final DIBHeader header;
@@ -29,9 +29,10 @@
 */
 package com.twelvemonkeys.imageio.plugins.bmp;

-import com.twelvemonkeys.lang.Validate;
+import static com.twelvemonkeys.lang.Validate.notNull;

 import java.awt.image.BufferedImage;
+import java.io.IOException;

 /**
 * Describes a bitmap structure.
@@ -47,14 +48,11 @@ abstract class BitmapDescriptor {
    protected BitmapMask mask;

    public BitmapDescriptor(final DirectoryEntry pEntry, final DIBHeader pHeader) {
-        Validate.notNull(pEntry, "entry");
-        Validate.notNull(pHeader, "header");
-        
-        entry = pEntry;
-        header = pHeader;
+        entry = notNull(pEntry, "entry");;
+        header = notNull(pHeader, "header");
    }

-    abstract public BufferedImage getImage();
+    abstract public BufferedImage getImage() throws IOException;

    public final int getWidth() {
        return entry.getWidth();
@@ -163,6 +163,7 @@ class BitmapIndexed extends BitmapDescriptor {
        return transparent;
    }

+    @Override
    public BufferedImage getImage() {
        if (image == null) {
            image = createImageIndexed();
@@ -46,6 +46,7 @@ class BitmapRGB extends BitmapDescriptor {
        super(pEntry, pHeader);
    }

+    @Override
    public BufferedImage getImage() {
        // Test is mask != null rather than hasMask(), as 32 bit (w/alpha)
        // might still have bitmask, but we don't read or use it.
@@ -31,6 +31,9 @@
 package com.twelvemonkeys.imageio.plugins.bmp;

 import java.awt.image.BufferedImage;
+import java.io.IOException;
+
+import javax.imageio.IIOException;

 /**
 * Represents bitmap structures we can't read.
@@ -42,13 +45,14 @@ import java.awt.image.BufferedImage;
 class BitmapUnsupported extends BitmapDescriptor {
    private String message;

-    public BitmapUnsupported(final DirectoryEntry pEntry, final String pMessage) {
-        super(pEntry, null);
+    public BitmapUnsupported(final DirectoryEntry pEntry, DIBHeader header, final String pMessage) {
+        super(pEntry, header);

        message = pMessage;
    }

-    public BufferedImage getImage() {
-        throw new IllegalStateException(message);
+    @Override
+    public BufferedImage getImage() throws IOException {
+        throw new IIOException(message);
    }
 }
@@ -30,11 +30,12 @@

 package com.twelvemonkeys.imageio.plugins.bmp;

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

+import javax.imageio.IIOException;
+
 /**
 * Represents the DIB (Device Independent Bitmap) Information header structure.
 *
@@ -213,7 +214,7 @@ abstract class DIBHeader {

            // NOTE: Unlike all other headers, width and height are unsigned SHORT values (16 bit)!
            width = pStream.readUnsignedShort();
-            height = pStream.readUnsignedShort();
+            height = pStream.readShort();

            if (height < 0) {
                height = -height;
@@ -240,6 +241,7 @@ abstract class DIBHeader {
     * @see <a href="http://www.fileformat.info/format/os2bmp/egff.htm">OS/2 Bitmap File Format Summary</a>
     */
    static final class BitmapCoreHeaderV2 extends DIBHeader {
+        @SuppressWarnings("unused")
        protected void read(final int pSize, final DataInput pStream) throws IOException {
            if (pSize != DIB.OS2_V2_HEADER_SIZE && pSize != DIB.OS2_V2_HEADER_16_SIZE) {
                throw new IIOException(String.format("Size: %s !=: %s", pSize, DIB.OS2_V2_HEADER_SIZE));
@@ -362,7 +364,11 @@ abstract class DIBHeader {

        public String getBMPVersion() {
            // This is to be compatible with the native metadata of the original com.sun....BMPMetadata
-            return compression == DIB.COMPRESSION_BITFIELDS ? "BMP v. 3.x NT" : "BMP v. 3.x";
+            return size > DIB.BITMAP_INFO_HEADER_SIZE
+                   ? "BMP V2/V3 INFO"
+                   : compression == DIB.COMPRESSION_BITFIELDS || compression == DIB.COMPRESSION_ALPHA_BITFIELDS
+                     ? "BMP v. 3.x NT"
+                     : "BMP v. 3.x";
        }
    }

@@ -30,16 +30,6 @@

 package com.twelvemonkeys.imageio.plugins.bmp;

-import com.twelvemonkeys.image.ImageUtil;
-import com.twelvemonkeys.imageio.ImageReaderBase;
-import com.twelvemonkeys.imageio.stream.SubImageInputStream;
-import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
-import com.twelvemonkeys.util.WeakWeakMap;
-
-import javax.imageio.*;
-import javax.imageio.spi.ImageReaderSpi;
-import javax.imageio.stream.ImageInputStream;
-import javax.swing.*;
 import java.awt.*;
 import java.awt.color.ColorSpace;
 import java.awt.event.WindowAdapter;
@@ -48,8 +38,26 @@ import java.awt.image.*;
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
-import java.util.*;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import javax.imageio.IIOException;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.spi.ImageReaderSpi;
+import javax.imageio.stream.ImageInputStream;
+import javax.swing.*;
+
+import com.twelvemonkeys.image.ImageUtil;
+import com.twelvemonkeys.imageio.ImageReaderBase;
+import com.twelvemonkeys.imageio.stream.SubImageInputStream;
+import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
+import com.twelvemonkeys.util.WeakWeakMap;

 /**
 * ImageReader for Microsoft Windows ICO (icon) format.
@@ -84,7 +92,7 @@ abstract class DIBImageReader extends ImageReaderBase {

    protected void resetMembers() {
        directory = null;
-        
+
        headers.clear();
        descriptors.clear();

@@ -287,7 +295,7 @@ abstract class DIBImageReader extends ImageReaderBase {

            // TODO: Support this, it's already in the BMP reader, spec allows RLE4 and RLE8
            if (header.getCompression() != DIB.COMPRESSION_RGB) {
-                descriptor = new BitmapUnsupported(pEntry, String.format("Unsupported compression: %d", header.getCompression()));
+                descriptor = new BitmapUnsupported(pEntry, header, String.format("Unsupported compression: %d", header.getCompression()));
            }
            else {
                int bitCount = header.getBitCount();
@@ -315,7 +323,7 @@ abstract class DIBImageReader extends ImageReaderBase {
                        break;

                    default:
-                        descriptor = new BitmapUnsupported(pEntry, String.format("Unsupported bit count %d", bitCount));
+                        descriptor = new BitmapUnsupported(pEntry, header, String.format("Unsupported bit count %d", bitCount));
                }
            }

@@ -355,7 +363,7 @@ abstract class DIBImageReader extends ImageReaderBase {
    }

    private void readBitmapIndexed1(final BitmapIndexed pBitmap, final boolean pAsMask) throws IOException {
-        int width = adjustToPadding(pBitmap.getWidth() >> 3);
+        int width = adjustToPadding((pBitmap.getWidth() + 7) >> 3);
        byte[] row = new byte[width];

        for (int y = 0; y < pBitmap.getHeight(); y++) {
@@ -389,7 +397,7 @@ abstract class DIBImageReader extends ImageReaderBase {
    }

    private void readBitmapIndexed4(final BitmapIndexed pBitmap) throws IOException {
-        int width = adjustToPadding(pBitmap.getWidth() >> 1);
+        int width = adjustToPadding((pBitmap.getWidth() + 1) >> 1);
        byte[] row = new byte[width];

        for (int y = 0; y < pBitmap.getHeight(); y++) {
@@ -457,13 +465,12 @@ abstract class DIBImageReader extends ImageReaderBase {
    }

    private void readBitmap16(final BitmapDescriptor pBitmap) throws IOException {
-        // TODO: No idea if this actually works..
        short[] pixels = new short[pBitmap.getWidth() * pBitmap.getHeight()];

        // TODO: Support TYPE_USHORT_565 and the RGB 444/ARGB 4444 layouts
        // Will create TYPE_USHORT_555
        DirectColorModel cm = new DirectColorModel(16, 0x7C00, 0x03E0, 0x001F);
-        DataBuffer buffer = new DataBufferShort(pixels, pixels.length);
+        DataBuffer buffer = new DataBufferUShort(pixels, pixels.length);
        WritableRaster raster = Raster.createPackedRaster(
                buffer, pBitmap.getWidth(), pBitmap.getHeight(), pBitmap.getWidth(), cm.getMasks(), null
        );
@@ -551,7 +558,7 @@ abstract class DIBImageReader extends ImageReaderBase {
            if (abortRequested()) {
                processReadAborted();
                break;
-            }            
+            }
            processImageProgress(100 * y / (float) pBitmap.getHeight());
        }

@@ -591,7 +598,7 @@ abstract class DIBImageReader extends ImageReaderBase {

        return directory.getEntry(pImageIndex);
    }
-    
+
    /// Test code below, ignore.. :-)
    public static void main(final String[] pArgs) throws IOException {
        if (pArgs.length == 0) {
@@ -701,10 +708,10 @@ abstract class DIBImageReader extends ImageReaderBase {
            }
        });

-        button.setText("" + image.getWidth() + "x" +
+        button.setText(image.getWidth() + "x" +
                image.getHeight() + ": "
                + ((image.getColorModel() instanceof IndexColorModel) ?
-                "" + ((IndexColorModel) image.getColorModel()).getMapSize() :
+                String.valueOf(((IndexColorModel) image.getColorModel()).getMapSize()) :
                "TrueColor"));

        pParent.add(button);
@@ -43,6 +43,7 @@ import java.nio.ByteOrder;
 * DIBImageWriter
 */
 abstract class DIBImageWriter extends ImageWriterBase {
+
    DIBImageWriter(ImageWriterSpi provider) {
        super(provider);
    }
@@ -50,7 +51,9 @@ abstract class DIBImageWriter extends ImageWriterBase {
    @Override
    public void setOutput(Object output) {
        super.setOutput(output);
-        imageOutput.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+        if (imageOutput != null) {
+            imageOutput.setByteOrder(ByteOrder.LITTLE_ENDIAN);
+        }
    }

    void writeDIBHeader(int infoHeaderSize, int width, int height, boolean isTopDown, int pixelSize, int compression) throws IOException {
@@ -82,9 +85,8 @@ abstract class DIBImageWriter extends ImageWriterBase {
    }

    void writeUncompressed(boolean isTopDown, BufferedImage img, int height, int width) throws IOException {
-        // TODO: Fix
        if (img.getType() != BufferedImage.TYPE_4BYTE_ABGR) {
-            throw new IIOException("Blows!");
+            throw new IIOException("Only TYPE_4BYTE_ABGR supported");
        }

        // Support
@@ -93,12 +95,13 @@ abstract class DIBImageWriter extends ImageWriterBase {
        // - TODO: Packed/DirectColorModel (16 and 32 bit, BI_BITFIELDS, BI_PNG? BI_JPEG?)

        Raster raster = img.getRaster();
-        WritableRaster rowRaster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, 1, width * 4, 4, new int[]{2, 1, 0, 3}, null);
+        WritableRaster rowRaster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, 1, width * 4, 4, new int[] {2, 1, 0, 3}, null);
        byte[] row = ((DataBufferByte) rowRaster.getDataBuffer()).getData();
+        final int[] bandList = {2, 1, 0, 3};

        for (int i = 0; i < height; i++) {
            int line = isTopDown ? i : height - 1 - i;
-            rowRaster.setDataElements(0, 0, raster.createChild(0, line, width, 1, 0, 0, new int[]{2, 1, 0, 3}));
+            rowRaster.setDataElements(0, 0, raster.createChild(0, line, width, 1, 0, 0, bandList));

            imageOutput.write(row);

@@ -143,7 +143,7 @@ public final class ICOImageWriter extends DIBImageWriter {
        }

        if (image.hasRaster()) {
-            throw new UnsupportedOperationException("image has a Raster");
+            throw new UnsupportedOperationException("Raster not supported");
        }

        if (sequenceIndex >= INITIAL_ENTRY_COUNT) {
@@ -155,7 +155,7 @@ public final class ICOImageWriter extends DIBImageWriter {
        ColorModel colorModel = image.getRenderedImage().getColorModel();

        // TODO: The output size may depend on the param (subsampling, source region, etc)
-        if (width > ICO_MAX_DIMENSION && height > ICO_MAX_DIMENSION) {
+        if (width > ICO_MAX_DIMENSION || height > ICO_MAX_DIMENSION) {
            throw new IIOException(String.format("ICO maximum width or height (%d) exceeded", ICO_MAX_DIMENSION));
        }

@@ -33,7 +33,7 @@ package com.twelvemonkeys.imageio.plugins.bmp;
 import com.twelvemonkeys.imageio.spi.ImageWriterSpiBase;

 import javax.imageio.ImageTypeSpecifier;
-import java.io.IOException;
+import java.awt.image.BufferedImage;
 import java.util.Locale;

 /**
@@ -46,11 +46,13 @@ public final class ICOImageWriterSpi extends ImageWriterSpiBase {

    @Override
    public boolean canEncodeImage(final ImageTypeSpecifier type) {
-        return true;
+        // TODO: Support more types, as time permits.
+        // NOTE: We do support more types, if writing using PNG compression
+        return type.getBufferedImageType() == BufferedImage.TYPE_4BYTE_ABGR;
    }

    @Override
-    public ICOImageWriter createWriterInstance(final Object extension) throws IOException {
+    public ICOImageWriter createWriterInstance(final Object extension) {
        return new ICOImageWriter(this);
    }

@@ -41,8 +41,8 @@ import java.util.Arrays;
 * @version $Id: RLE4Decoder.java#1 $
 */
 final class RLE4Decoder extends AbstractRLEDecoder {
-    final static int BIT_MASKS[] = {0xf0, 0x0f};
-    final static int BIT_SHIFTS[] = {4, 0};
+    final static int[] BIT_MASKS = {0xf0, 0x0f};
+    final static int[] BIT_SHIFTS = {4, 0};

    public RLE4Decoder(final int width) {
        super(width, 4);
@@ -94,7 +94,7 @@ final class RLE4Decoder extends AbstractRLEDecoder {
                        boolean paddingByte = (((byte2 + 1) / 2) % 2) != 0;

                        int packed = 0;
-                        for (int i = 0; i < byte2; i++) {
+                        for (int i = 0; i < byte2 && srcX / 2 < row.length; i++) {
                            if (i % 2 == 0) {
                                packed = checkEOF(stream.read());
                            }
@@ -111,7 +111,7 @@ final class RLE4Decoder extends AbstractRLEDecoder {
            else {
                // Encoded mode
                // Replicate the two samples in byte2 as many times as byte1 says
-                for (int i = 0; i < byte1; i++) {
+                for (int i = 0; i < byte1 && srcX / 2 < row.length; i++) {
                    row[srcX / 2] |= (byte) (((byte2 & BIT_MASKS[i % 2]) >> BIT_SHIFTS[i % 2]) << BIT_SHIFTS[srcX % 2]);
                    srcX++;
                }
@@ -94,7 +94,7 @@ final class RLE8Decoder extends AbstractRLEDecoder {
                        // an additional padding byte is in the stream and must be skipped
                        boolean paddingByte = (byte2 % 2) != 0;

-                        while (byte2-- > 0) {
+                        while (byte2-- > 0 && srcX < row.length) {
                            row[srcX++] = (byte) checkEOF(stream.read());
                        }

@@ -107,7 +107,7 @@ final class RLE8Decoder extends AbstractRLEDecoder {
                // Encoded mode
                // Replicate byte2 as many times as byte1 says
                byte value = (byte) byte2;
-                while (byte1-- > 0) {
+                while (byte1-- > 0  && srcX < row.length) {
                    row[srcX++] = value;
                }
            }
@@ -30,35 +30,43 @@

 package com.twelvemonkeys.imageio.plugins.bmp;

-import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
-import com.twelvemonkeys.xml.XMLSerializer;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeNoException;
+import static org.mockito.ArgumentMatchers.anyFloat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.imageio.IIOException;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.event.IIOReadProgressListener;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataNode;
+import javax.imageio.spi.ImageReaderSpi;
+
 import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

-import javax.imageio.*;
-import javax.imageio.event.IIOReadProgressListener;
-import javax.imageio.metadata.IIOMetadata;
-import javax.imageio.metadata.IIOMetadataNode;
-import javax.imageio.spi.ImageReaderSpi;
-import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.net.URISyntaxException;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-
-import static org.junit.Assert.*;
-import static org.junit.Assume.assumeNoException;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.*;
+import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
+import com.twelvemonkeys.xml.XMLSerializer;

 /**
 * BMPImageReaderTest
@@ -68,6 +76,12 @@ import static org.mockito.Mockito.*;
 * @version $Id: BMPImageReaderTest.java,v 1.0 Apr 1, 2008 10:39:17 PM haraldk Exp$
 */
 public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader> {
+    @Override
+    protected ImageReaderSpi createProvider() {
+        return new BMPImageReaderSpi();
+    }
+
+    @Override
    protected List<TestData> getTestData() {
        return Arrays.asList(
                // BMP Suite "Good"
@@ -144,27 +158,17 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
        );
    }

-    protected ImageReaderSpi createProvider() {
-        return new BMPImageReaderSpi();
-    }
-
    @Override
-    protected BMPImageReader createReader() {
-        return new BMPImageReader(createProvider());
-    }
-
-    protected Class<BMPImageReader> getReaderClass() {
-        return BMPImageReader.class;
-    }
-
    protected List<String> getFormatNames() {
        return Collections.singletonList("bmp");
    }

+    @Override
    protected List<String> getSuffixes() {
        return Arrays.asList("bmp", "rle");
    }

+    @Override
    protected List<String> getMIMETypes() {
        return Collections.singletonList("image/bmp");
    }
@@ -178,7 +182,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>

            ImageTypeSpecifier rawType = reader.getRawImageType(0);

-            // As the JPEGImageReader we delegate to returns null for YCbCr, we'll have to do the same
+            // As the JPEGImageReader we delegate to may return null for YCbCr, we'll have to do the same
            if (rawType == null && data.getInput().toString().contains("jpeg")) {
                continue;
            }
@@ -273,7 +277,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
    }

    @Test
-    public void testAddIIOReadProgressListenerCallbacksJPEG() {
+    public void testAddIIOReadProgressListenerCallbacksJPEG() throws IOException {
        ImageReader reader = createReader();
        TestData data = new TestData(getClassLoaderResource("/bmpsuite/q/rgb24jpeg.bmp"), new Dimension(127, 64));
        reader.setInput(data.getInputStream());
@@ -291,12 +295,12 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
        // At least imageStarted and imageComplete, plus any number of imageProgress
        InOrder ordered = inOrder(listener);
        ordered.verify(listener).imageStarted(reader, 0);
-        ordered.verify(listener, atLeastOnce()).imageProgress(eq(reader), anyInt());
+        ordered.verify(listener, atLeastOnce()).imageProgress(eq(reader), anyFloat());
        ordered.verify(listener).imageComplete(reader);
    }

    @Test
-    public void testAddIIOReadProgressListenerCallbacksPNG() {
+    public void testAddIIOReadProgressListenerCallbacksPNG() throws IOException {
        ImageReader reader = createReader();
        TestData data = new TestData(getClassLoaderResource("/bmpsuite/q/rgb24png.bmp"), new Dimension(127, 64));
        reader.setInput(data.getInputStream());
@@ -314,12 +318,12 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
        // At least imageStarted and imageComplete, plus any number of imageProgress
        InOrder ordered = inOrder(listener);
        ordered.verify(listener).imageStarted(reader, 0);
-        ordered.verify(listener, atLeastOnce()).imageProgress(eq(reader), anyInt());
+        ordered.verify(listener, atLeastOnce()).imageProgress(eq(reader), anyFloat());
        ordered.verify(listener).imageComplete(reader);
    }

    @Test
-    public void testMetadataEqualsJRE() throws IOException, URISyntaxException {
+    public void testMetadataEqualsJRE() throws IOException {
        ImageReader jreReader;
        try {
            @SuppressWarnings("unchecked")
@@ -338,6 +342,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>

        for (TestData data : getTestData()) {
            if (data.getInput().toString().contains("pal8offs")) {
+                // Skip: Contains extra bogus PaletteEntry nodes
                continue;
            }

@@ -354,9 +359,10 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
                System.err.println("WARNING: Reading " + data + " caused exception: " + e.getMessage());
                continue;
            }
+
            IIOMetadata jreMetadata = jreReader.getImageMetadata(0);

-            assertEquals(true, metadata.isStandardMetadataFormatSupported());
+            assertTrue(metadata.isStandardMetadataFormatSupported());
            assertEquals(jreMetadata.getNativeMetadataFormatName(), metadata.getNativeMetadataFormatName());
            assertArrayEquals(jreMetadata.getExtraMetadataFormatNames(), metadata.getExtraMetadataFormatNames());

@@ -366,6 +372,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
                String absolutePath = data.toString();
                String localPath = absolutePath.substring(absolutePath.lastIndexOf("test-classes") + 12);

+                // TODO: blauesglas_16_bitmask444 fails BMP Version for 11+
                Node expectedTree = jreMetadata.getAsTree(format);
                Node actualTree = metadata.getAsTree(format);

@@ -379,7 +386,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
                    new XMLSerializer(expected, "UTF-8").serialize(expectedTree, false);
                    new XMLSerializer(actual, "UTF-8").serialize(actualTree, false);

-                    assertEquals(e.getMessage(), new String(expected.toByteArray(), "UTF-8"), new String(actual.toByteArray(), "UTF-8"));
+                    assertEquals(e.getMessage(), new String(expected.toByteArray(), StandardCharsets.UTF_8), new String(actual.toByteArray(), StandardCharsets.UTF_8));

                    throw e;
                }
@@ -424,6 +431,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
        }
    }

+    @SuppressWarnings("RedundantIfStatement")
    private boolean excludeEqualValueTest(final Node expected) {
        if (expected.getLocalName().equals("ImageSize")) {
            // JRE metadata returns 0, even if known in reader...
@@ -0,0 +1,30 @@
+package com.twelvemonkeys.imageio.plugins.bmp;
+
+import com.twelvemonkeys.imageio.util.ImageWriterAbstractTest;
+
+import javax.imageio.spi.ImageWriterSpi;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * BMPImageWriterTest.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by : harald.kuhr$
+ * @version : BMPImageWriterTest.java,v 1.0 25/06/2020 harald.kuhr Exp$
+ */
+public class BMPImageWriterTest extends ImageWriterAbstractTest<BMPImageWriter> {
+    @Override
+    protected ImageWriterSpi createProvider() {
+        return new BMPImageWriterSpi();
+    }
+
+    @Override
+    protected List<? extends RenderedImage> getTestData() {
+        return Collections.singletonList(
+                new BufferedImage(10, 10, BufferedImage.TYPE_4BYTE_ABGR)
+        );
+    }
+}
@@ -31,6 +31,7 @@
 package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
+
 import org.junit.Ignore;
 import org.junit.Test;

@@ -53,6 +54,12 @@ import static org.junit.Assert.*;
 * @version $Id: CURImageReaderTest.java,v 1.0 Apr 1, 2008 10:39:17 PM haraldk Exp$
 */
 public class CURImageReaderTest extends ImageReaderAbstractTest<CURImageReader> {
+    @Override
+    protected ImageReaderSpi createProvider() {
+        return new CURImageReaderSpi();
+    }
+
+    @Override
    protected List<TestData> getTestData() {
        return Arrays.asList(
                new TestData(getClassLoaderResource("/cur/hand.cur"), new Dimension(32, 32)),
@@ -60,27 +67,17 @@ public class CURImageReaderTest extends ImageReaderAbstractTest<CURImageReader>
        );
    }

-    protected ImageReaderSpi createProvider() {
-        return new CURImageReaderSpi();
-    }
-
    @Override
-    protected CURImageReader createReader() {
-        return new CURImageReader();
-    }
-
-    protected Class<CURImageReader> getReaderClass() {
-        return CURImageReader.class;
-    }
-
    protected List<String> getFormatNames() {
        return Collections.singletonList("cur");
    }

+    @Override
    protected List<String> getSuffixes() {
        return Collections.singletonList("cur");
    }

+    @Override
    protected List<String> getMIMETypes() {
        return Arrays.asList("image/vnd.microsoft.cursor", "image/cursor", "image/x-cursor");
    }
@@ -99,7 +96,7 @@ public class CURImageReaderTest extends ImageReaderAbstractTest<CURImageReader>
            assertNotNull("Hotspot for cursor not present", hotspot);

            // Image weirdness
-            assertTrue("Hotspot for cursor undefined (java.awt.Image.UndefinedProperty)", Image.UndefinedProperty != hotspot);
+            assertNotSame("Hotspot for cursor undefined (java.awt.Image.UndefinedProperty)", Image.UndefinedProperty, hotspot);

            assertTrue(String.format("Hotspot not a java.awt.Point: %s", hotspot.getClass()), hotspot instanceof Point);
            assertEquals(pExpected, hotspot);
@@ -31,6 +31,7 @@
 package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
+
 import org.junit.Ignore;
 import org.junit.Test;

@@ -49,6 +50,12 @@ import java.util.List;
 * @version $Id: ICOImageReaderTest.java,v 1.0 Apr 1, 2008 10:39:17 PM haraldk Exp$
 */
 public class ICOImageReaderTest extends ImageReaderAbstractTest<ICOImageReader> {
+    @Override
+    protected ImageReaderSpi createProvider() {
+        return new ICOImageReaderSpi();
+    }
+
+    @Override
    protected List<TestData> getTestData() {
        return Arrays.asList(
                new TestData(
@@ -75,27 +82,17 @@ public class ICOImageReaderTest extends ImageReaderAbstractTest<ICOImageReader>
        );
    }

-    protected ImageReaderSpi createProvider() {
-        return new ICOImageReaderSpi();
-    }
-
    @Override
-    protected ICOImageReader createReader() {
-        return new ICOImageReader();
-    }
-
-    protected Class<ICOImageReader> getReaderClass() {
-        return ICOImageReader.class;
-    }
-
    protected List<String> getFormatNames() {
        return Collections.singletonList("ico");
    }

+    @Override
    protected List<String> getSuffixes() {
        return Collections.singletonList("ico");
    }

+    @Override
    protected List<String> getMIMETypes() {
        return Arrays.asList("image/vnd.microsoft.icon", "image/ico", "image/x-icon");
    }
@@ -0,0 +1,34 @@
+package com.twelvemonkeys.imageio.plugins.bmp;
+
+import com.twelvemonkeys.imageio.util.ImageWriterAbstractTest;
+
+import javax.imageio.spi.ImageWriterSpi;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * ICOImageWriterTest.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by : harald.kuhr$
+ * @version : ICOImageWriterTest.java,v 1.0 25/06/2020 harald.kuhr Exp$
+ */
+public class ICOImageWriterTest extends ImageWriterAbstractTest<ICOImageWriter> {
+    @Override
+    protected ImageWriterSpi createProvider() {
+        return new ICOImageWriterSpi();
+    }
+
+    @Override
+    protected List<? extends RenderedImage> getTestData() {
+        return Arrays.asList(
+                new BufferedImage(8, 8, BufferedImage.TYPE_4BYTE_ABGR),
+                new BufferedImage(16, 16, BufferedImage.TYPE_4BYTE_ABGR),
+                new BufferedImage(32, 32, BufferedImage.TYPE_4BYTE_ABGR),
+                new BufferedImage(64, 64, BufferedImage.TYPE_4BYTE_ABGR),
+                new BufferedImage(128, 128, BufferedImage.TYPE_4BYTE_ABGR)
+        );
+    }
+}
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-clippath</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Photoshop Path Support</name>
@@ -12,6 +12,10 @@
        Photoshop Clipping Path Support.
    </description>

+    <properties>
+        <project.jpms.module.name>com.twelvemonkeys.imageio.clippath</project.jpms.module.name>
+    </properties>
+
    <dependencies>
        <dependency>
            <groupId>com.twelvemonkeys.imageio</groupId>
@@ -21,6 +25,7 @@
            <groupId>com.twelvemonkeys.imageio</groupId>
            <artifactId>imageio-core</artifactId>
            <type>test-jar</type>
+            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.twelvemonkeys.imageio</groupId>
@@ -39,6 +39,7 @@ import java.io.IOException;
 *
 * @deprecated Use {@link AdobePathReader} instead. This class will be removed in a future release.
 */
+@Deprecated
 public final class AdobePathBuilder {

    private final AdobePathReader delegate;
@@ -107,8 +107,8 @@ final class AdobePathSegment {
            case OPEN_SUBPATH_BEZIER_LINKED:
            case OPEN_SUBPATH_BEZIER_UNLINKED:
                isTrue(
-                        cppx >= 0 && cppx <= 1 && cppy >= 0 && cppy <= 1,
-                        String.format("Expected point in range [0...1]: (%f, %f)", cppx ,cppy)
+                        cppx >= -16 && cppx <= 16 && cppy >= -16 && cppy <= 16,
+                        String.format("Expected point in range [-16...16]: (%f, %f)", cppx ,cppy)
                );
                break;
            case PATH_FILL_RULE_RECORD:
@@ -56,6 +56,8 @@ import java.awt.image.BufferedImage;
 import java.awt.image.RenderedImage;
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.SequenceInputStream;
 import java.nio.charset.StandardCharsets;
 import java.util.Iterator;
 import java.util.List;
@@ -131,7 +133,13 @@ public final class Paths {
            List<JPEGSegment> photoshop = JPEGSegmentUtil.readSegments(stream, segmentIdentifiers);

            if (!photoshop.isEmpty()) {
-                return readPathFromPhotoshopResources(new MemoryCacheImageInputStream(photoshop.get(0).data()));
+                InputStream data = null;
+
+                for (JPEGSegment ps : photoshop) {
+                    data = data == null ? ps.data() : new SequenceInputStream(data, ps.data());
+                }
+
+                return readPathFromPhotoshopResources(new MemoryCacheImageInputStream(data));
            }
        }
        else if (magic >>> 16 == TIFF.BYTE_ORDER_MARK_BIG_ENDIAN && (magic & 0xffff) == TIFF.TIFF_MAGIC
@@ -350,10 +358,10 @@ public final class Paths {
                IIOMetadataNode unknown = new IIOMetadataNode("unknown");
                unknown.setAttribute("MarkerTag", Integer.toString(JPEG.APP13 & 0xFF));

-                byte[] identfier = "Photoshop 3.0".getBytes(StandardCharsets.US_ASCII);
-                byte[] data = new byte[identfier.length + 1 + pathResource.length];
-                System.arraycopy(identfier, 0, data, 0, identfier.length);
-                System.arraycopy(pathResource, 0, data, identfier.length + 1, pathResource.length);
+                byte[] identifier = "Photoshop 3.0".getBytes(StandardCharsets.US_ASCII);
+                byte[] data = new byte[identifier.length + 1 + pathResource.length];
+                System.arraycopy(identifier, 0, data, 0, identifier.length);
+                System.arraycopy(pathResource, 0, data, identifier.length + 1, pathResource.length);

                unknown.setUserObject(data);

@@ -113,8 +113,13 @@ public class AdobePathSegmentTest {
    }

    @Test(expected = IllegalArgumentException.class)
-    public void testCreateOpenLinkedRecordNegative() {
-        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, -.5, -.5, 0, 0, 1, 1);
+    public void testCreateOpenLinkedRecordOutOfRangeNegative() {
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, -16.1, -16.1, 0, 0, 1, 1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateOpenLinkedRecordOutOfRangePositive() {
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, 16.1, 16.1, 0, 0, 1, 1);
    }

    @Test
@@ -138,8 +143,13 @@ public class AdobePathSegmentTest {


    @Test(expected = IllegalArgumentException.class)
-    public void testCreateOpenUnlinkedRecordNegative() {
-        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, -.5, -.5, 0, 0, 1, 1);
+    public void testCreateOpenUnlinkedRecordOutOfRangeNegative() {
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, -16.5, 0, 0, 0, 1, 1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateOpenUnlinkedRecorOutOfRangePositive() {
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, 0, -17, 0, 0, 16.5, 1);
    }

    /// Closed subpath
@@ -164,8 +174,13 @@ public class AdobePathSegmentTest {
    }

    @Test(expected = IllegalArgumentException.class)
-    public void testCreateClosedLinkedRecordNegative() {
-        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, -.5, -.5, 0, 0, 1, 1);
+    public void testCreateClosedLinkedRecordOutOfRangeNegative() {
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, -16.5, -.5, 0, 0, 1, 1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateClosedLinkedRecordOutOfRangePositive() {
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, .5, 16.5, 0, 0, 1, 1);
    }

    @Test
@@ -189,8 +204,13 @@ public class AdobePathSegmentTest {


    @Test(expected = IllegalArgumentException.class)
-    public void testCreateClosedUnlinkedRecordNegative() {
-        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, -.5, -.5, 0, 0, 1, 1);
+    public void testCreateClosedUnlinkedRecordOutOfRangeNegative() {
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, -.5, -16.5, 0, 0, 1, 1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateClosedUnlinkedRecordOutOfRangePositive() {
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, 16.5, .5, 0, 0, 1, 1);
    }

    @Test
@@ -4,11 +4,15 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.5</version>
+        <version>3.8.4-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-core</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Core</name>

+    <properties>
+        <project.jpms.module.name>com.twelvemonkeys.imageio.core</project.jpms.module.name>
+    </properties>
+
    <dependencies>
        <dependency>
            <groupId>com.twelvemonkeys.common</groupId>
@@ -265,8 +265,9 @@ public abstract class ImageReaderBase extends ImageReader {
                        // - transferType is ok
                        // - bands are ok
                        // TODO: Test if color model is ok?
-                        if (specifier.getSampleModel().getTransferType() == dest.getSampleModel().getTransferType() &&
-                                specifier.getNumBands() <= dest.getSampleModel().getNumBands()) {
+                        if (specifier.getSampleModel().getTransferType() == dest.getSampleModel().getTransferType()
+                                && Arrays.equals(specifier.getSampleModel().getSampleSize(), dest.getSampleModel().getSampleSize())
+                                && specifier.getNumBands() <= dest.getSampleModel().getNumBands()) {
                            found = true;
                            break;
                        }
@@ -314,12 +315,12 @@ public abstract class ImageReaderBase extends ImageReader {

        long dimension = (long) destWidth * destHeight;
        if (dimension > Integer.MAX_VALUE) {
-            throw new IllegalArgumentException(String.format("destination width * height > Integer.MAX_VALUE: %d", dimension));
+            throw new IIOException(String.format("destination width * height > Integer.MAX_VALUE: %d", dimension));
        }

        long size = dimension * imageType.getSampleModel().getNumDataElements();
        if (size > Integer.MAX_VALUE) {
-            throw new IllegalArgumentException(String.format("destination width * height * samplesPerPixel > Integer.MAX_VALUE: %d", size));
+            throw new IIOException(String.format("destination width * height * samplesPerPixel > Integer.MAX_VALUE: %d", size));
        }

        // Create a new image based on the type specifier
@@ -440,6 +441,7 @@ public abstract class ImageReaderBase extends ImageReader {
        static final String ZOOM_IN = "zoom-in";
        static final String ZOOM_OUT = "zoom-out";
        static final String ZOOM_ACTUAL = "zoom-actual";
+        static final String ZOOM_FIT = "zoom-fit";

        private BufferedImage image;

@@ -515,9 +517,20 @@ public abstract class ImageReaderBase extends ImageReader {

        private void setupActions() {
            // Mac weirdness... VK_MINUS/VK_PLUS seems to map to english key map always...
-            bindAction(new ZoomAction("Zoom in", 2), ZOOM_IN, KeyStroke.getKeyStroke('+'), KeyStroke.getKeyStroke(KeyEvent.VK_ADD, 0));
-            bindAction(new ZoomAction("Zoom out", .5), ZOOM_OUT, KeyStroke.getKeyStroke('-'), KeyStroke.getKeyStroke(KeyEvent.VK_SUBTRACT, 0));
-            bindAction(new ZoomAction("Zoom actual"), ZOOM_ACTUAL, KeyStroke.getKeyStroke('0'), KeyStroke.getKeyStroke(KeyEvent.VK_0, 0));
+            bindAction(new ZoomAction("Zoom in", 2), ZOOM_IN,
+                    KeyStroke.getKeyStroke('+'),
+                    KeyStroke.getKeyStroke(KeyEvent.VK_PLUS, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()),
+                    KeyStroke.getKeyStroke(KeyEvent.VK_ADD, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+            bindAction(new ZoomAction("Zoom out", .5), ZOOM_OUT,
+                    KeyStroke.getKeyStroke('-'),
+                    KeyStroke.getKeyStroke(KeyEvent.VK_MINUS, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()),
+                    KeyStroke.getKeyStroke(KeyEvent.VK_SUBTRACT, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+            bindAction(new ZoomAction("Zoom actual"), ZOOM_ACTUAL,
+                    KeyStroke.getKeyStroke('0'),
+                    KeyStroke.getKeyStroke(KeyEvent.VK_0, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+            bindAction(new ZoomToFitAction("Zoom fit"), ZOOM_FIT,
+                    KeyStroke.getKeyStroke('9'),
+                    KeyStroke.getKeyStroke(KeyEvent.VK_9, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));

            bindAction(TransferHandler.getCopyAction(), (String) TransferHandler.getCopyAction().getValue(Action.NAME), KeyStroke.getKeyStroke(KeyEvent.VK_C, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
            bindAction(TransferHandler.getPasteAction(), (String) TransferHandler.getPasteAction().getValue(Action.NAME), KeyStroke.getKeyStroke(KeyEvent.VK_V, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
@@ -534,6 +547,7 @@ public abstract class ImageReaderBase extends ImageReader {
        private JPopupMenu createPopupMenu() {
            JPopupMenu popup = new JPopupMenu();

+            popup.add(getActionMap().get(ZOOM_FIT));
            popup.add(getActionMap().get(ZOOM_ACTUAL));
            popup.add(getActionMap().get(ZOOM_IN));
            popup.add(getActionMap().get(ZOOM_OUT));
@@ -554,7 +568,7 @@ public abstract class ImageReaderBase extends ImageReader {
            addCheckBoxItem(new ChangeBackgroundAction("Dark", Color.DARK_GRAY), background, group);
            addCheckBoxItem(new ChangeBackgroundAction("Black", Color.BLACK), background, group);
            background.addSeparator();
-            ChooseBackgroundAction chooseBackgroundAction = new ChooseBackgroundAction("Choose...", defaultBG != null ? defaultBG : Color.BLUE);
+            ChooseBackgroundAction chooseBackgroundAction = new ChooseBackgroundAction("Choose...", defaultBG != null ? defaultBG : new Color(0xFF6600));
            chooseBackgroundAction.putValue(Action.SELECTED_KEY, backgroundPaint == defaultBG);
            addCheckBoxItem(chooseBackgroundAction, background, group);

@@ -668,14 +682,41 @@ public abstract class ImageReaderBase extends ImageReader {
                }
                else {
                    Icon current = getIcon();
-                    int w = (int) Math.max(Math.min(current.getIconWidth() * zoomFactor, image.getWidth() * 16), image.getWidth() / 16);
-                    int h = (int) Math.max(Math.min(current.getIconHeight() * zoomFactor, image.getHeight() * 16), image.getHeight() / 16);
+                    int w = Math.max(Math.min((int) (current.getIconWidth() * zoomFactor), image.getWidth() * 16), image.getWidth() / 16);
+                    int h = Math.max(Math.min((int) (current.getIconHeight() * zoomFactor), image.getHeight() * 16), image.getHeight() / 16);

                    setIcon(new BufferedImageIcon(image, Math.max(w, 2), Math.max(h, 2), w > image.getWidth() || h > image.getHeight()));
                }
            }
        }

+        private class ZoomToFitAction extends ZoomAction {
+            public ZoomToFitAction(final String name) {
+                super(name, -1);
+            }
+
+            public void actionPerformed(final ActionEvent e) {
+                JComponent source = (JComponent) e.getSource();
+
+                if (source instanceof JMenuItem) {
+                    JPopupMenu menu = (JPopupMenu) SwingUtilities.getAncestorOfClass(JPopupMenu.class, source);
+                    source = (JComponent) menu.getInvoker();
+                }
+
+                Container container = SwingUtilities.getAncestorOfClass(JViewport.class, source);
+
+                double ratioX = container.getWidth() / (double) image.getWidth();
+                double ratioY = container.getHeight() / (double) image.getHeight();
+
+                double zoomFactor = Math.min(ratioX, ratioY);
+
+                int w = Math.max(Math.min((int) (image.getWidth() * zoomFactor), image.getWidth() * 16), image.getWidth() / 16);
+                int h = Math.max(Math.min((int) (image.getHeight() * zoomFactor), image.getHeight() * 16), image.getHeight() / 16);
+
+                setIcon(new BufferedImageIcon(image, w, h, zoomFactor > 1));
+            }
+        }
+
        private static class ImageTransferable implements Transferable {
            private final BufferedImage image;

@@ -694,7 +735,7 @@ public abstract class ImageReaderBase extends ImageReader {
            }

            @Override
-            public Object getTransferData(final DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+            public Object getTransferData(final DataFlavor flavor) throws UnsupportedFlavorException {
                if (isDataFlavorSupported(flavor)) {
                    return image;
                }
@@ -0,0 +1,563 @@
+/*
+ * Copyright (c) 2021, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.color;
+
+import com.twelvemonkeys.io.FileUtil;
+import com.twelvemonkeys.lang.Platform;
+import com.twelvemonkeys.lang.SystemUtil;
+import com.twelvemonkeys.lang.Validate;
+
+import java.awt.color.ColorSpace;
+import java.awt.color.ICC_ColorSpace;
+import java.awt.color.ICC_Profile;
+import java.io.DataInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+import java.util.Properties;
+
+import static com.twelvemonkeys.imageio.color.ColorSpaces.DEBUG;
+
+/**
+ * A helper class for working with ICC color profiles.
+ * <p>
+ * Standard ICC color profiles are read from system-specific locations
+ * for known operating systems.
+ * </p>
+ * <p>
+ * Color profiles may be configured by placing a property-file
+ * {@code com/twelvemonkeys/imageio/color/icc_profiles.properties}
+ * on the classpath, specifying the full path to the profiles.
+ * ICC color profiles are probably already present on your system, or
+ * can be downloaded from
+ * <a href="http://www.color.org/profiles2.xalter">ICC</a>,
+ * <a href="http://www.adobe.com/downloads/">Adobe</a> or other places.
+ * * </p>
+ * <p>
+ * Example property file:
+ * </p>
+ * <pre>
+ * # icc_profiles.properties
+ * ADOBE_RGB_1998=/path/to/Adobe RGB 1998.icc
+ * GENERIC_CMYK=/path/to/Generic CMYK.icc
+ * </pre>
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: ColorSpaces.java,v 1.0 24.01.11 17.51 haraldk Exp$
+ */
+public final class ColorProfiles {
+    /**
+     * We need special ICC profile handling for KCMS vs LCMS. Delegate to specific strategy.
+     */
+    private final static ICCProfileSanitizer profileCleaner = ICCProfileSanitizer.Factory.get();
+
+    static final int ICC_PROFILE_MAGIC = 'a' << 24 | 'c' << 16 | 's' << 8 | 'p';
+    static final int ICC_PROFILE_HEADER_SIZE = 128;
+
+    static {
+        // In case we didn't activate through SPI already
+        ProfileDeferralActivator.activateProfiles();
+    }
+
+    private ColorProfiles() {
+    }
+
+    static byte[] getProfileHeaderWithProfileId(final ICC_Profile profile) {
+        // Get *entire profile data*... :-/
+        return getProfileHeaderWithProfileId(profile.getData());
+    }
+
+    static byte[] getProfileHeaderWithProfileId(byte[] data) {
+        // ICC profile header is the first 128 bytes
+        byte[] header = Arrays.copyOf(data, ICC_PROFILE_HEADER_SIZE);
+
+        // Clear out preferred CMM, platform & creator, as these don't affect the profile in any way
+        // - LCMS updates CMM + creator to "lcms" and platform to current platform
+        // - KCMS keeps the values in the file...
+        Arrays.fill(header, ICC_Profile.icHdrCmmId, ICC_Profile.icHdrCmmId + 4, (byte) 0);
+        Arrays.fill(header, ICC_Profile.icHdrPlatform, ICC_Profile.icHdrPlatform + 4, (byte) 0);
+        // + Clear out rendering intent, as this may be updated by application
+        Arrays.fill(header, ICC_Profile.icHdrRenderingIntent, ICC_Profile.icHdrRenderingIntent + 4, (byte) 0);
+        Arrays.fill(header, ICC_Profile.icHdrCreator, ICC_Profile.icHdrCreator + 4, (byte) 0);
+
+        // Clear out any existing MD5, as it is no longer correct
+        Arrays.fill(header, ICC_Profile.icHdrProfileID, ICC_Profile.icHdrProfileID + 16, (byte) 0);
+
+        // Generate new MD5 and store in header
+        byte[] md5 = computeMD5(header, data);
+        System.arraycopy(md5, 0, header, ICC_Profile.icHdrProfileID, md5.length);
+
+        return header;
+    }
+
+    private static byte[] computeMD5(byte[] header, byte[] data) {
+        try {
+            MessageDigest digest = MessageDigest.getInstance("MD5");
+            digest.update(header, 0, ICC_PROFILE_HEADER_SIZE);
+            digest.update(data, ICC_PROFILE_HEADER_SIZE, data.length - ICC_PROFILE_HEADER_SIZE);
+            return digest.digest();
+        }
+        catch (NoSuchAlgorithmException e) {
+            throw new IllegalStateException("Missing MD5 MessageDigest");
+        }
+    }
+
+    /**
+     * Tests whether an ICC color profile is equal to the default sRGB profile.
+     *
+     * @param profile the ICC profile to test. May not be {@code null}.
+     * @return {@code true} if {@code profile} is equal to the default sRGB profile.
+     * @throws IllegalArgumentException if {@code profile} is {@code null}
+     * @see java.awt.color.ColorSpace#CS_sRGB
+     * @see java.awt.color.ColorSpace#isCS_sRGB()
+     */
+    public static boolean isCS_sRGB(final ICC_Profile profile) {
+        Validate.notNull(profile, "profile");
+
+        return profile.getColorSpaceType() == ColorSpace.TYPE_RGB && Arrays.equals(getProfileHeaderWithProfileId(profile), sRGB.header);
+    }
+
+    /**
+     * Tests whether an ICC color profile is equal to the default GRAY profile.
+     *
+     * @param profile the ICC profile to test. May not be {@code null}.
+     * @return {@code true} if {@code profile} is equal to the default GRAY profile.
+     * @throws IllegalArgumentException if {@code profile} is {@code null}
+     * @see java.awt.color.ColorSpace#CS_GRAY
+     */
+    public static boolean isCS_GRAY(final ICC_Profile profile) {
+        Validate.notNull(profile, "profile");
+
+        return profile.getColorSpaceType() == ColorSpace.TYPE_GRAY && Arrays.equals(getProfileHeaderWithProfileId(profile), GRAY.header);
+    }
+
+    /**
+     * Tests whether an ICC color profile is known to cause problems for {@link java.awt.image.ColorConvertOp}.
+     * <p>
+     * <em>
+     * Note that this method only tests if a color conversion using this profile is known to fail.
+     * There's no guarantee that the color conversion will succeed even if this method returns {@code false}.
+     * </em>
+     * </p>
+     *
+     * @param profile the ICC color profile. May not be {@code null}.
+     * @return {@code true} if known to be offending, {@code false} otherwise
+     * @throws IllegalArgumentException if {@code profile} is {@code null}
+     */
+    static boolean isOffendingColorProfile(final ICC_Profile profile) {
+        Validate.notNull(profile, "profile");
+
+        // NOTE:
+        // Several embedded ICC color profiles are non-compliant with Java pre JDK7 and throws CMMException
+        // The problem with these embedded ICC profiles seems to be the rendering intent
+        // being 1 (01000000) - "Media Relative Colormetric" in the offending profiles,
+        // and 0 (00000000) - "Perceptual" in the good profiles
+        // (that is 1 single bit of difference right there.. ;-)
+        // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7064516
+
+        // This is particularly annoying, as the byte copying isn't really necessary,
+        // except the getRenderingIntent method is package protected in java.awt.color
+        byte[] header = profile.getData(ICC_Profile.icSigHead);
+
+        return header[ICC_Profile.icHdrRenderingIntent] != 0 || header[ICC_Profile.icHdrRenderingIntent + 1] != 0
+                || header[ICC_Profile.icHdrRenderingIntent + 2] != 0 || header[ICC_Profile.icHdrRenderingIntent + 3] > 3;
+    }
+
+    /**
+     * Tests whether an ICC color profile is valid.
+     * Invalid profiles are known to cause problems for {@link java.awt.image.ColorConvertOp}.
+     * <p>
+     * <em>
+     * Note that this method only tests if a color conversion using this profile is known to fail.
+     * There's no guarantee that the color conversion will succeed even if this method returns {@code false}.
+     * </em>
+     * </p>
+     *
+     * @param profile the ICC color profile. May not be {@code null}.
+     * @return {@code profile} if valid.
+     * @throws IllegalArgumentException    if {@code profile} is {@code null}
+     * @throws java.awt.color.CMMException if {@code profile} is invalid.
+     */
+    public static ICC_Profile validateProfile(final ICC_Profile profile) {
+        // Fix profile before validation
+        profileCleaner.fixProfile(profile);
+        ColorSpaces.validateColorSpace(new ICC_ColorSpace(profile)); // TODO: Should use createColorSpace and cache if good?
+
+        return profile;
+    }
+
+    /**
+     * Reads an ICC Profile from the given input stream, as-is, with no validation.
+     *
+     * This method behaves exactly like {@code ICC_Profile.getInstance(input)}.
+     *
+     * @param input the input stream to read from, may not be {@code null}
+     * @return an {@code ICC_Profile} object as read from the input stream.
+     * @throws IOException              If an I/O error occurs while reading the stream.
+     * @throws IllegalArgumentException If {@code input} is {@code null}
+     *                                  or the stream does not contain valid ICC Profile data.
+     * @see ICC_Profile#getInstance(InputStream)
+     * @see #readProfile(InputStream)
+     */
+    public static ICC_Profile readProfileRaw(final InputStream input) throws IOException {
+        Validate.notNull(input, "input");
+
+        return ICC_Profile.getInstance(input);
+    }
+
+    /**
+     * Reads an ICC Profile from the given input stream, with extra validation.
+     *
+     * If a matching profile already exists in cache, the cached instance is returned.
+     *
+     * @param input the input stream to read from, may not be {@code null}
+     * @return an {@code ICC_Profile} object as read from the input stream.
+     * @throws IOException              If an I/O error occurs while reading the stream.
+     * @throws IllegalArgumentException If {@code input} is {@code null}
+     *                                  or the stream does not contain valid ICC Profile data.
+     * @see ICC_Profile#getInstance(InputStream)
+     */
+    public static ICC_Profile readProfile(final InputStream input) throws IOException {
+        Validate.notNull(input, "input");
+
+        DataInputStream dataInput = new DataInputStream(input);
+        byte[] header = new byte[ICC_PROFILE_HEADER_SIZE];
+        try {
+            dataInput.readFully(header);
+
+            int size = validateHeaderAndGetSize(header);
+            byte[] data = Arrays.copyOf(header, size);
+            dataInput.readFully(data, header.length, size - header.length);
+
+            return createProfile(data);
+        }
+        catch (EOFException e) {
+            throw new IllegalArgumentException("Truncated ICC Profile data", e);
+        }
+    }
+
+    /**
+     * Creates an ICC Profile from the given byte array, as-is, with no validation.
+     *
+     * This method behaves exactly like {@code ICC_Profile.getInstance(input)},
+     * except that extraneous bytes at the end of the array is ignored.
+     *
+     * @param input the byte array to create a profile from, may not be {@code null}
+     * @return an {@code ICC_Profile} object created from the byte array
+     * @throws IllegalArgumentException If {@code input} is {@code null}
+     *                                  or the byte array does not contain valid ICC Profile data.
+     * @see ICC_Profile#getInstance(byte[])
+     * @see #createProfile(byte[])
+     */
+    public static ICC_Profile createProfileRaw(final byte[] input) {
+        int size = validateHeaderAndGetSize(input);
+
+        // Unlike the InputStream version, the byte version of ICC_Profile.getInstance()
+        // does not discard extra bytes at the end. We'll chop them off here for convenience
+        return ICC_Profile.getInstance(limit(input, size));
+    }
+
+    /**
+     * Reads an ICC Profile from the given byte array, with extra validation.
+     * Extraneous bytes at the end of the array are ignored.
+     *
+     * If a matching profile already exists in cache, the cached instance is returned.
+     *
+     * @param input the byte array to create a profile from, may not be {@code null}
+     * @return an {@code ICC_Profile} object created from the byte array
+     * @throws IllegalArgumentException If {@code input} is {@code null}
+     *                                  or the byte array does not contain valid ICC Profile data.
+     * @see ICC_Profile#getInstance(byte[])
+     */
+    public static ICC_Profile createProfile(final byte[] input) {
+        int size = validateAndGetSize(input);
+
+        // Look up in cache before returning, these are already validated
+        byte[] profileHeader = getProfileHeaderWithProfileId(input);
+        ICC_Profile internal = getInternalProfile(profileHeader);
+        if (internal != null) {
+            return internal;
+        }
+
+        ICC_ColorSpace cached = ColorSpaces.getCachedCS(profileHeader);
+        if (cached != null) {
+            return cached.getProfile();
+        }
+
+        ICC_Profile profile = ICC_Profile.getInstance(limit(input, size));
+
+        // We'll validate & cache by creating a color space and returning its profile...
+        // TODO: Rewrite with separate cache for profiles...
+        return ColorSpaces.createColorSpace(profile).getProfile();
+    }
+
+    private static byte[] limit(byte[] input, int size) {
+        return input.length == size ? input : Arrays.copyOf(input, size);
+    }
+
+    private static int validateAndGetSize(byte[] input) {
+        int size = validateHeaderAndGetSize(input);
+
+        if (size < 0 || size > input.length) {
+            throw new IllegalArgumentException("Truncated ICC profile data, length < " + size + ": " + input.length);
+        }
+
+        return size;
+    }
+
+    private static int validateHeaderAndGetSize(byte[] input) {
+        Validate.notNull(input, "input");
+
+        if (input.length < ICC_PROFILE_HEADER_SIZE) { // Can't be less than size of ICC header
+            throw new IllegalArgumentException("Truncated ICC profile data, length < 128: " + input.length);
+        }
+
+        int size = intBigEndian(input, ICC_Profile.icHdrSize);
+
+        if (intBigEndian(input, ICC_Profile.icHdrMagic) != ICC_PROFILE_MAGIC) {
+            throw new IllegalArgumentException("Not an ICC profile, missing file signature");
+        }
+
+        return size;
+    }
+
+    private static ICC_Profile getInternalProfile(final byte[] profileHeader) {
+        int profileCSType = getCsType(profileHeader);
+
+        if (profileCSType == ColorSpace.TYPE_RGB && Arrays.equals(profileHeader, ColorProfiles.sRGB.header)) {
+            return ICC_Profile.getInstance(ColorSpace.CS_sRGB);
+        }
+        else if (profileCSType == ColorSpace.TYPE_GRAY && Arrays.equals(profileHeader, ColorProfiles.GRAY.header)) {
+            return ICC_Profile.getInstance(ColorSpace.CS_GRAY);
+        }
+        else if (profileCSType == ColorSpace.TYPE_3CLR && Arrays.equals(profileHeader, ColorProfiles.PYCC.header)) {
+            return ICC_Profile.getInstance(ColorSpace.CS_PYCC);
+        }
+        else if (profileCSType == ColorSpace.TYPE_RGB && Arrays.equals(profileHeader, ColorProfiles.LINEAR_RGB.header)) {
+            return ICC_Profile.getInstance(ColorSpace.CS_LINEAR_RGB);
+        }
+        else if (profileCSType == ColorSpace.TYPE_XYZ && Arrays.equals(profileHeader, ColorProfiles.CIEXYZ.header)) {
+            return ICC_Profile.getInstance(ColorSpace.CS_CIEXYZ);
+        }
+
+        return null;
+    }
+
+    private static int intBigEndian(byte[] data, int index) {
+        return (data[index] & 0xff) << 24 | (data[index + 1] & 0xff) << 16 | (data[index + 2] & 0xff) << 8 | (data[index + 3] & 0xff);
+    }
+
+    private static int getCsType(byte[] profileHeader) {
+        int csSig = intBigEndian(profileHeader, ICC_Profile.icHdrColorSpace);
+
+        switch (csSig) {
+            case ICC_Profile.icSigXYZData:
+                return ColorSpace.TYPE_XYZ;
+            case ICC_Profile.icSigLabData:
+                return ColorSpace.TYPE_Lab;
+            case ICC_Profile.icSigLuvData:
+                return ColorSpace.TYPE_Luv;
+            case ICC_Profile.icSigYCbCrData:
+                return ColorSpace.TYPE_YCbCr;
+            case ICC_Profile.icSigYxyData:
+                return ColorSpace.TYPE_Yxy;
+            case ICC_Profile.icSigRgbData:
+                return ColorSpace.TYPE_RGB;
+            case ICC_Profile.icSigGrayData:
+                return ColorSpace.TYPE_GRAY;
+            case ICC_Profile.icSigHsvData:
+                return ColorSpace.TYPE_HSV;
+            case ICC_Profile.icSigHlsData:
+                return ColorSpace.TYPE_HLS;
+            case ICC_Profile.icSigCmykData:
+                return ColorSpace.TYPE_CMYK;
+            // Note: There is no TYPE_* 10...
+            case ICC_Profile.icSigCmyData:
+                return ColorSpace.TYPE_CMY;
+            case ICC_Profile.icSigSpace2CLR:
+                return ColorSpace.TYPE_2CLR;
+            case ICC_Profile.icSigSpace3CLR:
+                return ColorSpace.TYPE_3CLR;
+            case ICC_Profile.icSigSpace4CLR:
+                return ColorSpace.TYPE_4CLR;
+            case ICC_Profile.icSigSpace5CLR:
+                return ColorSpace.TYPE_5CLR;
+            case ICC_Profile.icSigSpace6CLR:
+                return ColorSpace.TYPE_6CLR;
+            case ICC_Profile.icSigSpace7CLR:
+                return ColorSpace.TYPE_7CLR;
+            case ICC_Profile.icSigSpace8CLR:
+                return ColorSpace.TYPE_8CLR;
+            case ICC_Profile.icSigSpace9CLR:
+                return ColorSpace.TYPE_9CLR;
+            case ICC_Profile.icSigSpaceACLR:
+                return ColorSpace.TYPE_ACLR;
+            case ICC_Profile.icSigSpaceBCLR:
+                return ColorSpace.TYPE_BCLR;
+            case ICC_Profile.icSigSpaceCCLR:
+                return ColorSpace.TYPE_CCLR;
+            case ICC_Profile.icSigSpaceDCLR:
+                return ColorSpace.TYPE_DCLR;
+            case ICC_Profile.icSigSpaceECLR:
+                return ColorSpace.TYPE_ECLR;
+            case ICC_Profile.icSigSpaceFCLR:
+                return ColorSpace.TYPE_FCLR;
+            default:
+                throw new IllegalArgumentException("Invalid ICC color space signature: " + csSig); // TODO: fourCC?
+        }
+    }
+
+    static ICC_Profile readProfileFromClasspathResource(@SuppressWarnings("SameParameterValue") final String profilePath) {
+        InputStream stream = ColorSpaces.class.getResourceAsStream(profilePath);
+
+        if (stream != null) {
+            if (DEBUG) {
+                System.out.println("Loading profile from classpath resource: " + profilePath);
+            }
+
+            try {
+                return ICC_Profile.getInstance(stream);
+            }
+            catch (@SuppressWarnings("CatchMayIgnoreException") IOException ignore) {
+                if (DEBUG) {
+                    ignore.printStackTrace();
+                }
+            }
+            finally {
+                FileUtil.close(stream);
+            }
+        }
+
+        return null;
+    }
+
+    static ICC_Profile readProfileFromPath(final String profilePath) {
+        if (profilePath != null) {
+            if (DEBUG) {
+                System.out.println("Loading profile from: " + profilePath);
+            }
+
+            try {
+                return ICC_Profile.getInstance(profilePath);
+            }
+            catch (@SuppressWarnings("CatchMayIgnoreException") SecurityException | IOException ignore) {
+                if (DEBUG) {
+                    ignore.printStackTrace();
+                }
+            }
+        }
+
+        return null;
+    }
+
+    static void fixProfile(ICC_Profile profile) {
+        profileCleaner.fixProfile(profile);
+    }
+
+    static boolean validationAltersProfileHeader() {
+        return profileCleaner.validationAltersProfileHeader();
+    }
+
+    // Cache header profile data to avoid excessive array creation/copying. Use static inner class for on-demand lazy init
+    static class sRGB {
+        static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_sRGB));
+    }
+
+    static class CIEXYZ {
+        static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_CIEXYZ));
+    }
+
+    static class PYCC {
+        static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_PYCC));
+    }
+
+    static class GRAY {
+        static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_GRAY));
+    }
+
+    static class LINEAR_RGB {
+        static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_LINEAR_RGB));
+    }
+
+    static class Profiles {
+        // TODO: Honour java.iccprofile.path property?
+        private static final Properties PROFILES = loadProfiles();
+
+        private static Properties loadProfiles() {
+            Properties systemDefaults;
+
+            try {
+                systemDefaults = SystemUtil.loadProperties(ColorSpaces.class, "com/twelvemonkeys/imageio/color/icc_profiles_" + Platform.os().id());
+            }
+            catch (@SuppressWarnings("CatchMayIgnoreException") SecurityException | IOException ignore) {
+                System.err.printf(
+                        "Warning: Could not load system default ICC profile locations from %s, will use bundled fallback profiles.\n",
+                        ignore.getMessage()
+                );
+
+                if (DEBUG) {
+                    ignore.printStackTrace();
+                }
+
+                systemDefaults = null;
+            }
+
+            // Create map with defaults and add user overrides if any
+            Properties profiles = new Properties(systemDefaults);
+
+            try {
+                Properties userOverrides = SystemUtil.loadProperties(
+                        ColorSpaces.class,
+                        "com/twelvemonkeys/imageio/color/icc_profiles"
+                );
+                profiles.putAll(userOverrides);
+            }
+            catch (SecurityException | IOException ignore) {
+                // Most likely, this file won't be there
+            }
+
+            if (DEBUG) {
+                System.out.println("User ICC profiles: " + profiles);
+                System.out.println("System ICC profiles : " + systemDefaults);
+            }
+
+            return profiles;
+        }
+
+        static String getPath(final String profileName) {
+            return PROFILES.getProperty(profileName);
+        }
+    }
+}
@@ -30,23 +30,17 @@

 package com.twelvemonkeys.imageio.color;

-import com.twelvemonkeys.io.FileUtil;
-import com.twelvemonkeys.lang.Platform;
-import com.twelvemonkeys.lang.SystemUtil;
 import com.twelvemonkeys.lang.Validate;
 import com.twelvemonkeys.util.LRUHashMap;

 import java.awt.color.ColorSpace;
 import java.awt.color.ICC_ColorSpace;
 import java.awt.color.ICC_Profile;
-import java.io.IOException;
-import java.io.InputStream;
 import java.lang.ref.WeakReference;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;
 import java.util.Map;
-import java.util.Properties;
+
+import static com.twelvemonkeys.imageio.color.ColorProfiles.*;

 /**
 * A helper class for working with ICC color profiles and color spaces.
@@ -83,9 +77,6 @@ public final class ColorSpaces {

    final static boolean DEBUG = "true".equalsIgnoreCase(System.getProperty("com.twelvemonkeys.imageio.color.debug"));

-    /** We need special ICC profile handling for KCMS vs LCMS. Delegate to specific strategy. */
-    private final static ICCProfileSanitizer profileCleaner = ICCProfileSanitizer.Factory.get();
-
    // NOTE: java.awt.color.ColorSpace.CS_* uses 1000-1004, we'll use 5000+ to not interfere with future additions

    /** The Adobe RGB 1998 (or compatible) color space. Either read from disk or built-in. */
@@ -96,24 +87,17 @@ public final class ColorSpaces {
    @SuppressWarnings("WeakerAccess")
    public static final int CS_GENERIC_CMYK = 5001;

+    // TODO: Move to ColorProfiles OR cache ICC_ColorSpace instead?
    // Weak references to hold the color spaces while cached
    private static WeakReference<ICC_Profile> adobeRGB1998 = new WeakReference<>(null);
    private static WeakReference<ICC_Profile> genericCMYK = new WeakReference<>(null);

    // Cache for the latest used color spaces
-    private static final Map<Key, ICC_ColorSpace> cache = new LRUHashMap<>(10);
+    private static final Map<Key, ICC_ColorSpace> cache = new LRUHashMap<>(16);

    static {
-        try {
-            // Force invocation of ProfileDeferralMgr.activateProfiles() to avoid JDK-6986863
-            ICC_Profile.getInstance(ColorSpace.CS_sRGB).getData();
-        }
-        catch (Throwable disasters) {
-            System.err.println("ICC Color Profile not properly activated due to the exception below.");
-            System.err.println("Expect to see JDK-6986863 in action, and consider filing a bug report to your JRE provider.");
-
-            disasters.printStackTrace();
-        }
+        // In case we didn't activate through SPI already
+        ProfileDeferralActivator.activateProfiles();
    }

    private ColorSpaces() {}
@@ -134,7 +118,7 @@ public final class ColorSpaces {
        Validate.notNull(profile, "profile");

        // Fix profile before lookup/create
-        profileCleaner.fixProfile(profile);
+        fixProfile(profile);

        byte[] profileHeader = getProfileHeaderWithProfileId(profile);

@@ -146,53 +130,20 @@ public final class ColorSpaces {
        return getCachedOrCreateCS(profile, profileHeader);
    }

-    private static byte[] getProfileHeaderWithProfileId(final ICC_Profile profile) {
-        // Get *entire profile data*... :-/
-        byte[] data = profile.getData();
-
-        // Clear out preferred CMM, platform & creator, as these does not affect the profile in any way
-        // - LCMS updates CMM + creator to "lcms" and platform to current platform
-        // - KCMS keeps the values in the file...
-        Arrays.fill(data, ICC_Profile.icHdrCmmId, ICC_Profile.icHdrCmmId + 4, (byte) 0);
-        Arrays.fill(data, ICC_Profile.icHdrPlatform, ICC_Profile.icHdrPlatform + 4, (byte) 0);
-        // + Clear out rendering intent, as this may be updated by application
-        Arrays.fill(data, ICC_Profile.icHdrRenderingIntent, ICC_Profile.icHdrRenderingIntent + 4, (byte) 0);
-        Arrays.fill(data, ICC_Profile.icHdrCreator, ICC_Profile.icHdrCreator + 4, (byte) 0);
-
-        // Clear out any existing MD5, as it is no longer correct
-        Arrays.fill(data, ICC_Profile.icHdrProfileID, ICC_Profile.icHdrProfileID + 16, (byte) 0);
-
-        // Generate new MD5 and store in header
-        byte[] md5 = computeMD5(data);
-        System.arraycopy(md5, 0, data, ICC_Profile.icHdrProfileID, md5.length);
-
-        // ICC profile header is the first 128 bytes
-        return Arrays.copyOf(data, 128);
-    }
-
-    private static byte[] computeMD5(byte[] data) {
-        try {
-            return MessageDigest.getInstance("MD5").digest(data);
-        }
-        catch (NoSuchAlgorithmException e) {
-            throw new IllegalStateException("Missing MD5 MessageDigest");
-        }
-    }
-
-    private static ICC_ColorSpace getInternalCS(final int profileCSType, final byte[] profileHeader) {
-        if (profileCSType == ColorSpace.TYPE_RGB && Arrays.equals(profileHeader, sRGB.header)) {
+    static ICC_ColorSpace getInternalCS(final int profileCSType, final byte[] profileHeader) {
+        if (profileCSType == ColorSpace.TYPE_RGB && Arrays.equals(profileHeader, ColorProfiles.sRGB.header)) {
            return (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_sRGB);
        }
-        else if (profileCSType == ColorSpace.TYPE_GRAY && Arrays.equals(profileHeader, GRAY.header)) {
+        else if (profileCSType == ColorSpace.TYPE_GRAY && Arrays.equals(profileHeader, ColorProfiles.GRAY.header)) {
            return (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_GRAY);
        }
-        else if (profileCSType == ColorSpace.TYPE_3CLR && Arrays.equals(profileHeader, PYCC.header)) {
+        else if (profileCSType == ColorSpace.TYPE_3CLR && Arrays.equals(profileHeader, ColorProfiles.PYCC.header)) {
            return (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_PYCC);
        }
-        else if (profileCSType == ColorSpace.TYPE_RGB && Arrays.equals(profileHeader, LINEAR_RGB.header)) {
+        else if (profileCSType == ColorSpace.TYPE_RGB && Arrays.equals(profileHeader, ColorProfiles.LINEAR_RGB.header)) {
            return (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB);
        }
-        else if (profileCSType == ColorSpace.TYPE_XYZ && Arrays.equals(profileHeader, CIEXYZ.header)) {
+        else if (profileCSType == ColorSpace.TYPE_XYZ && Arrays.equals(profileHeader, ColorProfiles.CIEXYZ.header)) {
            return (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_CIEXYZ);
        }

@@ -203,26 +154,36 @@ public final class ColorSpaces {
        Key key = new Key(profileHeader);

        synchronized (cache) {
-            ICC_ColorSpace cs = cache.get(key);
+            ICC_ColorSpace cs = getCachedCS(key);

            if (cs == null) {
                cs = new ICC_ColorSpace(profile);

                validateColorSpace(cs);

-                // On LCMS, validation *alters* the profile header, need to re-generate key
-                key = profileCleaner.validationAltersProfileHeader()
-                      ? new Key(getProfileHeaderWithProfileId(cs.getProfile()))
-                      : key;
-
                cache.put(key, cs);
+
+                // On LCMS, validation *alters* the profile header, need to re-generate key
+                if (ColorProfiles.validationAltersProfileHeader()) {
+                    cache.put(new Key(getProfileHeaderWithProfileId(cs.getProfile())), cs);
+                }
            }

            return cs;
        }
    }

-    private static void validateColorSpace(final ICC_ColorSpace cs) {
+    private static ICC_ColorSpace getCachedCS(Key profileKey) {
+        synchronized (cache) {
+            return cache.get(profileKey);
+        }
+    }
+
+    static ICC_ColorSpace getCachedCS(final byte[] profileHeader) {
+        return getCachedCS(new Key(profileHeader));
+    }
+
+    static void validateColorSpace(final ICC_ColorSpace cs) {
        // Validate the color space, to avoid caching bad profiles/color spaces
        // Will throw IllegalArgumentException or CMMException if the profile is bad
        cs.fromRGB(new float[] {0.999f, 0.5f, 0.001f});
@@ -233,73 +194,27 @@ public final class ColorSpaces {
    }

    /**
-     * Tests whether an ICC color profile is equal to the default sRGB profile.
-     *
-     * @param profile the ICC profile to test. May not be {@code null}.
-     * @return {@code true} if {@code profile} is equal to the default sRGB profile.
-     * @throws IllegalArgumentException if {@code profile} is {@code null}
-     *
-     * @see java.awt.color.ColorSpace#isCS_sRGB()
+     * @deprecated Use {@link ColorProfiles#isCS_sRGB(ICC_Profile)} instead.
     */
+    @Deprecated
    public static boolean isCS_sRGB(final ICC_Profile profile) {
-        Validate.notNull(profile, "profile");
-
-        return profile.getColorSpaceType() == ColorSpace.TYPE_RGB && Arrays.equals(getProfileHeaderWithProfileId(profile), sRGB.header);
+        return ColorProfiles.isCS_sRGB(profile);
    }

    /**
-     * Tests whether an ICC color profile is known to cause problems for {@link java.awt.image.ColorConvertOp}.
-     * <p>
-     * <em>
-     * Note that this method only tests if a color conversion using this profile is known to fail.
-     * There's no guarantee that the color conversion will succeed even if this method returns {@code false}.
-     * </em>
-     * </p>
-     *
-     * @param profile the ICC color profile. May not be {@code null}.
-     * @return {@code true} if known to be offending, {@code false} otherwise
-     * @throws IllegalArgumentException if {@code profile} is {@code null}
+     * @deprecated Use {@link ColorProfiles#isCS_GRAY(ICC_Profile)} instead.
     */
-    static boolean isOffendingColorProfile(final ICC_Profile profile) {
-        Validate.notNull(profile, "profile");
-
-        // NOTE:
-        // Several embedded ICC color profiles are non-compliant with Java pre JDK7 and throws CMMException
-        // The problem with these embedded ICC profiles seems to be the rendering intent
-        // being 1 (01000000) - "Media Relative Colormetric" in the offending profiles,
-        // and 0 (00000000) - "Perceptual" in the good profiles
-        // (that is 1 single bit of difference right there.. ;-)
-        // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7064516
-
-        // This is particularly annoying, as the byte copying isn't really necessary,
-        // except the getRenderingIntent method is package protected in java.awt.color
-        byte[] header = profile.getData(ICC_Profile.icSigHead);
-
-        return header[ICC_Profile.icHdrRenderingIntent] != 0 || header[ICC_Profile.icHdrRenderingIntent + 1] != 0
-                || header[ICC_Profile.icHdrRenderingIntent + 2] != 0 || header[ICC_Profile.icHdrRenderingIntent + 3] > 3;
+    @Deprecated
+    public static boolean isCS_GRAY(final ICC_Profile profile) {
+        return ColorProfiles.isCS_GRAY(profile);
    }

    /**
-     * Tests whether an ICC color profile is valid.
-     * Invalid profiles are known to cause problems for {@link java.awt.image.ColorConvertOp}.
-     * <p>
-     * <em>
-     * Note that this method only tests if a color conversion using this profile is known to fail.
-     * There's no guarantee that the color conversion will succeed even if this method returns {@code false}.
-     * </em>
-     * </p>
-     *
-     * @param profile the ICC color profile. May not be {@code null}.
-     * @return {@code profile} if valid.
-     * @throws IllegalArgumentException if {@code profile} is {@code null}
-     * @throws java.awt.color.CMMException if {@code profile} is invalid.
+     * @deprecated Use {@link ColorProfiles#validateProfile(ICC_Profile)} instead.
     */
+    @Deprecated
    public static ICC_Profile validateProfile(final ICC_Profile profile) {
-        // Fix profile before validation
-        profileCleaner.fixProfile(profile);
-        validateColorSpace(new ICC_ColorSpace(profile));
-
-        return profile;
+        return ColorProfiles.validateProfile(profile);
    }

    /**
@@ -382,50 +297,6 @@ public final class ColorSpaces {
        }
    }

-    @SuppressWarnings("SameParameterValue")
-    private static ICC_Profile readProfileFromClasspathResource(final String profilePath) {
-        InputStream stream = ColorSpaces.class.getResourceAsStream(profilePath);
-
-        if (stream != null) {
-            if (DEBUG) {
-                System.out.println("Loading profile from classpath resource: " + profilePath);
-            }
-
-            try {
-                return ICC_Profile.getInstance(stream);
-            }
-            catch (IOException ignore) {
-                if (DEBUG) {
-                    ignore.printStackTrace();
-                }
-            }
-            finally {
-                FileUtil.close(stream);
-            }
-        }
-
-        return null;
-    }
-
-    private static ICC_Profile readProfileFromPath(final String profilePath) {
-        if (profilePath != null) {
-            if (DEBUG) {
-                System.out.println("Loading profile from: " + profilePath);
-            }
-
-            try {
-                return ICC_Profile.getInstance(profilePath);
-            }
-            catch (SecurityException | IOException ignore) {
-                if (DEBUG) {
-                    ignore.printStackTrace();
-                }
-            }
-        }
-
-        return null;
-    }
-
    private static final class Key {
        private final byte[] data;

@@ -448,78 +319,4 @@ public final class ColorSpaces {
            return getClass().getSimpleName() + "@" + Integer.toHexString(hashCode());
        }
    }
-
-    // Cache header profile data to avoid excessive array creation/copying in static inner class for on-demand lazy init
-    private static class sRGB {
-        private static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_sRGB));
-    }
-
-    private static class CIEXYZ {
-        private static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_CIEXYZ));
-    }
-
-    private static class PYCC {
-        private static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_PYCC));
-    }
-
-    private static class GRAY {
-        private static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_GRAY));
-    }
-
-    private static class LINEAR_RGB {
-        private static final byte[] header = getProfileHeaderWithProfileId(ICC_Profile.getInstance(ColorSpace.CS_LINEAR_RGB));
-    }
-
-    private static class Profiles {
-        // TODO: Honour java.iccprofile.path property?
-        private static final Properties PROFILES = loadProfiles();
-
-        private static Properties loadProfiles() {
-            Properties systemDefaults;
-
-            try {
-                systemDefaults = SystemUtil.loadProperties(
-                        ColorSpaces.class,
-                        "com/twelvemonkeys/imageio/color/icc_profiles_" + Platform.os().id()
-                );
-            }
-            catch (SecurityException | IOException ignore) {
-                System.err.printf(
-                        "Warning: Could not load system default ICC profile locations from %s, will use bundled fallback profiles.\n",
-                        ignore.getMessage()
-                );
-
-                if (DEBUG) {
-                    ignore.printStackTrace();
-                }
-
-                systemDefaults = null;
-            }
-
-            // Create map with defaults and add user overrides if any
-            Properties profiles = new Properties(systemDefaults);
-
-            try {
-                Properties userOverrides = SystemUtil.loadProperties(
-                        ColorSpaces.class,
-                        "com/twelvemonkeys/imageio/color/icc_profiles"
-                );
-                profiles.putAll(userOverrides);
-            }
-            catch (SecurityException | IOException ignore) {
-                // Most likely, this file won't be there
-            }
-
-            if (DEBUG) {
-                System.out.println("User ICC profiles: " + profiles);
-                System.out.println("System ICC profiles : " + systemDefaults);
-            }
-
-            return profiles;
-        }
-
-        static String getPath(final String profileName) {
-            return PROFILES.getProperty(profileName);
-        }
-    }
 }
@@ -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,97 @@
+/*
+ * Copyright (c) 2021, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.color;
+
+import javax.imageio.spi.ImageInputStreamSpi;
+import javax.imageio.spi.ServiceRegistry;
+import javax.imageio.stream.ImageInputStream;
+import java.io.File;
+import java.util.Locale;
+
+import static com.twelvemonkeys.imageio.util.IIOUtil.deregisterProvider;
+
+/**
+ * This class exists to force early invocation of {@code ProfileDeferralMgr.activateProfiles()},
+ * in an attempt to avoid JDK-6986863 and related bugs in Java < 17.
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @see <a href="https://bugs.openjdk.java.net/browse/JDK-6986863">JDK-6986863</a>
+ */
+final class ProfileDeferralActivator {
+
+    static {
+        activateProfilesInternal();
+    }
+
+    private static void activateProfilesInternal() {
+        try {
+            // Force invocation of ProfileDeferralMgr.activateProfiles() to avoid JDK-6986863 and friends.
+            // Relies on static initializer in ColorConvertOp to actually invoke ProfileDeferralMgr.activateProfiles()
+            Class.forName("java.awt.image.ColorConvertOp");
+        }
+        catch (Throwable disasters) {
+            System.err.println("ProfileDeferralMgr.activateProfiles() failed. ICC Color Profiles may not work properly, see stack trace below.");
+            System.err.println("For more information, see https://bugs.openjdk.java.net/browse/JDK-6986863");
+            System.err.println("Please upgrade to Java 17 or later where this bug is fixed, or ask your JRE provider to backport the fix.");
+            System.err.println();
+            System.err.println("If you can't update to Java 17, a possible workaround is to add");
+            System.err.println("\tClass.forName(\"java.awt.image.ColorConvertOp\");");
+            System.err.println("*early* in your application startup code, to force profile activation before profiles are accessed.");
+            System.err.println();
+
+            disasters.printStackTrace();
+        }
+    }
+
+    static void activateProfiles() {
+        // This method exists for other classes in the package to
+        // ensure this class' static initializer is run.
+    }
+
+    /**
+     * This is not a service provider, but exploits the SPI mechanism as a hook to force early profile activation.
+     */
+    public static final class Spi extends ImageInputStreamSpi {
+        @Override public void onRegistration(ServiceRegistry registry, Class<?> category) {
+            activateProfiles();
+
+            deregisterProvider(registry, this, category);
+        }
+
+        @Override public String getDescription(Locale locale) {
+            return getClass().getName();
+        }
+
+        @Override public ImageInputStream createInputStreamInstance(Object input, boolean useCache, File cacheDir) {
+            throw new UnsupportedOperationException();
+        }
+    }
+}
@@ -61,7 +61,7 @@ public final class UInt32ColorModel extends ComponentColorModel {
        // This class only supports DataBuffer.TYPE_INT, cast is safe
        int[] ipixel = (int[]) pixel;
        for (int c = 0, nc = normOffset; c < numComponents; c++, nc++) {
-            normComponents[nc] = ((float) (ipixel[c] & 0xffffffffl)) / ((float) ((1l << getComponentSize(c)) - 1));
+            normComponents[nc] = ((float) (ipixel[c] & 0xFFFFFFFFL)) / ((float) ((1L << getComponentSize(c)) - 1));
        }

        int numColorComponents = getNumColorComponents();
@@ -45,36 +45,82 @@ public final class YCbCrConverter {
    private final static int CENTERJSAMPLE = 128;
    private final static int ONE_HALF = 1 << (SCALEBITS - 1);

-    private final static int[] Cr_R_LUT = new int[MAXJSAMPLE + 1];
-    private final static int[] Cb_B_LUT = new int[MAXJSAMPLE + 1];
-    private final static int[] Cr_G_LUT = new int[MAXJSAMPLE + 1];
-    private final static int[] Cb_G_LUT = new int[MAXJSAMPLE + 1];
+    private final static class JPEG {
+        private final static int[] Cr_R_LUT = new int[MAXJSAMPLE + 1];
+        private final static int[] Cb_B_LUT = new int[MAXJSAMPLE + 1];
+        private final static int[] Cr_G_LUT = new int[MAXJSAMPLE + 1];
+        private final static int[] Cb_G_LUT = new int[MAXJSAMPLE + 1];

-    /**
-     * Initializes tables for YCC->RGB color space conversion.
-     */
-    private static void buildYCCtoRGBtable() {
-        if (ColorSpaces.DEBUG) {
-            System.err.println("Building YCC conversion table");
+        /**
+         * Initializes tables for YCC->RGB color space conversion.
+         */
+        private static void buildYCCtoRGBtable() {
+            if (ColorSpaces.DEBUG) {
+                System.err.println("Building JPEG YCbCr conversion table");
+            }
+
+            for (int i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+                // i is the actual input pixel value, in the range 0..MAXJSAMPLE
+                // The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE
+                // Cr=>R value is nearest int to 1.40200 * x
+                Cr_R_LUT[i] = (int) ((1.40200 * (1 << SCALEBITS) + 0.5) * x + ONE_HALF) >> SCALEBITS;
+                // Cb=>B value is nearest int to 1.77200 * x
+                Cb_B_LUT[i] = (int) ((1.77200 * (1 << SCALEBITS) + 0.5) * x + ONE_HALF) >> SCALEBITS;
+                // Cr=>G value is scaled-up -0.71414 * x
+                Cr_G_LUT[i] = -(int) (0.71414 * (1 << SCALEBITS) + 0.5) * x;
+                // Cb=>G value is scaled-up -0.34414 * x
+                // We also add in ONE_HALF so that need not do it in inner loop
+                Cb_G_LUT[i] = -(int) ((0.34414) * (1 << SCALEBITS) + 0.5) * x + ONE_HALF;
+            }
        }

-        for (int i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
-            // i is the actual input pixel value, in the range 0..MAXJSAMPLE
-            // The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE
-            // Cr=>R value is nearest int to 1.40200 * x
-            Cr_R_LUT[i] = (int) ((1.40200 * (1 << SCALEBITS) + 0.5) * x + ONE_HALF) >> SCALEBITS;
-            // Cb=>B value is nearest int to 1.77200 * x
-            Cb_B_LUT[i] = (int) ((1.77200 * (1 << SCALEBITS) + 0.5) * x + ONE_HALF) >> SCALEBITS;
-            // Cr=>G value is scaled-up -0.71414 * x
-            Cr_G_LUT[i] = -(int) (0.71414 * (1 << SCALEBITS) + 0.5) * x;
-            // Cb=>G value is scaled-up -0.34414 * x
-            // We also add in ONE_HALF so that need not do it in inner loop
-            Cb_G_LUT[i] = -(int) ((0.34414) * (1 << SCALEBITS) + 0.5) * x + ONE_HALF;
+        static {
+            buildYCCtoRGBtable();
        }
    }

-    static {
-        buildYCCtoRGBtable();
+    private final static class ITU_R_601 {
+        private final static int[] Cr_R_LUT = new int[MAXJSAMPLE + 1];
+        private final static int[] Cb_B_LUT = new int[MAXJSAMPLE + 1];
+        private final static int[] Cr_G_LUT = new int[MAXJSAMPLE + 1];
+        private final static int[] Cb_G_LUT = new int[MAXJSAMPLE + 1];
+        private final static int[] Y_LUT = new int[MAXJSAMPLE + 1];
+
+        /**
+         * Initializes tables for YCC->RGB color space conversion.
+         */
+        private static void buildYCCtoRGBtable() {
+            if (ColorSpaces.DEBUG) {
+                System.err.println("Building ITU-R REC.601 YCbCr conversion table");
+            }
+
+            for (int i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+                // i is the actual input pixel value, in the range 0..MAXJSAMPLE
+                // The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE
+
+                // Y'CbCr to RGB conversion, using values from BT.601 specification:
+                //   R = 1.16438 * (Y'-16)                      + 1.59603 * (Cr-128)
+                //   G = 1.16438 * (Y'-16) - 0.39176 * (Cb-128) - 0.81297 * (Cr-128)
+                //   B = 1.16438 * (Y'-16) + 2.01723 * (Cb-128)
+
+                // Cr=>R value is nearest int to 1.59603 * x
+                Cr_R_LUT[i] = ((int) (1.59603 * (1 << SCALEBITS) + 0.5) * x + ONE_HALF) >> SCALEBITS;
+                // Cb=>B value is nearest int to 2.01723 * x
+                Cb_B_LUT[i] = ((int) (2.01723 * (1 << SCALEBITS) + 0.5) * x + ONE_HALF) >> SCALEBITS;
+                // Cr=>G value is scaled-up -0.81297 * x
+                Cr_G_LUT[i] = -(int) (0.81297 * (1 << SCALEBITS) + 0.5) * x;
+                // Cb=>G value is scaled-up -0.39176 * x
+                // We also add in ONE_HALF so that need not do it in inner loop
+                Cb_G_LUT[i] = -(int) ((0.39176) * (1 << SCALEBITS) + 0.5) * x + ONE_HALF;
+
+                // Y`=>RGB
+                Y_LUT[i] = ((int) (1.16438 * (1 << SCALEBITS) + 0.5) * (i - 16) + ONE_HALF) >> SCALEBITS;
+            }
+        }
+
+        static {
+            buildYCCtoRGBtable();
+        }
    }

    public static void convertYCbCr2RGB(final byte[] yCbCr, final byte[] rgb, final double[] coefficients, double[] referenceBW, final int offset) {
@@ -108,17 +154,27 @@ public final class YCbCrConverter {
        rgb[offset + 1] = clamp(green);
    }

-    public static void convertYCbCr2RGB(final byte[] yCbCr, final byte[] rgb, final int offset) {
-        int y = yCbCr[offset] & 0xff;
-        int cr = yCbCr[offset + 2] & 0xff;
+    public static void convertJPEGYCbCr2RGB(final byte[] yCbCr, final byte[] rgb, final int offset) {
+        int y  = yCbCr[offset    ] & 0xff;
        int cb = yCbCr[offset + 1] & 0xff;
+        int cr = yCbCr[offset + 2] & 0xff;

-        rgb[offset] = clamp(y + Cr_R_LUT[cr]);
-        rgb[offset + 1] = clamp(y + (Cb_G_LUT[cb] + Cr_G_LUT[cr] >> SCALEBITS));
-        rgb[offset + 2] = clamp(y + Cb_B_LUT[cb]);
+        rgb[offset    ] = clamp(y + JPEG.Cr_R_LUT[cr]);
+        rgb[offset + 1] = clamp(y + (JPEG.Cb_G_LUT[cb] + JPEG.Cr_G_LUT[cr] >> SCALEBITS));
+        rgb[offset + 2] = clamp(y + JPEG.Cb_B_LUT[cb]);
    }

-    private static byte clamp(int val) {
+    public static void convertRec601YCbCr2RGB(final byte[] yCbCr, final byte[] rgb, final int offset) {
+        int y =  yCbCr[offset    ] & 0xff;
+        int cb = yCbCr[offset + 1] & 0xff;
+        int cr = yCbCr[offset + 2] & 0xff;
+
+        rgb[offset    ] = clamp(ITU_R_601.Y_LUT[y] + ITU_R_601.Cr_R_LUT[cr]);
+        rgb[offset + 1] = clamp(ITU_R_601.Y_LUT[y] + (ITU_R_601.Cr_G_LUT[cr] + ITU_R_601.Cb_G_LUT[cb] >> SCALEBITS));
+        rgb[offset + 2] = clamp(ITU_R_601.Y_LUT[y] + ITU_R_601.Cb_B_LUT[cb]);
+    }
+
+    private static byte clamp(final int val) {
        return (byte) Math.max(0, Math.min(255, val));
    }
 }
@@ -49,10 +49,10 @@ public abstract class ReaderWriterProviderInfo extends ProviderInfo {
    private final String[] mimeTypes;
    private final String readerClassName;
    private final String[] readerSpiClassNames;
-    private final Class[] inputTypes = new Class[] {ImageInputStream.class};
+    private final Class<?>[] inputTypes = new Class<?>[] {ImageInputStream.class};
    private final String writerClassName;
    private final String[] writerSpiClassNames;
-    private final Class[] outputTypes = new Class[] {ImageOutputStream.class};
+    private final Class<?>[] outputTypes = new Class<?>[] {ImageOutputStream.class};
    private final boolean supportsStandardStreamMetadata;
    private final String nativeStreamMetadataFormatName;
    private final String nativeStreamMetadataFormatClassName;
@@ -80,7 +80,7 @@ public abstract class ReaderWriterProviderInfo extends ProviderInfo {
                                       final String writerClassName,
                                       final String[] writerSpiClassNames,
                                       final boolean supportsStandardStreamMetadata,
-                                       final String nativeStreameMetadataFormatName,
+                                       final String nativeStreamMetadataFormatName,
                                       final String nativeStreamMetadataFormatClassName,
                                       final String[] extraStreamMetadataFormatNames,
                                       final String[] extraStreamMetadataFormatClassNames,
@@ -99,7 +99,7 @@ public abstract class ReaderWriterProviderInfo extends ProviderInfo {
        this.writerClassName = writerClassName;
        this.writerSpiClassNames = writerSpiClassNames;
        this.supportsStandardStreamMetadata = supportsStandardStreamMetadata;
-        this.nativeStreamMetadataFormatName = nativeStreameMetadataFormatName;
+        this.nativeStreamMetadataFormatName = nativeStreamMetadataFormatName;
        this.nativeStreamMetadataFormatClassName = nativeStreamMetadataFormatClassName;
        this.extraStreamMetadataFormatNames = extraStreamMetadataFormatNames;
        this.extraStreamMetadataFormatClassNames = extraStreamMetadataFormatClassNames;
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 2021, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.stream;
+
+import javax.imageio.stream.ImageInputStreamImpl;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import static com.twelvemonkeys.lang.Validate.notNull;
+import static java.lang.Math.max;
+
+/**
+ * A buffered replacement for {@link javax.imageio.stream.FileImageInputStream}
+ * that provides greatly improved performance for shorter reads, like single
+ * byte or bit reads.
+ * As with {@code javax.imageio.stream.FileImageInputStream}, either
+ * {@link File} or {@link RandomAccessFile} can be used as input.
+ *
+ * @see javax.imageio.stream.FileImageInputStream
+ */
+// TODO: Create a memory-mapped version?
+//  Or not... 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.
+public final class BufferedFileImageInputStream extends ImageInputStreamImpl {
+    static final int DEFAULT_BUFFER_SIZE = 8192;
+
+    private byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
+    private int bufferPos;
+    private int bufferLimit;
+
+    private final ByteBuffer integralCache = ByteBuffer.allocate(8);
+    private final byte[] integralCacheArray = integralCache.array();
+
+    private RandomAccessFile raf;
+
+    /**
+     * Constructs a <code>BufferedFileImageInputStream</code> that will read from a given <code>File</code>.
+     *
+     * @param file a <code>File</code> to read from.
+     * @throws IllegalArgumentException if <code>file</code> is <code>null</code>.
+     * @throws FileNotFoundException    if <code>file</code> is a directory or cannot be opened for reading
+     *                                  for any reason.
+     */
+    public BufferedFileImageInputStream(final File file) throws FileNotFoundException {
+        this(new RandomAccessFile(notNull(file, "file"), "r"));
+    }
+
+    /**
+     * Constructs a <code>BufferedFileImageInputStream</code> that will read from a given <code>RandomAccessFile</code>.
+     *
+     * @param raf a <code>RandomAccessFile</code> to read from.
+     * @throws IllegalArgumentException if <code>raf</code> is <code>null</code>.
+     */
+    public BufferedFileImageInputStream(final RandomAccessFile raf) {
+        this.raf = notNull(raf, "raf");
+    }
+
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    private boolean fillBuffer() throws IOException {
+        int length = raf.read(buffer, 0, buffer.length);
+        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;
+        int read = raf.read(bytes, offset, length);
+
+        if (read > 0) {
+            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 raf.length();
+        }
+        catch (IOException ignore) {
+        }
+
+        return -1;
+    }
+
+    public void close() throws IOException {
+        super.close();
+
+        raf.close();
+
+        raf = null;
+        buffer = 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;
+            raf.seek(position);
+        }
+
+        streamPos = position;
+    }
+}
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2021, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.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.FileNotFoundException;
+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 BufferedFileImageInputStreamSpi() {
+        this(new StreamProviderInfo());
+    }
+
+    private BufferedFileImageInputStreamSpi(ProviderInfo providerInfo) {
+        super(providerInfo.getVendorName(), providerInfo.getVersion(), File.class);
+    }
+
+    @Override
+    public void onRegistration(final ServiceRegistry registry, final Class<?> category) {
+        Iterator<ImageInputStreamSpi> providers = registry.getServiceProviders(ImageInputStreamSpi.class, new FileInputFilter(), true);
+
+        while (providers.hasNext()) {
+            ImageInputStreamSpi provider = providers.next();
+            if (provider != this) {
+                registry.setOrdering(ImageInputStreamSpi.class, this, provider);
+            }
+        }
+    }
+
+    public ImageInputStream createInputStreamInstance(final Object input, final boolean pUseCache, final File pCacheDir) {
+        if (input instanceof File) {
+            try {
+                return new BufferedFileImageInputStream((File) input);
+            }
+            catch (FileNotFoundException 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,
+                // instead they should be allowed to inspect the instance, to see that the file does exist...
+                return null;
+            }
+        }
+
+        throw new IllegalArgumentException("Expected input of type File: " + input);
+    }
+
+    @Override
+    public boolean canUseCacheFile() {
+        return false;
+    }
+
+    public String getDescription(final Locale pLocale) {
+        return "Service provider that instantiates an ImageInputStream from a File";
+    }
+
+    private static class FileInputFilter implements ServiceRegistry.Filter {
+        @Override
+        public boolean filter(final Object provider) {
+            return ((ImageInputStreamSpi) provider).getInputClass() == File.class;
+        }
+    }
+}
@@ -43,22 +43,28 @@ import static com.twelvemonkeys.lang.Validate.notNull;
 * A buffered {@code ImageInputStream}.
 * Experimental - seems to be effective for {@link javax.imageio.stream.FileImageInputStream}
 * and {@link javax.imageio.stream.FileCacheImageInputStream} when doing a lot of single-byte reads
- * (or short byte-array reads) on OS X at least.
+ * (or short byte-array reads).
 * Code that uses the {@code readFully} methods are not affected by the issue.
+ * <p>
+ * NOTE: Invoking {@code close()} will  <em>NOT</em> close the wrapped stream.
+ * </p>
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @author last modified by $Author: haraldk$
 * @version $Id: BufferedFileImageInputStream.java,v 1.0 May 15, 2008 4:36:49 PM haraldk Exp$
+ *
+ * @deprecated Use {@link BufferedFileImageInputStream} instead.
 */
-// TODO: Create a provider for this (wrapping the FileIIS and FileCacheIIS classes), and disable the Sun built-in spis?
-// TODO: Test on other platforms, might be just an OS X issue
+@Deprecated
 public final class BufferedImageInputStream extends ImageInputStreamImpl implements ImageInputStream {
    static final int DEFAULT_BUFFER_SIZE = 8192;

    private ImageInputStream stream;

-    private ByteBuffer buffer;
-    private ByteBuffer integralCache = ByteBuffer.allocate(8);
+    private  ByteBuffer buffer;
+
+    private final ByteBuffer integralCache = ByteBuffer.allocate(8);
+    private final byte[] integralCacheArray = integralCache.array();

    public BufferedImageInputStream(final ImageInputStream pStream) throws IOException {
        this(pStream, DEFAULT_BUFFER_SIZE);
@@ -97,10 +103,10 @@ public final class BufferedImageInputStream extends ImageInputStreamImpl impleme

        if (!buffer.hasRemaining()) {
            fillBuffer();
-        }

-        if (!buffer.hasRemaining()) {
-            return -1;
+            if (!buffer.hasRemaining()) {
+                return -1;
+            }
        }

        bitOffset = 0;
@@ -172,21 +178,21 @@ public final class BufferedImageInputStream extends ImageInputStreamImpl impleme

    @Override
    public short readShort() throws IOException {
-        readFully(integralCache.array(), 0, 2);
+        readFully(integralCacheArray, 0, 2);

        return integralCache.getShort(0);
    }

    @Override
    public int readInt() throws IOException {
-        readFully(integralCache.array(), 0, 4);
+        readFully(integralCacheArray, 0, 4);

        return integralCache.getInt(0);
    }

    @Override
    public long readLong() throws IOException {
-        readFully(integralCache.array(), 0, 8);
+        readFully(integralCacheArray, 0, 8);

        return integralCache.getLong(0);
    }
@@ -253,6 +259,7 @@ public final class BufferedImageInputStream extends ImageInputStreamImpl impleme
            }

            int val = buffer.get() & 0xff;
+            streamPos++;

            accum <<= 8;
            accum |= val;
@@ -262,9 +269,7 @@ public final class BufferedImageInputStream extends ImageInputStreamImpl impleme
        // Move byte position back if in the middle of a byte
        if (newBitOffset != 0) {
            buffer.position(buffer.position() - 1);
-        }
-        else {
-            streamPos++;
+            streamPos--;
        }

        this.bitOffset = newBitOffset;
@@ -279,26 +284,26 @@ public final class BufferedImageInputStream extends ImageInputStreamImpl impleme
    }

    @Override
-    public void seek(long pPosition) throws IOException {
+    public void seek(long position) throws IOException {
        checkClosed();
        bitOffset = 0;

-        if (streamPos == pPosition) {
+        if (streamPos == position) {
            return;
        }

        // Optimized to not invalidate buffer if new position is within current buffer
-        long newBufferPos = buffer.position() + pPosition - streamPos;
+        long newBufferPos = buffer.position() + position - streamPos;
        if (newBufferPos >= 0 && newBufferPos <= buffer.limit()) {
            buffer.position((int) newBufferPos);
        }
        else {
            // Will invalidate buffer
            buffer.limit(0);
-            stream.seek(pPosition);
+            stream.seek(position);
        }

-        streamPos = pPosition;
+        streamPos = position;
    }

    @Override
@@ -330,7 +335,9 @@ public final class BufferedImageInputStream extends ImageInputStreamImpl impleme
    @Override
    public void close() throws IOException {
        if (stream != null) {
-            //stream.close();
+            // TODO: FixMe: Need to close underlying stream here!
+            //   For call sites that relies on not closing, we should instead not close the buffered stream.
+//             stream.close();
            stream = null;
            buffer = null;
        }
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2021, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.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.RandomAccessFile;
+import java.util.Iterator;
+import java.util.Locale;
+
+/**
+ * BufferedRAFImageInputStreamSpi
+ * Experimental
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @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 BufferedRAFImageInputStreamSpi() {
+        this(new StreamProviderInfo());
+    }
+
+    private BufferedRAFImageInputStreamSpi(ProviderInfo providerInfo) {
+        super(providerInfo.getVendorName(), providerInfo.getVersion(), RandomAccessFile.class);
+    }
+
+    @Override
+    public void onRegistration(final ServiceRegistry registry, final Class<?> category) {
+        Iterator<ImageInputStreamSpi> providers = registry.getServiceProviders(ImageInputStreamSpi.class, new RAFInputFilter(), true);
+
+        while (providers.hasNext()) {
+            ImageInputStreamSpi provider = providers.next();
+            if (provider != this) {
+                registry.setOrdering(ImageInputStreamSpi.class, this, provider);
+            }
+        }
+    }
+
+    public ImageInputStream createInputStreamInstance(final Object input, final boolean pUseCache, final File pCacheDir) {
+        if (input instanceof RandomAccessFile) {
+            return new BufferedFileImageInputStream((RandomAccessFile) input);
+        }
+
+        throw new IllegalArgumentException("Expected input of type RandomAccessFile: " + input);
+    }
+
+    @Override
+    public boolean canUseCacheFile() {
+        return false;
+    }
+
+    public String getDescription(final Locale pLocale) {
+        return "Service provider that instantiates an ImageInputStream from a RandomAccessFile";
+    }
+
+    private static class RAFInputFilter implements ServiceRegistry.Filter {
+        @Override
+        public boolean filter(final Object provider) {
+            return ((ImageInputStreamSpi) provider).getInputClass() == RandomAccessFile.class;
+        }
+    }
+}
@@ -30,10 +30,11 @@

 package com.twelvemonkeys.imageio.stream;

+import com.twelvemonkeys.imageio.spi.ProviderInfo;
+
 import javax.imageio.spi.ImageInputStreamSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.io.File;
-import java.io.IOException;
 import java.util.Locale;

 /**
@@ -47,10 +48,14 @@ import java.util.Locale;
 public class ByteArrayImageInputStreamSpi extends ImageInputStreamSpi {

    public ByteArrayImageInputStreamSpi() {
-        super("TwelveMonkeys", "1.0 BETA", byte[].class);
+        this(new StreamProviderInfo());
    }

-    public ImageInputStream createInputStreamInstance(Object pInput, boolean pUseCache, File pCacheDir) throws IOException {
+    private ByteArrayImageInputStreamSpi(ProviderInfo providerInfo) {
+        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);
        }
@@ -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
+
+        stream.close();
+        super.close();
+    }
+}
@@ -0,0 +1,9 @@
+package com.twelvemonkeys.imageio.stream;
+
+import com.twelvemonkeys.imageio.spi.ProviderInfo;
+
+final class StreamProviderInfo extends ProviderInfo {
+    StreamProviderInfo() {
+        super(StreamProviderInfo.class.getPackage());
+    }
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, Harald Kuhr
+ * Copyright (c) 2021, Harald Kuhr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -30,9 +30,10 @@

 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.FileImageInputStream;
 import javax.imageio.stream.ImageInputStream;
 import javax.imageio.stream.MemoryCacheImageInputStream;
 import java.io.File;
@@ -53,7 +54,11 @@ import java.util.Locale;
 // TODO: URI instead of URL?
 public class URLImageInputStreamSpi extends ImageInputStreamSpi {
    public URLImageInputStreamSpi() {
-        super("TwelveMonkeys", "1.0 BETA", URL.class);
+        this(new StreamProviderInfo());
+    }
+
+    private URLImageInputStreamSpi(ProviderInfo providerInfo) {
+        super(providerInfo.getVendorName(), providerInfo.getVersion(), URL.class);
    }

    // TODO: Create a URI or URLImageInputStream class, with a getUR[I|L] method, to allow for multiple file formats
@@ -66,7 +71,7 @@ public class URLImageInputStreamSpi extends ImageInputStreamSpi {
            // Special case for file protocol, a lot faster than FileCacheImageInputStream
            if ("file".equals(url.getProtocol())) {
                try {
-                    return new BufferedImageInputStream(new FileImageInputStream(new File(url.toURI())));
+                    return new BufferedFileImageInputStream(new File(url.toURI()));
                }
                catch (URISyntaxException ignore) {
                    // This should never happen, but if it does, we'll fall back to using the stream  
@@ -75,29 +80,29 @@ public class URLImageInputStreamSpi extends ImageInputStreamSpi {
            }

            // Otherwise revert to cached
-            final InputStream stream = url.openStream();
+            final InputStream urlStream = url.openStream();
            if (pUseCache) {
-                return new BufferedImageInputStream(new FileCacheImageInputStream(stream, pCacheDir) {
+                return new FileCacheImageInputStream(urlStream, pCacheDir) {
                    @Override
                    public void close() throws IOException {
                        try {
                            super.close();
                        }
                        finally {
-                            stream.close(); // NOTE: If this line throws IOE, it will shadow the original..
+                            urlStream.close(); // NOTE: If this line throws IOE, it will shadow the original..
                        }
                    }
-                });
+                };
            }
            else {
-                return new MemoryCacheImageInputStream(stream) {
+                return new MemoryCacheImageInputStream(urlStream) {
                    @Override
                    public void close() throws IOException {
                        try {
                            super.close();
                        }
                        finally {
-                            stream.close(); // NOTE: If this line throws IOE, it will shadow the original..
+                            urlStream.close(); // NOTE: If this line throws IOE, it will shadow the original..
                        }
                    }
                };
@@ -108,6 +113,11 @@ public class URLImageInputStreamSpi extends ImageInputStreamSpi {
        }
    }

+    @Override
+    public boolean canUseCacheFile() {
+        return true;
+    }
+
    public String getDescription(final Locale pLocale) {
        return "Service provider that instantiates an ImageInputStream from a URL";
    }
--- a/Show More
+++ b/Show More