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

[maven-release-plugin] prepare release twelvemonkeys-3.4.3
Stick to the git user, when using ssh
2026-05-19 00:00:03 -04:00 · 2020-01-09 19:40:24 +01:00 · 2020-01-09 19:40:16 +01:00 · 2020-01-09 19:28:35 +01:00 · 2020-01-09 19:25:48 +01:00 · 2020-01-09 19:25:48 +01:00
822 changed files with 51139 additions and 41226 deletions
@@ -1 +0,0 @@
-github: haraldk
@@ -1,53 +0,0 @@
---
-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.
@@ -1,20 +0,0 @@
---
-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.
@@ -1,13 +0,0 @@
---
-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.
@@ -1,11 +0,0 @@
-**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 
@@ -1,13 +0,0 @@
-version: 2
-updates:
-  # Maven/Java library updates
-  - package-ecosystem: "maven"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    open-pull-requests-limit: 10
-  # GitHub actions updates
-  - package-ecosystem: "github-actions"
-    directory: "/.github/workflows"
-    schedule:
-      interval: "daily"
@@ -1,102 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-      - '**'
-      - '!dependabot/**'
-  pull_request:
-    branches: [ 'master' ]
-
-permissions: read-all
-
-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, 21 ]
-    runs-on: ${{ matrix.os }}
-    permissions:
-      checks: write
-    steps:
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - uses: actions/setup-java@0ab4596768b603586c0de567f2430c30f5b0d2b0 # v3.13.0
-        with:
-          distribution: 'temurin'
-          java-version: ${{ matrix.java }}
-          java-package: jdk
-          cache: 'maven'
-      - name: Run Tests
-        run: mvn --batch-mode --no-transfer-progress test
-      - name: Publish Test Report
-        uses: mikepenz/action-junit-report@0831a82caad2465c31c6dd929978f640cb42556c # v4.0.3
-        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
-    permissions:
-      checks: write
-    strategy:
-      matrix:
-        kcms: [ true, false ]
-    steps:
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - 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@0ab4596768b603586c0de567f2430c30f5b0d2b0 # v3.13.0
-        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 --batch-mode --no-transfer-progress test
-      - name: Publish Test Report
-        uses: mikepenz/action-junit-report@0831a82caad2465c31c6dd929978f640cb42556c # v4.0.3
-        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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - name: Set up Maven Central
-        uses: actions/setup-java@0ab4596768b603586c0de567f2430c30f5b0d2b0 # v3.13.0
-        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 --batch-mode help:evaluate -Dexpression=project.version -q -DforceStdout)" >> $GITHUB_ENV
-      - name: Publish to Maven Central
-        if: ${{ endsWith(env.PROJECT_VERSION, '-SNAPSHOT') }}
-        run: mvn --batch-mode --no-transfer-progress deploy -P release -DskipTests
-        env:
-          MAVEN_CENTRAL_USERNAME: ${{ secrets.SONATYPE_USERNAME }} # must be the same env variable name as (1)
-          MAVEN_CENTRAL_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }} # must be the same env variable name as (2)
-          MAVEN_CENTRAL_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }} # must be the same env variable name as (3)
@@ -1,69 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ "master" ]
-  schedule:
-    - cron: '26 13 * * 6'
-
-permissions: {}
-
-jobs:
-  analyze:
-    name: Analyze
-    # Runner size impacts CodeQL analysis time. To learn more, please see:
-    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
-    #   - https://gh.io/supported-runners-and-hardware-resources
-    #   - https://gh.io/using-larger-runners
-    # Consider using larger runners for possible analysis time improvements.
-    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'java' ]
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5
-      with:
-        category: "/language:${{matrix.language}}"
@@ -1,62 +0,0 @@
-# This workflow uses actions that are not certified by GitHub. They are provided
-# by a third-party and are governed by separate terms of service, privacy
-# policy, and support documentation.
-
-name: Scorecard supply-chain security
-on:
-  # For Branch-Protection check. Only the default branch is supported. See
-  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
-  branch_protection_rule:
-  # To guarantee Maintained check is occasionally updated. See
-  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
-  schedule:
-    - cron: '38 8 * * 2'
-  push:
-    branches: [ "master" ]
-
-permissions: read-all # Declare default permissions as read only.
-
-jobs:
-  analysis:
-    name: Scorecard analysis
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write  # to upload the results to code-scanning dashboard.
-      id-token: write # to publish results and get a badge
-
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          persist-credentials: false
-
-      - name: "Run analysis"
-        uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
-          # you want to enable the Branch-Protection check on the repository
-          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-fine-grained-pat-optional.
-          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
-
-          # Publish Results:
-          #   - Publish results to OpenSSF REST API for easy access by consumers
-          #   - Allows the repository to include the Scorecard badge.
-          #   - See https://github.com/ossf/scorecard-action#publishing-results.
-          publish_results: true
-
-      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
-      # format to the repository Actions tab.
-      - name: "Upload artifact"
-        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-
-      # Upload the results to GitHub's code scanning dashboard.
-      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5
-        with:
-          sarif_file: results.sarif
@@ -15,4 +15,3 @@ private
 profiles.xml
 Thumbs.db
 .DS_Store
-/.metadata/
@@ -0,0 +1,14 @@
+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,6 +1,6 @@
 BSD 3-Clause License

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

 Redistribution and use in source and binary forms, with or without
@@ -1,84 +1,264 @@
-[![CI](https://github.com/haraldk/TwelveMonkeys/actions/workflows/ci.yml/badge.svg)](https://github.com/haraldk/TwelveMonkeys/actions/workflows/ci.yml)
-[![CodeQL](https://github.com/haraldk/TwelveMonkeys/actions/workflows/codeql.yml/badge.svg)](https://github.com/haraldk/TwelveMonkeys/actions/workflows/codeql.yml)
-[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/haraldk/TwelveMonkeys/badge)](https://securityscorecards.dev/viewer/?uri=github.com/haraldk/TwelveMonkeys)
-[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/7900/badge)](https://www.bestpractices.dev/projects/7900)
+## Latest

-[![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)
+Master branch build status: [![Build Status](https://travis-ci.org/haraldk/TwelveMonkeys.svg?branch=master)](https://travis-ci.org/haraldk/TwelveMonkeys)

-![Logo](logo.png)
+Latest release is TwelveMonkeys ImageIO [3.4.1](https://search.maven.org/search?q=g:com.twelvemonkeys.imageio%20AND%20v:3.4.1) (Sep. 7th, 2018).
+[Release notes](https://github.com/haraldk/TwelveMonkeys/releases/latest).

 ## About

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

-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
+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
 "in the wild", as well as to maintain access to data in legacy formats.
-As there is lots of legacy data out there, we see the need for open implementations of readers for popular 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.

 ----

-## File formats supported
+## Features

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

+#### 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

-**Important note on using Batik:** *Please read [The Apache™ XML Graphics Project - Security](https://xmlgraphics.apache.org/security.html), 
-and make sure you use an updated and secure version.*
+#### 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+.*

-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:

-```java
-BufferedImage image = ImageIO.read(file);
-```
+    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:

-```java
-if (!ImageIO.write(image, format, file)) {
-   // Handle image not written case
-}
-```
+    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.

@@ -89,44 +269,50 @@ 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 (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();
+    // Create input stream
+    ImageInputStream input = ImageIO.createImageInputStream(file);

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

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

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

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

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

-        // Optionally, read thumbnails, meta data, etc...
-        int numThumbs = reader.getNumThumbnails(0);
-        // ...
+            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();
+        }
    }
    finally {
-        // Dispose reader in finally block to avoid memory leaks
-        reader.dispose();
+        // Close stream in finally block to avoid resource leaks
+        input.close();
    }
-}
 ```

 Query the reader for source image dimensions using `reader.getWidth(n)` and `reader.getHeight(n)` without reading the
@@ -138,56 +324,86 @@ 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 (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);
+    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();
    }
-}
-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](https://docs.oracle.com/javase/7/docs/technotes/guides/imageio/spec/imageio_guideTOC.fm.html)
+[Java Image I/O API Guide](http://docs.oracle.com/javase/7/docs/technotes/guides/imageio/spec/imageio_guideTOC.fm.html)
 from Oracle.

-#### Adobe Clipping Path support

-```java
-import com.twelvemonkeys.imageio.path.Paths;
+#### 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.

-try (ImageInputStream stream = ImageIO.createImageInputStream(new File("image_with_path.jpg")) {
-    BufferedImage image = Paths.readClipped(stream);
+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.

-    // Do something with the clipped image...
-}
+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>
 ```
-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

@@ -195,15 +411,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
@@ -212,30 +428,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](https://git-scm.com/downloads)):
+Download the project (using [Git](http://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](https://maven.apache.org/download.cgi)):
+Build the project (using [Maven](http://maven.apache.org/download.cgi)):

    $ mvn package

-Currently, the recommended JDK for making a build is Oracle JDK 8.x. 
+Currently, the recommended JDK for making a build is Oracle JDK 7.x or 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.

@@ -257,10 +473,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:
@@ -272,162 +488,119 @@ The first line should print:
 To depend on the JPEG and TIFF plugin using Maven, add the following to your POM:

 ```xml
-...
-<dependencies>
    ...
-    <dependency>
-        <groupId>com.twelvemonkeys.imageio</groupId>
-        <artifactId>imageio-jpeg</artifactId>
-        <version>3.10.1</version>
-    </dependency>
-    <dependency>
-        <groupId>com.twelvemonkeys.imageio</groupId>
-        <artifactId>imageio-tiff</artifactId>
-        <version>3.10.1</version>
-    </dependency>
+    <dependencies>
+        ...
+        <dependency>
+            <groupId>com.twelvemonkeys.imageio</groupId>
+            <artifactId>imageio-jpeg</artifactId>
+            <version>3.4.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.twelvemonkeys.imageio</groupId>
+            <artifactId>imageio-tiff</artifactId>
+            <version>3.4.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.10.1</version>
-    </dependency>
-
-    <!--
-    Or Jakarta version, for Servlet API 5.0
-    -->
-    <dependency>
-        <groupId>com.twelvemonkeys.servlet</groupId>
-        <artifactId>servlet</artifactId>
-        <version>3.10.1</version>
-        <classifier>jakarta</classifier>
-    </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.4.1</version>
+        </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.10.1.jar
-    twelvemonkeys-common-io-3.10.1.jar
-    twelvemonkeys-common-image-3.10.1.jar
-    twelvemonkeys-imageio-core-3.10.1.jar
-    twelvemonkeys-imageio-metadata-3.10.1.jar
-    twelvemonkeys-imageio-jpeg-3.10.1.jar
-    twelvemonkeys-imageio-tiff-3.10.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.
+    twelvemonkeys-common-lang-3.4.1.jar
+    twelvemonkeys-common-io-3.4.1.jar
+    twelvemonkeys-common-image-3.4.1.jar
+    twelvemonkeys-imageio-core-3.4.1.jar
+    twelvemonkeys-imageio-metadata-3.4.1.jar
+    twelvemonkeys-imageio-jpeg-3.4.1.jar
+    twelvemonkeys-imageio-tiff-3.4.1.jar

 ### Links to prebuilt binaries

-##### Latest version (3.10.1)
+##### Latest version (3.4.1)

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

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

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

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

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

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

 ## License

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

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

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

 q: How do I use it?

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


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

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

-All you have to do, is to make sure you have the TwelveMonkeys ImageIO JARs in your classpath.
+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](https://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](http://docs.oracle.com/javase/7/docs/api/javax/imageio/spi/IIORegistry.html).

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


-q: Why is there no support for common formats like GIF or PNG?
-
-a: The short answer is simply that the built-in support in ImageIO for these formats are considered good enough as-is.
-If you are looking for better PNG write performance on Java 7 and 8, see [JDK9 PNG Writer Backport](https://github.com/gredler/jdk9-png-writer-backport).
-
-
-q: When is the next release? What is the current release schedule?
-
-a: The goal is to make monthly releases, containing bug fixes and minor new features. 
-And quarterly releases with more "major" features.
-
-
-q: I love this project! How can I help?
-
-a: Have a look at the open issues, and see if there are any issues you can help fix, or provide sample file or create test cases for.
-It is also possible for you or your organization to become a sponsor, through GitHub Sponsors. 
-Providing funding will allow us to spend more time on fixing bugs and implementing new features. 
-
-
 q: What about JAI? Several of the formats are already supported by JAI.

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

    <groupId>com.twelvemonkeys.bom</groupId>
@@ -123,16 +123,6 @@
                <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,19 +4,15 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.11.0-SNAPSHOT</version>
+        <version>3.4.4-SNAPSHOT</version>
    </parent>
    <artifactId>common-image</artifactId>
    <packaging>jar</packaging>
    <name>TwelveMonkeys :: Common :: Image</name>
    <description>
-        TwelveMonkeys Common image support classes.
+        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>
@@ -31,18 +27,9 @@
        <dependency>
            <groupId>jmagick</groupId>
            <artifactId>jmagick</artifactId>
-            <version>6.6.9</version>
+            <version>6.2.4</version>
            <optional>true</optional>
            <scope>provided</scope>
        </dependency>
    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.felix</groupId>
-                <artifactId>maven-bundle-plugin</artifactId>
-            </plugin>
-        </plugins>
-    </build>
 </project>
@@ -34,13 +34,7 @@ import java.awt.*;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
-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;
+import java.awt.image.*;

 /**
 * This is a drop-in replacement for {@link java.awt.image.AffineTransformOp}.
@@ -76,7 +70,6 @@ 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 {
@@ -87,9 +80,10 @@ public class AffineTransformOp implements BufferedImageOp, RasterOp {
                dst = createCompatibleDestImage(src, src.getColorModel());
            }

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

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

                if (interpolationType > 0) {
@@ -115,7 +109,9 @@ public class AffineTransformOp implements BufferedImageOp, RasterOp {
                return dst;
            }
            finally {
-                g2d.dispose();
+                if (g2d != null) {
+                    g2d.dispose();
+                }
            }
        }
    }
@@ -79,7 +79,7 @@ public final class BufferedImageFactory {
    private int scanSize;

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

    private Object sourcePixels;

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

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

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

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

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

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

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

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

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

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

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

-            try {
-                if (consumerException != null) {
-                    throw new ImageConversionException("Image conversion failed: " + consumerException.getMessage(), consumerException);
-                }
-
-                if (colorModelOnly) {
-                    createColorModel();
-                }
-                else {
-                    createBuffered();
-                }
+            if (consumerException != null) {
+                throw new ImageConversionException("Image conversion failed: " + consumerException.getMessage(), consumerException);
            }
-            finally {
-                // Clean up, in case any objects are copied/cloned, so we can free resources
-                freeResources();
+
+            if (pColorModelOnly) {
+                createColorModel();
+            }
+            else {
+                createBuffered();
            }
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -45,8 +45,8 @@ import java.awt.image.BufferedImage;
 */
 public class BufferedImageIcon implements Icon {
    private final BufferedImage image;
-    private final int width;
-    private final int height;
+    private int width;
+    private int height;
    private final boolean fast;

    public BufferedImageIcon(BufferedImage pImage) {
@@ -81,10 +81,11 @@ public class BufferedImageIcon implements Icon {
        else {
            //System.out.println("Scaling using interpolation");
            Graphics2D g2 = (Graphics2D) g;
-            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);
+            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);
        }
    }
 }
@@ -844,7 +844,7 @@ public final class ImageUtil {
                return false;
            }

-            for (int i = 0; i < mapSize1; i++) {
+            for (int i = 0; i > mapSize1; i++) {
                if (icm1.getRGB(i) != icm2.getRGB(i)) {
                    return false;
                }
@@ -587,7 +587,6 @@ 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,26 +30,17 @@

 package com.twelvemonkeys.image;

-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 org.junit.Test;

+import javax.imageio.ImageTypeSpecifier;
 import java.awt.color.ColorSpace;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
-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.awt.image.*;
 import java.util.Arrays;
 import java.util.List;

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

 /**
 * AffineTransformOpTest.
@@ -110,7 +101,6 @@ 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() {
@@ -138,8 +128,8 @@ public class AffineTransformOpTest {

    @Test
    public void testFilterRotateBIStandard() {
-        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);
+        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);

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

    @Test
    public void testFilterRotateBICustom() {
-        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);
+        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);

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

    @Test
    public void testFilterRotateRasterStandard() {
-        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);
+        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);

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

    @Test
    public void testFilterRotateRasterCustom() {
-        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);
+        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);

        for (ImageTypeSpecifier spec : SPECS) {
            Raster raster = spec.createBufferedImage(width, height).getRaster();
@@ -272,6 +264,8 @@ public class AffineTransformOpTest {
                    fail("No result!");
                }
                else {
+                    System.err.println("AffineTransformOpTest.testFilterRotateRasterCustom");
+                    System.err.println("spec: " + spec);
                    continue;
                }
            }
@@ -34,13 +34,14 @@ import org.junit.Ignore;
 import org.junit.Test;

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

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

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

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

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

-            progress = percentage;
+            progress = pPercentage;
        }


@@ -4,19 +4,15 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.11.0-SNAPSHOT</version>
+        <version>3.4.4-SNAPSHOT</version>
    </parent>
    <artifactId>common-io</artifactId>
    <packaging>jar</packaging>
    <name>TwelveMonkeys :: Common :: IO</name>
    <description>
-        TwelveMonkeys Common I/O support classes.
+        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>
@@ -31,12 +27,4 @@
        </dependency>
    </dependencies>

-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.felix</groupId>
-                <artifactId>maven-bundle-plugin</artifactId>
-            </plugin>
-        </plugins>
-    </build>
 </project>
@@ -56,8 +56,8 @@ public class CompoundReader extends Reader {

    private int currentReader;
    private int markedReader;
-    private long mark;
-    private long next;
+    private int mark;
+    private int mNext;

    /**
     * Create a new compound reader.
@@ -76,7 +76,7 @@ public class CompoundReader extends Reader {
        finalLock = pReaders; // NOTE: It's ok to sync on pReaders, as the
                          // reference can't change, only it's elements

-        readers = new ArrayList<>();
+        readers = new ArrayList<Reader>();

        boolean markSupported = true;
        while (pReaders.hasNext()) {
@@ -101,7 +101,7 @@ public class CompoundReader extends Reader {
        }
        
        // NOTE: Reset mNext for every reader, and record marked reader in mark/reset methods!
-        next = 0;
+        mNext = 0;
        return current;
    }

@@ -135,7 +135,7 @@ public class CompoundReader extends Reader {

        synchronized (finalLock) {
            ensureOpen();
-            mark = next;
+            mark = mNext;
            markedReader = currentReader;

            current.mark(pReadLimit);
@@ -158,7 +158,7 @@ public class CompoundReader extends Reader {
            }
            current.reset();

-            next = mark;
+            mNext = mark;
        }
    }

@@ -177,13 +177,13 @@ public class CompoundReader extends Reader {
                return read(); // In case of 0-length readers
            }

-            next++;
+            mNext++;

            return read;
        }
    }

-    public int read(char[] pBuffer, int pOffset, int pLength) throws IOException {
+    public int read(char pBuffer[], int pOffset, int pLength) throws IOException {
        synchronized (finalLock) {
            int read = current.read(pBuffer, pOffset, pLength);

@@ -192,7 +192,7 @@ public class CompoundReader extends Reader {
                return read(pBuffer, pOffset, pLength); // In case of 0-length readers
            }

-            next += read;
+            mNext += read;

            return read;
        }
@@ -213,7 +213,7 @@ public class CompoundReader extends Reader {
                return skip(pChars); // In case of 0-length readers
            }

-            next += skipped;
+            mNext += skipped;

            return skipped;
        }
@@ -34,7 +34,6 @@ 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
@@ -43,8 +42,11 @@ import java.util.Arrays;
 * @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.
@@ -70,7 +72,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();
@@ -95,8 +97,10 @@ public final class FastByteArrayOutputStream extends ByteArrayOutputStream {

    private void growIfNeeded(int pNewCount) {
        if (pNewCount > buf.length) {
-            int newSize = Math.max(buf.length << 1, pNewCount);
-            buf = Arrays.copyOf(buf, newSize);
+            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;
        }
    }

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

    /**
@@ -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 occurrence
+     * A file extension is the part of the filename, after the last occurence
     * of a period {@code '.'}.
     * If the filename contains no period, {@code null} is returned.
     *
@@ -922,7 +922,7 @@ public final class FileUtil {
            // A URL should never be able to represent an opaque URI, test anyway
            throw new IllegalArgumentException("URI is not hierarchical");
        }
-        if (path.isEmpty()) {
+        if (path.equals("")) {
            throw new IllegalArgumentException("URI path component is empty");
        }

@@ -65,7 +65,6 @@ import java.io.FilenameFilter;
 * @see WildcardStringParser
 * @deprecated
 */
-@Deprecated
 public class FilenameMaskFilter implements FilenameFilter {

     // TODO: Rewrite to use regexp, or create new class
@@ -442,7 +442,6 @@ 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();
@@ -50,8 +50,8 @@ public class StringArrayReader extends StringReader {
    protected final Object finalLock;
    private int currentSting;
    private int markedString;
-    private long mark;
-    private long next;
+    private int mark;
+    private int next;

    /**
     * Create a new string array reader.
@@ -151,7 +151,7 @@ public class StringArrayReader extends StringReader {
        }
    }

-    public int read(char[] pBuffer, int pOffset, int pLength) throws IOException {
+    public int read(char pBuffer[], int pOffset, int pLength) throws IOException {
        synchronized (finalLock) {
            int read = current.read(pBuffer, pOffset, pLength);

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

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

    /**
@@ -63,23 +64,22 @@ public final class SubStream extends FilterInputStream {
     */
    @Override
    public void close() throws IOException {
-        // NOTE: Do not close the underlying stream, but consume it
+        // NOTE: Do not close the underlying stream
        while (bytesLeft > 0) {
-            if (skip(bytesLeft) <= 0 && read() < 0) {
-                break;
-            }
+            //noinspection ResultOfMethodCallIgnored
+            skip(bytesLeft);
        }
    }

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

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

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

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

    @Override
-    public int read(final byte[] bytes, final int off, final int len) throws IOException {
+    public int read(final byte[] pBytes, final int pOffset, final int pLength) throws IOException {
        if (bytesLeft <= 0) {
            return -1;
        }

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

-    @Override
-    public long skip(long length) throws IOException {
-        long skipped = super.skip(findMaxLen(length)); // Skips 0 or more, never -1
-        bytesLeft -= skipped;
-
-        return skipped;
-    }
-
    /**
     * Finds the maximum number of bytes we can read or skip, from this stream.
     *
-     * @param length the requested length
+     * @param pLength the requested length
     * @return the maximum number of bytes to read
     */
-    private long findMaxLen(long length) {
-        return bytesLeft < length ? Math.max(bytesLeft, 0) : length;
+    private long findMaxLen(long pLength) {
+        if (bytesLeft < pLength) {
+            return (int) Math.max(bytesLeft, 0);
+        }
+        else {
+            return pLength;
+        }
+    }
+
+    @Override
+    public long skip(long pLength) throws IOException {
+        long skipped = super.skip(findMaxLen(pLength));// Skips 0 or more, never -1
+        bytesLeft -= skipped;
+        return skipped;
    }
 }
@@ -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 {
-    private final ByteBuffer buffer;
-    private final Decoder decoder;
+    protected final ByteBuffer buffer;
+    protected final Decoder decoder;

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

    /**
     * Creates a new decoder stream and chains it to the
-     * input stream specified by the {@code stream} argument.
+     * input stream specified by the {@code pStream} argument.
     *
-     * @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
+     * @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
     *
     * @see java.io.FilterInputStream#in
     */
-    public DecoderStream(final InputStream stream, final Decoder decoder, final int bufferSize) {
-        super(stream);
+    public DecoderStream(final InputStream pStream, final Decoder pDecoder, final int pBufferSize) {
+        super(pStream);

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

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

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

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

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

-        while (length > count) {
+        while (pLength > 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(length - count, buffer.remaining());
-            buffer.get(bytes, off, dstLen);
+            int dstLen = Math.min(pLength - count, buffer.remaining());
+            buffer.get(pBytes, off, dstLen);

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

-    public long skip(final long length) throws IOException {
+    public long skip(final long pLength) 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 length bytes, or have reached EOF
+        // Skip until we have skipped pLength bytes, or have reached EOF
        long total = 0;

-        while (total < length) {
+        while (total < pLength) {
            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(length - total, buffer.remaining());
+            int skipped = (int) Math.min(pLength - 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
     */
-    private int fill() throws IOException {
+    protected int fill() throws IOException {
        buffer.clear();
        int read = decoder.decode(in, buffer);

@@ -45,39 +45,41 @@ 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!!!

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

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

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

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

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

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

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

-    public void write(final byte[] bytes) throws IOException {
-        write(bytes, 0, bytes.length);
+    public final void write(final byte[] pBytes) throws IOException {
+        write(pBytes, 0, pBytes.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[] values, final int offset, final int length) throws IOException {
-        if (!flushOnWrite && length < buffer.remaining()) {
+    // 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()) {
            // Buffer data
-            buffer.put(values, offset, length);
+            buffer.put(pBytes, pOffset, pLength);
        }
        else {
            // Encode data already in the buffer
            encodeBuffer();

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

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

-        buffer.put((byte) value);
+        buffer.put((byte) pByte);
    }
 }
@@ -29,9 +29,6 @@

 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;
@@ -41,6 +38,9 @@ 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,6 +88,17 @@ 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.
@@ -158,7 +169,13 @@ public final class DOMSerializer {
            try {
                return DOMImplementationRegistry.newInstance();
            }
-            catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
+            catch (ClassNotFoundException e) {
+                throw new IllegalStateException(e);
+            }
+            catch (InstantiationException e) {
+                throw new IllegalStateException(e);
+            }
+            catch (IllegalAccessException e) {
                throw new IllegalStateException(e);
            }
        }
@@ -30,23 +30,16 @@

 package com.twelvemonkeys.xml;

-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 com.twelvemonkeys.lang.StringUtil;
+import org.w3c.dom.*;
+import org.xml.sax.SAXException;

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

 /**
 * XMLSerializer
@@ -297,7 +290,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, pStart, pEnd);
+        pBuilder.append(pString.substring(pStart, pEnd));
        pBuilder.append(pEntity);
        return pEnd + 1;
    }
@@ -534,7 +527,8 @@ public class XMLSerializer {
            builder = factory.newDocumentBuilder();
        }
        catch (ParserConfigurationException e) {
-            throw new IOException(e);
+            //noinspection ThrowableInstanceNeverThrown BOGUS
+            throw (IOException) new IOException(e.getMessage()).initCause(e);
        }

        DOMImplementation dom = builder.getDOMImplementation();
@@ -1,114 +0,0 @@
-package com.twelvemonkeys.io;
-
-import org.junit.Test;
-
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Arrays;
-import java.util.Random;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-
-/**
- * SubStreamTest.
- *
- * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
- * @author last modified by $Author: haraldk$
- * @version $Id: SubStreamTest.java,v 1.0 07/11/2023 haraldk Exp$
- */
-public class SubStreamTest {
-
-    private final Random rng = new Random(2918475687L);
-
-    @SuppressWarnings("resource")
-    @Test(expected = IllegalArgumentException.class)
-    public void testCreateNullStream() {
-        new SubStream(null, 42);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testCreateNegativeLength() {
-        new SubStream(new ByteArrayInputStream(new byte[1]), -1);
-    }
-
-    @Test
-    public void testReadAll() throws IOException {
-        byte[] buf = new byte[128];
-        rng.nextBytes(buf);
-
-        try (InputStream stream = new SubStream(new ByteArrayInputStream(buf), buf.length)) {
-            for (byte b : buf) {
-                assertEquals(b, (byte) stream.read());
-            }
-
-            assertEquals(-1, stream.read());
-        }
-    }
-
-    @Test
-    public void testReadAllArray() throws IOException {
-        byte[] buf = new byte[128];
-        rng.nextBytes(buf);
-
-        try (InputStream stream = new SubStream(new ByteArrayInputStream(buf), buf.length)) {
-            byte[] temp = new byte[buf.length / 4];
-            for (int i = 0; i < 4; i++) {
-                assertEquals(temp.length, stream.read(temp)); // Depends on ByteArrayInputStream specifics...
-                assertArrayEquals(Arrays.copyOfRange(buf, i * temp.length, (i + 1) * temp.length), temp);
-            }
-
-            assertEquals(-1, stream.read());
-        }
-    }
-
-    @Test
-    public void testSkipAll() throws IOException {
-        byte[] buf = new byte[128];
-
-        try (InputStream stream = new SubStream(new ByteArrayInputStream(buf), buf.length)) {
-            assertEquals(128, stream.skip(buf.length)); // Depends on ByteArrayInputStream specifics...
-            assertEquals(-1, stream.read());
-        }
-    }
-
-    @SuppressWarnings("EmptyTryBlock")
-    @Test
-    public void testCloseConsumesAll() throws IOException {
-        ByteArrayInputStream stream = new ByteArrayInputStream(new byte[128]);
-
-        try (InputStream ignore = new SubStream(stream, 128)) {
-            // Nothing here...
-        }
-
-        assertEquals(0, stream.available());
-        assertEquals(-1, stream.read());
-    }
-
-    @SuppressWarnings("EmptyTryBlock")
-    @Test
-    public void testCloseConsumesAllLongStream() throws IOException {
-        ByteArrayInputStream stream = new ByteArrayInputStream(new byte[256]);
-
-        try (InputStream ignore = new SubStream(stream, 128)) {
-            // Nothing here...
-        }
-
-        assertEquals(128, stream.available());
-        assertEquals(0, stream.read());
-    }
-
-    @SuppressWarnings("EmptyTryBlock")
-    @Test(timeout = 500L)
-    public void testCloseConsumesAllShortStream() throws IOException {
-        ByteArrayInputStream stream = new ByteArrayInputStream(new byte[13]);
-
-        try (InputStream ignore = new SubStream(stream, 42)) {
-            // Nothing here...
-        }
-
-        assertEquals(0, stream.available());
-        assertEquals(-1, stream.read());
-    }
-}
@@ -1,130 +0,0 @@
-/*
- * 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.assertArrayEquals;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

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

-    private byte[] createData(final int pLength) {
+    private byte[] createData(final int pLength) throws Exception {
        byte[] bytes = new byte[pLength];
        RANDOM.nextBytes(bytes);
        return bytes;
@@ -82,8 +82,9 @@ 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 (OutputStream out = new EncoderStream(outBytes, createEncoder(), true)) {
+        try {
            // Provoke failure for encoders that doesn't take array offset properly into account
            int off = (data.length + 1) / 2;
            out.write(data, 0, off);
@@ -91,6 +92,9 @@ public abstract class EncoderAbstractTest extends ObjectAbstractTest {
                out.write(data, off, data.length - off);
            }
        }
+        finally {
+            out.close();
+        }

        byte[] encoded = outBytes.toByteArray();

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

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

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

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

    @Test
@@ -125,6 +129,10 @@ 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) {
@@ -135,6 +143,10 @@ 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) {
@@ -145,8 +157,14 @@ 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.
+
+
 }
@@ -1,111 +0,0 @@
-/*
- * 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());
-        }
-    }
-}
@@ -33,12 +33,12 @@ package com.twelvemonkeys.io.ole2;
 import com.twelvemonkeys.io.InputStreamAbstractTest;
 import com.twelvemonkeys.io.LittleEndianDataOutputStream;
 import com.twelvemonkeys.io.MemoryCacheSeekableStream;
+import com.twelvemonkeys.io.SeekableInputStream;
 import org.junit.Test;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
+import java.net.URISyntaxException;
+import java.net.URL;
 import java.nio.charset.Charset;
 import java.util.Arrays;

@@ -4,25 +4,13 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.11.0-SNAPSHOT</version>
+        <version>3.4.4-SNAPSHOT</version>
    </parent>
    <artifactId>common-lang</artifactId>
    <packaging>jar</packaging>
    <name>TwelveMonkeys :: Common :: Language support</name>
    <description>
-        TwelveMonkeys Common language support classes.
+        The TwelveMonkeys Common Language support
    </description>

-    <properties>
-        <project.jpms.module.name>com.twelvemonkeys.common.lang</project.jpms.module.name>
-    </properties>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.felix</groupId>
-                <artifactId>maven-bundle-plugin</artifactId>
-            </plugin>
-        </plugins>
-    </build>
 </project>
@@ -88,7 +88,7 @@ public final class BeanUtil {

        while (begIdx < pProperty.length() && begIdx >= 0) {

-            endIdx = pProperty.indexOf('.', endIdx + 1);
+            endIdx = pProperty.indexOf(".", endIdx + 1);
            if (endIdx > 0) {
                subProp = pProperty.substring(begIdx, endIdx);
                begIdx = endIdx + 1;
@@ -106,7 +106,7 @@ public final class BeanUtil {
            Class[] paramClass = new Class[0];

            int begBracket;
-            if ((begBracket = subProp.indexOf('[')) > 0) {
+            if ((begBracket = subProp.indexOf("[")) > 0) {
                // An error if there is no matching bracket
                if (!subProp.endsWith("]")) {
                    return null;
@@ -770,7 +770,6 @@ public final class StringUtil {
     */

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

@@ -904,7 +903,7 @@ public final class StringUtil {
        }
        catch (ParseException pe) {
            // Wrap in RuntimeException
-            throw new IllegalArgumentException(pe.getMessage() + " at pos " + pe.getErrorOffset());
+            throw new IllegalArgumentException(pe.getMessage());
        }
    }

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

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

@@ -175,7 +175,6 @@ 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(String.valueOf(t.getSeconds()), digits, "0", true);
+        return StringUtil.pad("" + 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(String.valueOf(t.getMinutes()), digits, "0", true);
+        return StringUtil.pad("" + t.getMinutes(), digits, "0", true);
    }
 }

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

 /**
- * A {@code Map} implementation that removes (expires) its elements after
+ * A {@code Map} implementation that removes (exipres) 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 = Long.MAX_VALUE;
+    private volatile long nextExpiryTime;
    //////////////////////

    /**
@@ -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 entry = (TimedEntry) entries.get(pKey);
+        TimedEntry<K, V> entry = (TimedEntry<K, V>) 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 entry = (TimedEntry) entries.get(pKey);
+        TimedEntry<K, V> entry = (TimedEntry<K, V>) 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 entry = (TimedEntry) entries.remove(pKey);
+        TimedEntry<K, V> entry = (TimedEntry<K, V>) entries.remove(pKey);
        return (entry != null) ? entry.getValue() : null;
    }

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

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

    /**
     * Removes any expired mappings.
+     *
     */
    protected void removeExpiredEntries() {
        // Remove any expired elements
@@ -311,7 +312,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 entry = (TimedEntry) iterator.next();
+                TimedEntry<K, V> entry = (TimedEntry<K, V>) iterator.next();
                ////
                long expires = entry.expires();
                if (expires < next) {
@@ -375,7 +376,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 timed = (TimedEntry) entry.getValue();
+                TimedEntry<K, V> timed = (TimedEntry<K, V>) entry.getValue();

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

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

        public V setValue(V pValue) {
-            updateTimestamp();
-            return super.setValue(pValue);
-        }
-
-        private void updateTimestamp() {
            mTimestamp = System.currentTimeMillis();
-
-            long expires = expires();
-            if (expires < nextExpiryTime) {
-                nextExpiryTime = expires;
-            }
+            return super.setValue(pValue);
        }

        final boolean isExpired() {
@@ -111,7 +111,6 @@ 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

@@ -623,7 +622,7 @@ public class WildcardStringParser {
            buffer.append("\n");
            buffer.append("      Format: <state index>: <character> (<last free state>)");
            buffer.append("\n");
-            buffer.append("      Number of strings parsed: ").append(totalNumberOfStringsParsed);
+            buffer.append("      Number of strings parsed: " + totalNumberOfStringsParsed);
            buffer.append("\n");
        }
        return buffer.toString();
@@ -30,7 +30,7 @@

 package com.twelvemonkeys.lang;

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

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

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

 /**
 * 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);

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

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

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

    @Test
@@ -113,7 +113,6 @@ 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));
@@ -146,7 +145,6 @@ public class StringUtilTest {
        assertFalse(StringUtil.containsIgnoreCase(null, null));
    }

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

@@ -477,7 +475,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));
-        assertNotEquals(TEST_STRING, StringUtil.rtrim(WHITESPACE_STRING + TEST_STRING));
+        assertFalse(TEST_STRING.equals(StringUtil.rtrim(WHITESPACE_STRING + TEST_STRING)));
        // TODO: Test is not complete
    }

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

    @Test
@@ -554,13 +552,13 @@ public class StringUtilTest {
    public void testToDateWithFormatString() {
        Calendar cal = new GregorianCalendar();
        cal.clear();
-        cal.set(1976, Calendar.MARCH, 16); // Month is 0-based
+        cal.set(1976, 2, 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, Calendar.MAY, 13, 23, 51, 3);
+        cal.set(2004, 4, 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);
@@ -578,23 +576,23 @@ public class StringUtilTest {
    public void testToDateWithFormat() {
        Calendar cal = new GregorianCalendar();
        cal.clear();
-        cal.set(1976, Calendar.MARCH, 16); // Month is 0-based
+        cal.set(1976, 2, 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, 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);
+        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")));
        assertNotNull(date);
        assertEquals(cal.getTime(), date);

        cal.clear();
        cal.set(Calendar.HOUR, 1);
        cal.set(Calendar.MINUTE, 2);
-        format = new SimpleDateFormat("HH:mm");
-        date = StringUtil.toDate("1:02", format);
+        date = StringUtil.toDate("1:02 am",
+                                 DateFormat.getTimeInstance(DateFormat.SHORT, Locale.US));
        assertNotNull(date);
        assertEquals(cal.getTime(), date);
    }
@@ -603,9 +601,10 @@ public class StringUtilTest {
    public void testToTimestamp() {
        Calendar cal = new GregorianCalendar();
        cal.clear();
-        cal.set(1976, Calendar.MARCH, 16, 21, 28, 4); // Month is 0-based
-        Timestamp date = StringUtil.toTimestamp("1976-03-16 21:28:04");
+        cal.set(1976, 2, 16, 21, 28, 4); // Month is 0-based
+        Date date = StringUtil.toTimestamp("1976-03-16 21:28:04");
        assertNotNull(date);
+        assertTrue(date instanceof Timestamp);
        assertEquals(cal.getTime(), date);
    }

@@ -822,7 +821,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) + Long.MAX_VALUE));
+        assertTrue(StringUtil.isNumber(String.valueOf(Long.MAX_VALUE) + String.valueOf(Long.MAX_VALUE)));
        assertFalse(StringUtil.isNumber("abc"));
        assertFalse(StringUtil.isNumber(TEST_STRING));
    }
@@ -832,7 +831,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) + Long.MAX_VALUE));
+        assertTrue(StringUtil.isNumber('-' + String.valueOf(Long.MAX_VALUE) + String.valueOf(Long.MAX_VALUE)));
        assertFalse(StringUtil.isNumber("-abc"));
        assertFalse(StringUtil.isNumber('-' + TEST_STRING));
    }
@@ -1117,19 +1117,18 @@ 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);
-        assertNull("Last element should be set to null", a[0]);
+        assertEquals("Given array shouldn't shrink", array, a);
+        assertEquals("Last element should be set to null", a[0], null);
        verifyAll();

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

        try {
-            collection.toArray((Object[]) null);
+            array = collection.toArray(null);
            fail("toArray(null) should raise NPE");
        } catch (NullPointerException e) {
            // expected
@@ -1151,13 +1150,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<Class<?>> classes = new HashSet<>();
+        HashSet 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 static void assertCorrectListIterator(ListIterator<String> iterator, final Object[] elements) {
+    private 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 static void assertCorrectListIterator(ListIterator<String> iterator, final Object[] elements, boolean skipRemove, boolean skipAdd) {
+    private 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 ignore) {
+                    catch (InterruptedException e) {
                    }
                }
            }
@@ -651,24 +651,5 @@ 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.11.0-SNAPSHOT</version>
+        <version>3.4.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.13.2</version>
+            <version>4.7</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
@@ -4,13 +4,13 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.11.0-SNAPSHOT</version>
+        <version>3.4.4-SNAPSHOT</version>
    </parent>
    <groupId>com.twelvemonkeys.contrib</groupId>
    <artifactId>contrib</artifactId>
    <name>TwelveMonkeys :: Contrib</name>
    <description>
-      Contributions to TwelveMonkeys and code that doesn't fit anywhere else.
+      Contributions to TwelveMonkeys which are not matching into the ImageIO plug-ins.
    </description>

    <dependencies>
@@ -65,17 +65,8 @@
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
-            <version>4.13.2</version>
+            <version>4.7</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.felix</groupId>
-                <artifactId>maven-bundle-plugin</artifactId>
-            </plugin>
-        </plugins>
-    </build>
 </project>
@@ -1,178 +0,0 @@
-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);
-        }
-    }
-}
@@ -1,63 +0,0 @@
-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;
-    }
-}
@@ -45,9 +45,11 @@ import javax.imageio.stream.ImageInputStream;
 import javax.imageio.stream.ImageOutputStream;
 import java.awt.geom.AffineTransform;
 import java.awt.image.BufferedImage;
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;

@@ -200,10 +202,11 @@ 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);

-        final int pageCount = IFDs.directoryCount();
-        List<TIFFPage> pages = new ArrayList<>(pageCount);
+        int pageCount = IFDs.directoryCount();
        for (int pageIndex = 0; pageIndex < pageCount; pageIndex++) {
            pages.add(new TIFFPage(IFDs.getDirectory(pageIndex), imageInput));
        }
@@ -355,21 +358,13 @@ public final class TIFFUtilities {
                }
            }

-            int compression = -1;
-            Entry compressionEntry = IFD.getEntryById(TIFF.TAG_COMPRESSION);
-            if (compressionEntry != null && compressionEntry.getValue() instanceof Number) {
-                compression = ((Number) compressionEntry.getValue()).shortValue();
-            }
-
            boolean rearrangedByteStrips = false;
            Entry oldJpegData = IFD.getEntryById(TIFF.TAG_JPEG_INTERCHANGE_FORMAT);
            Entry oldJpegDataLength = IFD.getEntryById(TIFF.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
-            long[] jpegByteCounts = null;
-            long[] jpegOffsets = null;
            if (oldJpegData != null && oldJpegData.valueCount() > 0) {
                // convert JPEGInterchangeFormat to new-style-JPEG
-                jpegByteCounts = new long[0];
-                jpegOffsets = getValueAsLongArray(oldJpegData);
+                long[] jpegByteCounts = new long[0];
+                long[] jpegOffsets = getValueAsLongArray(oldJpegData);
                if (oldJpegDataLength != null && oldJpegDataLength.valueCount() > 0) {
                    jpegByteCounts = getValueAsLongArray(oldJpegDataLength);
                }
@@ -393,20 +388,6 @@ public final class TIFFUtilities {
                    newIFD.remove(oldJpegDataLength);
                    rearrangedByteStrips = true;
                }
-                else if (offsets.length == 1 && oldJpegDataLength != null && (jpegOffsets[0] < offsets[0]) && (jpegOffsets[0] + jpegByteCounts[0]) > (offsets[0] + byteCounts[0])) {
-
-                    // ByteStrip contains only a part of JPEGInterchangeFormat
-                    newOffsets = writeData(jpegOffsets, jpegByteCounts, outputStream);
-
-                    newIFD.remove(stripOffsetsEntry);
-                    newIFD.add(new TIFFEntry(useTiles ? TIFF.TAG_TILE_OFFSETS : TIFF.TAG_STRIP_OFFSETS, newOffsets));
-                    newIFD.remove(stripByteCountsEntry);
-                    newIFD.add(new TIFFEntry(useTiles ? TIFF.TAG_TILE_BYTE_COUNTS : TIFF.TAG_STRIP_BYTE_COUNTS, new int[]{(int) (jpegByteCounts[0])}));
-
-                    newIFD.remove(oldJpegData);
-                    newIFD.remove(oldJpegDataLength);
-                    rearrangedByteStrips = true;
-                }
                else if (oldJpegDataLength != null) {
                    // multiple bytestrips
                    // search for SOF on first strip and copy to each if needed
@@ -442,7 +423,7 @@ public final class TIFFUtilities {
                        byte[] buffer = new byte[(int) byteCounts[i]];
                        newByteCounts[i] = (int) (jpegInterchangeData.length + byteCounts[i]);
                        stream.readFully(buffer);
-                        if (buffer[0] != ((byte) 0xff) || buffer[1] != ((byte) 0xda)) {
+                        if (buffer[0] != 0xff && buffer[1] != 0xda) {
                            outputStream.write(sosMarker);
                            newByteCounts[i] += sosMarker.length;
                        }
@@ -459,58 +440,7 @@ public final class TIFFUtilities {
                    rearrangedByteStrips = true;
                }
            }
-            else if (compression == TIFFExtension.COMPRESSION_OLD_JPEG) {
-                // old-style but no JPEGInterchangeFormat

-                long[] yCbCrSubSampling = getValueAsLongArray(IFD.getEntryById(TIFF.TAG_YCBCR_SUB_SAMPLING));
-                int subsampling = yCbCrSubSampling != null
-                        ? (int) ((yCbCrSubSampling[0] & 0xf) << 4 | yCbCrSubSampling[1] & 0xf)
-                        : 0x22;
-                int bands = ((Number) IFD.getEntryById(TIFF.TAG_SAMPLES_PER_PIXEL).getValue()).intValue();
-
-                int w = ((Number) IFD.getEntryById(TIFF.TAG_IMAGE_WIDTH).getValue()).intValue();
-                int h = ((Number) IFD.getEntryById(TIFF.TAG_IMAGE_HEIGHT).getValue()).intValue();
-
-                int r = ((Number) (useTiles ? IFD.getEntryById(TIFF.TAG_TILE_HEIGTH) : IFD.getEntryById(TIFF.TAG_ROWS_PER_STRIP)).getValue()).intValue();
-                int c = useTiles ? ((Number) IFD.getEntryById(TIFF.TAG_TILE_WIDTH).getValue()).intValue() : w;
-
-                newOffsets = new int[offsets.length];
-                int[] newByteCounts = new int[byteCounts.length];
-
-                // No JPEGInterchangeFormat
-                for (int i = 0; i < offsets.length; i++) {
-                    byte[] start = new byte[2];
-                    stream.seek(offsets[i]);
-                    stream.readFully(start);
-                    newOffsets[i] = (int) outputStream.getStreamPosition();
-                    if (start[0] == ((byte) 0xff) && start[1] == ((byte) 0xd8)) {
-                        // full image stream, nothing to do
-                        writeData(stream, outputStream, offsets[i], byteCounts[i]);
-                    }
-                    else if (start[0] == ((byte) 0xff) && start[1] == ((byte) 0xda)) {
-                        // starts with SOS
-                        outputStream.writeShort(JPEG.SOI);
-                        writeSOF0(outputStream, bands, c, r, subsampling);
-                        writeData(stream, outputStream, offsets[i], byteCounts[i]);
-                        outputStream.writeShort(JPEG.EOI);
-                    }
-                    else {
-                        // raw data
-                        outputStream.writeShort(JPEG.SOI);
-                        writeSOF0(outputStream, bands, c, r, subsampling);
-                        writeSOS(outputStream, bands);
-                        writeData(stream, outputStream, offsets[i], byteCounts[i]);
-                        outputStream.writeShort(JPEG.EOI);
-                    }
-                    newByteCounts[i] = ((int) outputStream.getStreamPosition()) - newOffsets[i];
-                }
-
-                newIFD.remove(stripOffsetsEntry);
-                newIFD.add(new TIFFEntry(useTiles ? TIFF.TAG_TILE_OFFSETS : TIFF.TAG_STRIP_OFFSETS, newOffsets));
-                newIFD.remove(stripByteCountsEntry);
-                newIFD.add(new TIFFEntry(useTiles ? TIFF.TAG_TILE_BYTE_COUNTS : TIFF.TAG_STRIP_BYTE_COUNTS, newByteCounts));
-                rearrangedByteStrips = true;
-            }

            if (!rearrangedByteStrips && stripOffsetsEntry != null && stripByteCountsEntry != null) {
                newOffsets = writeData(offsets, byteCounts, outputStream);
@@ -527,21 +457,12 @@ public final class TIFFUtilities {
            oldJpegTableQ = IFD.getEntryById(TIFF.TAG_OLD_JPEG_Q_TABLES);
            oldJpegTableDC = IFD.getEntryById(TIFF.TAG_OLD_JPEG_DC_TABLES);
            oldJpegTableAC = IFD.getEntryById(TIFF.TAG_OLD_JPEG_AC_TABLES);
-            if ((oldJpegTableQ != null) || (oldJpegTableDC != null) || (oldJpegTableAC != null)) {
+            if (oldJpegTableQ != null || oldJpegTableDC != null || oldJpegTableAC != null) {
                if (IFD.getEntryById(TIFF.TAG_JPEG_TABLES) != null) {
                    throw new IOException("Found old-style and new-style JPEGTables");
                }

-                boolean tablesInStream = jfifContainsTables(oldJpegTableQ, jpegOffsets, jpegByteCounts);
-                tablesInStream &= jfifContainsTables(oldJpegTableDC, jpegOffsets, jpegByteCounts);
-                tablesInStream &= jfifContainsTables(oldJpegTableAC, jpegOffsets, jpegByteCounts);
-                if (!tablesInStream) {
-                    // merge them only to JPEGTables if they are not already contained within the stream
-                    Entry jpegTables = mergeTables(oldJpegTableQ, oldJpegTableDC, oldJpegTableAC);
-                    if (jpegTables != null) {
-                        newIFD.add(jpegTables);
-                    }
-                }
+                newIFD.add(mergeTables(oldJpegTableQ, oldJpegTableDC, oldJpegTableAC));
                if (oldJpegTableQ != null) {
                    newIFD.remove(oldJpegTableQ);
                }
@@ -553,66 +474,17 @@ public final class TIFFUtilities {
                }
            }

-            if (compressionEntry != null && compression == TIFFExtension.COMPRESSION_OLD_JPEG) {
-                newIFD.remove(compressionEntry);
-                newIFD.add(new TIFFEntry(TIFF.TAG_COMPRESSION, TIFF.TYPE_SHORT, TIFFExtension.COMPRESSION_JPEG));
+            Entry compressionEntry = IFD.getEntryById(TIFF.TAG_COMPRESSION);
+            if(compressionEntry != null) {
+                Number compression = (Number) compressionEntry.getValue();
+                if (compression.shortValue() == TIFFExtension.COMPRESSION_OLD_JPEG) {
+                    newIFD.remove(compressionEntry);
+                    newIFD.add(new TIFFEntry(TIFF.TAG_COMPRESSION, TIFF.TYPE_SHORT, TIFFExtension.COMPRESSION_JPEG));
+                }
            }
            return newIFD;
        }

-        //TODO merge/extract from TIFFReader Jpeg/6 stream reconstruction
-        private void writeSOF0(ImageOutputStream outputStream, int bands, int width, int height, int subsampling) throws IOException {
-            outputStream.writeShort(JPEG.SOF0); // TODO: Use correct process for data
-            outputStream.writeShort(2 + 6 + 3 * bands); // SOF0 len
-            outputStream.writeByte(8); // bits TODO: Consult raster/transfer type or BitsPerSample for 12/16 bits support
-            outputStream.writeShort(height); // height
-            outputStream.writeShort(width); // width
-            outputStream.writeByte(bands); // Number of components
-
-            for (int comp = 0; comp < bands; comp++) {
-                outputStream.writeByte(comp); // Component id
-                outputStream.writeByte(comp == 0 ? subsampling : 0x11); // h/v subsampling
-                outputStream.writeByte(comp); // Q table selector TODO: Consider merging if tables are equal, correct selection if only 1 or 2 valid tables are contained
-            }
-        }
-
-        //TODO merge/extract from TIFFReader Jpeg/6 stream reconstruction
-        private void writeSOS(ImageOutputStream outputStream, int bands) throws IOException {
-            outputStream.writeShort(JPEG.SOS);
-            outputStream.writeShort(6 + 2 * bands); // SOS length
-            outputStream.writeByte(bands); // Num comp
-
-            for (int component = 0; component < bands; component++) {
-                outputStream.writeByte(component); // Comp id
-                outputStream.writeByte(component == 0 ? component : 0x10 + (component & 0xf)); // dc/ac selector TODO: correct selection if only 1 or 2 valid tables are contained
-            }
-
-            outputStream.writeByte(0); // Spectral selection start
-            outputStream.writeByte(0); // Spectral selection end
-            outputStream.writeByte(0); // Approx high & low
-        }
-
-        private void writeData(ImageInputStream input, ImageOutputStream output, long offset, long length) throws IOException {
-            input.seek(offset);
-            byte[] buffer = new byte[(int) length];
-            stream.readFully(buffer);
-            output.write(buffer);
-        }
-
-        private boolean jfifContainsTables(Entry tableEntry, long[] jpegOffsets, long[] jpegLengths) throws IOException {
-            if (jpegLengths == null || jpegOffsets == null || jpegLengths.length == 0) return false;
-            if (tableEntry != null) {
-                long[] tableOffsets = getValueAsLongArray(tableEntry);
-                for (long offset : tableOffsets) {
-                    if (offset < jpegOffsets[0] || offset > (jpegOffsets[0] + jpegLengths[0])) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        }
-
-        //TODO merge/extract from TIFFReader Jpeg/6 stream reconstruction
        private Entry mergeTables(Entry qEntry, Entry dcEntry, Entry acEntry) throws IOException {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            DataOutputStream dos = new DataOutputStream(bos);
@@ -622,16 +494,12 @@ public final class TIFFUtilities {
                long[] off = getValueAsLongArray(qEntry);
                byte[] table = new byte[64];
                for (int tableId = 0; tableId < off.length; tableId++) {
-                    try {
-                        stream.seek(off[tableId]);
-                        stream.readFully(table);
-                        dos.writeShort(JPEG.DQT);
-                        dos.writeShort(3 + 64);
-                        dos.writeByte(tableId);
-                        dos.write(table);
-                    } catch (EOFException e) {
-                        // invalid table pointer, ignore
-                    }
+                    stream.seek(off[tableId]);
+                    stream.readFully(table);
+                    dos.writeShort(JPEG.DQT);
+                    dos.writeShort(3 + 64);
+                    dos.writeByte(tableId);
+                    dos.write(table);
                }
            }

@@ -639,50 +507,30 @@ public final class TIFFUtilities {
            if (dcEntry != null && dcEntry.valueCount() > 0) {
                long[] off = getValueAsLongArray(dcEntry);
                for (int tableId = 0; tableId < off.length; tableId++) {
-                    try {
-                        stream.seek(off[tableId]);
-                        byte[] table = readHUFFTable();
-                        if (table.length > (16 + 17)) {
-                            // to long, table is invalid, just ignoe
-                            continue;
-                        }
-                        dos.writeShort(JPEG.DHT);
-                        dos.writeShort(3 + table.length);
-                        dos.writeByte(tableId);
-                        dos.write(table);
-                    } catch (EOFException e) {
-                        // invalid table pointer, ignore
-                    }
+                    stream.seek(off[tableId]);
+                    byte[] table = readHUFFTable();
+                    dos.writeShort(JPEG.DHT);
+                    dos.writeShort(3 + table.length);
+                    dos.writeByte(tableId);
+                    dos.write(table);
                }
            }

            if (acEntry != null && acEntry.valueCount() > 0) {
                long[] off = getValueAsLongArray(acEntry);
                for (int tableId = 0; tableId < off.length; tableId++) {
-                    try {
-                        stream.seek(off[tableId]);
-                        byte[] table = readHUFFTable();
-                        if (table.length > (16 + 256)) {
-                            // to long, table is invalid, just ignoe
-                            continue;
-                        }
-                        dos.writeShort(JPEG.DHT);
-                        dos.writeShort(3 + table.length);
-                        dos.writeByte(16 | tableId);
-                        dos.write(table);
-                    } catch (EOFException e) {
-                        // invalid table pointer, ignore
-                    }
+                    stream.seek(off[tableId]);
+                    byte[] table = readHUFFTable();
+                    dos.writeShort(JPEG.DHT);
+                    dos.writeShort(3 + table.length);
+                    dos.writeByte(16 | tableId);
+                    dos.write(table);
                }
            }

            dos.writeShort(JPEG.EOI);

            bos.close();
-            if (bos.size() == 4) {
-                // no valid tables, don't add
-                return null;
-            }

            return new TIFFEntry(TIFF.TAG_JPEG_TABLES, TIFF.TYPE_UNDEFINED, bos.toByteArray());
        }
@@ -692,11 +540,15 @@ public final class TIFFUtilities {
            stream.readFully(lengths);
            int numCodes = 0;
            for (int i = 0; i < lengths.length; i++) {
-                numCodes += ((int) lengths[i]) & 0xff;
+                numCodes += lengths[i];
            }
            byte table[] = new byte[16 + numCodes];
            System.arraycopy(lengths, 0, table, 0, 16);
-            stream.readFully(table, 16, numCodes);
+            int off = 16;
+            for (int i = 0; i < lengths.length; i++) {
+                stream.read(table, off, lengths[i]);
+                off += lengths[i];
+            }
            return table;
        }

@@ -707,11 +559,7 @@ public final class TIFFUtilities {
                stream.seek(offsets[i]);

                byte[] buffer = new byte[(int) byteCounts[i]];
-                try {
-                    stream.readFully(buffer);
-                } catch (EOFException e) {
-                    // invalid strip length
-                }
+                stream.readFully(buffer);
                outputStream.write(buffer);
            }
            return newOffsets;
@@ -723,7 +571,7 @@ public final class TIFFUtilities {

            if (entry.valueCount() == 1) {
                // For single entries, this will be a boxed type
-                value = new long[]{((Number) entry.getValue()).longValue()};
+                value = new long[] {((Number) entry.getValue()).longValue()};
            }
            else if (entry.getValue() instanceof short[]) {
                short[] shorts = (short[]) entry.getValue();
@@ -1,75 +0,0 @@
-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,9 +31,8 @@
 package com.twelvemonkeys.contrib.tiff;

 import com.twelvemonkeys.contrib.tiff.TIFFUtilities.TIFFExtension;
-import com.twelvemonkeys.imageio.plugins.tiff.TIFFImageMetadataFormat;
+import com.twelvemonkeys.imageio.plugins.tiff.TIFFMedataFormat;
 import com.twelvemonkeys.io.FileUtil;
-
 import org.junit.Assert;
 import org.junit.Test;
 import org.w3c.dom.Node;
@@ -155,7 +154,7 @@ public class TIFFUtilitiesTest {
        reader.setInput(checkTest1);
        for (int i = 0; i < 3; i++) {
            Node metaData = reader.getImageMetadata(i)
-                    .getAsTree(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
+                    .getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
            short orientation = ((Number) expression.evaluate(metaData, XPathConstants.NUMBER)).shortValue();
            Assert.assertEquals(orientation, TIFFExtension.ORIENTATION_RIGHTTOP);
        }
@@ -172,7 +171,7 @@ public class TIFFUtilitiesTest {
        reader.setInput(checkTest2);
        for (int i = 0; i < 3; i++) {
            Node metaData = reader.getImageMetadata(i)
-                    .getAsTree(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
+                    .getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
            short orientation = ((Number) expression.evaluate(metaData, XPathConstants.NUMBER)).shortValue();
            Assert.assertEquals(orientation, i == 1
                                             ? TIFFExtension.ORIENTATION_BOTRIGHT
@@ -203,39 +202,36 @@ public class TIFFUtilitiesTest {
    }

    @Test
-    public void testOldStyleJPEGTransform() throws IOException {
-        String[] testFiles = new String[]{
+    public void testMergeBogusInterchangeFormatLength() throws IOException {
+        String[] testFiles = new String[] {
                "/tiff/old-style-jpeg-bogus-jpeginterchangeformatlength.tif", // InterchangeFormat before StripOffset, length not including StripOffset
                "/tiff/old-style-jpeg-no-jpeginterchangeformatlength.tif", // missing JPEGInterChangeFormatLength and JPEGInterchangeFormat == StipOffset
-                "/tiff/old-style-jpeg-multiple-strips.tif", // InterchangeFormat with multiple strips
-                "/contrib/tiff/old-style-jpeg-invalid-tables.tif", // AC/DC Tables are invalid (to long) and lie within the JPEGInterchangeFormat stream
-                "/contrib/tiff/smallliz.tif", // InterchangeFormat contains whole JPEG, ByteStrip only raw ImageData after SOS
-                "/contrib/tiff/WangJPEG.tif", // multiple strips, first strip contains SOS
-                "/contrib/tiff/zackthecat.tif" // No JPEGInterchangeFormat, ByteStrip contains only raw image data
+                "/tiff/old-style-jpeg-multiple-strips.tif" // InterchangeFormat with multiple strips
        };

        for (String testFile : testFiles) {
-            try {
-                File output = File.createTempFile("imageiotest", ".tif");
-                ImageOutputStream outputStream = ImageIO.createImageOutputStream(output);
-                InputStream inputStream = getClassLoaderResource(testFile).openStream();
-                ImageInputStream imageInput = ImageIO.createImageInputStream(inputStream);
-                List<TIFFUtilities.TIFFPage> pages = TIFFUtilities.getPages(imageInput);
-                TIFFUtilities.writePages(outputStream, pages);
+            File output = File.createTempFile("imageiotest", ".tif");
+            ImageOutputStream outputStream = ImageIO.createImageOutputStream(output);
+            InputStream inputStream1 = getClassLoaderResource(testFile).openStream();
+            ImageInputStream imageInput1 = ImageIO.createImageInputStream(inputStream1);
+            InputStream inputStream2 = getClassLoaderResource(testFile).openStream();
+            ImageInputStream imageInput2 = ImageIO.createImageInputStream(inputStream2);
+            ArrayList<TIFFUtilities.TIFFPage> pages = new ArrayList<>();
+            pages.addAll(TIFFUtilities.getPages(imageInput1));
+            pages.addAll(TIFFUtilities.getPages(imageInput2));
+            TIFFUtilities.writePages(outputStream, pages);

-                ImageInputStream testOutput = ImageIO.createImageInputStream(output);
-                ImageReader reader = ImageIO.getImageReaders(testOutput).next();
-                reader.setInput(testOutput);
-                int numImages = reader.getNumImages(true);
-                for (int i = 0; i < numImages; i++) {
-                    reader.read(i);
-                }
-
-                imageInput.close();
-                outputStream.close();
-            } catch (Exception exc) {
-                throw new IOException(testFile, exc);
+            ImageInputStream testOutput = ImageIO.createImageInputStream(output);
+            ImageReader reader = ImageIO.getImageReaders(testOutput).next();
+            reader.setInput(testOutput);
+            int numImages = reader.getNumImages(true);
+            for (int i = 0; i < numImages; i++) {
+                reader.read(i);
            }
+
+            imageInput1.close();
+            imageInput2.close();
+            outputStream.close();
        }
    }

@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.11.0-SNAPSHOT</version>
+        <version>3.4.4-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-batik</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Batik Plugin</name>
@@ -15,39 +15,6 @@
        for more information.]]>
    </description>

-    <properties>
-        <project.jpms.module.name>com.twelvemonkeys.imageio.batik</project.jpms.module.name>
-        <batik.version>1.17</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>
-            <plugin>
-                <groupId>org.apache.felix</groupId>
-                <artifactId>maven-bundle-plugin</artifactId>
-                <configuration>
-                    <instructions>
-                        <Provide-Capability>
-                            osgi.serviceloader;
-                            osgi.serviceloader=javax.imageio.spi.ImageReaderSpi
-                        </Provide-Capability>
-                    </instructions>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-
    <dependencies>
        <dependency>
            <groupId>com.twelvemonkeys.imageio</groupId>
@@ -57,14 +24,6 @@
            <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.15.0</version>
-            <scope>provided</scope>
        </dependency>

        <dependency>
@@ -87,6 +46,13 @@
            <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>
@@ -110,7 +76,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 the specified version
+            making everything end up depending on Batik 1.5, not 1.6
            -->
            <exclusions>
                <exclusion>
@@ -120,4 +86,8 @@
            </exclusions>
        </dependency>
    </dependencies>
+
+    <properties>
+        <batik.version>1.9</batik.version>
+    </properties>
 </project>
@@ -33,9 +33,6 @@ 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.imageio.util.ImageTypeSpecifiers;
-import com.twelvemonkeys.lang.StringUtil;
-
 import org.apache.batik.anim.dom.SVGDOMImplementation;
 import org.apache.batik.anim.dom.SVGOMDocument;
 import org.apache.batik.bridge.*;
@@ -46,11 +43,7 @@ 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.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.*;
 import org.apache.batik.transcoder.image.ImageTranscoder;
 import org.apache.batik.util.ParsedURL;
 import org.apache.batik.util.SVGConstants;
@@ -63,8 +56,10 @@ import javax.imageio.ImageReadParam;
 import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.spi.ImageReaderSpi;
 import java.awt.*;
-import java.awt.geom.*;
-import java.awt.image.*;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Dimension2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -78,24 +73,18 @@ 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}.
     *
-     * @param provider the provider
+     * @param pProvider the provider
     */
-    public SVGImageReader(final ImageReaderSpi provider) {
-        super(provider);
+    public SVGImageReader(final ImageReaderSpi pProvider) {
+        super(pProvider);
    }

    protected void resetMembers() {
@@ -109,23 +98,20 @@ public class SVGImageReader extends ImageReaderBase {
    }

    @Override
-    public void setInput(Object input, boolean seekForwardOnly, boolean ignoreMetadata) {
-        super.setInput(input, seekForwardOnly, ignoreMetadata);
+    public void setInput(Object pInput, boolean seekForwardOnly, boolean ignoreMetadata) {
+        super.setInput(pInput, seekForwardOnly, ignoreMetadata);

        if (imageInput != null) {
-            TranscoderInput transcoderInput = new TranscoderInput(IIOUtil.createStreamAdapter(imageInput));
-            rasterizer.setInput(transcoderInput);
+            TranscoderInput input = new TranscoderInput(IIOUtil.createStreamAdapter(imageInput));
+            rasterizer.setInput(input);
        }
    }

-    public BufferedImage read(int imageIndex, ImageReadParam param) throws IOException {
-        checkBounds(imageIndex);
+    public BufferedImage read(int pIndex, ImageReadParam pParam) throws IOException {
+        checkBounds(pIndex);

-        if (param instanceof SVGReadParam) {
-            SVGReadParam svgParam = (SVGReadParam) param;
-
-            // set the external-resource-resolution preference
-            allowExternalResources = svgParam.isAllowExternalResources();
+        if (pParam instanceof SVGReadParam) {
+            SVGReadParam svgParam = (SVGReadParam) pParam;

            // Get the base URI
            // This must be done before converting the params to hints
@@ -135,38 +121,43 @@ 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));
        }

        Dimension size = null;
-        if (param != null) {
-            size = param.getSourceRenderSize();
+        if (pParam != null) {
+            size = pParam.getSourceRenderSize();
        }
        if (size == null) {
-            size = new Dimension(getWidth(imageIndex), getHeight(imageIndex));
+            size = new Dimension(getWidth(pIndex), getHeight(pIndex));
        }

-        BufferedImage destination = getDestination(param, getImageTypes(imageIndex), size.width, size.height);
+        BufferedImage destination = getDestination(pParam, getImageTypes(pIndex), size.width, size.height);

        // Read in the image, using the Batik Transcoder
-        processImageStarted(imageIndex);
-
-        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();
-        }
+            processImageStarted(pIndex);

-        processImageComplete();
+            BufferedImage image = rasterizer.getImage();

-        return destination;
+            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;
+        }
+        catch (TranscoderException e) {
+            Throwable cause = unwrapException(e);
+            throw new IIOException(cause.getMessage(), cause);
+        }
    }

    private static Throwable unwrapException(TranscoderException ex) {
@@ -174,18 +165,18 @@ public class SVGImageReader extends ImageReaderBase {
        return ex.getException() != null ? ex.getException() : ex;
    }

-    private TranscodingHints paramsToHints(SVGReadParam param) throws IOException {
+    private TranscodingHints paramsToHints(SVGReadParam pParam) throws IOException {
        TranscodingHints hints = new TranscodingHints();
        // Note: We must allow generic ImageReadParams, so converting to
        //       TanscodingHints should be done outside the SVGReadParam class.

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

        if (size != null) {
@@ -194,7 +185,7 @@ public class SVGImageReader extends ImageReaderBase {
        }

        // Set area of interest
-        Rectangle region = param.getSourceRegion();
+        Rectangle region = pParam.getSourceRegion();
        if (region != null) {
            hints.put(ImageTranscoder.KEY_AOI, region);

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

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

        // Background color
-        Paint bg = param.getBackgroundColor();
+        Paint bg = pParam.getBackgroundColor();
        if (bg != null) {
            hints.put(ImageTranscoder.KEY_BACKGROUND_COLOR, bg);
        }
@@ -226,10 +217,10 @@ public class SVGImageReader extends ImageReaderBase {
        return hints;
    }

-    private Dimension getSourceRenderSizeFromSubsamping(ImageReadParam param, Dimension origSize) {
-        if (param.getSourceXSubsampling() > 1 || param.getSourceYSubsampling() > 1) {
-            return new Dimension((int) (origSize.width / (float) param.getSourceXSubsampling()),
-                    (int) (origSize.height / (float) param.getSourceYSubsampling()));
+    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()));
        }
        return null;
    }
@@ -238,19 +229,28 @@ public class SVGImageReader extends ImageReaderBase {
        return new SVGReadParam();
    }

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

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

-    public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) {
-        return Collections.singleton(ImageTypeSpecifiers.createFromRenderedImage(rasterizer.createImage(1, 1))).iterator();
+    public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) throws IOException {
+        return Collections.singleton(ImageTypeSpecifier.createFromRenderedImage(rasterizer.createImage(1, 1))).iterator();
    }

    /**
@@ -260,11 +260,12 @@ public class SVGImageReader extends ImageReaderBase {
     * and needs major refactoring!
     * </p>
     */
-    private class Rasterizer extends SVGAbstractTranscoder {
+    private class Rasterizer extends SVGAbstractTranscoder /*ImageTranscoder*/ {
+
        private BufferedImage image;
        private TranscoderInput transcoderInput;
-        private final Rectangle2D viewBox = new Rectangle2D.Float();
-        private final Dimension defaultSize = new Dimension();
+        private float defaultWidth;
+        private float defaultHeight;
        private boolean initialized = false;
        private SVGOMDocument document;
        private String uri;
@@ -277,7 +278,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) {
+        protected void transcode(Document document, final String uri, final TranscoderOutput output) throws TranscoderException {
            // Sets up root, curTxf & curAoi
            // ----
            if (document != null) {
@@ -323,66 +324,24 @@ public class SVGImageReader extends ImageReaderBase {
            }

            // ----
-            SVGSVGElement rootElement = svgDoc.getRootElement();

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

            // Hack to work around exception above
@@ -397,7 +356,7 @@ public class SVGImageReader extends ImageReaderBase {
            ctx = null;
        }

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

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

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


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

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

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

-            if (Px.isIdentity() && (width != defaultSize.width || height != defaultSize.height)) {
+            if (Px.isIdentity() && (width != defaultWidth || height != defaultHeight)) {
                // 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 / defaultSize.width;
-                yscale = height / defaultSize.height;
+                xscale = width / defaultWidth;
+                yscale = height / defaultHeight;
                float scale = Math.min(xscale, yscale);
                Px = AffineTransform.getScaleInstance(scale, scale);
            }
@@ -515,7 +474,7 @@ public class SVGImageReader extends ImageReaderBase {
                }
            }
            catch (BridgeException ex) {
-                throw new IIOException(ex.getMessage(), ex);
+                throw new TranscoderException(ex);
            }

            this.root = gvtRoot;
@@ -584,7 +543,9 @@ public class SVGImageReader extends ImageReaderBase {
                return dest;
            }
            catch (Exception ex) {
-                throw new IIOException(ex.getMessage(), ex);
+                TranscoderException exception = new TranscoderException(ex.getMessage());
+                exception.initCause(ex);
+                throw exception;
            }
            finally {
                if (context != null) {
@@ -593,7 +554,7 @@ public class SVGImageReader extends ImageReaderBase {
            }
        }

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

                initialized = true;

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

-        private BufferedImage getImage() throws IOException {
+        private BufferedImage getImage() throws TranscoderException {
            if (image == null) {
                image = readImage();
            }
@@ -620,23 +574,18 @@ public class SVGImageReader extends ImageReaderBase {
            return image;
        }

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

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

-        Rectangle getViewBox() throws IOException {
-            init();
-            return viewBox.getBounds();
-        }
-
-        void setInput(final TranscoderInput input) {
-            transcoderInput = input;
+        void setInput(final TranscoderInput pInput) {
+            transcoderInput = pInput;
        }

        @Override
@@ -659,14 +608,6 @@ 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);
-            }
        }
    }
 }
@@ -60,22 +60,22 @@ public final class SVGImageReaderSpi extends ImageReaderSpiBase {
        super(new SVGProviderInfo());
    }

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

    @SuppressWarnings("StatementWithEmptyBody")
-    private static boolean canDecode(final ImageInputStream input) throws IOException {
+    private static boolean canDecode(final ImageInputStream pInput) throws IOException {
        // NOTE: This test is quite quick as it does not involve any parsing,
        // however it may not recognize all kinds of SVG documents.
        try {
-            input.mark();
+            pInput.mark();

            // TODO: This is not ok for UTF-16 and other wide encodings
            // TODO: Use an XML (encoding) aware Reader instance instead
            // Need to figure out pretty fast if this is XML or not
            int b;
-            while (Character.isWhitespace((char) (b = input.read()))) {
+            while (Character.isWhitespace((char) (b = pInput.read()))) {
                // Skip over leading WS
            }

@@ -95,30 +95,30 @@ public final class SVGImageReaderSpi extends ImageReaderSpiBase {

            byte[] buffer = new byte[4];
            while (true) {
-                input.readFully(buffer);
+                pInput.readFully(buffer);

                if (buffer[0] == '?') {
                    // This is the XML declaration or a processing instruction
-                    while (!((input.readByte() & 0xFF) == '?' && input.read() == '>')) {
+                    while (!((pInput.readByte() & 0xFF) == '?' && pInput.read() == '>')) {
                        // Skip until end of XML declaration or processing instruction or EOF
                    }
                }
                else if (buffer[0] == '!') {
                    if (buffer[1] == '-' && buffer[2] == '-') {
                        // This is a comment
-                        while (!((input.readByte() & 0xFF) == '-' && input.read() == '-' && input.read() == '>')) {
+                        while (!((pInput.readByte() & 0xFF) == '-' && pInput.read() == '-' && pInput.read() == '>')) {
                            // Skip until end of comment or EOF
                        }
                    }
                    else if (buffer[1] == 'D' && buffer[2] == 'O' && buffer[3] == 'C'
-                            && input.read() == 'T' && input.read() == 'Y'
-                            && input.read() == 'P' && input.read() == 'E') {
+                            && pInput.read() == 'T' && pInput.read() == 'Y'
+                            && pInput.read() == 'P' && pInput.read() == 'E') {
                        // This is the DOCTYPE declaration
-                        while (Character.isWhitespace((char) (b = input.read()))) {
+                        while (Character.isWhitespace((char) (b = pInput.read()))) {
                            // Skip over WS
                        }

-                        if (b == 's' && input.read() == 'v' && input.read() == 'g') {
+                        if (b == 's' && pInput.read() == 'v' && pInput.read() == 'g') {
                            // It's SVG, identified by DOCTYPE
                            return true;
                        }
@@ -142,7 +142,7 @@ public final class SVGImageReaderSpi extends ImageReaderSpiBase {
                    return false;
                }

-                while ((input.readByte() & 0xFF) != '<') {
+                while ((pInput.readByte() & 0xFF) != '<') {
                    // Skip over, until next begin tag or EOF
                }
            }
@@ -153,7 +153,7 @@ public final class SVGImageReaderSpi extends ImageReaderSpiBase {
        }
        finally {
            //noinspection ThrowFromFinallyBlock
-            input.reset();
+            pInput.reset();
        }
    }

@@ -41,34 +41,21 @@ 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;
    }

-    public void setBackgroundColor(Paint color) {
-        background = color;
+    public void setBackgroundColor(Paint pColor) {
+        background = pColor;
    }

    public String getBaseURI() {
        return baseURI;
    }

-    public void setBaseURI(String baseURI) {
-        this.baseURI = baseURI;
-    }
-
-    public void setAllowExternalResources(boolean allow) {
-        allowExternalResources = allow;
-    }
-
-    public boolean isAllowExternalResources() {
-        return allowExternalResources;
+    public void setBaseURI(String pBaseURI) {
+        baseURI = pBaseURI;
    }

    @Override
@@ -1,143 +1,141 @@
-/*
- * 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);
-    }
-}
+/*
+ * 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);
+    }
+
+}
@@ -31,7 +31,6 @@
 package com.twelvemonkeys.imageio.plugins.svg;

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

@@ -43,19 +42,21 @@ import javax.imageio.event.IIOReadWarningListener;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.*;
-import java.awt.image.*;
+import java.awt.image.BufferedImage;
+import java.awt.image.ImagingOpException;
+import java.io.File;
 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.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.*;

 /**
@@ -66,25 +67,30 @@ 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> {
-
-    @Override
-    protected ImageReaderSpi createProvider() {
-        return new SVGImageReaderSpi();
-    }
+    private SVGImageReaderSpi provider = 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/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))
+                new TestData(getClassLoaderResource("/svg/Android_robot.svg"), new Dimension(294, 345))
        );
    }

+    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");
    }
@@ -101,6 +107,8 @@ 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();

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

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

            while (cause.getCause() != null) {
@@ -194,12 +202,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);
-        assertRGBEquals("Expected all red", 0xFF0000, imageRed.getRGB(50, 50) & 0xFFFFFF, 0);
+        assertEquals(0xFF0000, imageRed.getRGB(50, 50) & 0xFFFFFF);

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

    @Test
@@ -216,7 +224,6 @@ 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);

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

            // CSS and embedded resources all go!
-            verifyNoInteractions(listener);
+            verifyZeroInteractions(listener);
        }
        finally {
            reader.dispose();
@@ -237,8 +244,6 @@ 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();
@@ -266,7 +271,7 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
            assertEquals(500, image.getHeight());

            // No more warnings now that the base URI is set
-            verifyNoInteractions(listener);
+            verifyZeroInteractions(listener);
        }
        finally {
            reader.dispose();
@@ -277,17 +282,18 @@ 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);

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

-            fail("reader.read should've thrown an exception, but didn't");
+            assertNotNull(image);
+            assertEquals(450, image.getWidth());
+            assertEquals(500, image.getHeight());
        }
        catch (IIOException allowed) {
            assertTrue(allowed.getMessage().contains("batikLogo.svg")); // The embedded resource we don't find
@@ -296,112 +302,4 @@ 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,7 +31,6 @@
 package com.twelvemonkeys.imageio.plugins.wmf;

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

@@ -50,10 +49,7 @@ 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> {
-    @Override
-    protected ImageReaderSpi createProvider() {
-        return new WMFImageReaderSpi();
-    }
+    private WMFImageReaderSpi provider = new WMFImageReaderSpi();

    protected List<TestData> getTestData() {
        return Collections.singletonList(
@@ -61,17 +57,27 @@ 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");
    }
@@ -1,6 +0,0 @@
-<?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>
@@ -1,7 +0,0 @@
-<?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>
@@ -1,7 +0,0 @@
-<?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>
@@ -1,7 +0,0 @@
-<?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>
@@ -1,7 +0,0 @@
-<?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,16 +4,12 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.11.0-SNAPSHOT</version>
+        <version>3.4.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>
@@ -23,26 +19,6 @@
            <groupId>com.twelvemonkeys.imageio</groupId>
            <artifactId>imageio-core</artifactId>
            <type>test-jar</type>
-            <scope>test</scope>
        </dependency>
    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.felix</groupId>
-                <artifactId>maven-bundle-plugin</artifactId>
-                <configuration>
-                    <instructions>
-                        <Provide-Capability>
-                            osgi.serviceloader;
-                            osgi.serviceloader=javax.imageio.spi.ImageReaderSpi,
-                            osgi.serviceloader;
-                            osgi.serviceloader=javax.imageio.spi.ImageWriterSpi
-                        </Provide-Capability>
-                    </instructions>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
 </project>
@@ -4,28 +4,26 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;
@@ -4,28 +4,26 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;
@@ -39,11 +37,7 @@ import com.twelvemonkeys.io.LittleEndianDataInputStream;
 import com.twelvemonkeys.io.enc.DecoderStream;
 import com.twelvemonkeys.xml.XMLSerializer;

-import javax.imageio.IIOException;
-import javax.imageio.ImageIO;
-import javax.imageio.ImageReadParam;
-import javax.imageio.ImageReader;
-import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.*;
 import javax.imageio.event.IIOReadUpdateListener;
 import javax.imageio.event.IIOReadWarningListener;
 import javax.imageio.metadata.IIOMetadata;
@@ -51,13 +45,13 @@ import javax.imageio.metadata.IIOMetadataFormatImpl;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.*;
-import java.awt.color.*;
+import java.awt.color.ColorSpace;
 import java.awt.image.*;
 import java.io.DataInput;
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteOrder;
-import java.util.Collections;
+import java.util.Arrays;
 import java.util.Iterator;

 /**
@@ -65,8 +59,8 @@ import java.util.Iterator;
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @author last modified by $Author: haraldk$
- * @version $Id: BMPImageReader.java,v 1.0 Apr 20, 2009 11:54:28 AM haraldk Exp$
- * @see ICOImageReader
+ * @version $Id: CURImageReader.java,v 1.0 Apr 20, 2009 11:54:28 AM haraldk Exp$
+ * @see com.twelvemonkeys.imageio.plugins.bmp.ICOImageReader
 */
 public final class BMPImageReader extends ImageReaderBase {
    private long pixelOffset;
@@ -81,8 +75,8 @@ public final class BMPImageReader extends ImageReaderBase {
        super(new BMPImageReaderSpi());
    }

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

    @Override
@@ -129,11 +123,6 @@ public final class BMPImageReader extends ImageReaderBase {

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

@@ -187,84 +176,79 @@ public final class BMPImageReader extends ImageReaderBase {
    }

    @Override
-    public int getWidth(int imageIndex) throws IOException {
-        checkBounds(imageIndex);
+    public int getWidth(int pImageIndex) throws IOException {
+        checkBounds(pImageIndex);

        return header.getWidth();
    }

    @Override
-    public int getHeight(int imageIndex) throws IOException {
-        checkBounds(imageIndex);
+    public int getHeight(int pImageIndex) throws IOException {
+        checkBounds(pImageIndex);

        return header.getHeight();
    }

    @Override
-    public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) throws IOException {
-        checkBounds(imageIndex);
+    public Iterator<ImageTypeSpecifier> getImageTypes(int pImageIndex) throws IOException {
+        checkBounds(pImageIndex);

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

    @Override
-    public ImageTypeSpecifier getRawImageType(int imageIndex) throws IOException {
-        checkBounds(imageIndex);
+    public ImageTypeSpecifier getRawImageType(int pImageIndex) throws IOException {
+        checkBounds(pImageIndex);

        if (header.getPlanes() != 1) {
            throw new IIOException("Multiple planes not supported");
        }

-        try {
-            switch (header.getBitCount()) {
-                case 1:
-                case 2:
-                case 4:
-                case 8:
-                    return ImageTypeSpecifiers.createFromIndexColorModel(readColorMap());
+        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());
-            }
-        }
-        catch (IllegalArgumentException e) {
-            throw new IIOException(e.getMessage(), e);
+            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());
        }
    }

@@ -363,18 +347,14 @@ public final class BMPImageReader extends ImageReaderBase {

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

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

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

            processImageProgress(100f * y / height);
@@ -414,13 +394,6 @@ 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()));
@@ -461,6 +434,12 @@ 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:
@@ -485,14 +464,9 @@ 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 (srcY % ySub != 0 || srcY < srcRegion.y || srcY >= srcRegion.y + srcRegion.height) {
+        if (y % ySub != 0 || height - 1 - y < srcRegion.y || height - 1 - y >= srcRegion.y + srcRegion.height) {
            input.skipBytes(rowDataByte.length);

            return;
@@ -502,20 +476,24 @@ public final class BMPImageReader extends ImageReaderBase {

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

-        destChannel.setDataElements(0, dstY, srcChannel);
+        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);
+        }
    }

    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 (srcY % ySub != 0 || srcY < srcRegion.y || srcY >= srcRegion.y + srcRegion.height) {
+        if (y % ySub != 0 || height - 1 - y < srcRegion.y || height - 1 - y >= srcRegion.y + srcRegion.height) {
            input.skipBytes(rowDataUShort.length * 2 + (rowDataUShort.length % 2) * 2);

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

-        destChannel.setDataElements(0, dstY, srcChannel);
+        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);
+        }
    }

    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 (srcY % ySub != 0 || srcY < srcRegion.y || srcY >= srcRegion.y + srcRegion.height) {
+        if (y % ySub != 0 || height - 1 - y < srcRegion.y || height - 1 - y >= srcRegion.y + srcRegion.height) {
            input.skipBytes(rowDataInt.length * 4);

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

-        destChannel.setDataElements(0, dstY, srcChannel);
+        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);
+        }
    }

    // TODO: Candidate util method
@@ -626,13 +612,12 @@ public final class BMPImageReader extends ImageReaderBase {
        }

        // Why, oh why..? Instead of accepting it's own native format as it should,
-        // The DIBImageWriter only accepts instances of com.sun.imageio.plugins.bmp.BMPMetadata...
+        // The BMPImageWriter only accepts instances of com.sun.imageio.plugins.bmp.BMPMetadata...
        // TODO: Consider reflectively construct a BMPMetadata and inject fields
        return new BMPMetadata(header, colors);
    }

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

@@ -685,9 +670,9 @@ public final class BMPImageReader extends ImageReaderBase {
        }
    }

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

    private class ListenerDelegator extends ProgressListenerBase implements IIOReadUpdateListener, IIOReadWarningListener {
@@ -4,28 +4,26 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;
@@ -65,16 +63,16 @@ public final class BMPImageReaderSpi extends ImageReaderSpiBase {
        }
    }

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

-    private static boolean canDecode(final ImageInputStream input) throws IOException {
+    private static boolean canDecode(final ImageInputStream pInput) throws IOException {
        byte[] fileHeader = new byte[18]; // Strictly: file header (14 bytes) + BMP header size field (4 bytes)

        try {
-            input.mark();
-            input.readFully(fileHeader);
+            pInput.mark();
+            pInput.readFully(fileHeader);

            // Magic: BM
            if (fileHeader[0] != 'B' || fileHeader[1] != 'M') {
@@ -112,15 +110,15 @@ public final class BMPImageReaderSpi extends ImageReaderSpiBase {
            }
        }
        finally {
-            input.reset();
+            pInput.reset();
        }
    }

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

-    public String getDescription(final Locale locale) {
+    public String getDescription(final Locale pLocale) {
        return "Windows Device Independent Bitmap Format (BMP) Reader";
    }
 }
@@ -1,150 +0,0 @@
-/*
- * Copyright (c) 2017, 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.bmp;
-
-import javax.imageio.IIOImage;
-import javax.imageio.ImageIO;
-import javax.imageio.ImageTypeSpecifier;
-import javax.imageio.ImageWriteParam;
-import javax.imageio.metadata.IIOMetadata;
-import javax.imageio.plugins.bmp.BMPImageWriteParam;
-import javax.imageio.spi.ImageWriterSpi;
-import javax.imageio.stream.ImageOutputStream;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteOrder;
-
-/**
- * BMPImageWriter
- */
-public final class BMPImageWriter extends DIBImageWriter {
-    BMPImageWriter(ImageWriterSpi provider) {
-        super(provider);
-    }
-
-    @Override
-    public ImageWriteParam getDefaultWriteParam() {
-        // We can use the existing BMPImageWriteParam, as it's part of the javax.imageio API.
-        return new BMPImageWriteParam(getLocale());
-    }
-
-    @Override
-    public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType, ImageWriteParam param) {
-        // TODO
-        return null;
-    }
-
-    @Override
-    public IIOMetadata convertImageMetadata(IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param) {
-        // TODO: Support both our own and the com.sun.. metadata + standard metadata
-        return null;
-    }
-
-    @Override
-    public void write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) throws IOException {
-        assertOutput();
-
-        if (image == null) {
-            throw new IllegalArgumentException("image may not be null");
-        }
-
-        if (image.hasRaster()) {
-            // TODO: The default BMPWriter seems to support this, consider doing so as well
-            throw new UnsupportedOperationException("image has a Raster!");
-        }
-
-        imageOutput.setByteOrder(ByteOrder.LITTLE_ENDIAN);
-
-        clearAbortRequest();
-        processImageStarted(0);
-
-        if (param == null) {
-            param = getDefaultWriteParam();
-        }
-
-        // Default to bottom-up
-        // TODO: top-down only allowed for RGB and BITFIELDS compressions (not RLE or PNG)!
-        // Though Windows seems to support top-down for RLE too...
-        final boolean isTopDown = param instanceof BMPImageWriteParam && ((BMPImageWriteParam) param).isTopDown();
-//        int compression = DIB.COMPRESSION_ALPHA_BITFIELDS; // BMP can use BIFTFIELDS or ALPHA_BITFIELDS
-        int compression = DIB.COMPRESSION_RGB;
-
-        // TODO: Fix
-        BufferedImage img = (BufferedImage) image.getRenderedImage();
-
-        int height = img.getHeight();
-        int width = img.getWidth();
-
-        // Write File header
-        // TODO: Always use V4/V5 header, when writing with alpha, to avoid ambiguity
-        // TODO: Allow writing normal BITMAP_INFO_HEADER_SIZE with "fake" alpha as well?
-        int infoHeaderSize = DIB.BITMAP_INFO_HEADER_SIZE;
-        boolean hasExtraMasks = infoHeaderSize == DIB.BITMAP_INFO_HEADER_SIZE && (compression == DIB.COMPRESSION_BITFIELDS || compression == DIB.COMPRESSION_ALPHA_BITFIELDS);
-        // TODO: Allow writing without file header for ICO/CUR support
-        writeFileHeader(infoHeaderSize, DIB.BMP_FILE_HEADER_SIZE + infoHeaderSize + width * height * 4, hasExtraMasks);
-        writeDIBHeader(infoHeaderSize, img.getWidth(), img.getHeight(), isTopDown, img.getColorModel().getPixelSize(), compression);
-//        writeDIBHeader(infoHeaderSize, img, isTopDown, DIB.COMPRESSION_RGB);
-
-        if (hasExtraMasks) {
-            imageOutput.writeInt(0x000000FF); // B
-            imageOutput.writeInt(0x0000FF00); // G
-            imageOutput.writeInt(0x00FF0000); // R
-            imageOutput.writeInt(0xFF000000); // A
-        }
-
-        writeUncompressed(isTopDown, img, height, width);
-
-        processImageComplete();
-    }
-
-    private void writeFileHeader(int infoHeaderSize, int fileSize, boolean hasMasks) throws IOException {
-        // 14 bytes
-        imageOutput.writeShort('M' << 8 | 'B');
-        imageOutput.writeInt(fileSize + (hasMasks ? 16 : 0)); // File size (only known at this time if uncompressed!)
-        imageOutput.writeShort(0); // Reserved
-        imageOutput.writeShort(0); // Reserved
-
-        imageOutput.writeInt(DIB.BMP_FILE_HEADER_SIZE + infoHeaderSize + (hasMasks ? 16 : 0)); // Offset to image data
-    }
-
-    public static void main(String[] args) throws IOException {
-        File input = new File(args[0]);
-        File output = new File(args[0].replace('.', '_') + "_copy.bmp");
-
-        try (ImageOutputStream stream = ImageIO.createImageOutputStream(output)) {
-            DIBImageWriter writer = new BMPImageWriter(null);
-            writer.setOutput(stream);
-            writer.write(ImageIO.read(input));
-        }
-    }
-
-}
@@ -1,76 +0,0 @@
-/*
- * Copyright (c) 2017, 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.bmp;
-
-import com.twelvemonkeys.imageio.spi.ImageWriterSpiBase;
-
-import javax.imageio.ImageTypeSpecifier;
-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
- */
-public final class BMPImageWriterSpi extends ImageWriterSpiBase {
-    public BMPImageWriterSpi() {
-        super(new BMPProviderInfo());
-    }
-
-    @Override
-    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 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) Writer";
-    }
-}
@@ -4,35 +4,32 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.imageio.AbstractMetadata;
 import com.twelvemonkeys.lang.Validate;
-
 import org.w3c.dom.Node;

 import javax.imageio.metadata.IIOMetadataNode;
@@ -142,7 +139,7 @@ final class BMPMetadata extends AbstractMetadata {
    @Override
    protected IIOMetadataNode getStandardChromaNode() {
        // NOTE: BMP files may contain a color map, even if true color...
-        // Not sure if this is a good idea to expose to the metadata,
+        // Not sure if this is a good idea to expose to the meta data,
        // as it might be unexpected... Then again...
        if (colorMap != null) {
            IIOMetadataNode chroma = new IIOMetadataNode("Chroma");
@@ -171,90 +168,87 @@ final class BMPMetadata extends AbstractMetadata {
    protected IIOMetadataNode getStandardCompressionNode() {
        IIOMetadataNode compression = new IIOMetadataNode("Compression");
        IIOMetadataNode compressionTypeName = addChildNode(compression, "CompressionTypeName", null);
-
-        // TODO: Should the compression names always match the compression names used in the ImageWriteParam?
-        // OR should they be as standard as possible..?
-        // The built-in plugin uses "BI_RGB", "BI_RLE8", "BI_RLE4", "BI_BITFIELDS", "BI_JPEG and "BI_PNG"
-        switch (header.compression) {
-            case DIB.COMPRESSION_RLE4:
-            case DIB.COMPRESSION_RLE8:
-                compressionTypeName.setAttribute("value", "RLE");
-                break;
-            case DIB.COMPRESSION_JPEG:
-                compressionTypeName.setAttribute("value", "JPEG");
-                break;
-            case DIB.COMPRESSION_PNG:
-                compressionTypeName.setAttribute("value", "PNG");
-                break;
-            case DIB.COMPRESSION_RGB:
-            case DIB.COMPRESSION_BITFIELDS:
-            case DIB.COMPRESSION_ALPHA_BITFIELDS:
-            default:
-                compressionTypeName.setAttribute("value", "NONE");
-                break;
-        }
+        compressionTypeName.setAttribute("value", "NONE");

        return compression;
+//        switch (header.getImageType()) {
+//            case TGA.IMAGETYPE_COLORMAPPED_RLE:
+//            case TGA.IMAGETYPE_TRUECOLOR_RLE:
+//            case TGA.IMAGETYPE_MONOCHROME_RLE:
+//            case TGA.IMAGETYPE_COLORMAPPED_HUFFMAN:
+//            case TGA.IMAGETYPE_COLORMAPPED_HUFFMAN_QUADTREE:
+//                IIOMetadataNode node = new IIOMetadataNode("Compression");
+//                IIOMetadataNode compressionTypeName = new IIOMetadataNode("CompressionTypeName");
+//
+//                // Compression can be RLE4, RLE8, PNG, JPEG or NONE
+//                String value = header.getImageType() == TGA.IMAGETYPE_COLORMAPPED_HUFFMAN || header.getImageType() == TGA.IMAGETYPE_COLORMAPPED_HUFFMAN_QUADTREE
+//                                ? "Uknown" : "RLE";
+//                compressionTypeName.setAttribute("value", value);
+//                node.appendChild(compressionTypeName);
+//
+//                IIOMetadataNode lossless = new IIOMetadataNode("Lossless");
+//                lossless.setAttribute("value", "TRUE"); // TODO: Unless JPEG!
+//                node.appendChild(lossless);
+//
+//                return node;
+//            default:
+//                // No compression
+//                return null;
+//        }
    }

    @Override
    protected IIOMetadataNode getStandardDataNode() {
        IIOMetadataNode node = new IIOMetadataNode("Data");

+//        IIOMetadataNode planarConfiguration = new IIOMetadataNode("PlanarConfiguration");
+//        planarConfiguration.setAttribute("value", "PixelInterleaved");
+//        node.appendChild(planarConfiguration);
+
+//        IIOMetadataNode sampleFormat = new IIOMetadataNode("SampleFormat");
+//        switch (header.getImageType()) {
+//            case TGA.IMAGETYPE_COLORMAPPED:
+//            case TGA.IMAGETYPE_COLORMAPPED_RLE:
+//            case TGA.IMAGETYPE_COLORMAPPED_HUFFMAN:
+//            case TGA.IMAGETYPE_COLORMAPPED_HUFFMAN_QUADTREE:
+//                sampleFormat.setAttribute("value", "Index");
+//                break;
+//            default:
+//                sampleFormat.setAttribute("value", "UnsignedIntegral");
+//                break;
+//        }
+
+//        node.appendChild(sampleFormat);
+
        IIOMetadataNode bitsPerSample = new IIOMetadataNode("BitsPerSample");
        switch (header.getBitCount()) {
-            // TODO: case 0: determined by embedded format (PNG/JPEG)
            case 1:
            case 2:
            case 4:
            case 8:
                bitsPerSample.setAttribute("value", createListValue(1, Integer.toString(header.getBitCount())));
                break;
-
            case 16:
-                // Default is 555
-                bitsPerSample.setAttribute("value", header.hasMasks()
-                        ? createBitsPerSampleForBitMasks()
-                        : createListValue(3, Integer.toString(5)));
+                // TODO: Consult masks here!
+                bitsPerSample.setAttribute("value", createListValue(4, Integer.toString(4)));
                break;
-
            case 24:
                bitsPerSample.setAttribute("value", createListValue(3, Integer.toString(8)));
                break;
-
            case 32:
-                // Default is 888
-                bitsPerSample.setAttribute("value", header.hasMasks()
-                        ? createBitsPerSampleForBitMasks()
-                        : createListValue(3, Integer.toString(8)));
-
+                bitsPerSample.setAttribute("value", createListValue(4, Integer.toString(8)));
                break;
        }

        node.appendChild(bitsPerSample);

+        // TODO: Do we need MSB?
+//        IIOMetadataNode sampleMSB = new IIOMetadataNode("SampleMSB");
+//        sampleMSB.setAttribute("value", createListValue(header.getChannels(), "0"));
+
        return node;
    }

-    private String createBitsPerSampleForBitMasks() {
-        boolean hasAlpha = header.masks[3] != 0;
-
-        return createListValue(hasAlpha ? 4 : 3,
-                Integer.toString(countMaskBits(header.masks[0])), Integer.toString(countMaskBits(header.masks[1])),
-                Integer.toString(countMaskBits(header.masks[2])), Integer.toString(countMaskBits(header.masks[3])));
-    }
-
-    private int countMaskBits(int mask) {
-        // See https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
-        int count;
-
-        for (count = 0; mask != 0; count++) {
-            mask &= mask - 1; // clear the least significant bit set
-        }
-
-        return count;
-    }
-
    private String createListValue(final int itemCount, final String... values) {
        StringBuilder buffer = new StringBuilder();

@@ -271,31 +265,28 @@ final class BMPMetadata extends AbstractMetadata {

    @Override
    protected IIOMetadataNode getStandardDimensionNode() {
-        IIOMetadataNode dimension = new IIOMetadataNode("Dimension");
+        if (header.xPixelsPerMeter > 0 || header.yPixelsPerMeter > 0) {
+            IIOMetadataNode dimension = new IIOMetadataNode("Dimension");

-        if (header.xPixelsPerMeter > 0 && header.yPixelsPerMeter > 0) {
-            float ratio = header.xPixelsPerMeter / (float) header.yPixelsPerMeter;
-            addChildNode(dimension, "PixelAspectRatio", null)
-                    .setAttribute("value", String.valueOf(ratio));
+            addChildNode(dimension, "PixelAspectRatio", null);
+            addChildNode(dimension, "HorizontalPhysicalPixelSpacing", null);
+            addChildNode(dimension, "VerticalPhysicalPixelSpacing", null);

-            addChildNode(dimension, "HorizontalPixelSize", null)
-                    .setAttribute("value", String.valueOf(1f / header.xPixelsPerMeter * 1000));
-            addChildNode(dimension, "VerticalPixelSize", null)
-                    .setAttribute("value", String.valueOf(1f / header.yPixelsPerMeter * 1000));
+//        IIOMetadataNode imageOrientation = new IIOMetadataNode("ImageOrientation");
+//
+//        if (header.topDown) {
+//            imageOrientation.setAttribute("value", "FlipH");
+//        }
+//        else {
+//            imageOrientation.setAttribute("value", "Normal");
+//        }
+//
+//        dimension.appendChild(imageOrientation);

-            // Hmmm.. The JRE version includes these for some reason, even if values seem to be same as default...
-            addChildNode(dimension, "HorizontalPhysicalPixelSpacing", null)
-                    .setAttribute("value", String.valueOf(0));
-            addChildNode(dimension, "VerticalPhysicalPixelSpacing", null)
-                    .setAttribute("value", String.valueOf(0));
+            return dimension;
        }

-        if (header.topDown) {
-            addChildNode(dimension, "ImageOrientation", null)
-                    .setAttribute("value", "FlipH"); // For BMP, bottom-up is "normal"...
-        }
-
-        return dimension;
+        return null;
    }

    // No document node
@@ -306,15 +297,16 @@ final class BMPMetadata extends AbstractMetadata {

    @Override
    protected IIOMetadataNode getStandardTransparencyNode() {
-        if (header.hasMasks() && header.masks[3] != 0) {
-            IIOMetadataNode transparency = new IIOMetadataNode("Transparency");
-            IIOMetadataNode alpha = new IIOMetadataNode("Alpha");
-            alpha.setAttribute("value", "nonpremultiplied");
-            transparency.appendChild(alpha);
-
-            return transparency;
-        }
-
        return null;
+
+//        IIOMetadataNode transparency = new IIOMetadataNode("Transparency");
+//
+//        IIOMetadataNode alpha = new IIOMetadataNode("Alpha");
+//
+//        // TODO: Consult masks
+//        alpha.setAttribute("value", header.getBitCount() == 32 ? "nonpremultiplied" : "none");
+//        transparency.appendChild(alpha);
+//
+//        return transparency;
    }
 }
@@ -1,33 +1,3 @@
-/*
- * Copyright (c) 2015, Harald Kuhr
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright notice,
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
- *
- * * Neither the name of the copyright holder nor the names of its
- *   contributors may be used to endorse or promote products derived from
- *   this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
 package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfo;
@@ -40,24 +10,22 @@ import com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfo;
 * @version $Id: BMPProviderInfo.java,v 1.0 20/03/15 harald.kuhr Exp$
 */
 final class BMPProviderInfo extends ReaderWriterProviderInfo {
-    BMPProviderInfo() {
+    protected BMPProviderInfo() {
        super(
                BMPProviderInfo.class,
                new String[] {"bmp", "BMP"},
                new String[] {"bmp", "rle"},
                new String[] {
                        "image/bmp",
-                        "image/x-bmp",
-                        "image/vnd.microsoft.bitmap"
+                        "image/x-bmp"
+//                        "image/vnd.microsoft.bitmap",   // TODO: Official IANA MIME
                },
                "com.twelvemonkeys.imageio.plugins.bmp.BMPImageReader",
                new String[] {"com.twelvemonkeys.imageio.plugins.bmp.BMPImageReaderSpi"},
-                "com.twelvemonkeys.imageio.plugins.bmp.BMPImageWriter",
-                new String[] {"com.twelvemonkeys.imageio.plugins.bmp.BMPImageWriterSpi"},
-                false, null, null,
-                null, null,
-                true, BMPMetadata.nativeMetadataFormatName, "com.sun.imageio.plugins.bmp.BMPMetadataFormat",
-                null, null
+                "com.sun.imageio.plugins.bmp.BMPImageWriter",
+                new String[]{"com.sun.imageio.plugins.bmp.BMPImageWriterSpi"}, // We support the same native metadata format
+                false, null, null, null, null,
+                true, BMPMetadata.nativeMetadataFormatName, "com.sun.imageio.plugins.bmp.BMPMetadataFormat", null, null
        );
    }
 }
@@ -4,35 +4,33 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+
 package com.twelvemonkeys.imageio.plugins.bmp;

-import java.awt.image.*;
-import java.io.IOException;
+import com.twelvemonkeys.lang.Validate;

-import static com.twelvemonkeys.lang.Validate.notNull;
+import java.awt.image.BufferedImage;

 /**
 * Describes a bitmap structure.
@@ -47,12 +45,15 @@ abstract class BitmapDescriptor {
    protected BufferedImage image;
    protected BitmapMask mask;

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

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

    public final int getWidth() {
        return entry.getWidth();
@@ -75,7 +76,7 @@ abstract class BitmapDescriptor {
        return getClass().getSimpleName() + "[" + entry + ", " + header + "]";
    }

-    final void setMask(final BitmapMask mask) {
+    public final void setMask(final BitmapMask mask) {
        this.mask = mask;
    }

@@ -4,32 +4,34 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+
 package com.twelvemonkeys.imageio.plugins.bmp;

-import java.awt.image.*;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBuffer;
+import java.awt.image.IndexColorModel;
+import java.awt.image.WritableRaster;
 import java.util.Hashtable;

 /**
@@ -38,13 +40,12 @@ import java.util.Hashtable;
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @version $Id: BitmapIndexed.java,v 1.0 25.feb.2006 00:29:44 haku Exp$
 */
-final class BitmapIndexed extends BitmapDescriptor {
-    final int[] bits;
-    final int[] colors;
-
-    public BitmapIndexed(final DirectoryEntry entry, final DIBHeader header) {
-        super(entry, header);
+class BitmapIndexed extends BitmapDescriptor {
+    protected final int[] bits;
+    protected final int[] colors;

+    public BitmapIndexed(final DirectoryEntry pEntry, final DIBHeader pHeader) {
+        super(pEntry, pHeader);
        bits = new int[getWidth() * getHeight()];

        // NOTE: We're adding space for one extra color, for transparency
@@ -57,16 +58,20 @@ final class BitmapIndexed extends BitmapDescriptor {

        IndexColorModel icm = createColorModel();

-        // We add cursor hotspot as a property to images created from CUR format.
-        // This is slightly obscure, and should probably be moved...
+        // This is slightly obscure, and should probably be moved..
        Hashtable<String, Object> properties = null;
        if (entry instanceof DirectoryEntry.CUREntry) {
            properties = new Hashtable<>(1);
            properties.put("cursor_hotspot", ((DirectoryEntry.CUREntry) this.entry).getHotspot());
        }

-        WritableRaster raster = icm.createCompatibleWritableRaster(getWidth(), getHeight());
-        BufferedImage image = new BufferedImage(icm, raster, icm.isAlphaPremultiplied(), properties);
+        BufferedImage image = new BufferedImage(
+                icm,
+                icm.createCompatibleWritableRaster(getWidth(), getHeight()),
+                icm.isAlphaPremultiplied(), properties
+        );
+
+        WritableRaster raster = image.getRaster();

        // Make pixels transparent according to mask
        final int trans = icm.getTransparentPixel();
@@ -99,7 +104,7 @@ final class BitmapIndexed extends BitmapDescriptor {
            int index = findTransparentIndexMaybeRemap(this.colors, this.bits);

            if (index == -1) {
-                // No duplicate found, increase bit count
+                // No duplicate found, increase bitcount
                bits++;
                transparent = this.colors.length - 1;
            }
@@ -111,8 +116,10 @@ final class BitmapIndexed extends BitmapDescriptor {
        }

        // NOTE: Setting hasAlpha to true, makes things work on 1.2
-        return new IndexColorModel(bits, colors, this.colors, 0, true, transparent,
-                                   bits <= 8 ? DataBuffer.TYPE_BYTE : DataBuffer.TYPE_USHORT);
+        return new IndexColorModel(
+                bits, colors, this.colors, 0, true, transparent,
+                bits <= 8 ? DataBuffer.TYPE_BYTE : DataBuffer.TYPE_USHORT
+        );
    }

    private static int findTransparentIndexMaybeRemap(final int[] colors, final int[] bits) {
@@ -155,7 +162,6 @@ final class BitmapIndexed extends BitmapDescriptor {
        return transparent;
    }

-    @Override
    public BufferedImage getImage() {
        if (image == null) {
            image = createImageIndexed();
@@ -4,33 +4,31 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;

-import java.awt.image.*;
+import java.awt.image.BufferedImage;


 /**
@@ -39,17 +37,17 @@ import java.awt.image.*;
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @version $Id: BitmapMask.java,v 1.0 25.feb.2006 00:29:44 haku Exp$
 */
-final class BitmapMask extends BitmapDescriptor {
-    final BitmapIndexed bitMask;
+class BitmapMask extends BitmapDescriptor {
+    protected final BitmapIndexed bitMask;

-    public BitmapMask(final DirectoryEntry parent, final DIBHeader header) {
-        super(parent, header);
-        bitMask = new BitmapIndexed(parent, header);
+    public BitmapMask(final DirectoryEntry pParent, final DIBHeader pHeader) {
+        super(pParent, pHeader);
+        bitMask = new BitmapIndexed(pParent, pHeader);
    }

-    boolean isTransparent(final int x, final int y) {
+    boolean isTransparent(final int pX, final int pY) {
        // NOTE: 1: Fully transparent, 0: Opaque...
-        return bitMask.bits[x + y * getWidth()] != 0;
+        return bitMask.bits[pX + pY * getWidth()] != 0;
    }

    public BufferedImage getImage() {
@@ -4,34 +4,33 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;

 import java.awt.*;
-import java.awt.image.*;
+import java.awt.image.BufferedImage;
+import java.awt.image.WritableRaster;

 /**
 * Describes an RGB/true color bitmap structure (16, 24 and 32 bits per pixel).
@@ -39,13 +38,12 @@ import java.awt.image.*;
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @version $Id: BitmapRGB.java,v 1.0 25.feb.2006 00:29:44 haku Exp$
 */
-final class BitmapRGB extends BitmapDescriptor {
+class BitmapRGB extends BitmapDescriptor {

-    public BitmapRGB(final DirectoryEntry entry, final DIBHeader header) {
-        super(entry, header);
+    public BitmapRGB(final DirectoryEntry pEntry, final DIBHeader pHeader) {
+        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.
@@ -70,7 +68,7 @@ final class BitmapRGB extends BitmapDescriptor {

        WritableRaster alphaRaster = masked.getAlphaRaster();

-        byte[] trans = {0x00};
+        byte[] trans = {0x0};
        for (int y = 0; y < getHeight(); y++) {
            for (int x = 0; x < getWidth(); x++) {
                if (mask.isTransparent(x, y)) {
@@ -4,35 +4,31 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;

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

 /**
 * Represents bitmap structures we can't read.
@@ -41,17 +37,16 @@ import java.io.IOException;
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @version $Id: BitmapUnsupported.java,v 1.0 25.feb.2006 00:29:44 haku Exp$
 */
-final class BitmapUnsupported extends BitmapDescriptor {
-    private final String message;
+class BitmapUnsupported extends BitmapDescriptor {
+    private String message;

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

-        this.message = message;
+        message = pMessage;
    }

-    @Override
-    public BufferedImage getImage() throws IOException {
-        throw new IIOException(message);
+    public BufferedImage getImage() {
+        throw new IllegalStateException(message);
    }
 }
@@ -4,28 +4,26 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;
@@ -48,22 +46,22 @@ public final class CURImageReader extends DIBImageReader {
        super(new CURImageReaderSpi());
    }

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

    /**
     * Returns the hot spot location for the cursor.
     *
-     * @param imageIndex the index of the cursor in the current input.
+     * @param pImageIndex the index of the cursor in the current input.
     * @return the hot spot location for the cursor
     *
     * @throws java.io.IOException if an I/O exception occurs during reading of image meta data
     * @throws IndexOutOfBoundsException if {@code pImageIndex} is less than {@code 0} or greater than/equal to
     *         the number of cursors in the file
     */
-    public Point getHotSpot(final int imageIndex) throws IOException {
-        DirectoryEntry.CUREntry entry = (DirectoryEntry.CUREntry) getEntry(imageIndex);
+    public final Point getHotSpot(final int pImageIndex) throws IOException {
+        DirectoryEntry.CUREntry entry = (DirectoryEntry.CUREntry) getEntry(pImageIndex);
        return entry.getHotspot();
    }
 }
@@ -4,34 +4,33 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.imageio.spi.ImageReaderSpiBase;

+import javax.imageio.ImageReader;
 import javax.imageio.stream.ImageInputStream;
 import java.io.IOException;
 import java.util.Locale;
@@ -48,15 +47,15 @@ public final class CURImageReaderSpi extends ImageReaderSpiBase {
        super(new CURProviderInfo());
    }

-    public boolean canDecodeInput(final Object source) throws IOException {
-        return source instanceof ImageInputStream && ICOImageReaderSpi.canDecode((ImageInputStream) source, DIB.TYPE_CUR);
+    public boolean canDecodeInput(final Object pSource) throws IOException {
+        return pSource instanceof ImageInputStream && ICOImageReaderSpi.canDecode((ImageInputStream) pSource, DIB.TYPE_CUR);
    }

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

-    public String getDescription(final Locale locale) {
+    public String getDescription(final Locale pLocale) {
        return "Windows Cursor Format (CUR) Reader";
    }
 }
@@ -4,28 +4,26 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;
@@ -40,7 +38,7 @@ import com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfo;
 * @version $Id: CURProviderInfo.java,v 1.0 20/03/15 harald.kuhr Exp$
 */
 final class CURProviderInfo extends ReaderWriterProviderInfo {
-    CURProviderInfo() {
+    protected CURProviderInfo() {
        super(
                CURProviderInfo.class,
                new String[]{"cur", "CUR"},
@@ -4,28 +4,26 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;
@@ -90,17 +90,17 @@ abstract class DIBHeader {
    protected DIBHeader() {
    }

-    public static DIBHeader read(final DataInput stream) throws IOException {
-        int size = stream.readInt();
+    public static DIBHeader read(final DataInput pStream) throws IOException {
+        int size = pStream.readInt();

        DIBHeader header = createHeader(size);
-        header.read(size, stream);
+        header.read(size, pStream);

        return header;
    }

-    private static DIBHeader createHeader(final int size) throws IOException {
-        switch (size) {
+    private static DIBHeader createHeader(final int pSize) throws IOException {
+        switch (pSize) {
            case DIB.BITMAP_CORE_HEADER_SIZE:
                return new BitmapCoreHeader();
            case DIB.OS2_V2_HEADER_16_SIZE:
@@ -117,12 +117,11 @@ abstract class DIBHeader {
            case DIB.BITMAP_V5_INFO_HEADER_SIZE:
                return new BitmapV5InfoHeader();
            default:
-                throw new IIOException(String.format("Unknown Bitmap Information Header (size: %s)", size));
+                throw new IIOException(String.format("Unknown Bitmap Information Header (size: %s)", pSize));
        }
    }

-    protected abstract void read(int size, DataInput stream) throws IOException;
-    protected abstract void write(final DataOutput stream) throws IOException;
+    protected abstract void read(int pSize, DataInput pStream) throws IOException;

    public final int getSize() {
        return size;
@@ -189,12 +188,12 @@ abstract class DIBHeader {
        );
    }

-    private static int[] readMasks(final DataInput stream, final boolean hasAlphaMask) throws IOException {
+    private static int[] readMasks(final DataInput pStream, final boolean hasAlphaMask) throws IOException {
        int maskCount = hasAlphaMask ? 4 : 3;
        int[] masks = new int[4];

        for (int i = 0; i < maskCount; i++) {
-            masks[i] = stream.readInt();
+            masks[i] = pStream.readInt();
        }

        return masks;
@@ -205,30 +204,24 @@ abstract class DIBHeader {
    // TODO: Get rid of code duplication below...

    static final class BitmapCoreHeader extends DIBHeader {
-        @Override
-        protected void read(final int size, final DataInput stream) throws IOException {
-            if (size != DIB.BITMAP_CORE_HEADER_SIZE) {
-                throw new IIOException(String.format("Size: %s !=: %s", size, DIB.BITMAP_CORE_HEADER_SIZE));
+        protected void read(final int pSize, final DataInput pStream) throws IOException {
+            if (pSize != DIB.BITMAP_CORE_HEADER_SIZE) {
+                throw new IIOException(String.format("Size: %s !=: %s", pSize, DIB.BITMAP_CORE_HEADER_SIZE));
            }

-            this.size = size;
+            size = pSize;

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

            if (height < 0) {
                height = -height;
                topDown = true;
            }

-            planes = stream.readUnsignedShort();
-            bitCount = stream.readUnsignedShort();
-        }
-
-        @Override
-        protected void write(DataOutput stream) {
-            throw new UnsupportedOperationException();
+            planes = pStream.readUnsignedShort();
+            bitCount = pStream.readUnsignedShort();
        }

        public String getBMPVersion() {
@@ -247,52 +240,45 @@ 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")
-        @Override
-        protected void read(final int size, final DataInput stream) throws IOException {
-            if (size != DIB.OS2_V2_HEADER_SIZE && size != DIB.OS2_V2_HEADER_16_SIZE) {
-                throw new IIOException(String.format("Size: %s !=: %s", size, DIB.OS2_V2_HEADER_SIZE));
+        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));
            }

-            this.size = size;
+            size = pSize;

-            width = stream.readInt();
-            height = stream.readInt();
+            width = pStream.readInt();
+            height = pStream.readInt();

            if (height < 0) {
                height = -height;
                topDown = true;
            }

-            planes = stream.readUnsignedShort();
-            bitCount = stream.readUnsignedShort();
+            planes = pStream.readUnsignedShort();
+            bitCount = pStream.readUnsignedShort();

-            if (size != DIB.OS2_V2_HEADER_16_SIZE) {
-                compression = stream.readInt();
+            if (pSize != DIB.OS2_V2_HEADER_16_SIZE) {
+                compression = pStream.readInt();

-                imageSize = stream.readInt();
+                imageSize = pStream.readInt();

-                xPixelsPerMeter = stream.readInt();
-                yPixelsPerMeter = stream.readInt();
+                xPixelsPerMeter = pStream.readInt();
+                yPixelsPerMeter = pStream.readInt();

-                colorsUsed = stream.readInt();
-                colorsImportant = stream.readInt();
+                colorsUsed = pStream.readInt();
+                colorsImportant = pStream.readInt();
            }

            // TODO: Use? These fields are not reflected in metadata as per now...
-            int units = stream.readShort();
-            int reserved = stream.readShort();
-            int recording = stream.readShort(); // Recording algorithm
-            int rendering = stream.readShort(); // Halftoning algorithm
-            int size1 = stream.readInt(); // Reserved for halftoning use
-            int size2 = stream.readInt(); // Reserved for halftoning use
-            int colorEncoding = stream.readInt(); // Color model used in bitmap
-            int identifier = stream.readInt(); // Reserved for application use
-        }
-
-        @Override
-        protected void write(DataOutput stream) {
-            throw new UnsupportedOperationException();
+            int units = pStream.readShort();
+            int reserved = pStream.readShort();
+            int recording = pStream.readShort(); // Recording algorithm
+            int rendering = pStream.readShort(); // Halftoning algorithm
+            int size1 = pStream.readInt(); // Reserved for halftoning use
+            int size2 = pStream.readInt(); // Reserved for halftoning use
+            int colorEncoding = pStream.readInt(); // Color model used in bitmap
+            int identifier = pStream.readInt(); // Reserved for application use
        }

        public String getBMPVersion() {
@@ -300,6 +286,7 @@ abstract class DIBHeader {
        }
    }

+
    /**
     * Represents the DIB (Device Independent Bitmap) Windows 3.0 Bitmap Information header structure.
     * This is the common format for persistent DIB structures, even if Windows
@@ -315,73 +302,46 @@ abstract class DIBHeader {
     * @see <a href="https://forums.adobe.com/message/3272950#3272950">BITMAPV3INFOHEADER</a>.
     */
    static final class BitmapInfoHeader extends DIBHeader {
-        @Override
-        protected void read(final int size, final DataInput stream) throws IOException {
-            if (!(size == DIB.BITMAP_INFO_HEADER_SIZE || size == DIB.BITMAP_V2_INFO_HEADER_SIZE || size == DIB.BITMAP_V3_INFO_HEADER_SIZE)) {
-                throw new IIOException(String.format("Size: %s !=: %s", size, DIB.BITMAP_INFO_HEADER_SIZE));
+        protected void read(final int pSize, final DataInput pStream) throws IOException {
+            if (!(pSize == DIB.BITMAP_INFO_HEADER_SIZE || pSize == DIB.BITMAP_V2_INFO_HEADER_SIZE || pSize == DIB.BITMAP_V3_INFO_HEADER_SIZE)) {
+                throw new IIOException(String.format("Size: %s !=: %s", pSize, DIB.BITMAP_INFO_HEADER_SIZE));
            }

-            this.size = size;
+            size = pSize;

-            width = stream.readInt();
-            height = stream.readInt();
+            width = pStream.readInt();
+            height = pStream.readInt();

            if (height < 0) {
                height = -height;
                topDown = true;
            }

-            planes = stream.readUnsignedShort();
-            bitCount = stream.readUnsignedShort();
-            compression = stream.readInt();
+            planes = pStream.readUnsignedShort();
+            bitCount = pStream.readUnsignedShort();
+            compression = pStream.readInt();

-            imageSize = stream.readInt();
+            imageSize = pStream.readInt();

-            xPixelsPerMeter = stream.readInt();
-            yPixelsPerMeter = stream.readInt();
+            xPixelsPerMeter = pStream.readInt();
+            yPixelsPerMeter = pStream.readInt();

-            colorsUsed = stream.readInt();
-            colorsImportant = stream.readInt();
+            colorsUsed = pStream.readInt();
+            colorsImportant = pStream.readInt();

            // Read masks if we have V2 or V3
            // or if we have compression BITFIELDS or ALPHA_BITFIELDS
-            if (this.size == DIB.BITMAP_V2_INFO_HEADER_SIZE || compression == DIB.COMPRESSION_BITFIELDS) {
-                masks = readMasks(stream, false);
+            if (size == DIB.BITMAP_V2_INFO_HEADER_SIZE || compression == DIB.COMPRESSION_BITFIELDS) {
+                masks = readMasks(pStream, false);
            }
-            else if (this.size == DIB.BITMAP_V3_INFO_HEADER_SIZE || compression == DIB.COMPRESSION_ALPHA_BITFIELDS) {
-                masks = readMasks(stream, true);
+            else if (size == DIB.BITMAP_V3_INFO_HEADER_SIZE || compression == DIB.COMPRESSION_ALPHA_BITFIELDS) {
+                masks = readMasks(pStream, true);
            }
        }

-        @Override
-        protected void write(final DataOutput stream) throws IOException {
-            stream.writeInt(DIB.BITMAP_INFO_HEADER_SIZE);
-
-            stream.writeInt(width);
-            stream.writeInt(topDown ? -height : height);
-
-            stream.writeShort(planes);
-            stream.writeShort(bitCount);
-            stream.writeInt(compression);
-
-            stream.writeInt(imageSize);
-
-            stream.writeInt(xPixelsPerMeter);
-            stream.writeInt(yPixelsPerMeter);
-
-            stream.writeInt(colorsUsed);
-            stream.writeInt(colorsImportant);
-
-            // TODO: Write masks, if COMPRESSION_BITFIELDS/COMPRESSION_ALPHA_BITFIELDS
-        }
-
        public String getBMPVersion() {
            // This is to be compatible with the native metadata of the original com.sun....BMPMetadata
-            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";
+            return compression == DIB.COMPRESSION_BITFIELDS ? "BMP v. 3.x NT" : "BMP v. 3.x";
        }
    }

@@ -389,160 +349,105 @@ abstract class DIBHeader {
     * Represents the BITMAPV4INFOHEADER structure.
     */
    static final class BitmapV4InfoHeader extends DIBHeader {
-        @Override
-        protected void read(final int size, final DataInput stream) throws IOException {
-            if (size != DIB.BITMAP_V4_INFO_HEADER_SIZE) {
-                throw new IIOException(String.format("Size: %s !=: %s", size, DIB.BITMAP_V4_INFO_HEADER_SIZE));
+        protected void read(final int pSize, final DataInput pStream) throws IOException {
+            if (pSize != DIB.BITMAP_V4_INFO_HEADER_SIZE) {
+                throw new IIOException(String.format("Size: %s !=: %s", pSize, DIB.BITMAP_V4_INFO_HEADER_SIZE));
            }

-            this.size = size;
+            size = pSize;

-            width = stream.readInt();
-            height = stream.readInt();
+            width = pStream.readInt();
+            height = pStream.readInt();

            if (height < 0) {
                height = -height;
                topDown = true;
            }

-            planes = stream.readUnsignedShort();
-            bitCount = stream.readUnsignedShort();
-            compression = stream.readInt();
+            planes = pStream.readUnsignedShort();
+            bitCount = pStream.readUnsignedShort();
+            compression = pStream.readInt();

-            imageSize = stream.readInt();
+            imageSize = pStream.readInt();

-            xPixelsPerMeter = stream.readInt();
-            yPixelsPerMeter = stream.readInt();
+            xPixelsPerMeter = pStream.readInt();
+            yPixelsPerMeter = pStream.readInt();

-            colorsUsed = stream.readInt();
-            colorsImportant = stream.readInt();
+            colorsUsed = pStream.readInt();
+            colorsImportant = pStream.readInt();

-            masks = readMasks(stream, true);
+            masks = readMasks(pStream, true);

-            colorSpaceType = stream.readInt(); // Should be 0 for V4
+            colorSpaceType = pStream.readInt(); // Should be 0 for V4
            cieXYZEndpoints = new double[9];

            for (int i = 0; i < cieXYZEndpoints.length; i++) {
-                cieXYZEndpoints[i] = stream.readInt(); // TODO: Hmmm...?
+                cieXYZEndpoints[i] = pStream.readInt(); // TODO: Hmmm...?
            }

            gamma = new int[3];

            for (int i = 0; i < gamma.length; i++) {
-                gamma[i] = stream.readInt();
+                gamma[i] = pStream.readInt();
            }
        }

        public String getBMPVersion() {
            return "BMP v. 4.x";
        }
-
-        @Override
-        protected void write(DataOutput stream) throws IOException {
-            stream.writeInt(DIB.BITMAP_V4_INFO_HEADER_SIZE);
-
-            stream.writeInt(width);
-            stream.writeInt(topDown ? -height : height);
-
-            stream.writeShort(planes);
-            stream.writeShort(bitCount);
-            stream.writeInt(compression);
-
-            stream.writeInt(imageSize);
-
-            stream.writeInt(xPixelsPerMeter);
-            stream.writeInt(yPixelsPerMeter);
-
-            stream.writeInt(colorsUsed);
-            stream.writeInt(colorsImportant);
-
-            // Red, Green, Blue, Alpha masks
-            stream.writeInt(masks[0]);
-            stream.writeInt(masks[1]);
-            stream.writeInt(masks[2]);
-            stream.writeInt(masks[3]);
-
-            // color space ("sRGB" LITTLE endian)
-            stream.writeInt(DIB.LCS_sRGB);
-
-            // 36 bytes CIE XYZ triples, unused for sRGB
-            stream.writeInt(0);
-            stream.writeInt(0);
-            stream.writeInt(0);
-
-            stream.writeInt(0);
-            stream.writeInt(0);
-            stream.writeInt(0);
-
-            stream.writeInt(0);
-            stream.writeInt(0);
-            stream.writeInt(0);
-
-            // Red gamma, unused for sRGB
-            // Green gamma, unused for sRGB
-            // Blue gamma, unused for sRGB
-            stream.writeInt(0);
-            stream.writeInt(0);
-            stream.writeInt(0);
-        }
    }

    /**
     * Represents the BITMAPV5INFOHEADER structure.
     */
    static final class BitmapV5InfoHeader extends DIBHeader {
-        protected void read(final int size, final DataInput stream) throws IOException {
-            if (size != DIB.BITMAP_V5_INFO_HEADER_SIZE) {
-                throw new IIOException(String.format("Size: %s !=: %s", size, DIB.BITMAP_V5_INFO_HEADER_SIZE));
+        protected void read(final int pSize, final DataInput pStream) throws IOException {
+            if (pSize != DIB.BITMAP_V5_INFO_HEADER_SIZE) {
+                throw new IIOException(String.format("Size: %s !=: %s", pSize, DIB.BITMAP_V5_INFO_HEADER_SIZE));
            }

-            this.size = size;
+            size = pSize;

-            width = stream.readInt();
-            height = stream.readInt();
+            width = pStream.readInt();
+            height = pStream.readInt();

            if (height < 0) {
                height = -height;
                topDown = true;
            }

-            planes = stream.readUnsignedShort();
-            bitCount = stream.readUnsignedShort();
-            compression = stream.readInt();
+            planes = pStream.readUnsignedShort();
+            bitCount = pStream.readUnsignedShort();
+            compression = pStream.readInt();

-            imageSize = stream.readInt();
+            imageSize = pStream.readInt();

-            xPixelsPerMeter = stream.readInt();
-            yPixelsPerMeter = stream.readInt();
+            xPixelsPerMeter = pStream.readInt();
+            yPixelsPerMeter = pStream.readInt();

-            colorsUsed = stream.readInt();
-            colorsImportant = stream.readInt();
+            colorsUsed = pStream.readInt();
+            colorsImportant = pStream.readInt();

-            masks = readMasks(stream, true);
+            masks = readMasks(pStream, true);

-            colorSpaceType = stream.readInt();
+            colorSpaceType = pStream.readInt();

            cieXYZEndpoints = new double[9];

            for (int i = 0; i < cieXYZEndpoints.length; i++) {
-                cieXYZEndpoints[i] = stream.readInt(); // TODO: Hmmm...?
+                cieXYZEndpoints[i] = pStream.readInt(); // TODO: Hmmm...?
            }

            gamma = new int[3];

            for (int i = 0; i < gamma.length; i++) {
-                gamma[i] = stream.readInt();
+                gamma[i] = pStream.readInt();
            }

-            intent = stream.readInt(); // TODO: Verify if this is same as ICC intent
-            profileData = stream.readInt() & 0xffffffffL;
-            profileSize = stream.readInt() & 0xffffffffL;
-            stream.readInt(); // Reserved
-        }
-
-        @Override
-        protected void write(DataOutput stream) {
-            throw new UnsupportedOperationException();
+            intent = pStream.readInt(); // TODO: Verify if this is same as ICC intent
+            profileData = pStream.readInt() & 0xffffffffL;
+            profileSize = pStream.readInt() & 0xffffffffL;
+            pStream.readInt(); // Reserved
        }

        public String getBMPVersion() {
@@ -4,58 +4,51 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.image.ImageUtil;
 import com.twelvemonkeys.imageio.ImageReaderBase;
-import com.twelvemonkeys.imageio.stream.SubImageInputStream;
+import com.twelvemonkeys.imageio.util.IIOUtil;
 import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
 import com.twelvemonkeys.util.WeakWeakMap;

-import javax.imageio.IIOException;
-import javax.imageio.ImageIO;
-import javax.imageio.ImageReadParam;
-import javax.imageio.ImageReader;
-import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.*;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import javax.swing.*;
 import java.awt.*;
-import java.awt.color.*;
-import java.awt.event.*;
+import java.awt.color.ColorSpace;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
 import java.awt.image.*;
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.ByteOrder;
-import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
-import java.util.WeakHashMap;
+import java.util.*;

 /**
 * ImageReader for Microsoft Windows ICO (icon) format.
@@ -79,18 +72,18 @@ abstract class DIBImageReader extends ImageReaderBase {
    private Directory directory;

    // TODO: Review these, make sure we don't have a memory leak
-    private final Map<DirectoryEntry, DIBHeader> headers = new WeakHashMap<>();
-    private final Map<DirectoryEntry, BitmapDescriptor> descriptors = new WeakWeakMap<>();
+    private Map<DirectoryEntry, DIBHeader> headers = new WeakHashMap<>();
+    private Map<DirectoryEntry, BitmapDescriptor> descriptors = new WeakWeakMap<>();

    private ImageReader pngImageReader;

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

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

@@ -100,8 +93,8 @@ abstract class DIBImageReader extends ImageReaderBase {
        }
    }

-    public Iterator<ImageTypeSpecifier> getImageTypes(final int imageIndex) throws IOException {
-        DirectoryEntry entry = getEntry(imageIndex);
+    public Iterator<ImageTypeSpecifier> getImageTypes(final int pImageIndex) throws IOException {
+        DirectoryEntry entry = getEntry(pImageIndex);

        // NOTE: Delegate to PNG reader
        if (isPNG(entry)) {
@@ -153,39 +146,39 @@ abstract class DIBImageReader extends ImageReaderBase {
        return getDirectory().count();
    }

-    public int getWidth(final int imageIndex) throws IOException {
-        return getEntry(imageIndex).getWidth();
+    public int getWidth(final int pImageIndex) throws IOException {
+        return getEntry(pImageIndex).getWidth();
    }

-    public int getHeight(final int imageIndex) throws IOException {
-        return getEntry(imageIndex).getHeight();
+    public int getHeight(final int pImageIndex) throws IOException {
+        return getEntry(pImageIndex).getHeight();
    }

-    public BufferedImage read(final int imageIndex, final ImageReadParam param) throws IOException {
-        checkBounds(imageIndex);
+    public BufferedImage read(final int pImageIndex, final ImageReadParam pParam) throws IOException {
+        checkBounds(pImageIndex);

-        processImageStarted(imageIndex);
+        processImageStarted(pImageIndex);

-        DirectoryEntry entry = getEntry(imageIndex);
+        DirectoryEntry entry = getEntry(pImageIndex);

        BufferedImage destination;

        if (isPNG(entry)) {
            // NOTE: Special case for Windows Vista, 256x256 PNG encoded images, with no DIB header...
-            destination = readPNG(entry, param);
+            destination = readPNG(entry, pParam);
        }
        else {
            // NOTE: If param does not have explicit destination, we'll try to create a BufferedImage later,
            //       to allow for storing the cursor hotspot for CUR images
-            destination = hasExplicitDestination(param) ?
-                    getDestination(param, getImageTypes(imageIndex), getWidth(imageIndex), getHeight(imageIndex)) : null;
+            destination = hasExplicitDestination(pParam) ?
+                    getDestination(pParam, getImageTypes(pImageIndex), getWidth(pImageIndex), getHeight(pImageIndex)) : null;

            BufferedImage image = readBitmap(entry);

            // TODO: Handle AOI and subsampling inline, probably not of big importance...
-            if (param != null) {
-                image = fakeAOI(image, param);
-                image = ImageUtil.toBuffered(fakeSubsampling(image, param));
+            if (pParam != null) {
+                image = fakeAOI(image, pParam);
+                image = ImageUtil.toBuffered(fakeSubsampling(image, pParam));
            }

            if (destination == null) {
@@ -211,10 +204,10 @@ abstract class DIBImageReader extends ImageReaderBase {
        return destination;
    }

-    private boolean isPNG(final DirectoryEntry entry) throws IOException {
+    private boolean isPNG(final DirectoryEntry pEntry) throws IOException {
        long magic;

-        imageInput.seek(entry.getOffset());
+        imageInput.seek(pEntry.getOffset());
        imageInput.setByteOrder(ByteOrder.BIG_ENDIAN);

        try {
@@ -227,20 +220,21 @@ abstract class DIBImageReader extends ImageReaderBase {
        return magic == DIB.PNG_MAGIC;
    }

-    private BufferedImage readPNG(final DirectoryEntry entry, final ImageReadParam param) throws IOException {
+    private BufferedImage readPNG(final DirectoryEntry pEntry, final ImageReadParam pParam) throws IOException {
        // TODO: Consider delegating listener calls
-        return initPNGReader(entry).read(0, param);
+        return initPNGReader(pEntry).read(0, pParam);
    }

-    private Iterator<ImageTypeSpecifier> getImageTypesPNG(final DirectoryEntry entry) throws IOException {
-        return initPNGReader(entry).getImageTypes(0);
+    private Iterator<ImageTypeSpecifier> getImageTypesPNG(final DirectoryEntry pEntry) throws IOException {
+        return initPNGReader(pEntry).getImageTypes(0);
    }

-    private ImageReader initPNGReader(final DirectoryEntry entry) throws IOException {
+    private ImageReader initPNGReader(final DirectoryEntry pEntry) throws IOException {
        ImageReader pngReader = getPNGReader();

-        imageInput.seek(entry.getOffset());
-        ImageInputStream stream = new SubImageInputStream(imageInput, entry.getSize());
+        imageInput.seek(pEntry.getOffset());
+        InputStream inputStream = IIOUtil.createStreamAdapter(imageInput, pEntry.getSize());
+        ImageInputStream stream = ImageIO.createImageInputStream(inputStream);

        // NOTE: Will throw IOException on later reads if input is not PNG
        pngReader.setInput(stream);
@@ -267,31 +261,31 @@ abstract class DIBImageReader extends ImageReaderBase {
        return pngImageReader;
    }

-    private DIBHeader getHeader(final DirectoryEntry entry) throws IOException {
-        if (!headers.containsKey(entry)) {
-            imageInput.seek(entry.getOffset());
+    private DIBHeader getHeader(final DirectoryEntry pEntry) throws IOException {
+        if (!headers.containsKey(pEntry)) {
+            imageInput.seek(pEntry.getOffset());
            DIBHeader header = DIBHeader.read(imageInput);
-            headers.put(entry, header);
+            headers.put(pEntry, header);
        }

-        return headers.get(entry);
+        return headers.get(pEntry);
    }

-    private BufferedImage readBitmap(final DirectoryEntry entry) throws IOException {
+    private BufferedImage readBitmap(final DirectoryEntry pEntry) throws IOException {
        // TODO: Get rid of the caching, as the images are mutable
-        BitmapDescriptor descriptor = descriptors.get(entry);
+        BitmapDescriptor descriptor = descriptors.get(pEntry);

-        if (descriptor == null || !descriptors.containsKey(entry)) {
-            DIBHeader header = getHeader(entry);
+        if (descriptor == null || !descriptors.containsKey(pEntry)) {
+            DIBHeader header = getHeader(pEntry);

-            int offset = entry.getOffset() + header.getSize();
+            int offset = pEntry.getOffset() + header.getSize();
            if (offset != imageInput.getStreamPosition()) {
                imageInput.seek(offset);
            }

            // TODO: Support this, it's already in the BMP reader, spec allows RLE4 and RLE8
-            if (header.getCompression() != DIB.COMPRESSION_RGB) {
-                descriptor = new BitmapUnsupported(entry, header, String.format("Unsupported compression: %d", header.getCompression()));
+            if (header.getCompression() != 0) {
+                descriptor = new BitmapUnsupported(pEntry, String.format("Unsupported compression: %d", header.getCompression()));
            }
            else {
                int bitCount = header.getBitCount();
@@ -301,75 +295,75 @@ abstract class DIBImageReader extends ImageReaderBase {
                    case 1:
                    case 4:
                    case 8: // TODO: Gray!
-                        descriptor = new BitmapIndexed(entry, header);
+                        descriptor = new BitmapIndexed(pEntry, header);
                        readBitmapIndexed((BitmapIndexed) descriptor);
                        break;
                    // RGB style
                    case 16:
-                        descriptor = new BitmapRGB(entry, header);
+                        descriptor = new BitmapRGB(pEntry, header);
                        readBitmap16(descriptor);
                        break;
                    case 24:
-                        descriptor = new BitmapRGB(entry, header);
+                        descriptor = new BitmapRGB(pEntry, header);
                        readBitmap24(descriptor);
                        break;
                    case 32:
-                        descriptor = new BitmapRGB(entry, header);
+                        descriptor = new BitmapRGB(pEntry, header);
                        readBitmap32(descriptor);
                        break;

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

-            descriptors.put(entry, descriptor);
+            descriptors.put(pEntry, descriptor);
        }

        return descriptor.getImage();
    }

-    private void readBitmapIndexed(final BitmapIndexed bitmap) throws IOException {
-        readColorMap(bitmap);
+    private void readBitmapIndexed(final BitmapIndexed pBitmap) throws IOException {
+        readColorMap(pBitmap);

-        switch (bitmap.getBitCount()) {
+        switch (pBitmap.getBitCount()) {
            case 1:
-                readBitmapIndexed1(bitmap, false);
+                readBitmapIndexed1(pBitmap, false);
                break;
            case 4:
-                readBitmapIndexed4(bitmap);
+                readBitmapIndexed4(pBitmap);
                break;
            case 8:
-                readBitmapIndexed8(bitmap);
+                readBitmapIndexed8(pBitmap);
                break;
        }

-        BitmapMask mask = new BitmapMask(bitmap.entry, bitmap.header);
+        BitmapMask mask = new BitmapMask(pBitmap.entry, pBitmap.header);
        readBitmapIndexed1(mask.bitMask, true);
-        bitmap.setMask(mask);
+        pBitmap.setMask(mask);
    }

-    private void readColorMap(final BitmapIndexed bitmap) throws IOException {
-        int colorCount = bitmap.getColorCount();
+    private void readColorMap(final BitmapIndexed pBitmap) throws IOException {
+        int colorCount = pBitmap.getColorCount();

        for (int i = 0; i < colorCount; i++) {
            // aRGB (a is "Reserved")
-            bitmap.colors[i] = (imageInput.readInt() & 0xffffff) | 0xff000000;
+            pBitmap.colors[i] = (imageInput.readInt() & 0xffffff) | 0xff000000;
        }
    }

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

-        for (int y = 0; y < bitmap.getHeight(); y++) {
+        for (int y = 0; y < pBitmap.getHeight(); y++) {
            imageInput.readFully(row, 0, width);
            int rowPos = 0;
            int xOrVal = 0x80;
-            int pos = (bitmap.getHeight() - y - 1) * bitmap.getWidth();
+            int pos = (pBitmap.getHeight() - y - 1) * pBitmap.getWidth();

-            for (int x = 0; x < bitmap.getWidth(); x++) {
-                bitmap.bits[pos++] = ((row[rowPos] & xOrVal) / xOrVal) & 0xFF;
+            for (int x = 0; x < pBitmap.getWidth(); x++) {
+                pBitmap.bits[pos++] = ((row[rowPos] & xOrVal) / xOrVal) & 0xFF;

                if (xOrVal == 1) {
                    xOrVal = 0x80;
@@ -380,29 +374,29 @@ abstract class DIBImageReader extends ImageReaderBase {
                }
            }

-            // NOTE: If we are reading the mask, we can't abort or report progress
-            if (!asMask) {
+            // NOTE: If we are reading the mask, we don't abort or report progress
+            if (!pAsMask) {
                if (abortRequested()) {
                    processReadAborted();
                    break;
                }

-                processImageProgress(100 * y / (float) bitmap.getHeight());
+                processImageProgress(100 * y / (float) pBitmap.getHeight());
            }
        }
    }

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

-        for (int y = 0; y < bitmap.getHeight(); y++) {
+        for (int y = 0; y < pBitmap.getHeight(); y++) {
            imageInput.readFully(row, 0, width);
            int rowPos = 0;
            boolean high4 = true;
-            int pos = (bitmap.getHeight() - y - 1) * bitmap.getWidth();
+            int pos = (pBitmap.getHeight() - y - 1) * pBitmap.getWidth();

-            for (int x = 0; x < bitmap.getWidth(); x++) {
+            for (int x = 0; x < pBitmap.getWidth(); x++) {
                int value;

                if (high4) {
@@ -413,7 +407,7 @@ abstract class DIBImageReader extends ImageReaderBase {
                    rowPos++;
                }

-                bitmap.bits[pos++] = value & 0xFF;
+                pBitmap.bits[pos++] = value & 0xFF;
                high4 = !high4;
            }

@@ -422,22 +416,22 @@ abstract class DIBImageReader extends ImageReaderBase {
                break;
            }

-            processImageProgress(100 * y / (float) bitmap.getHeight());
+            processImageProgress(100 * y / (float) pBitmap.getHeight());
        }
    }

-    private void readBitmapIndexed8(final BitmapIndexed bitmap) throws IOException {
-        int width = adjustToPadding(bitmap.getWidth());
+    private void readBitmapIndexed8(final BitmapIndexed pBitmap) throws IOException {
+        int width = adjustToPadding(pBitmap.getWidth());

        byte[] row = new byte[width];

-        for (int y = 0; y < bitmap.getHeight(); y++) {
+        for (int y = 0; y < pBitmap.getHeight(); y++) {
            imageInput.readFully(row, 0, width);
            int rowPos = 0;
-            int pos = (bitmap.getHeight() - y - 1) * bitmap.getWidth();
+            int pos = (pBitmap.getHeight() - y - 1) * pBitmap.getWidth();

-            for (int x = 0; x < bitmap.getWidth(); x++) {
-                bitmap.bits[pos++] = row[rowPos++] & 0xFF;
+            for (int x = 0; x < pBitmap.getWidth(); x++) {
+                pBitmap.bits[pos++] = row[rowPos++] & 0xFF;
            }

            if (abortRequested()) {
@@ -445,41 +439,41 @@ abstract class DIBImageReader extends ImageReaderBase {
                break;
            }

-            processImageProgress(100 * y / (float) bitmap.getHeight());
+            processImageProgress(100 * y / (float) pBitmap.getHeight());
        }
    }

    /**
-     * @param width Bytes per scan line (i.e., 1BPP, width = 9 -> bytes = 2)
+     * @param pWidth Bytes per scan line (i.e., 1BPP, width = 9 -> bytes = 1)
     * @return padded width
     */
-    private static int adjustToPadding(final int width) {
-        if ((width & 0x03) != 0) {
-             return (width & ~0x03) + 4;
+    private static int adjustToPadding(final int pWidth) {
+        if ((pWidth & 0x03) != 0) {
+             return (pWidth & ~0x03) + 4;
        }
-
-        return width;
+        return pWidth;
    }

-    private void readBitmap16(final BitmapDescriptor bitmap) throws IOException {
-        short[] pixels = new short[bitmap.getWidth() * bitmap.getHeight()];
+    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 DataBufferUShort(pixels, pixels.length);
+        DataBuffer buffer = new DataBufferShort(pixels, pixels.length);
        WritableRaster raster = Raster.createPackedRaster(
-                buffer, bitmap.getWidth(), bitmap.getHeight(), bitmap.getWidth(), cm.getMasks(), null
+                buffer, pBitmap.getWidth(), pBitmap.getHeight(), pBitmap.getWidth(), cm.getMasks(), null
        );
-        bitmap.image = new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null);
+        pBitmap.image = new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null);

-        for (int y = 0; y < bitmap.getHeight(); y++) {
-            int offset = (bitmap.getHeight() - y - 1) * bitmap.getWidth();
-            imageInput.readFully(pixels, offset, bitmap.getWidth());
+        for (int y = 0; y < pBitmap.getHeight(); y++) {
+            int offset = (pBitmap.getHeight() - y - 1) * pBitmap.getWidth();
+            imageInput.readFully(pixels, offset, pBitmap.getWidth());


            // Skip to 32 bit boundary
-            if (bitmap.getWidth() % 2 != 0) {
+            if (pBitmap.getWidth() % 2 != 0) {
                imageInput.readShort();
            }

@@ -488,14 +482,14 @@ abstract class DIBImageReader extends ImageReaderBase {
                break;
            }

-            processImageProgress(100 * y / (float) bitmap.getHeight());
+            processImageProgress(100 * y / (float) pBitmap.getHeight());
        }

        // TODO: Might be mask!?
    }

-    private void readBitmap24(final BitmapDescriptor bitmap) throws IOException {
-        byte[] pixels = new byte[bitmap.getWidth() * bitmap.getHeight() * 3];
+    private void readBitmap24(final BitmapDescriptor pBitmap) throws IOException {
+        byte[] pixels = new byte[pBitmap.getWidth() * pBitmap.getHeight() * 3];

        // Create TYPE_3BYTE_BGR
        DataBuffer buffer = new DataBufferByte(pixels, pixels.length);
@@ -506,17 +500,17 @@ abstract class DIBImageReader extends ImageReaderBase {
                cs, nBits, false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE
        );

-        int scanlineStride = bitmap.getWidth() * 3;
+        int scanlineStride = pBitmap.getWidth() * 3;
        // BMP rows are padded to 4 byte boundary
        int rowSizeBytes = ((8 * scanlineStride + 31) / 32) * 4;

        WritableRaster raster = Raster.createInterleavedRaster(
-                buffer, bitmap.getWidth(), bitmap.getHeight(), scanlineStride, 3, bOffs, null
+                buffer, pBitmap.getWidth(), pBitmap.getHeight(), scanlineStride, 3, bOffs, null
        );
-        bitmap.image = new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null);
+        pBitmap.image = new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null);

-        for (int y = 0; y < bitmap.getHeight(); y++) {
-            int offset = (bitmap.getHeight() - y - 1) * scanlineStride;
+        for (int y = 0; y < pBitmap.getHeight(); y++) {
+            int offset = (pBitmap.getHeight() - y - 1) * scanlineStride;
            imageInput.readFully(pixels, offset, scanlineStride);
            imageInput.skipBytes(rowSizeBytes - scanlineStride);

@@ -525,38 +519,38 @@ abstract class DIBImageReader extends ImageReaderBase {
                break;
            }

-            processImageProgress(100 * y / (float) bitmap.getHeight());
+            processImageProgress(100 * y / (float) pBitmap.getHeight());
        }

        // 24 bit icons usually have a bit mask
-        if (bitmap.hasMask()) {
-            BitmapMask mask = new BitmapMask(bitmap.entry, bitmap.header);
+        if (pBitmap.hasMask()) {
+            BitmapMask mask = new BitmapMask(pBitmap.entry, pBitmap.header);
            readBitmapIndexed1(mask.bitMask, true);

-            bitmap.setMask(mask);
+            pBitmap.setMask(mask);
        }
    }

-    private void readBitmap32(final BitmapDescriptor bitmap) throws IOException {
-        int[] pixels = new int[bitmap.getWidth() * bitmap.getHeight()];
+    private void readBitmap32(final BitmapDescriptor pBitmap) throws IOException {
+        int[] pixels = new int[pBitmap.getWidth() * pBitmap.getHeight()];

        // Will create TYPE_INT_ARGB
        DirectColorModel cm = (DirectColorModel) ColorModel.getRGBdefault();
        DataBuffer buffer = new DataBufferInt(pixels, pixels.length);
        WritableRaster raster = Raster.createPackedRaster(
-                buffer, bitmap.getWidth(), bitmap.getHeight(), bitmap.getWidth(), cm.getMasks(), null
+                buffer, pBitmap.getWidth(), pBitmap.getHeight(), pBitmap.getWidth(), cm.getMasks(), null
        );
-        bitmap.image = new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null);
+        pBitmap.image = new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null);

-        for (int y = 0; y < bitmap.getHeight(); y++) {
-            int offset = (bitmap.getHeight() - y - 1) * bitmap.getWidth();
-            imageInput.readFully(pixels, offset, bitmap.getWidth());
+        for (int y = 0; y < pBitmap.getHeight(); y++) {
+            int offset = (pBitmap.getHeight() - y - 1) * pBitmap.getWidth();
+            imageInput.readFully(pixels, offset, pBitmap.getWidth());

            if (abortRequested()) {
                processReadAborted();
                break;
-            }
-            processImageProgress(100 * y / (float) bitmap.getHeight());
+            }            
+            processImageProgress(100 * y / (float) pBitmap.getHeight());
        }

        // There might be a mask here as well, but we'll ignore it,
@@ -587,18 +581,18 @@ abstract class DIBImageReader extends ImageReaderBase {
        directory = Directory.read(type, imageCount, imageInput);
    }

-    final DirectoryEntry getEntry(final int imageIndex) throws IOException {
+    final DirectoryEntry getEntry(final int pImageIndex) throws IOException {
        Directory directory = getDirectory();
-        if (imageIndex < 0 || imageIndex >= directory.count()) {
-            throw new IndexOutOfBoundsException(String.format("Index: %d, ImageCount: %d", imageIndex, directory.count()));
+        if (pImageIndex < 0 || pImageIndex >= directory.count()) {
+            throw new IndexOutOfBoundsException(String.format("Index: %d, ImageCount: %d", pImageIndex, directory.count()));
        }

-        return directory.getEntry(imageIndex);
+        return directory.getEntry(pImageIndex);
    }
-
+    
    /// Test code below, ignore.. :-)
-    public static void main(final String[] args) throws IOException {
-        if (args.length == 0) {
+    public static void main(final String[] pArgs) throws IOException {
+        if (pArgs.length == 0) {
            System.err.println("Please specify the icon file name");
            System.exit(1);
        }
@@ -610,7 +604,7 @@ abstract class DIBImageReader extends ImageReaderBase {
            // Ignore
        }

-        String title = new File(args[0]).getName();
+        String title = new File(pArgs[0]).getName();
        JFrame frame = createWindow(title);
        JPanel root = new JPanel(new FlowLayout());
        JScrollPane scroll =
@@ -626,7 +620,7 @@ abstract class DIBImageReader extends ImageReaderBase {

        ImageReader reader = readers.next();

-        for (String arg : args) {
+        for (String arg : pArgs) {
            JPanel panel = new JPanel(null);
            panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
            readImagesInFile(arg, reader, panel);
@@ -637,28 +631,28 @@ abstract class DIBImageReader extends ImageReaderBase {
        frame.setVisible(true);
    }

-    private static void readImagesInFile(String fileName, ImageReader reader, final Container container) throws IOException {
-        File file = new File(fileName);
+    private static void readImagesInFile(String pFileName, ImageReader pReader, final Container pContainer) throws IOException {
+        File file = new File(pFileName);
        if (!file.isFile()) {
-            System.err.println(fileName + " not found, or is no file");
+            System.err.println(pFileName + " not found, or is no file");
        }

-        reader.setInput(ImageIO.createImageInputStream(file));
-        int imageCount = reader.getNumImages(true);
+        pReader.setInput(ImageIO.createImageInputStream(file));
+        int imageCount = pReader.getNumImages(true);
        for (int i = 0; i < imageCount; i++) {
            try {
-                addImage(container, reader, i);
+                addImage(pContainer, pReader, i);
            }
            catch (Exception e) {
-                System.err.println("FileName: " + fileName);
+                System.err.println("FileName: " + pFileName);
                System.err.println("Icon: " + i);
                e.printStackTrace();
            }
        }
    }

-    private static JFrame createWindow(final String title) {
-        JFrame frame = new JFrame(title);
+    private static JFrame createWindow(final String pTitle) {
+        JFrame frame = new JFrame(pTitle);
        frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosed(WindowEvent e) {
@@ -668,15 +662,15 @@ abstract class DIBImageReader extends ImageReaderBase {
        return frame;
    }

-    private static void addImage(final Container parent, final ImageReader reader, final int imageNo) throws IOException {
+    private static void addImage(final Container pParent, final ImageReader pReader, final int pImageNo) throws IOException {
        final JButton button = new JButton();

-        BufferedImage image = reader.read(imageNo);
+        BufferedImage image = pReader.read(pImageNo);
        button.setIcon(new ImageIcon(image) {
            TexturePaint texture;

-            private void createTexture(final GraphicsConfiguration graphicsConfiguration) {
-                BufferedImage pattern = graphicsConfiguration.createCompatibleImage(20, 20);
+            private void createTexture(final GraphicsConfiguration pGraphicsConfiguration) {
+                BufferedImage pattern = pGraphicsConfiguration.createCompatibleImage(20, 20);
                Graphics2D g = pattern.createGraphics();
                try {
                    g.setColor(Color.LIGHT_GRAY);
@@ -705,12 +699,12 @@ abstract class DIBImageReader extends ImageReaderBase {
            }
        });

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

-        parent.add(button);
+        pParent.add(button);
    }
 }
@@ -1,116 +0,0 @@
-/*
- * Copyright (c) 2017, 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.bmp;
-
-import com.twelvemonkeys.imageio.ImageWriterBase;
-import com.twelvemonkeys.imageio.plugins.bmp.DIBHeader.BitmapInfoHeader;
-
-import javax.imageio.IIOException;
-import javax.imageio.spi.ImageWriterSpi;
-import java.awt.image.*;
-import java.io.IOException;
-import java.nio.ByteOrder;
-
-/**
- * DIBImageWriter
- */
-abstract class DIBImageWriter extends ImageWriterBase {
-
-    DIBImageWriter(ImageWriterSpi provider) {
-        super(provider);
-    }
-
-    @Override
-    public void setOutput(Object output) {
-        super.setOutput(output);
-        if (imageOutput != null) {
-            imageOutput.setByteOrder(ByteOrder.LITTLE_ENDIAN);
-        }
-    }
-
-    void writeDIBHeader(int infoHeaderSize, int width, int height, boolean isTopDown, int pixelSize, int compression) throws IOException {
-        switch (infoHeaderSize) {
-            case DIB.BITMAP_INFO_HEADER_SIZE:
-                BitmapInfoHeader header = new BitmapInfoHeader();
-                // TODO: Consider a constructor/factory for this
-                header.width = width;
-                header.height = height;
-                header.topDown = isTopDown;
-
-                header.planes = 1; // Always 1 plane
-                header.bitCount = pixelSize;
-                header.compression = compression;
-
-                header.colorsUsed = 0;      // Means 2 ^ bitCount
-                header.colorsImportant = 0; // Means all colors important
-
-                header.imageSize = header.height * ((header.width * header.bitCount + 31) / 32) * 4; // Rows padded to 32 bit
-
-                header.xPixelsPerMeter = 2835; // 72 DPI
-                header.yPixelsPerMeter = 2835;
-
-                header.write(imageOutput);
-                break;
-            default:
-                throw new IIOException("Unsupported header size: " + infoHeaderSize);
-        }
-    }
-
-    void writeUncompressed(boolean isTopDown, BufferedImage img, int height, int width) throws IOException {
-        if (img.getType() != BufferedImage.TYPE_4BYTE_ABGR) {
-            throw new IIOException("Only TYPE_4BYTE_ABGR supported");
-        }
-
-        // Support
-        // - TODO: IndexColorModel (ucompressed, RLE4, RLE8 or BI_PNG)
-        // - TODO: ComponentColorModel (1 channel gray, 3 channel BGR and 4 channel BGRA, uncompressed and RLE8? BI_BITFIELDS? BI_PNG? BI_JPEG?)
-        // - 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);
-        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, bandList));
-
-            imageOutput.write(row);
-
-            if (abortRequested()) {
-                processWriteAborted();
-                break;
-            }
-
-            processImageProgress(100f * i / (float) height);
-        }
-    }
-}
@@ -4,28 +4,26 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;
@@ -44,25 +42,24 @@ import java.util.List;
 class Directory {
    private final List<DirectoryEntry> entries;

-    private Directory(int imageCount) {
-        entries = Arrays.asList(new DirectoryEntry[imageCount]);
+    private Directory(int pImageCount) {
+        entries = Arrays.asList(new DirectoryEntry[pImageCount]);
    }

-    public static Directory read(final int type, final int imageCount, final DataInput stream) throws IOException {
-        Directory directory = new Directory(imageCount);
-        directory.readEntries(type,  stream);
-
+    public static Directory read(final int pType, final int pImageCount, final DataInput pStream) throws IOException {
+        Directory directory = new Directory(pImageCount);
+        directory.readEntries(pType,  pStream);
        return directory;
    }

-    private void readEntries(final int type, final DataInput stream) throws IOException {
+    private void readEntries(final int pType, final DataInput pStream) throws IOException {
        for (int i = 0; i < entries.size(); i++) {
-            entries.set(i, DirectoryEntry.read(type, stream));
+            entries.set(i, DirectoryEntry.read(pType, pStream));
        }
    }

-    public DirectoryEntry getEntry(final int entryIndex) {
-        return entries.get(entryIndex);
+    public DirectoryEntry getEntry(final int pEntryIndex) {
+        return entries.get(pEntryIndex);
    }

    public int count() {
@@ -4,37 +4,33 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;

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

 /**
@@ -46,66 +42,58 @@ import java.io.IOException;
 * @see <a href="http://en.wikipedia.org/wiki/ICO_(icon_image_file_format)#Directory">Wikipedia</a>
 */
 abstract class DirectoryEntry {
-    int width;
-    int height;
-    int colorCount;
+    private int width;
+    private int height;
+    private int colorCount;
    int planes;
    int bitCount;
-    int size;
-    int offset;
+    private int size;
+    private int offset;

    DirectoryEntry() {
    }

-    public static DirectoryEntry read(final int type, final DataInput stream) throws IOException {
-        DirectoryEntry entry = createEntry(type);
-        entry.read(stream);
-
+    public static DirectoryEntry read(final int pType, final DataInput pStream) throws IOException {
+        DirectoryEntry entry = createEntry(pType);
+        entry.read(pStream);
        return entry;
    }

-    private static DirectoryEntry createEntry(int type) throws IIOException {
-        switch (type) {
+    private static DirectoryEntry createEntry(int pType) throws IIOException {
+        switch (pType) {
            case DIB.TYPE_ICO:
                return new ICOEntry();
            case DIB.TYPE_CUR:
                return new CUREntry();
            default:
-                throw new IIOException(String.format("Unknown DIB type: %s, expected: %s (ICO) or %s (CUR)", type, DIB.TYPE_ICO, DIB.TYPE_CUR));
+                throw new IIOException(
+                        String.format(
+                                "Unknown DIB type: %s, expected: %s (ICO) or %s (CUR)",
+                                pType, DIB.TYPE_ICO, DIB.TYPE_CUR
+                        )
+                );
        }
    }

-    protected void read(final DataInput stream) throws IOException {
+    protected void read(final DataInput pStream) throws IOException {
        // Width/height = 0, means 256
-        int w = stream.readUnsignedByte();
+        int w = pStream.readUnsignedByte();
        width = w == 0 ? 256 : w;
-        int h = stream.readUnsignedByte();
+        int h = pStream.readUnsignedByte();
        height = h == 0 ? 256 : h;
        
        // Color count = 0, means 256 or more colors
-        colorCount = stream.readUnsignedByte();
+        colorCount = pStream.readUnsignedByte();

        // Ignore. Should be 0, but .NET (System.Drawing.Icon.Save) sets this value to 255, according to Wikipedia
-        stream.readUnsignedByte();
+        pStream.readUnsignedByte();

-        planes = stream.readUnsignedShort();     // Should be 0 or 1 for ICO, x hotspot for CUR
-        bitCount = stream.readUnsignedShort();   // bit count for ICO, y hotspot for CUR
+        planes = pStream.readUnsignedShort();     // Should be 0 or 1 for ICO, x hotspot for CUR
+        bitCount = pStream.readUnsignedShort();   // bit count for ICO, y hotspot for CUR

        // Size of bitmap in bytes
-        size = stream.readInt();
-        offset = stream.readInt();
-    }
-
-    void write(final DataOutput output) throws IOException {
-        output.writeByte(width  % 256);
-        output.writeByte(height % 256);
-        output.writeByte(colorCount);
-        output.writeByte(0); // Reserved
-        output.writeShort(1); // Color planes 0 or 1
-        output.writeShort(bitCount);
-        output.writeInt(size); // Size, depends on compression...
-        output.writeInt(offset);
-
+        size = pStream.readInt();
+        offset = pStream.readInt();
    }

    public String toString() {
@@ -152,8 +140,8 @@ abstract class DirectoryEntry {
        private int yHotspot;

        @Override
-        protected void read(final DataInput stream) throws IOException {
-            super.read(stream);
+        protected void read(final DataInput pStream) throws IOException {
+            super.read(pStream);

            // NOTE: This is a hack...
            xHotspot = planes;
@@ -172,16 +160,5 @@ abstract class DirectoryEntry {
     * Icon directory entry.
     */
    static final class ICOEntry extends DirectoryEntry {
-        private ICOEntry() {}
-
-        ICOEntry(final int width, final int height, final ColorModel colorModel, int size, final int offset) {
-            this.width = width;
-            this.height = height;
-            this.colorCount = colorModel instanceof IndexColorModel ? ((IndexColorModel) colorModel).getMapSize() : 0;
-            this.planes = 1;
-            this.bitCount = colorModel.getPixelSize();
-            this.size = size;
-            this.offset = offset;
-        }
    }
 }
@@ -4,28 +4,26 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;
@@ -46,7 +44,8 @@ public final class ICOImageReader extends DIBImageReader {
        super(new ICOImageReaderSpi());
    }

-    ICOImageReader(final ImageReaderSpi provider) {
-        super(provider);
+    protected ICOImageReader(final ImageReaderSpi pProvider) {
+        super(pProvider);
    }
+
 }
@@ -4,34 +4,33 @@
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name "TwelveMonkeys" nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
 *
- * * 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.imageio.spi.ImageReaderSpiBase;

+import javax.imageio.ImageReader;
 import javax.imageio.stream.ImageInputStream;
 import java.io.IOException;
 import java.util.Locale;
@@ -48,32 +47,32 @@ public final class ICOImageReaderSpi extends ImageReaderSpiBase {
        super(new ICOProviderInfo());
    }

-    public boolean canDecodeInput(final Object source) throws IOException {
-        return source instanceof ImageInputStream && canDecode((ImageInputStream) source, DIB.TYPE_ICO);
+    public boolean canDecodeInput(final Object pSource) throws IOException {
+        return pSource instanceof ImageInputStream && canDecode((ImageInputStream) pSource, DIB.TYPE_ICO);
    }

-    static boolean canDecode(final ImageInputStream input, final int type) throws IOException {
+    static boolean canDecode(final ImageInputStream pInput, final int pType) throws IOException {
        byte[] signature = new byte[4];

        try {
-            input.mark();
-            input.readFully(signature);
+            pInput.mark();
+            pInput.readFully(signature);

-            int count = input.readByte() + (input.readByte() << 8);
+            int count = pInput.readByte() + (pInput.readByte() << 8);

-            return (signature[0] == 0x0 && signature[1] == 0x0 && signature[2] == type
+            return (signature[0] == 0x0 && signature[1] == 0x0 && signature[2] == pType
                    && signature[3] == 0x0 && count > 0);
        }
        finally {
-            input.reset();
+            pInput.reset();
        }
    }

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

-    public String getDescription(final Locale locale) {
+    public String getDescription(final Locale pLocale) {
        return "Windows Icon Format (ICO) Reader";
    }
 }
@@ -1,331 +0,0 @@
-/*
- * Copyright (c) 2017, 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.bmp;
-
-import com.twelvemonkeys.imageio.stream.SubImageOutputStream;
-import com.twelvemonkeys.imageio.util.ProgressListenerBase;
-
-import javax.imageio.IIOException;
-import javax.imageio.IIOImage;
-import javax.imageio.ImageIO;
-import javax.imageio.ImageReader;
-import javax.imageio.ImageTypeSpecifier;
-import javax.imageio.ImageWriteParam;
-import javax.imageio.ImageWriter;
-import javax.imageio.event.IIOWriteWarningListener;
-import javax.imageio.metadata.IIOMetadata;
-import javax.imageio.spi.ImageWriterSpi;
-import javax.imageio.stream.ImageInputStream;
-import javax.imageio.stream.ImageOutputStream;
-import java.awt.image.*;
-import java.io.File;
-import java.io.IOException;
-import java.util.Iterator;
-
-import static com.twelvemonkeys.imageio.plugins.bmp.DirectoryEntry.ICOEntry;
-
-/**
- * ImageWriter implementation for Windows Icon (ICO) format.
- */
-public final class ICOImageWriter extends DIBImageWriter {
-
-    // TODO: Support appending/updating an existing ICO file?
-    // - canInsertImage/canRemoveImage
-
-    private static final int ENTRY_SIZE = 16;
-    private static final int ICO_MAX_DIMENSION = 256;
-    private static final int INITIAL_ENTRY_COUNT = 8;
-
-    private int sequenceIndex = -1;
-
-    private ImageWriter pngDelegate;
-
-    ICOImageWriter(final ImageWriterSpi provider) {
-        super(provider);
-    }
-
-    @Override
-    protected void resetMembers() {
-        sequenceIndex = -1;
-
-        if (pngDelegate != null) {
-            pngDelegate.dispose();
-            pngDelegate = null;
-        }
-    }
-
-    @Override
-    public IIOMetadata getDefaultImageMetadata(final ImageTypeSpecifier imageType, final ImageWriteParam param) {
-        return null;
-    }
-
-    @Override
-    public IIOMetadata convertImageMetadata(final IIOMetadata inData, final ImageTypeSpecifier imageType, final ImageWriteParam param) {
-        return null;
-    }
-
-    @Override
-    public void write(final IIOMetadata streamMetadata, final IIOImage image, final ImageWriteParam param) throws IOException {
-        prepareWriteSequence(streamMetadata);
-        writeToSequence(image, param);
-        endWriteSequence();
-    }
-
-    @Override
-    public boolean canWriteSequence() {
-        return true;
-    }
-
-    @Override
-    public void prepareWriteSequence(final IIOMetadata streamMetadata) throws IOException {
-        assertOutput();
-
-        if (sequenceIndex >= 0) {
-            throw new IllegalStateException("writeSequence already started");
-        }
-
-        writeICOHeader();
-
-        // Count: Needs to be updated for each new image
-        imageOutput.writeShort(0);
-        sequenceIndex = 0;
-
-        // TODO: Allow passing the initial size of the directory in the stream metadata?
-        // - as this is much more efficient than growing...
-        // How do we update the "image directory" containing "image entries",
-        // and which must be written *before* the image data?
-        // - Allocate a block of N * 16 bytes
-        //   - If image count % N > N, we need to move the first image backwards in the file and allocate another N items...
-        imageOutput.write(new byte[INITIAL_ENTRY_COUNT * ENTRY_SIZE]); // Allocate room for 8 entries for now
-    }
-
-    @Override
-    public void endWriteSequence() {
-        assertOutput();
-
-        if (sequenceIndex < 0) {
-            throw new IllegalStateException("prepareWriteSequence not called");
-        }
-
-        sequenceIndex = -1;
-    }
-
-    @Override
-    public void writeToSequence(final IIOImage image, final ImageWriteParam param) throws IOException {
-        assertOutput();
-
-        if (sequenceIndex < 0) {
-            throw new IllegalStateException("prepareWriteSequence not called");
-        }
-
-        if (image.hasRaster()) {
-            throw new UnsupportedOperationException("Raster not supported");
-        }
-
-        if (sequenceIndex >= INITIAL_ENTRY_COUNT) {
-            growIfNecessary();
-        }
-
-        int width = image.getRenderedImage().getWidth();
-        int height = image.getRenderedImage().getHeight();
-        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) {
-            throw new IIOException(String.format("ICO maximum width or height (%d) exceeded", ICO_MAX_DIMENSION));
-        }
-
-        long imageOffset = imageOutput.getStreamPosition();
-
-        if (imageOffset > Integer.MAX_VALUE) {
-            throw new IIOException("ICO file too large");
-        }
-
-        // Uncompressed, RLE4/RLE8 or PNG compressed
-        boolean pngCompression = param != null && "BI_PNG".equals(param.getCompressionType());
-
-        processImageStarted(sequenceIndex);
-
-        if (pngCompression) {
-            // NOTE: Embedding a PNG in a ICO is slightly different than a BMP with BI_PNG compression,
-            // so we'll just handle it directly
-            ImageWriter writer = getPNGDelegate();
-            writer.setOutput(new SubImageOutputStream(imageOutput));
-            writer.write(null, image, copyParam(param, writer));
-        }
-        else {
-            RenderedImage img = image.getRenderedImage();
-            // ICO needs height to include height of mask, even if mask isn't written
-            writeDIBHeader(DIB.BITMAP_INFO_HEADER_SIZE, img.getWidth(), img.getHeight() * 2,
-                    false, img.getColorModel().getPixelSize(), DIB.COMPRESSION_RGB);
-            writeUncompressed(false, (BufferedImage) img, img.getWidth(), img.getHeight());
-            // TODO: Write mask
-            imageOutput.write(new byte[((width * height + 31) / 32) * 4]);
-//            writeUncompressed(false, new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY), img.getWidth(), img.getHeight());
-        }
-
-        processImageComplete();
-
-        long nextPosition = imageOutput.getStreamPosition();
-
-        // Update count
-        imageOutput.seek(4);
-        imageOutput.writeShort(sequenceIndex + 1);
-
-        // Write entry
-        int entryPosition = 6 + sequenceIndex * ENTRY_SIZE;
-        imageOutput.seek(entryPosition);
-
-        long size = nextPosition - imageOffset;
-        writeEntry(width,  height, colorModel, (int) size, (int) imageOffset);
-
-        sequenceIndex++;
-
-        imageOutput.seek(nextPosition);
-    }
-
-    private void writeICOHeader() throws IOException {
-        if (imageOutput.getStreamPosition() != 0) {
-            throw new IllegalStateException("Stream already written to");
-        }
-
-        imageOutput.writeShort(0);
-        imageOutput.writeShort(DIB.TYPE_ICO);
-        imageOutput.flushBefore(imageOutput.getStreamPosition());
-    }
-
-    private void growIfNecessary() {
-        // TODO: Allow growing the directory index...
-        // Move the first icon to the back, update offset
-        throw new IllegalStateException(String.format("Maximum number of icons supported (%d) exceeded", INITIAL_ENTRY_COUNT));
-    }
-
-    @Override
-    public ImageWriteParam getDefaultWriteParam() {
-        return new ICOImageWriteParam(getLocale());
-    }
-
-    private ImageWriteParam copyParam(final ImageWriteParam param, ImageWriter writer) {
-        if (param == null) {
-            return null;
-        }
-
-        ImageWriteParam writeParam = writer.getDefaultWriteParam();
-        writeParam.setSourceSubsampling(param.getSourceXSubsampling(), param.getSourceYSubsampling(), param.getSubsamplingXOffset(), param.getSubsamplingYOffset());
-        writeParam.setSourceRegion(param.getSourceRegion());
-        writeParam.setSourceBands(param.getSourceBands());
-
-        return writeParam;
-    }
-
-    private ImageWriter getPNGDelegate() {
-        if (pngDelegate == null) {
-            // There's always a PNG writer...
-            pngDelegate = ImageIO.getImageWritersByFormatName("PNG").next();
-            pngDelegate.setLocale(getLocale());
-            pngDelegate.addIIOWriteProgressListener(new ProgressListenerBase() {
-                @Override
-                public void imageProgress(ImageWriter source, float percentageDone) {
-                    processImageProgress(percentageDone);
-                }
-
-                @Override
-                public void writeAborted(ImageWriter source) {
-                    processWriteAborted();
-                }
-            });
-            pngDelegate.addIIOWriteWarningListener(new IIOWriteWarningListener() {
-                @Override
-                public void warningOccurred(ImageWriter source, int imageIndex, String warning) {
-                    processWarningOccurred(sequenceIndex, warning);
-                }
-            });
-        }
-
-        return pngDelegate;
-    }
-
-    private void writeEntry(final int width, final int height, final ColorModel colorModel, int size, final int offset) throws IOException {
-        new ICOEntry(width, height, colorModel, size, offset)
-                .write(imageOutput);
-    }
-
-    public static void main(String[] args) throws IOException {
-        boolean pngCompression = false;
-        int firstArg = 0;
-
-        while (args.length > firstArg && args[firstArg].charAt(0) == '-') {
-            if (args[firstArg].equals("-p") || args[firstArg].equals("--png")) {
-                pngCompression = true;
-            }
-
-            firstArg++;
-        }
-
-        if (args.length - firstArg < 2) {
-            System.err.println("Usage: command [-p|--png] <output.ico> <input> [<input>...]");
-            System.exit(1);
-        }
-
-        try (ImageOutputStream out = ImageIO.createImageOutputStream(new File(args[firstArg++]))) {
-            ImageWriter writer = new ICOImageWriter(null);
-            writer.setOutput(out);
-
-            ImageWriteParam param = writer.getDefaultWriteParam();
-            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
-            param.setCompressionType(pngCompression ? "BI_PNG" : "BI_RGB");
-
-            writer.prepareWriteSequence(null);
-
-            for (int i = firstArg; i < args.length; i++) {
-                File inFile = new File(args[i]);
-                try (ImageInputStream input = ImageIO.createImageInputStream(inFile)) {
-                    Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
-
-                    if (!readers.hasNext()) {
-                        System.err.printf("Can't read %s\n", inFile.getAbsolutePath());
-                    }
-                    else {
-                        ImageReader reader = readers.next();
-                        reader.setInput(input);
-                        for (int j = 0; j < reader.getNumImages(true); j++) {
-                            IIOImage image = reader.readAll(j, null);
-                            writer.writeToSequence(image, param);
-                        }
-                    }
-                }
-            }
-
-            writer.endWriteSequence();
-            writer.dispose();
-        }
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Harald Kuhr	26d3de45a7	[maven-release-plugin] prepare for next development iteration	2020-01-09 19:40:24 +01:00
Harald Kuhr	13507ce303	[maven-release-plugin] prepare release twelvemonkeys-3.4.3	2020-01-09 19:40:16 +01:00
Harald Kuhr	a8508dc234	Stick to the git user, when using ssh (cherry picked from commit `b6aec25f00`)	2020-01-09 19:28:35 +01:00
Harald Kuhr	b3cf467f0b	log4j removal (cherry picked from commit `ae213dcf5e`)	2020-01-09 19:25:48 +01:00
Harald Kuhr	b0e6fbed9f	#510 : Fixes possible hang situation (cherry picked from commit `5501c0e709`)	2020-01-09 19:25:48 +01:00
Harald Kuhr	c087addb76	#501 : Fix for TYPE_USHORT_555/565_RGB, ColorModel now 16 bits (cherry picked from commit `42e17f2063`)	2020-01-09 19:25:48 +01:00
Harald Kuhr	250c58cc2e	#289 , #493 : Finally implemented subsampling for < 8 bit samples (cherry picked from commit `0c2433dc9f`)	2020-01-09 19:25:48 +01:00
Oliver Schmidtmer	c33b3a76f4	Test correction for ViewBox based svg sizes (cherry picked from commit `810b7197ab`)	2020-01-09 19:24:58 +01:00
Oliver Schmidtmer	f14e6823bd	When rescaling SVGs use the ViewBox, if defined, for default sizes (cherry picked from commit `24a0786d64`)	2020-01-09 19:24:58 +01:00
Harald Kuhr	cae72336a2	[maven-release-plugin] prepare for next development iteration	2019-08-12 21:05:55 +02:00
Harald Kuhr	c5bf0a6f0b	[maven-release-plugin] prepare release twelvemonkeys-3.4.2	2019-08-12 21:03:23 +02:00
Harald Kuhr	691b7560db	Switched Maven SCM to use ssh. (cherry picked from commit `c1834dc78d`)	2019-08-12 20:42:24 +02:00
Harald Kuhr	e1025f9540	Fixed JavaDoc errors to enable Java 8 build. (cherry picked from commit `9e23413456`)	2019-08-10 00:58:08 +02:00
Harald Kuhr	fa09099da0	Fixed encoding issues in readme. (cherry picked from commit `7d2c692663`)	2019-08-09 21:04:41 +02:00
Harald Kuhr	140b074ac6	#398 : Better exception message when BufferedImage size > Integer.MAX (cherry picked from commit `9ce1a86cae`)	2019-08-09 21:04:41 +02:00
Harald Kuhr	59c6c18cbb	#477 : Better tests to for cyclic loops in IFDs. (cherry picked from commit `b0b5de5fa4`)	2019-08-09 21:04:41 +02:00
Harald Kuhr	c48e17dabf	#474 : Fix java.awt.color.CMMException: Can not access specified profile (cherry picked from commit `64178bd636`)	2019-08-09 21:04:41 +02:00
Harald Kuhr	22a842eb78	449# Missing test to verify that we ignore bogus 0 byte counts. (cherry picked from commit `7985cdd4a7`)	2019-08-09 21:04:41 +02:00
Harald Kuhr	bdd7f5b228	#492 : Now correctly parses multiple strings for ASCII fields. (cherry picked from commit `8247861095`)	2019-08-09 21:04:40 +02:00
Harald Kuhr	0e41d4a5f7	#477 : Avoid cyclic loops in IFDs. (cherry picked from commit `8480c929c1`)	2019-08-09 21:04:40 +02:00
Harald Kuhr	653360e054	Moving travis build to trusty, to fix JDK8 build (cherry picked from commit `e6f437f55b`)	2019-08-09 21:04:40 +02:00
Harald Kuhr	4f193d543c	#488 : Fix for AIOOBE in getEmbeddedICCProfile when ICC profile is empty (cherry picked from commit `ee049d9465`)	2019-08-09 21:04:40 +02:00
Harald Kuhr	1d0cc43476	#489 Fix for Unexpected End of PackBits Stream for padded streams. (cherry picked from commit `f6aa810f8b`)	2019-08-09 21:04:40 +02:00
Harald Kuhr	9791a251ed	#469 Fix for OOME while reading Exif with corrupted IFDs/counts (cherry picked from commit `e8d1b999a2`)	2019-08-09 21:04:40 +02:00
Harald Kuhr	0bc30f4d18	JPEG Exif parsing optimization. (cherry picked from commit `d7fbd6594e`)	2019-08-09 21:04:40 +02:00
Harald Kuhr	022fc03fbb	XMLSerializer speedup. (cherry picked from commit `caef9b6a9e`)	2019-08-09 21:04:39 +02:00
Harald Kuhr	8b66842859	#475 : Fix support for writing TIFF > 2 GB (cherry picked from commit `7fad4d5cd8`)	2019-08-09 21:04:39 +02:00
Harald Kuhr	5251f4665e	#473 : Fix for ColorMap (Indexed) TIFF with non-alpha ExtraSamples. (cherry picked from commit `3e4b14f984`)	2019-08-09 21:04:39 +02:00
Paul Verest	b98b81b877	colorize code snippets in README using GFM ```java,` ``xml (cherry picked from commit `51b0734462`)	2019-08-09 21:03:01 +02:00
Harald Kuhr	774b494fec	Updated commons-fileupload dependency to safe version, even if in scope provided, just in case. (cherry picked from commit `8e3cd5aedb`)	2019-08-09 21:03:00 +02:00
Oliver Schmidtmer	90ef605b0c	Fix for #455 : Ignore profiles PhotometricInterpretation MinIsWhite with 1bit/pixel (cherry picked from commit `cbaa0dc688`)	2019-08-09 21:03:00 +02:00
Harald Kuhr	b40eea0fc4	Fix test case for #446 in case of "Gerenic CMYK" profile not being available. (cherry picked from commit `61bac97933`)	2019-08-09 21:03:00 +02:00
Harald Kuhr	9ac2013965	Better assertion failed messages. (cherry picked from commit `3e9be32279`)	2019-08-09 21:03:00 +02:00
Harald Kuhr	4740a39cd2	Test case for #446 . (cherry picked from commit `a0955875d8`)	2019-08-09 21:03:00 +02:00
Harald Kuhr	7ebcc437c3	Various Java 9 and beyond fixes: - ExtraSamplesColorModel now overrides getComponentSize for correct size - TIFFImageReader/WriterSpi now recognizes the JEP 262 TIFF plugin - CCITTFaxEncoderStreamTest now directly creates writer (not JDK one) (cherry picked from commit `7e0de14783`)	2019-08-09 21:02:30 +02:00
Harald Kuhr	70c16dfdd9	Various Java 9 and beyond fixes. (cherry picked from commit `de34d4642e`)	2019-08-09 21:02:30 +02:00
Harald Kuhr	c9e2e21727	Equals method for DiscreteAlphaIndexColorModel, needed for Java 10. (cherry picked from commit `b86bad2bf9`)	2019-08-09 21:02:30 +02:00
Harald Kuhr	230ac33283	#442 SVG BaseURI issue fix (cherry picked from commit `cc5af0134c`)	2019-08-09 21:02:30 +02:00
Bernhard Fey	66e0acb668	Added test file for non-alpha extra channel Added test file for CMYK TIFF with non-alpha extra channel (cherry picked from commit `edcac25f5e`)	2019-08-09 21:02:30 +02:00
Bernhard Fey	7d8858c177	Modified new create[ImageTypeSpecifier] method according to suggestions by @haraldk Renamed "create" method to "createImageTypeSpecifier". Added exception thrown for unsupported planarConfiguration values. (cherry picked from commit `5a5c1f996b`)	2019-08-09 21:02:30 +02:00
Bernhard Fey	faab9517dd	Fix for non-RGB images with extra sample Added "create" method to TIFFImageReader that centralizes the use of "createBanded" and "createInterleaved" as well as the "extra samples" special case and fixes non-RGB images with non-alpha extra samples (cherry picked from commit `f9b8cae0ea`)	2019-08-09 21:02:30 +02:00
Harald Kuhr	2433777b6d	Updated readme (cherry picked from commit `62538c3db9`)	2019-08-09 21:02:13 +02:00
Harald Kuhr	3980c937cf	Fixed release date. (cherry picked from commit `48aa504be4`)	2019-08-09 21:02:13 +02:00
Harald Kuhr	468ffb891d	Updated versions from 3.4 to 3.4.1. (cherry picked from commit `ed2eb7642a`)	2019-08-09 21:02:13 +02:00
Harald Kuhr	e27e8a7ccb	#408 Added servlet JAR to dependency example. (cherry picked from commit `24ec5ae34d`)	2019-08-09 21:02:03 +02:00
Harald Kuhr	f2dba604da	#311 Updated some more license headers that was left out in the initial change. (cherry picked from commit `a7b374e51a`)	2019-08-09 21:01:29 +02:00
Harald Kuhr	04f27a1694	#438 CompoundDocument file descriptor fix	2018-09-08 16:21:01 +02:00
Harald Kuhr	2630a6a795	[maven-release-plugin] prepare for next development iteration	2018-09-07 19:48:17 +02:00
Harald Kuhr	ab2f1f7e91	[maven-release-plugin] prepare release twelvemonkeys-3.4.1	2018-09-07 19:48:10 +02:00
Harald Kuhr	7110e89bda	Prepare next release	2018-09-07 19:42:06 +02:00
Harald Kuhr	a06cbfd6f4	#437 Catching exception from static init, prints a warning and moves on. (cherry picked from commit `d8d0131`)	2018-08-30 15:04:55 +02:00
Harald Kuhr	3b68d676f3	#439 : Unclear exception message when passing image metadata as stream metadata (cherry picked from commit `6018093`)	2018-08-30 15:04:52 +02:00