313 changed files with 6499 additions and 7719 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@ -1,2 +0,0 @@
-[alias]
-xtask = "run --manifest-path xtask/Cargo.toml --"
--- a/.dockerignore
+++ b/.dockerignore
@ -1,7 +0,0 @@
-.editorconfig
-.gitignore
-/.git/
-/.github/
-/.pre-commit-hooks.yaml
-/scripts/
-/target/
--- a/.editorconfig
+++ b/.editorconfig
@ -1,11 +1,10 @@
 root = true

 [*]
-charset = utf-8
 end_of_line = lf
-indent_style = space
 insert_final_newline = true
-trim_trailing_whitespace = true

 [*.rs]
+charset = utf-8
+indent_style = space
 indent_size = 4
--- a/.gitattributes
+++ b/.gitattributes
@ -1,2 +0,0 @@
-# Enforce Unix newlines
-* text=auto eol=lf
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@ -1,24 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 5
-    commit-message:
-      prefix: "chore"
-      include: "scope"
-    labels:
-      - "dependencies"
-      - "rust"
-    groups:
-      rust-dependencies:
-        patterns:
-          - "*"
-        update-types:
-          - "minor"
-          - "patch"
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@ -3,136 +3,155 @@ name: deploy
 on:
  push:
    tags:
-      - v*.*.*
-
-concurrency:
-  # If we ever end up with two concurrent jobs for releasing the same tag, the former should be cancelled
-  group: release-${{ github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  actions: read
-  contents: write
+      - 'v*.*.*'

 jobs:
-  deploy:
-    name: Deploy release

-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-
-    # Prevent job from running on forks
-    if: ${{ !github.event.repository.fork }}
+  create-windows-binaries:

    strategy:
-      # Execute one job at a time to avoid potential race conditions in the
-      # GitHub release management APIs. See:
-      # https://github.com/softprops/action-gh-release/issues/445#issuecomment-2407940052
-      max-parallel: 1
      matrix:
-        target:
-          - x86_64-unknown-linux-gnu
-          - x86_64-unknown-linux-musl
-          - aarch64-unknown-linux-gnu
-          - aarch64-unknown-linux-musl
-          - x86_64-pc-windows-msvc
-          - i686-pc-windows-msvc
-          - x86_64-apple-darwin
-          - aarch64-apple-darwin
+        conf: [x86_64]
+# Temporarily disable i686 binaries, they are failing on linking libdeflate
+# and I don't have a Windows machine set up to experiment with fixing it.
+#        conf: [x86_64, i686]
+
+    runs-on: windows-latest

    steps:
-      - name: Checkout source
-        uses: actions/checkout@v6
+    - uses: actions/checkout@v2

-      - name: Install Rust toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          toolchain: nightly
-          cache-bin: false
-          cache-shared-key: cache
+    - name: Install stable
+      uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+        target: ${{ matrix.conf }}-pc-windows-msvc
+        override: true

-      - name: Install cargo-deb
-        if: endsWith(matrix.target, '-linux-gnu')
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-deb
+    - name: Build oxipng
+      run: |
+        cargo build --release --target ${{ matrix.conf }}-pc-windows-msvc

-      - name: Get the Oxipng version
-        id: oxipngMeta
-        run: >
-          echo "version=$(cargo metadata --format-version 1 --no-deps |
-          jq -r '.packages[] | select(.name == "oxipng").version')" >> "$GITHUB_OUTPUT"
+    - name: Get the version
+      shell: bash
+      id: tagName
+      run: |
+        VERSION=$(cargo pkgid | cut -d# -f2 | cut -d: -f2)
+        echo "::set-output name=tag::$VERSION"

-      - name: Retrieve ${{ matrix.target }} binary
-        uses: dawidd6/action-download-artifact@v21
-        with:
-          workflow: oxipng.yml
-          commit: ${{ github.sha }}
-          name: Oxipng binary (${{ matrix.target }})
-          path: target
+    - name: Build package
+      id: package
+      shell: bash
+      run: |
+        ARCHIVE_TARGET="${{ matrix.conf }}-pc-windows-msvc"
+        ARCHIVE_NAME="oxipng-${{ steps.tagName.outputs.tag }}-$ARCHIVE_TARGET"
+        ARCHIVE_FILE="${ARCHIVE_NAME}.zip"
+        mv LICENSE LICENSE.txt
+        7z a ${ARCHIVE_FILE} \
+             ./target/${{ matrix.conf }}-pc-windows-msvc/release/oxipng.exe \
+             ./CHANGELOG.md ./LICENSE.txt ./README.md
+        echo "::set-output name=file::${ARCHIVE_FILE}"
+        echo "::set-output name=name::${ARCHIVE_NAME}.zip"

-      - name: Generate up to date manual
-        run: scripts/manual.sh
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: ${{ steps.package.outputs.name }}
+        path: ${{ steps.package.outputs.file }}

-      - name: Build archives
-        working-directory: target
+  create-unix-binaries:
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+          - os: macos-latest
+            target: x86_64-apple-darwin
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+        target: ${{ matrix.target }}
+        override: true
+
+    - name: Install musl
+      if: contains(matrix.target, 'linux-musl')
+      run: |
+        sudo apt-get install musl-tools
+
+    - name: Build oxipng
+      run: |
+        cargo build --release --target ${{ matrix.target }}
+
+    - name: Strip binary
+      run: |
+        strip target/${{ matrix.target }}/release/oxipng
+
+    - name: Get the version
+      id: tagName
+      run: |
+        VERSION=$(cargo pkgid | cut -d# -f2 | cut -d: -f2)
+        echo "::set-output name=tag::$VERSION"
+
+    - name: Build package
+      id: package
+      run: |
+        ARCHIVE_TARGET=${{ matrix.target }}
+        ARCHIVE_NAME="oxipng-${{ steps.tagName.outputs.tag }}-$ARCHIVE_TARGET"
+        ARCHIVE_FILE="${ARCHIVE_NAME}.tar.gz"
+        mkdir "/tmp/${ARCHIVE_NAME}"
+        cp README.md CHANGELOG.md LICENSE \
+           target/${{ matrix.target }}/release/oxipng \
+           /tmp/${ARCHIVE_NAME}
+        tar -czf ${PWD}/${ARCHIVE_FILE} -C /tmp/ ${ARCHIVE_NAME}
+        echo ::set-output "name=file::${ARCHIVE_FILE}"
+        echo ::set-output "name=name::${ARCHIVE_NAME}.tar.gz"
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: ${{ steps.package.outputs.name }}
+        path: ${{ steps.package.outputs.file }}
+
+
+  deploy:
+
+    needs: [create-windows-binaries, create-unix-binaries]
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Get version and release description
+        id: tagName
        run: |
-          ARCHIVE_NAME="oxipng-${{ steps.oxipngMeta.outputs.version }}-${{ matrix.target }}"
+          VERSION=$(cargo pkgid | cut -d# -f2 | cut -d: -f2)
+          tail -n +2 CHANGELOG.md | sed -e '/^$/,$d' > CHANGELOG.txt
+          echo "::set-output name=tag::$VERSION"

-          mkdir "$ARCHIVE_NAME"
-          cp ../CHANGELOG.md ../README.md ../MANUAL.txt "$ARCHIVE_NAME"
-
-          case '${{ matrix.target }}' in
-            *-windows-*)
-              cp ../LICENSE "$ARCHIVE_NAME/LICENSE.txt"
-              cp oxipng.exe "$ARCHIVE_NAME"
-              zip "${ARCHIVE_NAME}.zip" "$ARCHIVE_NAME"/*;;
-            *)
-              cp ../LICENSE "$ARCHIVE_NAME"
-              cp oxipng "$ARCHIVE_NAME"
-              # Execute permissions are not stored in artifact files,
-              # so make the binary world-executable to meet user
-              # expectations set by preceding releases.
-              # Related issue:
-              # https://github.com/oxipng/oxipng/issues/575
-              chmod ugo+x "$ARCHIVE_NAME"/oxipng
-              tar -vczf "${ARCHIVE_NAME}.tar.gz" "$ARCHIVE_NAME"/*;;
-          esac
-
-      - name: Install AArch64 libc components
-        if: matrix.target == 'aarch64-unknown-linux-gnu'
-        run: |
-          sudo apt-get -yq update
-          # The shared libc AArch64 libraries are needed for cargo deb below
-          # to be able to infer package requirements with dpkg-shlibdeps
-          # properly
-          sudo apt-get -yq install libc6-arm64-cross libgcc-s1-arm64-cross
-
-      - name: Build Debian packages
-        if: endsWith(matrix.target, '-linux-gnu')
-        env:
-          # The *-arm64-cross packages above install AArch64 libraries in
-          # /usr/<arch>/lib instead of /usr/lib/<arch>, as expected by
-          # cargo-deb and dpkg-shlibdeps to find such shared libraries.
-          # Make both of them visible to such commands by adding that directory
-          # to the dynamic linker's library search path. See:
-          # - <https://man7.org/linux/man-pages/man1/dpkg-shlibdeps.1.html> ("Errors" section)
-          # - <https://github.com/kornelski/cargo-deb/issues/21>
-          LD_LIBRARY_PATH: /usr/aarch64-linux-gnu/lib
-        run: |
-          mkdir -p "target/${{ matrix.target }}/release"
-          mv target/oxipng "target/${{ matrix.target }}/release"
-          cargo deb --target "${{ matrix.target }}" --no-build --no-strip
-
-      - name: Create release notes
-        run: tail -n +3 CHANGELOG.md | sed -e '/^$/,$d' > RELEASE_NOTES.txt
-
-      - name: Create release
-        uses: softprops/action-gh-release@v3
+      - name: Download artifacts
+        uses: actions/download-artifact@v2
        with:
-          name: v${{ steps.oxipngMeta.outputs.version }}
-          body_path: RELEASE_NOTES.txt
+          path: ./binaries
+
+      - name: Create a release
+        uses: softprops/action-gh-release@v1
+        with:
+          name: v${{ steps.tagName.outputs.tag }}
+          body_path: CHANGELOG.txt
          files: |
-            target/*.zip
-            target/*.tar.gz
-            target/${{ matrix.target }}/debian/*.deb
+            ./binaries/**/*.zip
+            ./binaries/**/*.tar.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@ -1,60 +0,0 @@
-name: docker
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - v*.*.*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-  workflow_dispatch:
-    inputs:
-      use_cache:
-        description: "Use build cache"
-        required: true
-        type: boolean
-        default: true
-
-concurrency:
-  # If we ever end up with two concurrent Docker build jobs for the same commit
-  # and same versioning context, the former should be cancelled
-  group: docker-${{ github.sha }}-${{ github.ref_type }}-${{ github.head_ref }}
-  cancel-in-progress: true
-
-jobs:
-  build:
-    uses: docker/github-builder/.github/workflows/build.yml@v1
-    permissions:
-      contents: read
-      packages: write
-      id-token: write
-      attestations: write
-    with:
-      output: image
-      platforms: linux/amd64,linux/arm64
-      push: ${{ github.event_name != 'pull_request' }}
-      cache: ${{ github.event_name != 'workflow_dispatch' || inputs.use_cache }}
-      # We don't sign the image because ghcr.io doesn't support OCI Referrers API yet, and the fallback relies on pushing new tags on each build
-      # https://github.com/docker/github-builder/issues/109#issuecomment-3885082486
-      # https://github.com/opencontainers/distribution-spec/blob/v1.1.0/spec.md#backwards-compatibility
-      sign: false
-      sbom: true
-      meta-images: ghcr.io/${{ github.repository }}
-      meta-tags: |
-        type=ref,event=branch
-        type=ref,event=pr
-        type=semver,pattern={{raw}}
-      set-meta-annotations: true
-      set-meta-labels: true
-      labels: |
-        org.opencontainers.image.title=Oxipng
-      annotations: |
-        org.opencontainers.image.title=Oxipng
-
-    secrets:
-      registry-auths: |
-        - registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/oxipng.yml
+++ b/.github/workflows/oxipng.yml
@ -2,179 +2,91 @@ name: oxipng

 on:
  push:
+    branches:
+      - master
  pull_request:
-    types:
-      - opened
-      - synchronize
-  workflow_dispatch:
-
-concurrency:
-  # If we ever end up with two concurrent CI jobs for the same commit, the former should be cancelled
-  group: ci-${{ github.sha }}
-  cancel-in-progress: true
+    branches:
+      - master

 jobs:
-  ci:
-    name: CI
-
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 60
-
-    # Prevent tags and in-repo PRs from triggering this workflow more than once for a commit
-    if: github.ref_type != 'tag' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork)
-
+  test:
    strategy:
-      fail-fast: false
      matrix:
        target:
          - x86_64-unknown-linux-gnu
          - x86_64-unknown-linux-musl
-          - aarch64-unknown-linux-gnu
-          - aarch64-unknown-linux-musl
          - x86_64-pc-windows-msvc
-          - i686-pc-windows-msvc
          - x86_64-apple-darwin
-          - aarch64-apple-darwin
-
+        toolchain:
+          # Minimum stable
+          - "1.61.0"
+          - stable
+          - beta
+          - nightly
        include:
          - target: x86_64-unknown-linux-gnu
-            os: ubuntu-24.04
-            target-apt-arch: amd64
+            os: ubuntu-latest
          - target: x86_64-unknown-linux-musl
-            os: ubuntu-24.04
-            target-apt-arch: amd64
-          - target: aarch64-unknown-linux-gnu
-            os: ubuntu-24.04-arm
-            target-apt-arch: arm64
-          - target: aarch64-unknown-linux-musl
-            os: ubuntu-24.04-arm
-            target-apt-arch: arm64
+            os: ubuntu-latest
          - target: x86_64-pc-windows-msvc
            os: windows-latest
-          - target: i686-pc-windows-msvc
-            os: windows-latest
          - target: x86_64-apple-darwin
-            os: macos-15
-          - target: aarch64-apple-darwin
-            os: macos-15
-
-    env:
-      CARGO_BUILD_TARGET: ${{ matrix.target }}
-
+            os: macOS-latest
+        exclude:
+          - target: x86_64-pc-windows-msvc
+            toolchain: beta
+          - target: x86_64-pc-windows-msvc
+            toolchain: nightly
+          - target: x86_64-apple-darwin
+            toolchain: beta
+          - target: x86_64-apple-darwin
+            toolchain: nightly
+          - target: x86_64-unknown-linux-musl
+            toolchain: beta
+          - target: x86_64-unknown-linux-musl
+            toolchain: nightly
+    runs-on: ${{ matrix.os }}
    steps:
-      - name: Checkout source
-        uses: actions/checkout@v6
+      - uses: actions/checkout@v2
+      - name: Install musl tools
+        run: sudo apt-get install musl-tools
+        if: "contains(matrix.target, 'musl')"
+      - name: Install ${{ matrix.toolchain }}
+        uses: actions-rs/toolchain@v1
        with:
-          persist-credentials: false
-
-      - name: Install musl development files
-        if: endsWith(matrix.target, '-musl')
-        run: |
-          sudo apt-get -yq update
-          sudo apt-get -yq install musl-tools musl-dev:${{ matrix.target-apt-arch }}
-
-      - name: Install Rust toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
+          profile: minimal
+          toolchain: ${{ matrix.toolchain }}
+          override: true
+          components: clippy, rustfmt
+      - name: Cache cargo registry
+        uses: actions/cache@v1
        with:
-          toolchain: nightly
-          target: ${{ env.CARGO_BUILD_TARGET }}
-          components: clippy, rustfmt, rust-src
-          cache-bin: false
-          cache-shared-key: cache
-
-      - name: Install nextest
-        uses: taiki-e/install-action@nextest
-
-      - name: Install cargo-hack
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        uses: taiki-e/install-action@cargo-hack
-
-      - name: Install clippy-sarif
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        uses: taiki-e/install-action@v2
-        with:
-          tool: clippy-sarif
-
-      - name: Install sarif-fmt
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        uses: taiki-e/install-action@v2
-        with:
-          tool: sarif-fmt
-
+          path: ~/.cargo/registry/cache
+          key: ${{ matrix.target }}-${{ matrix.toolchain }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ matrix.target }}-${{ matrix.toolchain }}-cargo-registry-
      - name: Run rustfmt
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        run: cargo fmt --check
-
-      - name: Run Clippy for all feature combinations
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        run: >
-          set -o pipefail;
-          cargo hack clippy --no-deps --all-targets --feature-powerset \
-            --exclude-features sanity-checks,system-libdeflate \
-            --message-format=json -- -D warnings \
-          | clippy-sarif
-          | tee clippy-results.sarif
-          | sarif-fmt
-
+        if: matrix.toolchain == 'stable'
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: -- --check
+      - name: Run clippy
+        if: matrix.toolchain == 'stable'
+        uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: -- -D warnings
      - name: Run tests
-        run: |
-          cargo nextest run --release --features sanity-checks
-          cargo test --doc --release --features sanity-checks
-
+        run: cargo test
      - name: Build benchmarks
+        if: matrix.toolchain == 'nightly'
        run: cargo bench --no-run
-
      - name: Build docs
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        run: cargo doc --release --no-deps
-
-      - name: Build CLI binary
-        run: cargo build --release -Zbuild-std
-        env:
-          RUSTFLAGS: "-Zlocation-detail=none -Zunstable-options -Cpanic=immediate-abort"
-
-      - name: Upload CLI binary as artifact
-        uses: actions/upload-artifact@v7
+        run: cargo doc --no-deps
+      - name: Check no default features
+        if: matrix.toolchain == 'stable'
+        uses: actions-rs/clippy-check@v1
        with:
-          name: Oxipng binary (${{ matrix.target }})
-          path: |
-            target/${{ env.CARGO_BUILD_TARGET }}/release/oxipng
-            target/${{ env.CARGO_BUILD_TARGET }}/release/oxipng.exe
-
-      - name: Upload analysis results to GitHub
-        uses: github/codeql-action/upload-sarif@v4
-        if: always() && matrix.target == 'x86_64-unknown-linux-gnu'
-        continue-on-error: true
-        with:
-          sarif_file: clippy-results.sarif
-          category: clippy
-
-  msrv-check:
-    name: MSRV check
-
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-
-    # Prevent tags and in-repo PRs from triggering this workflow more than once for a commit
-    if: github.ref_type != 'tag' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork)
-
-    steps:
-      - name: Checkout source
-        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-
-      - name: Install MSRV Rust toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          toolchain: 1.85.1
-          cache-bin: false
-          cache-shared-key: cache
-
-      - name: Install nextest
-        uses: taiki-e/install-action@nextest
-
-      - name: Run tests
-        run: |
-          cargo nextest run --release --features sanity-checks
-          cargo test --doc --release --features sanity-checks
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --no-default-features -- -D warnings
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,6 @@
-.DS_Store
+target
 *.bk
+.DS_Store
 *.out.png
-/.idea/
-/node_modules/
-/target/
+/.idea
+/node_modules
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,106 +1,3 @@
-## Version 10.1.1
-
- [Performance] Improve Bigrams performance, giving notably faster results at lower levels.
- [Improvement] Change `--np` flag to also prevent conversion to indexed from other color types.
- [Improvement] Improve support for recompressing ICC profiles with high compression ratios.
- [Misc] Add warning when `--ziwi` exceeds `--zi`.
- [Build] Further reduce size of binaries.
-
-## Version 10.1.0
-
- [Feature] Add `--json` option for machine-readable output.
- [Improvement] New default output with file counter and summary. (Use an extra `-v` flag to get the same output as before.)
- [Bugfix] Fix fast mode sometimes giving suboptimal results for small, indexed images.
-
-## Version 10.0.0
-
- [Breaking] CLI: Change short zopfli flag from `-Z` to `-z`.
- [Breaking] CLI: Change `--pretend`/`-P` to `--dry-run`/`-d`.
- [Breaking] CLI: Change `--interlace` options from `1`/`0` to `on`/`off`.
- [Breaking] API: Change `Options.interlace: Option<Interlacing>` to `Options.interlace: Option<bool>`.
- [Breaking] API: Change `Options.filter: IndexSet<RowFilter>` to `Options.filters: IndexSet<FilterStrategy>`.
- [Breaking] API: Change `Options.deflate: Deflaters` to `Options.deflater: Deflater`.
- [Breaking] API: Change `Deflaters::Zopfli { .. }` to `Deflater::Zopfli(ZopfliOptions { .. })`.
- [Breaking] API: Change `optimize()` to return `(usize, usize)`, with original and optimized sizes.
- [Feature] Allow zopfli iterations higher than 255.
- [Feature] Add `--ziwi` option for zopfli iterations without improvement.
- [Feature] Add `--max-raw-size` option to skip images that are too large.
- [Feature] Add `--brute-level` and `--brute-lines` options for advanced control of Brute filter.
- [Improvement] Reduce memory usage for `fast` mode.
- [Improvement] Slightly improve compression with Brute filter at levels 5 and 6.
- [Misc] Change `--preserve` option to no longer preserve last access time.
- [Misc] Make help output colored.
-
-## Version 9.1.5
-
- [Feature] Add `--sequential` option to process files sequentially rather than in parallel.
- [Performance] Update to latest Zopfli with greatly improved performance.
- [Improvement] Reduce memory usage.
- [Bugfix] Correct handling of grayscale conversion when ICC profile is present.
-
-## Version 9.1.4
-
- [Improvement] Improve optimization of APNG files (reductions still not supported yet).
- [Improvement] Improve reductions for small images and ensure consistent results for repeat runs.
- [Build] Add feature `system-libdeflate` to use the system-installed version of libdeflate.
- [Misc] Strip C2PA metadata by default.
-
-## Version 9.1.3
-
- [Feature] Add `--zi` option to control the number of Zopfli iterations.
- [Improvement] Allow setting compression level to 0.
- [Performance] Improve filtering performance for some images.
- [Build] Move man page generation to an xtask.
-
-## Version 9.1.2
-
- [Bugfix] Fix `--nx` still applying deinterlacing by default.
- [Bugfix] Fix wildcard matching being case-sensitive on Windows.
- [Bugfix] Fix optimized APNGs not being compatible with some programs.
- [Build] Fix feature `sanity-checks` not working without `parallel`.
- [Misc] Resolve ambiguity between optional dependencies and crate features.
-
-## Version 9.1.1
-
- [Build] Change man page generation path to resolve issue with cargo publish.
-
-## Version 9.1.0
-
- [Improvement] Add `--keep display` equivalent to `--strip safe`.
- [Improvement] Add modified zeng palette sorting method, improving optimization of indexed images.
- [Improvement] If only one filter is specified, guarantee to only use this one.
- [Improvement] Evaluate low-depth indexed even if low-depth grayscale was already achieved.
- [Bugfix] Fix battiato palette sorting method not being used if the input was not already indexed.
- [Bugfix] Fix rare crash caused by a truncated palette.
- [Build] Reduce size of binaries.
- [Build] Add man page generation.
- [Build] Publish deb archives for Linux.
- [Misc] Bump minimum Rust version to 1.74.0.
-
-## Version 9.0.0
-
- [Breaking] Remove `--backup` option. Use `--out` or `--dir` to preserve existing files.
- [Breaking] Remove `--check` option. Use `--nx --nz` to perform a non-optimizing run.
- [Breaking] API: Replace `pretend` option with `OutFile::None`.
- [Breaking] API: Move `preserve_attrs` into `OutFile::Path`.
- [Breaking] Default to removing interlacing. Use `-i keep` to retain existing interlacing.
- [Feature] Add Raw API for creating optimised PNGs from raw image data.
- [Feature] Add basic support for APNG files.
- [Feature] Add `--scale16` option to forcibly reduce 16-bit images to 8-bit.
- [Improvement] Process multiple files in parallel.
- [Improvement] Improve reductions, particularly for indexed or very small images.
- [Improvement] Improve compression with latest version of libdeflate.
- [Improvement] Recompress iCCP chunks.
- [Improvement] Change recursive mode to only process .png/.apng files.
- [Improvement] Add support for glob patterns in quotes on Windows.
- [Improvement] Quieter default output logging, with multiple levels of verbosity.
- [Bugfix] Fix deadlock when using oxipng within an existing Rayon thread pool.
- [Bugfix] Fix early abort in recursive mode when a read error occurred.
- [Bugfix] Fix losing aux chunks when there's more than one of the same type.
- [Bugfix] Fix sometimes writing output even when it was larger.
- [Misc] Revamp CI workflow to upload artifacts and generate binaries for additional architectures.
- [Misc] Bump minimum Rust version to 1.66.0.
-
 ## Version 8.0.0

 - [Breaking] Revamp alpha optimization
@ -199,51 +96,51 @@
 ### Version 3.0.0

 - [Breaking] Bump minimum Rust version to 1.41.0
- [Breaking] Use IndexMap/IndexSet to provide more consistent performance ([#202](https://github.com/oxipng/oxipng/pull/202))
+- [Breaking] Use IndexMap/IndexSet to provide more consistent performance ([#202](https://github.com/shssoichiro/oxipng/pull/202))
  - This changes some public-facing types.
    `IndexMap` and `IndexSet` are reexported
    at the crate root to aid migration.
- [Breaking] Remove fields from the `Options` struct which were never used ([#211](https://github.com/oxipng/oxipng/pull/211/files#diff-b4aea3e418ccdb71239b96952d9cddb6L217), [#212](https://github.com/oxipng/oxipng/pull/212/files#diff-b4aea3e418ccdb71239b96952d9cddb6L134))
- [Breaking] Refactor zlib-specific options in the `Options` struct ([#210](https://github.com/oxipng/oxipng/pull/210/files))
- [Feature] Add libdeflater as an option ([#203](https://github.com/oxipng/oxipng/pull/203))
- [Feature] Use standard `log` library ([#218](https://github.com/oxipng/oxipng/pull/218))
- [Feature] Add `-o max` setting which will always reference the highest compression preset ([#224](https://github.com/oxipng/oxipng/pull/224))
+- [Breaking] Remove fields from the `Options` struct which were never used ([#211](https://github.com/shssoichiro/oxipng/pull/211/files#diff-b4aea3e418ccdb71239b96952d9cddb6L217), [#212](https://github.com/shssoichiro/oxipng/pull/212/files#diff-b4aea3e418ccdb71239b96952d9cddb6L134))
+- [Breaking] Refactor zlib-specific options in the `Options` struct ([#210](https://github.com/shssoichiro/oxipng/pull/210/files))
+- [Feature] Add libdeflater as an option ([#203](https://github.com/shssoichiro/oxipng/pull/203))
+- [Feature] Use standard `log` library ([#218](https://github.com/shssoichiro/oxipng/pull/218))
+- [Feature] Add `-o max` setting which will always reference the highest compression preset ([#224](https://github.com/shssoichiro/oxipng/pull/224))
 - [Deprecated] `-o 4` was found to be equivalent to `-o 3` and is deprecated.
  It will likely be removed in a future release.
-  For now it remains equivalent to `-o 3`. ([#224](https://github.com/oxipng/oxipng/pull/224))
- [Bugfix] Ensure output is deterministic ([#199](https://github.com/oxipng/oxipng/pull/199))
+  For now it remains equivalent to `-o 3`. ([#224](https://github.com/shssoichiro/oxipng/pull/224))
+- [Bugfix] Ensure output is deterministic ([#199](https://github.com/shssoichiro/oxipng/pull/199))
 - Update `image` crate to 0.23
 - Update `itertools` crate to 0.9
 - Various performance and internal improvements

 ### Version 2.3.0

- Allow disabling all alpha optimizations ([#181](https://github.com/oxipng/oxipng/pull/181))
- Fix interlacing issues on tiny images ([#182](https://github.com/oxipng/oxipng/pull/182))
- Reduce memory usage in filtering ([#191](https://github.com/oxipng/oxipng/pull/191))
- Implement palette sorting to improve compression ([#193](https://github.com/oxipng/oxipng/pull/193))
- Disable alpha optimizations by default ([#187](https://github.com/oxipng/oxipng/pull/187))
- Add support for WASM ([#194](https://github.com/oxipng/oxipng/pull/194))
+- Allow disabling all alpha optimizations ([#181](https://github.com/shssoichiro/oxipng/pull/181))
+- Fix interlacing issues on tiny images ([#182](https://github.com/shssoichiro/oxipng/pull/182))
+- Reduce memory usage in filtering ([#191](https://github.com/shssoichiro/oxipng/pull/191))
+- Implement palette sorting to improve compression ([#193](https://github.com/shssoichiro/oxipng/pull/193))
+- Disable alpha optimizations by default ([#187](https://github.com/shssoichiro/oxipng/pull/187))
+- Add support for WASM ([#194](https://github.com/shssoichiro/oxipng/pull/194))

 ### Version 2.2.2

- Fix grayscale bit-depth reduction ([#171](https://github.com/oxipng/oxipng/pull/171))
- Fix typos and incorrect log message ([#172](https://github.com/oxipng/oxipng/pull/172))
- Make metadata order deterministic ([#174](https://github.com/oxipng/oxipng/pull/174))
- Fix 32-bit builds ([#176](https://github.com/oxipng/oxipng/pull/176))
- Enable LTO in release builds ([#177](https://github.com/oxipng/oxipng/pull/177))
- Use deterministic compression strategy ([#179](https://github.com/oxipng/oxipng/pull/179))
- Fix decoding interlaced images with height or width <= 2 ([#175](https://github.com/oxipng/oxipng/pull/175))
- Preallocate memory in reduced_alpha_to_up ([#180](https://github.com/oxipng/oxipng/pull/180))
+- Fix grayscale bit-depth reduction ([#171](https://github.com/shssoichiro/oxipng/pull/171))
+- Fix typos and incorrect log message ([#172](https://github.com/shssoichiro/oxipng/pull/172))
+- Make metadata order deterministic ([#174](https://github.com/shssoichiro/oxipng/pull/174))
+- Fix 32-bit builds ([#176](https://github.com/shssoichiro/oxipng/pull/176))
+- Enable LTO in release builds ([#177](https://github.com/shssoichiro/oxipng/pull/177))
+- Use deterministic compression strategy ([#179](https://github.com/shssoichiro/oxipng/pull/179))
+- Fix decoding interlaced images with height or width <= 2 ([#175](https://github.com/shssoichiro/oxipng/pull/175))
+- Preallocate memory in reduced_alpha_to_up ([#180](https://github.com/shssoichiro/oxipng/pull/180))
 - Update `bit-vec` crate to 0.6

 ### Version 2.2.1

- Fix compression of very large files ([#167](https://github.com/oxipng/oxipng/pull/167)) ([#168](https://github.com/oxipng/oxipng/pull/168))
+- Fix compression of very large files ([#167](https://github.com/shssoichiro/oxipng/pull/167)) ([#168](https://github.com/shssoichiro/oxipng/pull/168))

 ### Version 2.2.0

- Various internal improvements ([#154](https://github.com/oxipng/oxipng/pull/154)) ([#158](https://github.com/oxipng/oxipng/pull/158)) ([#160](https://github.com/oxipng/oxipng/pull/160)) ([#161](https://github.com/oxipng/oxipng/pull/161)) ([#162](https://github.com/oxipng/oxipng/pull/162)) ([#163](https://github.com/oxipng/oxipng/pull/163))
+- Various internal improvements ([#154](https://github.com/shssoichiro/oxipng/pull/154)) ([#158](https://github.com/shssoichiro/oxipng/pull/158)) ([#160](https://github.com/shssoichiro/oxipng/pull/160)) ([#161](https://github.com/shssoichiro/oxipng/pull/161)) ([#162](https://github.com/shssoichiro/oxipng/pull/162)) ([#163](https://github.com/shssoichiro/oxipng/pull/163))
 - Update `image` crate to 0.21.0
 - Update `itertools` crate to 0.8.0
 - Update `zopfli` crate to 0.4.0
@ -252,24 +149,24 @@

 ### Version 2.1.8

- Fix non-standard sBIT headers in other code locations ([#153](https://github.com/oxipng/oxipng/issues/153))
+- Fix non-standard sBIT headers in other code locations ([#153](https://github.com/shssoichiro/oxipng/issues/153))

 ### Version 2.1.7

- 80x faster palette reduction ([#150](https://github.com/oxipng/oxipng/pull/150))
- Optimize RGB to palette conversion ([#148](https://github.com/oxipng/oxipng/pull/148))
- Various microoptimizations ([#146](https://github.com/oxipng/oxipng/pull/146))
- Introduce third-party safe wrapper around cloudflare-zlib ([#149](https://github.com/oxipng/oxipng/pull/149))
+- 80x faster palette reduction ([#150](https://github.com/shssoichiro/oxipng/pull/150))
+- Optimize RGB to palette conversion ([#148](https://github.com/shssoichiro/oxipng/pull/148))
+- Various microoptimizations ([#146](https://github.com/shssoichiro/oxipng/pull/146))
+- Introduce third-party safe wrapper around cloudflare-zlib ([#149](https://github.com/shssoichiro/oxipng/pull/149))

 ### Version 2.1.6

- Identify and drop useless sRGB profiles ([#143](https://github.com/oxipng/oxipng/pull/143))
- Alpha heuristic improvements ([#144](https://github.com/oxipng/oxipng/pull/144))
+- Identify and drop useless sRGB profiles ([#143](https://github.com/shssoichiro/oxipng/pull/143))
+- Alpha heuristic improvements ([#144](https://github.com/shssoichiro/oxipng/pull/144))
 - Bump `miniz_oxide` and `cloudflare-zlib-sys` to 0.2.0

 ### Version 2.1.5

- Fix issue where some images will incorrectly reduce bit depth ([#140](https://github.com/oxipng/oxipng/issues/140))
+- Fix issue where some images will incorrectly reduce bit depth ([#140](https://github.com/shssoichiro/oxipng/issues/140))

 ### Version 2.1.4

@ -282,22 +179,22 @@

 ### Version 2.1.2

- Fix issue with PNG to Indexed reduction on images with transparency pixel ([#129](https://github.com/oxipng/oxipng/issues/129))
+- Fix issue with PNG to Indexed reduction on images with transparency pixel ([#129](https://github.com/shssoichiro/oxipng/issues/129))

 ### Version 2.1.1

- More fixes for alpha optimization on interlaced images ([#133](https://github.com/oxipng/oxipng/issues/133))
+- More fixes for alpha optimization on interlaced images ([#133](https://github.com/shssoichiro/oxipng/issues/133))

 ### Version 2.1.0

 - [SEMVER_MINOR] Bump minimum Rust version to 1.27.0
 - [SEMVER_MINOR] Reenable faster Cloudflare zlib compression on platforms that support it
- Fix memory leak with Cloudflare zlib ([#126](https://github.com/oxipng/oxipng/issues/126))
+- Fix memory leak with Cloudflare zlib ([#126](https://github.com/shssoichiro/oxipng/issues/126))
 - Minor fixes and cleanup

 ### Version 2.0.2

- Fix an issue in alpha optimization on interlaced images ([#113](https://github.com/oxipng/oxipng/issues/113))
+- Fix an issue in alpha optimization on interlaced images ([#113](https://github.com/shssoichiro/oxipng/issues/113))

 ### Version 2.0.1

@ -334,12 +231,12 @@

 ### Version 1.0.1

- Bump rayon to 1.0 ([#99](https://github.com/oxipng/oxipng/pull/99) @cuviper)
+- Bump rayon to 1.0 ([#99](https://github.com/shssoichiro/oxipng/pull/99) @cuviper)
 - Bump minor versions of other dependencies for binary distribution

 ### Version 1.0.0

- Remove the C dependency on miniz, and replace it with a Rust version ([#57](https://github.com/oxipng/oxipng/issues/57))
+- Remove the C dependency on miniz, and replace it with a Rust version ([#57](https://github.com/shssoichiro/oxipng/issues/57))
  - This improves decompression speed by 15%. Compression speed is not affected.
  - [SEMVER_MAJOR] This also obsoletes the `-zm` command line option and the `memory` key on the `Options` struct.
  - Presets will be updated automatically. This means that presets 3 and higher will run significantly more quickly.
@ -366,30 +263,30 @@

 ### Version 0.18.3

- Return exit code of 1 if an error occurred while processing a file using the CLI app ([#93](https://github.com/oxipng/oxipng/issues/93))
+- Return exit code of 1 if an error occurred while processing a file using the CLI app ([#93](https://github.com/shssoichiro/oxipng/issues/93))

 ### Version 0.18.2

 - Bump `image` to 0.18
- Fix unfiltering of scan lines in interlaced images ([#92](https://github.com/oxipng/oxipng/issues/92))
+- Fix unfiltering of scan lines in interlaced images ([#92](https://github.com/shssoichiro/oxipng/issues/92))

 ### Version 0.18.1

 - Bump `rayon` to 0.9
- Fix failure to optimize on certain grayscale images ([#89](https://github.com/oxipng/oxipng/issues/89))
+- Fix failure to optimize on certain grayscale images ([#89](https://github.com/shssoichiro/oxipng/issues/89))

 ### Version 0.18.0

 - Bump `itertools` to 0.7
 - Bump `image` to 0.17
 - [SEMVER_MAJOR] Bump minimum rustc version to 1.20.0
- Fix parsing of glob paths on Windows ([#90](https://github.com/oxipng/oxipng/issues/90))
+- Fix parsing of glob paths on Windows ([#90](https://github.com/shssoichiro/oxipng/issues/90))

 ### Version 0.17.2

 - Bump `image` to 0.16
- Quickly pass over files that do not have a PNG header ([#85](https://github.com/oxipng/oxipng/issues/85) @emielbeinema)
- Return an error instead of crashing on APNG files ([#83](https://github.com/oxipng/oxipng/issues/83) @emielbeinema)
+- Quickly pass over files that do not have a PNG header ([#85](https://github.com/shssoichiro/oxipng/issues/85) @emielbeinema)
+- Return an error instead of crashing on APNG files ([#83](https://github.com/shssoichiro/oxipng/issues/83) @emielbeinema)

 ### Version 0.17.1

@ -405,14 +302,14 @@
  trials for optimizing the alpha channel, using the previously mentioned fast heuristic.
  This option will make optimization of images with transparency somewhat slower,
  but may improve compression.
- Fixed a bug in reducing palettes for images with bit depth of two ([#80](https://github.com/oxipng/oxipng/issues/80))
- Fixed another bug in reducing palettes for images with bit depth less than eight ([#82](https://github.com/oxipng/oxipng/issues/82))
+- Fixed a bug in reducing palettes for images with bit depth of two ([#80](https://github.com/shssoichiro/oxipng/issues/80))
+- Fixed another bug in reducing palettes for images with bit depth less than eight ([#82](https://github.com/shssoichiro/oxipng/issues/82))
 - Code cleanup
 - Bump `image` to 0.15

 ### Version 0.16.3

- Fix command-line help text ([#70](https://github.com/oxipng/oxipng/issues/70))
+- Fix command-line help text ([#70](https://github.com/shssoichiro/oxipng/issues/70))

 ### Version 0.16.2

@ -430,18 +327,18 @@

 ### Version 0.15.2

- Bump `image` to 0.13 ([#65](https://github.com/oxipng/oxipng/pull/65))
+- Bump `image` to 0.13 ([#65](https://github.com/shssoichiro/oxipng/pull/65))
 - Bump `rayon` to 0.7
 - Bump `itertools` to 0.6

 ### Version 0.15.1

- Ignore color reductions that would increase file size ([#61](https://github.com/oxipng/oxipng/issues/61))
+- Ignore color reductions that would increase file size ([#61](https://github.com/shssoichiro/oxipng/issues/61))

 ### Version 0.15.0

- [SEMVER_MINOR] Check images for correctness before writing result ([#60](https://github.com/oxipng/oxipng/issues/60))
- Fix invalid output when reducing image to a different color type but file size does not improve ([#60](https://github.com/oxipng/oxipng/issues/60))
+- [SEMVER_MINOR] Check images for correctness before writing result ([#60](https://github.com/shssoichiro/oxipng/issues/60))
+- Fix invalid output when reducing image to a different color type but file size does not improve ([#60](https://github.com/shssoichiro/oxipng/issues/60))
 - Don't write new file if moving from interlaced to non-interlaced if new file would be larger

 ### Version 0.14.4
@ -475,14 +372,14 @@

 ### Version 0.13.0

- Fix bug in certain PNG headers when reducing color type ([#52](https://github.com/oxipng/oxipng/issues/52))
+- Fix bug in certain PNG headers when reducing color type ([#52](https://github.com/shssoichiro/oxipng/issues/52))
 - [SEMVER_MAJOR] Reduction functions now take `&mut PngData` and return a `bool` indicating whether the image was reduced
 - [SMEVER_MAJOR] Bump minimum required rustc version to 1.12.0

 ### Version 0.12.0

 - Performance optimizations
- Fix processing filenames that contain commas (@aliceatlas [#50](https://github.com/oxipng/oxipng/pull/50))
+- Fix processing filenames that contain commas (@aliceatlas [#50](https://github.com/shssoichiro/oxipng/pull/50))
 - [SEMVER_MINOR] Add zopfli option (-Z), disabled by default. Gives about 10% better compression, but is currently 50-100x slower.

 ### Version 0.11.0
@ -507,7 +404,7 @@

 ### Version 0.8.2

- Fix issue where images smaller than 4px width would crash on interlacing ([#42](https://github.com/oxipng/oxipng/issues/42))
+- Fix issue where images smaller than 4px width would crash on interlacing ([#42](https://github.com/shssoichiro/oxipng/issues/42))

 ### Version 0.8.1

@ -523,7 +420,7 @@
 - Minor compression improvement on interlaced images
 - Performance optimizations
 - [SEMVER_MINOR] Move default Options into a Default impl
- [SEMVER_MINOR] Add option for setting number of threads ([#39](https://github.com/oxipng/oxipng/issues/39))
+- [SEMVER_MINOR] Add option for setting number of threads ([#39](https://github.com/shssoichiro/oxipng/issues/39))

 ### Version 0.6.0

@ -534,47 +431,47 @@

 ### Version 0.5.0

- [SEMVER_MINOR] Palette entries can now reduced, on by default ([#11](https://github.com/oxipng/oxipng/issues/11))
+- [SEMVER_MINOR] Palette entries can now reduced, on by default ([#11](https://github.com/shssoichiro/oxipng/issues/11))
 - Don't report that we are in pretend mode if verbosity is set to none
- Add cargo bench suite ([#7](https://github.com/oxipng/oxipng/issues/7))
+- Add cargo bench suite ([#7](https://github.com/shssoichiro/oxipng/issues/7))

 ### Version 0.4.0

 - Performance optimizations
- [SEMVER_MAJOR] `-s` automatically infers `--strip safe` ([#31](https://github.com/oxipng/oxipng/issues/31))
+- [SEMVER_MAJOR] `-s` automatically infers `--strip safe` ([#31](https://github.com/shssoichiro/oxipng/issues/31))
 - Update byteorder and clap crates
 - Fix issue where interlaced images incorrectly applied filters on the first line of a pass

 ### Version 0.3.0

 - Properly decode interlaced images
- [SEMVER_MINOR] Allow converting between progressive and interlaced images ([#3](https://github.com/oxipng/oxipng/issues/3))
+- [SEMVER_MINOR] Allow converting between progressive and interlaced images ([#3](https://github.com/shssoichiro/oxipng/issues/3))
 - Fix a bug that would cause oxipng to crash on very small images

 ### Version 0.2.2

 - Limit number of threads to 1.5x number of cores
- Significantly improve memory usage, especially with high optimization levels. ([#32](https://github.com/oxipng/oxipng/issues/32))
- Refactor output code ([#19](https://github.com/oxipng/oxipng/issues/19))
+- Significantly improve memory usage, especially with high optimization levels. ([#32](https://github.com/shssoichiro/oxipng/issues/32))
+- Refactor output code ([#19](https://github.com/shssoichiro/oxipng/issues/19))

 ### Version 0.2.1

 - Add rustdoc for public methods and structs
- Improve filter mode 5 heuristic ([#16](https://github.com/oxipng/oxipng/issues/16))
- Add tests for edge-case images with subtitles ([#29](https://github.com/oxipng/oxipng/issues/29))
+- Improve filter mode 5 heuristic ([#16](https://github.com/shssoichiro/oxipng/issues/16))
+- Add tests for edge-case images with subtitles ([#29](https://github.com/shssoichiro/oxipng/issues/29))

 ### Version 0.2.0

 - Fix program version that is displayed when running `oxipng -V`
- Ensure `--quiet` mode is actually quiet (@SethDusek [#20](https://github.com/oxipng/oxipng/pull/20))
+- Ensure `--quiet` mode is actually quiet (@SethDusek [#20](https://github.com/shssoichiro/oxipng/pull/20))
 - Write status/debug information to stderr instead of stdout
- Use heuristics to determine best combination for `-o1` ([#21](https://github.com/oxipng/oxipng/issues/21))
+- Use heuristics to determine best combination for `-o1` ([#21](https://github.com/shssoichiro/oxipng/issues/21))
 - [SEMVER_MAJOR] Allow 'safe', 'all', or comma-separated list as options for `--strip`
 - [SEMVER_MINOR] Add `-s` alias for `--strip`

 ### Version 0.1.1

- Fix `oxipng *` writing all input files to one output file ([#15](https://github.com/oxipng/oxipng/issues/15))
+- Fix `oxipng *` writing all input files to one output file ([#15](https://github.com/shssoichiro/oxipng/issues/15))

 ### Version 0.1.0

--- a/Cargo.lock
+++ b/Cargo.lock
@ -1,74 +1,41 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 4
+version = 3

 [[package]]
-name = "adler2"
-version = "2.0.1"
+name = "adler"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"

 [[package]]
-name = "anstream"
-version = "1.0.0"
+name = "adler32"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "is_terminal_polyfill",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
-
-[[package]]
-name = "anstyle-parse"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
-dependencies = [
- "windows-sys",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
-dependencies = [
- "anstyle",
- "once_cell_polyfill",
- "windows-sys",
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi",
 ]

 [[package]]
 name = "autocfg"
-version = "1.5.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

 [[package]]
 name = "bitflags"
-version = "2.11.1"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

 [[package]]
 name = "bitvec"
@ -82,171 +49,150 @@ dependencies = [
 "wyz",
 ]

-[[package]]
-name = "bumpalo"
-version = "3.20.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
-
 [[package]]
 name = "bytemuck"
-version = "1.25.0"
+version = "1.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+checksum = "aaa3a8d9a1ca92e282c96a32d6511b695d7d994d1d102ba85d279f9b2756947f"

 [[package]]
-name = "byteorder-lite"
-version = "0.1.0"
+name = "byteorder"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"

 [[package]]
 name = "cc"
-version = "1.2.60"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
-dependencies = [
- "find-msvc-tools",
- "shlex",
-]
+checksum = "a20104e2335ce8a659d6dd92a51a767a0c062599c73b343fd152cb401e828c3d"

 [[package]]
 name = "cfg-if"
-version = "1.0.4"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "clap"
-version = "4.6.1"
+version = "3.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
+checksum = "71655c45cb9845d3270c9d6df84ebe72b4dad3c2ba3f7023ad47c144e4e473a5"
 dependencies = [
- "clap_builder",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
-dependencies = [
- "anstream",
- "anstyle",
+ "atty",
+ "bitflags",
 "clap_lex",
+ "indexmap",
 "strsim",
- "terminal_size",
+ "termcolor",
+ "textwrap",
 ]

 [[package]]
 name = "clap_lex"
-version = "1.1.0"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
+]

 [[package]]
-name = "colorchoice"
-version = "1.0.5"
+name = "color_quant"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
+name = "crc"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53757d12b596c16c78b83458d732a5d1a17ab3f53f2f7412f6fb57cc8a140ab3"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d0165d2900ae6778e36e80bbc4da3b5eefccee9ba939761f9c2882a5d9af3ff"

 [[package]]
 name = "crc32fast"
-version = "1.5.0"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
 dependencies = [
 "cfg-if",
 ]

 [[package]]
-name = "crossbeam-deque"
-version = "0.8.6"
+name = "crossbeam-channel"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
 dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
+dependencies = [
+ "cfg-if",
 "crossbeam-epoch",
 "crossbeam-utils",
 ]

 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.18"
+version = "0.9.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "01a9af1f4c2ef74bb8aa1f7e19706bc72d03598c8a570bb5de72243c7a9d9d5a"
 dependencies = [
+ "autocfg",
+ "cfg-if",
 "crossbeam-utils",
+ "memoffset",
+ "scopeguard",
 ]

 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "4fb766fa798726286dbbb842f174001dab8abc7b627a1dd86e0b7222a95d929f"
+dependencies = [
+ "cfg-if",
+]

 [[package]]
 name = "either"
-version = "1.15.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"

 [[package]]
-name = "env_filter"
-version = "1.0.1"
+name = "filetime"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32e90c2accc4b07a8456ea0debdc2e7587bdd890680d71173a15d4ae604f6eef"
-dependencies = [
- "log",
-]
-
-[[package]]
-name = "env_logger"
-version = "0.11.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a"
-dependencies = [
- "anstream",
- "anstyle",
- "env_filter",
- "log",
-]
-
-[[package]]
-name = "equivalent"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
-
-[[package]]
-name = "errno"
-version = "0.3.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+checksum = "4e884668cd0c7480504233e951174ddc3b382f7c2666e3b7310b5c4e7b0c37f9"
 dependencies = [
+ "cfg-if",
 "libc",
+ "redox_syscall",
 "windows-sys",
 ]

-[[package]]
-name = "fdeflate"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
-dependencies = [
- "simd-adler32",
-]
-
-[[package]]
-name = "find-msvc-tools"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
-
 [[package]]
 name = "flate2"
-version = "1.1.9"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841"
 dependencies = [
 "crc32fast",
 "miniz_oxide",
@ -260,199 +206,211 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"

 [[package]]
 name = "glob"
-version = "0.3.3"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"

 [[package]]
 name = "hashbrown"
-version = "0.17.0"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
+dependencies = [
+ "libc",
+]

 [[package]]
 name = "image"
-version = "0.25.9"
+version = "0.24.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a"
+checksum = "69b7ea949b537b0fd0af141fff8c77690f2ce96f4f41f042ccb6c69c6c965945"
 dependencies = [
 "bytemuck",
- "byteorder-lite",
- "moxcms",
+ "byteorder",
+ "color_quant",
+ "num-rational",
 "num-traits",
 "png",
 ]

 [[package]]
 name = "indexmap"
-version = "2.14.0"
+version = "1.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
 dependencies = [
- "equivalent",
+ "autocfg",
 "hashbrown",
 "rayon",
 ]

 [[package]]
-name = "is_terminal_polyfill"
-version = "1.70.2"
+name = "iter-read"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+checksum = "c397ca3ea05ad509c4ec451fea28b4771236a376ca1c69fd5143aae0cf8f93c4"

 [[package]]
-name = "itoa"
-version = "1.0.18"
+name = "itertools"
+version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]

 [[package]]
 name = "libc"
-version = "0.2.185"
+version = "0.2.139"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
+checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"

 [[package]]
 name = "libdeflate-sys"
-version = "1.25.2"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72753e0008ea87963d2f0770042d0df7abe51fafbb8dcaf618ac440f2f1fec0a"
+checksum = "cb6784b6b84b67d71b4307963d456a9c7c29f9b47c658f533e598de369e34277"
 dependencies = [
 "cc",
- "pkg-config",
 ]

 [[package]]
 name = "libdeflater"
-version = "1.25.2"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1ee41cf6fb1bb6030dfb59ffb7bc01ab26aade44142084c87f0fc7a1658fe71"
+checksum = "d8e285aa6a046fd338b2592c16bee148b2b00789138ed6b7bb56bb13d585050d"
 dependencies = [
 "libdeflate-sys",
 ]

-[[package]]
-name = "linux-raw-sys"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
-
 [[package]]
 name = "log"
-version = "0.4.30"
+version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5"
-
-[[package]]
-name = "memchr"
-version = "2.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
-
-[[package]]
-name = "miniz_oxide"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
 dependencies = [
- "adler2",
- "simd-adler32",
+ "cfg-if",
 ]

 [[package]]
-name = "moxcms"
-version = "0.7.11"
+name = "memoffset"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97"
-dependencies = [
- "num-traits",
- "pxfm",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
 dependencies = [
 "autocfg",
 ]

 [[package]]
-name = "once_cell_polyfill"
-version = "1.70.2"
+name = "miniz_oxide"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+dependencies = [
+ "hermit-abi 0.2.6",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
+
+[[package]]
+name = "os_str_bytes"
+version = "6.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"

 [[package]]
 name = "oxipng"
-version = "10.1.1"
+version = "8.0.0"
 dependencies = [
 "bitvec",
 "clap",
- "env_logger",
- "glob",
+ "crossbeam-channel",
+ "filetime",
 "image",
 "indexmap",
+ "itertools",
 "libdeflater",
 "log",
- "parse-size",
 "rayon",
 "rgb",
 "rustc-hash",
- "serde_json",
+ "rustc_version",
+ "stderrlog",
+ "wild",
 "zopfli",
 ]

-[[package]]
-name = "parse-size"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "487f2ccd1e17ce8c1bfab3a65c89525af41cfad4c8659021a1e9a2aacd73b89b"
-
-[[package]]
-name = "pkg-config"
-version = "0.3.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
-
 [[package]]
 name = "png"
-version = "0.18.1"
+version = "0.17.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+checksum = "5d708eaf860a19b19ce538740d2b4bdeeb8337fa53f7738455e706623ad5c638"
 dependencies = [
 "bitflags",
 "crc32fast",
- "fdeflate",
 "flate2",
 "miniz_oxide",
 ]

-[[package]]
-name = "proc-macro2"
-version = "1.0.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "pxfm"
-version = "0.1.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
-
-[[package]]
-name = "quote"
-version = "1.0.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
-dependencies = [
- "proc-macro2",
-]
-
 [[package]]
 name = "radium"
 version = "0.7.0"
@ -461,9 +419,9 @@ checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"

 [[package]]
 name = "rayon"
-version = "1.12.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+checksum = "6db3a213adf02b3bcfd2d3846bb41cb22857d131789e01df434fb7e7bc0759b7"
 dependencies = [
 "either",
 "rayon-core",
@ -471,112 +429,78 @@ dependencies = [

 [[package]]
 name = "rayon-core"
-version = "1.13.0"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+checksum = "cac410af5d00ab6884528b4ab69d1e8e146e8d471201800fa1b4524126de6ad3"
 dependencies = [
+ "crossbeam-channel",
 "crossbeam-deque",
 "crossbeam-utils",
+ "num_cpus",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+dependencies = [
+ "bitflags",
 ]

 [[package]]
 name = "rgb"
-version = "0.8.53"
+version = "0.8.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4"
+checksum = "3603b7d71ca82644f79b5a06d1220e9a58ede60bd32255f698cb1af8838b8db3"
 dependencies = [
 "bytemuck",
 ]

 [[package]]
 name = "rustc-hash"
-version = "2.1.2"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"

 [[package]]
-name = "rustix"
-version = "1.1.4"
+name = "rustc_version"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
- "bitflags",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys",
+ "semver",
 ]

 [[package]]
-name = "serde"
-version = "1.0.228"
+name = "scopeguard"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "semver"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"
+
+[[package]]
+name = "stderrlog"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69a26bbf6de627d389164afa9783739b56746c6c72c4ed16539f4ff54170327b"
 dependencies = [
- "serde_core",
+ "atty",
+ "log",
+ "termcolor",
+ "thread_local",
 ]

-[[package]]
-name = "serde_core"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.150"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
-dependencies = [
- "itoa",
- "memchr",
- "serde",
- "serde_core",
- "zmij",
-]
-
-[[package]]
-name = "shlex"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
-[[package]]
-name = "simd-adler32"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
-
 [[package]]
 name = "strsim"
-version = "0.11.1"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
-
-[[package]]
-name = "syn"
-version = "2.0.117"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

 [[package]]
 name = "tap"
@ -585,42 +509,132 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"

 [[package]]
-name = "terminal_size"
-version = "0.4.4"
+name = "termcolor"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
 dependencies = [
- "rustix",
- "windows-sys",
+ "winapi-util",
 ]

 [[package]]
-name = "unicode-ident"
-version = "1.0.24"
+name = "textwrap"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"

 [[package]]
-name = "utf8parse"
-version = "0.2.2"
+name = "thread_local"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+dependencies = [
+ "once_cell",
+]

 [[package]]
-name = "windows-link"
-version = "0.2.1"
+name = "typed-arena"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+checksum = "0685c84d5d54d1c26f7d3eb96cd41550adb97baed141a761cf335d3d33bcd0ae"
+
+[[package]]
+name = "wild"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05b116685a6be0c52f5a103334cbff26db643826c7b3735fc0a3ba9871310a74"
+dependencies = [
+ "glob",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

 [[package]]
 name = "windows-sys"
-version = "0.61.2"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
 dependencies = [
- "windows-link",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]

+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"
+
 [[package]]
 name = "wyz"
 version = "0.5.1"
@ -630,20 +644,16 @@ dependencies = [
 "tap",
 ]

-[[package]]
-name = "zmij"
-version = "1.0.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
-
 [[package]]
 name = "zopfli"
-version = "0.8.3"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
+checksum = "f1e0d16c30236860686a8f03d36b384dc2fc0675a8916367d2f9a1ecd795eab6"
 dependencies = [
- "bumpalo",
- "crc32fast",
+ "adler32",
+ "byteorder",
+ "crc",
+ "iter-read",
 "log",
- "simd-adler32",
+ "typed-arena",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@ -2,29 +2,18 @@
 authors = ["Joshua Holmer <jholmer.in@gmail.com>"]
 categories = ["command-line-utilities", "compression"]
 description = "A lossless PNG compression optimizer"
-keywords = ["png", "image-compression", "optimization", "multi-threading", "lossless"]
 documentation = "https://docs.rs/oxipng"
-edition = "2024"
-exclude = [
-  ".editorconfig",
-  ".gitattributes",
-  ".github/*",
-  ".gitignore",
-  ".pre-commit-hooks.yaml",
-  "Dockerfile",
-  "scripts/*",
-  "tests/*",
-  "xtask/*",
-]
-homepage = "https://github.com/oxipng/oxipng"
+edition = "2021"
+exclude = ["tests/*", "bench/*"]
+homepage = "https://github.com/shssoichiro/oxipng"
 license = "MIT"
 name = "oxipng"
-repository = "https://github.com/oxipng/oxipng"
-version = "10.1.1"
-rust-version = "1.85.1"
+repository = "https://github.com/shssoichiro/oxipng"
+version = "8.0.0"
+rust-version = "1.61.0"

 [badges]
-travis-ci = { repository = "oxipng/oxipng", branch = "master" }
+travis-ci = { repository = "shssoichiro/oxipng", branch = "master" }
 maintenance = { status = "actively-developed" }

 [[bin]]
@ -33,38 +22,47 @@ name = "oxipng"
 path = "src/main.rs"
 required-features = ["binary"]

-[[bench]]
-name = "zopfli"
-required-features = ["zopfli"]
-
 [dependencies]
+itertools = "0.10.3"
+zopfli = { version = "0.7.1", optional = true }
+rgb = "0.8.33"
+indexmap = "1.9.1"
+libdeflater = "0.11.0"
+log = "0.4.17"
+stderrlog = { version = "0.5.3", optional = true, default-features = false }
+crossbeam-channel = "0.5.6"
 bitvec = "1.0.1"
-clap = { version = "4.6.0", optional = true, features = ["wrap_help"] }
-env_logger = { version = "0.11.10", optional = true, default-features = false, features = ["auto-color"] }
-image = { version = "0.25.9", optional = true, default-features = false, features = ["png"] }
-indexmap = "2.14.0"
-libdeflater = "1.25.2"
-log = "0.4.30"
-parse-size = { version = "1.1.0", optional = true }
-rayon = { version = "1.11.0", optional = true }
-rgb = "0.8.53"
-rustc-hash = "2.1.2"
-zopfli = { version = "0.8.3", optional = true, default-features = false, features = ["std", "zlib"] }
+rustc-hash = "1.1.0"

-[target.'cfg(windows)'.dependencies]
-glob = { version = "0.3.3", optional = true }
+[dependencies.filetime]
+optional = true
+version = "0.2.17"

-[dev-dependencies]
-serde_json = "1.0.150"
+[dependencies.rayon]
+optional = true
+version = "1.5.3"
+
+[dependencies.clap]
+optional = true
+version = "3.2.20"
+
+[dependencies.wild]
+optional = true
+version = "2.1.0"
+
+[dependencies.image]
+default-features = false
+features = ["png"]
+version = "0.24.3"
+
+[build-dependencies]
+rustc_version = "0.4.0"

 [features]
-binary = ["dep:clap", "dep:glob", "dep:env_logger", "dep:parse-size"]
-default = ["binary", "parallel", "zopfli"]
-parallel = ["dep:rayon", "indexmap/rayon"]
+binary = ["clap", "wild", "stderrlog"]
+default = ["binary", "filetime", "parallel", "zopfli"]
+parallel = ["rayon", "indexmap/rayon"]
 freestanding = ["libdeflater/freestanding"]
-sanity-checks = ["dep:image"]
-zopfli = ["dep:zopfli"]
-system-libdeflate = ["libdeflater/dynamic"]

 [lib]
 name = "oxipng"
@ -74,48 +72,7 @@ path = "src/lib.rs"
 opt-level = 2

 [profile.release]
-lto = "fat"
-strip = "symbols"
-panic = "abort"
+lto = "thin"

-[package.metadata.deb]
-assets = [
-    ["target/release/oxipng", "usr/bin/", "755"],
-    ["target/xtask/mangen/manpages/oxipng.1", "usr/share/man/man1/", "644"],
-    ["README.md", "usr/share/doc/oxipng/", "644"],
-    ["CHANGELOG.md", "usr/share/doc/oxipng/", "644"],
-]
-
-[lints.rust]
-missing_copy_implementations = "deny"
-missing_debug_implementations = "deny"
-trivial_casts = "warn"
-trivial_numeric_casts = "warn"
-unused_import_braces = "warn"
-
-[lints.clippy]
-cloned_instead_of_copied = "warn"
-expl_impl_clone_on_copy = "warn"
-float_cmp_const = "warn"
-if_not_else = "warn"
-ignored_unit_patterns = "warn"
-linkedlist = "warn"
-manual_let_else = "warn"
-map_flatten = "warn"
-map_unwrap_or = "warn"
-match_same_arms = "warn"
-mem_forget = "warn"
-missing_const_for_fn = "warn"
-mut_mut = "warn"
-mutex_integer = "warn"
-needless_continue = "warn"
-option_if_let_else = "warn"
-path_buf_push_overwrite = "warn"
-range_plus_one = "warn"
-redundant_clone = "warn"
-redundant_closure_for_method_calls = "warn"
-semicolon_if_nothing_returned = "warn"
-unnecessary_semicolon = "warn"
-unseparated_literal_suffix = "warn"
-use_self = "warn"
-useless_let_if_seq = "warn"
+[profile.dev.package.bitvec]
+opt-level = 3
--- a/46
+++ b/46
@ -1,46 +1,20 @@
-# syntax=docker/dockerfile:1
-# check=error=true
-FROM --platform=$BUILDPLATFORM tonistiigi/xx AS xx
+FROM rust:alpine as base

-FROM --platform=$BUILDPLATFORM rust:1.85.1-alpine AS base
+COPY . /src

-RUN apk update && \
-    apk add \
+RUN rustup update 1.64 && rustup default 1.64
+
+RUN apk update \
+    && apk add \
        gcc \
-        g++ \
-        clang
+        g++

-COPY --from=xx / /
+RUN cd /src && cargo build --release

-ARG TARGETPLATFORM
-RUN xx-info env
+FROM alpine as tool

-RUN xx-apk add \
-    gcc \
-    musl-dev \
-    libdeflate
+COPY --from=base /src/target/release/oxipng /usr/local/bin

 WORKDIR /src
-
-COPY . .
-
-RUN --mount=type=cache,target=/root/.cargo/git/db \
-    --mount=type=cache,target=/root/.cargo/registry/cache \
-    --mount=type=cache,target=/root/.cargo/registry/index \
-    xx-cargo build --release && \
-    xx-verify /src/target/$(xx-cargo --print-target-triple)/release/oxipng && \
-    cp /src/target/$(xx-cargo --print-target-triple)/release/oxipng /src/target/oxipng
-
-FROM scratch AS tool
-
-LABEL org.opencontainers.image.title="Oxipng"
-LABEL org.opencontainers.image.description="Multithreaded PNG optimizer written in Rust"
-LABEL org.opencontainers.image.authors="Joshua Holmer <jholmer.in@gmail.com>"
-LABEL org.opencontainers.image.licenses="MIT"
-LABEL org.opencontainers.image.source="https://github.com/oxipng/oxipng"
-
-COPY --from=base /src/target/oxipng /usr/local/bin/oxipng
-
-WORKDIR /work
 ENTRYPOINT [ "oxipng" ]
 CMD [ "--help" ]
--- a/MANUAL.txt
+++ b/MANUAL.txt
@ -1,227 +0,0 @@
-oxipng 10.1.0
-Losslessly improve compression of PNG files
-
-Usage: oxipng [OPTIONS] <files>...
-
-Arguments:
-  <files>...
-          File(s) to compress (use '-' for stdin)
-
-Options:
-  -o, --opt <level>
-          Set the optimization level preset. The default level 2 is quite fast and provides good
-          compression. Lower levels are faster, higher levels provide better compression, though
-          with increasingly diminishing returns.
-          
-              0   => --zc 5  --fast              (filter chosen heuristically)
-              1   => --zc 10 --fast              (filter chosen heuristically)
-              2   => --zc 11 -f 0,1,6,7 --fast
-              3   => --zc 11 -f 0,7,8,9         --brute-level 1 --brute-lines 3
-              4   => --zc 12 -f 0,7,8,9         --brute-level 1 --brute-lines 4
-              5   => --zc 12 -f 0,1,2,5,6,7,8,9 --brute-level 4 --brute-lines 4
-              6   => --zc 12 -f 0-9             --brute-level 5 --brute-lines 8
-              max => (stable alias for the maximum level)
-          
-          Manually specifying a compression option (zc, f, etc.) will override the optimization
-          preset, regardless of the order you write the arguments.
-          
-          [default: 2]
-
-  -r, --recursive
-          When directories are given as input, traverse the directory trees and optimize all PNG
-          files found (files with “.png” or “.apng” extension).
-
-      --dir <directory>
-          Write output file(s) to <directory>. If the directory does not exist, it will be created.
-          Note that this will not preserve the directory structure of the input files when used with
-          '--recursive'.
-
-      --out <file>
-          Write output file to <file>
-
-      --stdout
-          Write output to stdout
-
-  -p, --preserve
-          Preserve file permissions and timestamps if possible
-
-  -d, --dry-run
-          Do not write any files, only show compression results
-
-  -s
-          Strip safely-removable chunks, same as '--strip safe'
-
-      --strip <mode>
-          Strip metadata chunks, where <mode> is one of:
-          
-              safe    =>  Strip all non-critical chunks, except for the following:
-                              cICP, iCCP, sRGB, pHYs, acTL, fcTL, fdAT
-              all     =>  Strip all non-critical chunks
-              <list>  =>  Strip chunks in the comma-separated list, e.g. 'bKGD,cHRM'
-          
-          CAUTION: 'all' will convert APNGs to standard PNGs.
-          
-          Please note that regardless of any options set, some chunks will necessarily be stripped
-          when invalidated by the optimization:
-              bKGD, sBIT, hIST: Stripped if the color type or bit depth changes.
-              iDOT: Always stripped.
-              caBX: Stripped if it contains C2PA metadata. If explicitly retained by `--keep`,
-              optimization will be aborted.
-          
-          The default when --strip is not passed is to keep all chunks that remain valid.
-
-      --keep <list>
-          Strip all metadata chunks except those in the comma-separated list. The special value
-          'display' includes chunks that affect the image appearance, equivalent to '--strip safe'.
-          
-          E.g. '--keep eXIf,display' will strip chunks, keeping only eXIf and those that affect the
-          image appearance.
-
-  -a, --alpha
-          Perform additional optimization on images with an alpha channel, by altering the color
-          values of fully transparent pixels. This is generally recommended for better compression,
-          but take care as while this is “visually lossless”, it is technically a lossy
-          transformation and may be unsuitable for some applications.
-
-  -i, --interlace <mode>
-          Set the PNG interlacing mode, where <mode> is one of:
-          
-              off   =>  Remove interlacing from all images that are processed
-              on    =>  Apply Adam7 interlacing on all images that are processed
-              keep  =>  Keep the existing interlacing mode of each image
-          
-          Note that interlacing can add 25-50% to the size of an optimized image. Only use it if you
-          believe the benefits outweigh the costs for your use case.
-          
-          [default: off]
-
-      --scale16
-          Forcibly reduce images with 16 bits per channel to 8 bits per channel. This is a lossy
-          operation but can provide significant savings when you have no need for higher depth.
-          Reduction is performed by scaling the values such that, e.g. 0x00FF is reduced to 0x01
-          rather than 0x00.
-          
-          Without this flag, 16-bit images will only be reduced in depth if it can be done
-          losslessly.
-
-  -v, --verbose...
-          Show per-file info (use multiple times for more detail)
-
-  -q, --quiet
-          Suppress all output messages
-
-  -j, --json
-          Print results as JSON
-
-  -f, --filters <list>
-          Perform compression trials with each of the given filter types. You can specify a
-          comma-separated list, or a range of values. E.g. '-f 0-3' is the same as '-f 0,1,2,3'.
-          
-          PNG delta filters (apply the same filter to every line)
-              0  =>  None      (recommended to always include this filter)
-              1  =>  Sub
-              2  =>  Up
-              3  =>  Average
-              4  =>  Paeth
-          
-          Heuristic strategies (try to find the best delta filter for each line)
-              5  =>  MinSum    Minimum sum of absolute differences
-              6  =>  Entropy   Smallest Shannon entropy
-              7  =>  Bigrams   Lowest count of distinct bigrams
-              8  =>  BigEnt    Smallest Shannon entropy of bigrams
-              9  =>  Brute     Smallest compressed size (slow)
-          
-          The default value depends on the optimization level preset.
-
-      --fast
-          Perform a fast compression evaluation of each enabled filter, followed by a single main
-          compression trial of the best result. Recommended if you have more filters enabled than
-          CPU cores.
-
-      --zc <level>
-          Deflate compression level (0-12) for main compression trials. The levels here are defined
-          by the libdeflate compression library.
-          
-          The default value depends on the optimization level preset.
-
-      --nb
-          Do not change bit depth
-
-      --nc
-          Do not change color type
-
-      --np
-          Do not change color palette
-
-      --ng
-          Do not change to or from grayscale
-
-      --nx
-          Do not perform any transformations and do not deinterlace by default.
-
-      --nz
-          Do not recompress IDAT unless required due to transformations. Recompression of other
-          compressed chunks (such as iCCP) will also be disabled. Note that the combination of
-          '--nx' and '--nz' will fully disable all optimization.
-
-      --fix
-          Do not perform checksum validation of PNG chunks. This may allow some files with errors to
-          be processed successfully. The output will always have correct checksums.
-
-      --force
-          Write the output even if it is larger than the input
-
-  -z, --zopfli
-          Use the much slower but stronger Zopfli compressor for main compression trials.
-          Recommended use is with '-o max' and '--fast'.
-
-      --zi <iterations>
-          Set the number of iterations to use for Zopfli compression. Using fewer iterations may
-          speed up compression for large files. This option requires '--zopfli' to be set.
-          
-          [default: 15]
-
-      --ziwi <iterations>
-          Stop Zopfli compression after this number of iterations without improvement. Use this in
-          conjunction with a high value for '--zi' to achieve better compression in reasonable time.
-
-      --brute-level <level>
-          Set the libdeflate compression level to use with the Brute filter strategy. Sane values
-          are 1-5. Higher values are not necessarily better.
-
-      --brute-lines <lines>
-          Set the number of lines to compress at once with the Brute filter strategy. Sane values
-          are 2-16. Higher values are not necessarily better.
-
-      --timeout <secs>
-          Maximum amount of time, in seconds, to spend on optimizations. Oxipng will check the
-          timeout before each transformation or compression trial, and will stop trying to optimize
-          the file if the timeout is exceeded. Note that this does not cut short any operations that
-          are already in progress, so it is currently of limited effectiveness for large files with
-          high compression levels.
-
-      --max-raw-size <bytes>
-          Maximum size to allow for the input image. If the raw, decompressed image data (or the
-          file size) of the image exceeds this size, it will be skipped. This is useful for limiting
-          memory usage or avoiding long processing times on large images. The value may be specified
-          with a unit suffix such as k, KB, m, MB, etc.
-          
-          The decompressed size of an image is roughly equal to width * height * bit-depth / 8. E.g.
-          a 1920x1080 image with 24-bit color depth would be roughly 6MB.
-
-  -t, --threads <num>
-          Set the maximum number of threads to use. Oxipng uses multithreading to evaluate multiple
-          optimizations on the same file in parallel as well as process multiple files in parallel.
-          You can set this to a lower value if you need to limit memory or CPU usage.
-          
-          [default: num logical CPUs]
-
-      --sequential
-          Process multiple files sequentially rather than in parallel. Use this if you need
-          determinism in the processing order. Note this is not necessary if using '--threads 1'.
-
-  -h, --help
-          Print help (see a summary with '-h')
-
-  -V, --version
-          Print version
--- a/README.md
+++ b/README.md
@ -1,150 +1,90 @@
 # Oxipng

-[![Build Status](https://github.com/oxipng/oxipng/workflows/oxipng/badge.svg)](https://github.com/oxipng/oxipng/actions?query=branch%3Amaster)
+[![Build Status](https://github.com/shssoichiro/oxipng/workflows/oxipng/badge.svg)](https://github.com/shssoichiro/oxipng/actions?query=branch%3Amaster)
 [![Version](https://img.shields.io/crates/v/oxipng.svg)](https://crates.io/crates/oxipng)
-[![License](https://img.shields.io/crates/l/oxipng.svg)](https://github.com/oxipng/oxipng/blob/master/LICENSE)
+[![License](https://img.shields.io/crates/l/oxipng.svg)](https://github.com/shssoichiro/oxipng/blob/master/LICENSE)
 [![Docs](https://docs.rs/oxipng/badge.svg)](https://docs.rs/oxipng)

 ## Overview

-Oxipng is a multithreaded lossless PNG/APNG compression optimizer. It can be used via a command-line
-interface or as a library in other Rust programs. It is fast and highly effective.
+Oxipng is a multithreaded lossless PNG compression optimizer. It can be used via a command-line
+interface or as a library in other Rust programs.

 ## Installing

-Oxipng for Windows can be downloaded via the
-[Releases](https://github.com/oxipng/oxipng/releases) section on its GitHub page. Recently,
-however, Oxipng has also been made available through package managers. Check the list below for
-up-to-date options.
+Oxipng for Windows can be downloaded from the [Releases](https://github.com/shssoichiro/oxipng/releases) link on the GitHub page.

-For MacOS or Linux, it is recommended to install from your distro's package repository, provided
-Oxipng is available there in a not too outdated version for your use case.
+For MacOS or Linux, it is recommended to install from your distro's package repository, if possible.

-Oxipng is known to be packaged for the environments listed below.
-
-[![Packaging status](https://repology.org/badge/vertical-allrepos/oxipng.svg?exclude_unsupported=1&columns=3&exclude_sources=modules,site)](https://repology.org/project/oxipng/versions)
-
-Alternatively, Oxipng can be installed from Cargo, via the following command:
+Alternatively, oxipng can be installed from Cargo, via the following command:

 ```
 cargo install oxipng
 ```

-Oxipng can also be built from source using the latest stable or nightly Rust.
-This is primarily useful for developing on Oxipng.
+Oxipng can be built from source using the latest stable or nightly Rust.
+This is primarily useful for developing on oxipng.

 ```
-git clone https://github.com/oxipng/oxipng.git
+git clone https://github.com/shssoichiro/oxipng.git
 cd oxipng
 cargo build --release
 cp target/release/oxipng /usr/local/bin
 ```

-The current minimum supported Rust version is **1.85.1**.
+The current minimum supported Rust version is **1.61.0**.

 Oxipng follows Semantic Versioning.

 ## Usage

-Oxipng is a command-line utility. An example usage, suitable for web, may be the following:
+Oxipng is a command-line utility. Basic usage looks similar to the following:

 ```
-oxipng -o 4 --strip safe --alpha *.png
+oxipng -o 4 -i 1 --strip safe *.png
 ```

 The most commonly used options are as follows:

- Optimization: `-o 0` through `-o 6` (or `-o max`), lower is faster, higher is better compression.
-  The default (`-o 2`) is quite fast and provides good compression. Higher levels can be notably
-  better* but generally have increasingly diminishing returns.
+- Optimization: `-o 1` through `-o 6`, lower is faster, higher is better compression.
+  The default (`-o 2`) is sufficiently fast on a modern CPU and provides 30-50% compression
+  gains over an unoptimized PNG. `-o 4` is 6 times slower than `-o 2` but can provide 5-10%
+  extra compression over `-o 2`. Using any setting higher than `-o 4` is unlikely
+  to give any extra compression gains and is not recommended.
+- Interlacing: `-i 1` will enable [Adam7](https://en.wikipedia.org/wiki/Adam7_algorithm)
+  PNG interlacing on any images that are processed. `-i 0` will remove interlacing from all
+  processed images. Not specifying either will keep the same interlacing state as the
+  input image. Note: Interlacing can add 25-50% to the size of an optimized image. Only use
+  it if you believe the benefits outweigh the costs for your use case.
 - Strip: Used to remove metadata info from processed images. Used via `--strip [safe,all]`.
  Can save a few kilobytes if you don't need the metadata. "Safe" removes only metadata that
  will never affect rendering of the image. "All" removes all metadata that is not critical
  to the image. You can also pass a comma-separated list of specific metadata chunks to remove.
  `-s` can be used as a shorthand for `--strip safe`.
- Alpha: `--alpha` can improve compression of images with transparency, by altering the color
-  values of fully transparent pixels. This is generally recommended, but take care as this is
-  technically a lossy transformation and may be unsuitable for some specific applications.

-More advanced options can be found by running `oxipng --help`, or viewed [here](MANUAL.txt).
-
-Some options have both short (`-a`) and long (`--alpha`) forms. Which form you use is just a
-matter of preference. Multiple short options can be combined together, e.g.:
-`-savvo6` is equivalent to to `--strip safe --alpha --verbose --verbose --opt 6`.
-All options are case-sensitive.
-
-\* Note that oxipng is not a brute-force optimizer. This means that while higher optimization levels
-are almost always better or equal to lower levels, this is not guaranteed and it is possible in
-rare circumstances that a lower level may give a marginally smaller output. Similarly, using Zopfli
-compression (`-z`) is not guaranteed to always be better than default compression.
-
-## APNG support
-
-Oxipng currently only supports limited optimization of animated PNGs (APNGs). It can perform
-alpha-optimization, refiltering and recompression of all frames, but all transformations will be
-disabled. For best results, it is recommended to use another tool such as
-[apngopt](https://sourceforge.net/projects/apng/files/APNG_Optimizer/) before running Oxipng.
-
-## Git integration via [pre-commit]
-
-Create a `.pre-commit-config.yaml` file like this, or add the lines after the `repos` map
-preamble to an already existing one:
-
-```yaml
-repos:
-  - repo: https://github.com/oxipng/oxipng
-    rev: v10.0.0
-    hooks:
-      - id: oxipng
-        args: ["-o", "4", "--strip", "safe", "--alpha"]
-```
-[pre-commit]: https://pre-commit.com/
-
-## Docker
-
-A Docker image is availlable at [`ghcr.io/oxipng/oxipng`](https://github.com/oxipng/oxipng/pkgs/container/oxipng) for `linux/amd64` and `linux/arm64`.
-
-You can use it the following way:
-
-```bash
-docker run --rm -v $(pwd):/work ghcr.io/oxipng/oxipng -o 4 /work/file.png
-```
-
-Some older images are also available at [`ghcr.io/shssoichiro/oxipng`](https://github.com/users/shssoichiro/packages/container/package/oxipng).
+More advanced options can be found by running `oxipng -h`.

 ## Library Usage

-Although originally intended to be used as an executable, Oxipng can also be used as a library in
-other Rust projects. To do so, simply add Oxipng as a dependency in your Cargo.toml. You should then
-have access to all of the library functions [documented here](https://docs.rs/oxipng). The simplest
-method of usage involves creating an [Options
-struct](https://docs.rs/oxipng/latest/oxipng/struct.Options.html) and passing it, along with an
-input filename, into the [optimize function](https://docs.rs/oxipng/latest/oxipng/fn.optimize.html).
-
-It is recommended to disable the "binary" feature when including Oxipng as a library. Currently, there is
-no simple way to just disable one feature in Cargo, it has to be done by disabling default features
-and specifying the desired ones, for example:
-`oxipng = { version = "10.0", features = ["parallel", "zopfli", "filetime"], default-features = false }`
-
-## Software using Oxipng
-
- [ImageOptim](https://imageoptim.com): Mac app and web service for optimizing images
- [Squoosh](https://squoosh.app): Web app for optimizing images
- [FileOptimizer](https://nikkhokkho.sourceforge.io/?page=FileOptimizer): Windows app for optimizing files
- [Curtail](https://github.com/Huluti/Curtail): Linux app for optimizing images
- [pyoxipng](https://pypi.org/project/pyoxipng/): Python wrapper for Oxipng
- [jSquash](https://github.com/jamsinclair/jSquash): Collection of WebAssembly image codecs
- [Trunk](https://trunk.io): Developer experience toolkit for managing code
+Although originally intended to be used as an executable, oxipng can also be used as a library in
+other Rust projects. To do so, simply add oxipng as a dependency in your Cargo.toml,
+then `extern crate oxipng` in your project. You should then have access to all of the library
+functions [documented here](https://docs.rs/oxipng). The simplest
+method of usage involves creating an
+[Options struct](https://docs.rs/oxipng/3.0.1/oxipng/struct.Options.html) and
+passing it, along with an input filename, into the
+[optimize function](https://docs.rs/oxipng/3.0.1/oxipng/fn.optimize.html).

 ## History

-Oxipng began in 2015 as a rewrite of the OptiPNG project. The core goal was to implement
-multithreading, which would have been very difficult to do within the existing C codebase of OptiPNG.
-This also served as an opportunity to choose a more modern, safer language (Rust).
+Oxipng began as a complete rewrite of the OptiPNG project,
+which was assumed to be dead as no commit had been made to it since March 2014.
+(OptiPNG has since released a new version, after Oxipng was first released.)
+The name has been changed to avoid confusion and potential legal issues.

-However, Oxipng has evolved considerably since then. While some of the options remain similar to
-OptiPNG, the architecture and capabilities are now quite different. It is not a drop-in
-replacement - if you are migrating from OptiPNG, please check the [help](MANUAL.txt) before use.
+The core goal of rewriting OptiPNG was to implement multithreading,
+which would be very difficult to do within the existing C codebase of OptiPNG.
+This also served as an opportunity to choose a more modern, safer language (Rust).

 ## Contributing

@ -154,11 +94,40 @@ to submit a fix with the bug report, it is preferred that you do so via pull req
 however you do not need to be a Rust developer to contribute.
 Other contributions (such as improving documentation or translations) are also welcome via GitHub.

-## Benchmarks
-
-An independent benchmark is linked here with permission by the author:\
-[oxipng and friends: A comparison of PNG optimization tools](https://op111.net/posts/2025/09/png-compression-oxipng-optipng-fileoptimizer-cwebp/)
-
 ## License

 Oxipng is open-source software, distributed under the MIT license.
+
+## Benchmarks
+
+Tested oxipng 5.0.0 (compiled on rustc 1.55.0-nightly (7a16cfcff 2021-07-11)) against OptiPNG version 0.7.7 on AMD Ryzen 7 4800H with Radeon Graphics with 16 logical cores
+
+```
+
+Benchmark #1: ./target/release/oxipng -P ./tests/files/rgb_16_should_be_grayscale_8.png
+  Time (mean ± σ):     128.8 ms ±  14.2 ms    [User: 296.0 ms, System: 14.3 ms]
+  Range (min … max):    98.8 ms … 152.3 ms    21 runs
+
+Benchmark #2: optipng -simulate ./tests/files/rgb_16_should_be_grayscale_8.png
+  Time (mean ± σ):     254.2 ms ±  16.0 ms    [User: 252.8 ms, System: 1.2 ms]
+  Range (min … max):   208.4 ms … 263.8 ms    14 runs
+
+Summary
+  './target/release/oxipng -P ./tests/files/rgb_16_should_be_grayscale_8.png' ran
+    1.97 ± 0.25 times faster than 'optipng -simulate ./tests/files/rgb_16_should_be_grayscale_8.png'
+
+
+
+Benchmark #1: ./target/release/oxipng -o4 -P ./tests/files/rgb_16_should_be_grayscale_8.png
+  Time (mean ± σ):     141.4 ms ±  14.9 ms    [User: 611.7 ms, System: 21.1 ms]
+  Range (min … max):   100.2 ms … 160.4 ms    23 runs
+
+Benchmark #2: optipng -o 4 -simulate ./tests/files/rgb_16_should_be_grayscale_8.png
+  Time (mean ± σ):     730.0 ms ±  25.9 ms    [User: 728.0 ms, System: 1.2 ms]
+  Range (min … max):   713.3 ms … 768.2 ms    10 runs
+
+Summary
+  './target/release/oxipng -o4 -P ./tests/files/rgb_16_should_be_grayscale_8.png' ran
+    5.16 ± 0.58 times faster than 'optipng -o 4 -simulate ./tests/files/rgb_16_should_be_grayscale_8.png'
+
+```
--- a/README.template.md
+++ b/README.template.md
@ -0,0 +1,101 @@
+# Oxipng
+
+[![Build Status](https://github.com/shssoichiro/oxipng/workflows/oxipng/badge.svg)](https://github.com/shssoichiro/oxipng/actions?query=branch%3Amaster)
+[![Version](https://img.shields.io/crates/v/oxipng.svg)](https://crates.io/crates/oxipng)
+[![License](https://img.shields.io/crates/l/oxipng.svg)](https://github.com/shssoichiro/oxipng/blob/master/LICENSE)
+[![Docs](https://docs.rs/oxipng/badge.svg)](https://docs.rs/oxipng)
+
+## Overview
+
+Oxipng is a multithreaded lossless PNG compression optimizer. It can be used via a command-line
+interface or as a library in other Rust programs.
+
+## Installing
+
+Oxipng for Windows can be downloaded from the [Releases](https://github.com/shssoichiro/oxipng/releases) link on the GitHub page.
+
+For MacOS or Linux, it is recommended to install from your distro's package repository, if possible.
+
+Alternatively, oxipng can be installed from Cargo, via the following command:
+
+```
+cargo install oxipng
+```
+
+Oxipng can be built from source using the latest stable or nightly Rust.
+This is primarily useful for developing on oxipng.
+
+```
+git clone https://github.com/shssoichiro/oxipng.git
+cd oxipng
+cargo build --release
+cp target/release/oxipng /usr/local/bin
+```
+
+The current minimum supported Rust version is **1.61.0**.
+
+Oxipng follows Semantic Versioning.
+
+## Usage
+
+Oxipng is a command-line utility. Basic usage looks similar to the following:
+
+```
+oxipng -o 4 -i 1 --strip safe *.png
+```
+
+The most commonly used options are as follows:
+
+- Optimization: `-o 1` through `-o 6`, lower is faster, higher is better compression.
+  The default (`-o 2`) is sufficiently fast on a modern CPU and provides 30-50% compression
+  gains over an unoptimized PNG. `-o 4` is 6 times slower than `-o 2` but can provide 5-10%
+  extra compression over `-o 2`. Using any setting higher than `-o 4` is unlikely
+  to give any extra compression gains and is not recommended.
+- Interlacing: `-i 1` will enable [Adam7](https://en.wikipedia.org/wiki/Adam7_algorithm)
+  PNG interlacing on any images that are processed. `-i 0` will remove interlacing from all
+  processed images. Not specifying either will keep the same interlacing state as the
+  input image. Note: Interlacing can add 25-50% to the size of an optimized image. Only use
+  it if you believe the benefits outweigh the costs for your use case.
+- Strip: Used to remove metadata info from processed images. Used via `--strip [safe,all]`.
+  Can save a few kilobytes if you don't need the metadata. "Safe" removes only metadata that
+  will never affect rendering of the image. "All" removes all metadata that is not critical
+  to the image. You can also pass a comma-separated list of specific metadata chunks to remove.
+  `-s` can be used as a shorthand for `--strip safe`.
+
+More advanced options can be found by running `oxipng -h`.
+
+## Library Usage
+
+Although originally intended to be used as an executable, oxipng can also be used as a library in
+other Rust projects. To do so, simply add oxipng as a dependency in your Cargo.toml,
+then `extern crate oxipng` in your project. You should then have access to all of the library
+functions [documented here](https://docs.rs/oxipng). The simplest
+method of usage involves creating an
+[Options struct](https://docs.rs/oxipng/3.0.1/oxipng/struct.Options.html) and
+passing it, along with an input filename, into the
+[optimize function](https://docs.rs/oxipng/3.0.1/oxipng/fn.optimize.html).
+
+## History
+
+Oxipng began as a complete rewrite of the OptiPNG project,
+which was assumed to be dead as no commit had been made to it since March 2014.
+(OptiPNG has since released a new version, after Oxipng was first released.)
+The name has been changed to avoid confusion and potential legal issues.
+
+The core goal of rewriting OptiPNG was to implement multithreading,
+which would be very difficult to do within the existing C codebase of OptiPNG.
+This also served as an opportunity to choose a more modern, safer language (Rust).
+
+## Contributing
+
+Any contributions are welcome and will be accepted via pull request on GitHub. Bug reports can be
+filed via GitHub issues. Please include as many details as possible. If you have the capability
+to submit a fix with the bug report, it is preferred that you do so via pull request,
+however you do not need to be a Rust developer to contribute.
+Other contributions (such as improving documentation or translations) are also welcome via GitHub.
+
+## License
+
+Oxipng is open-source software, distributed under the MIT license.
+
+## Benchmarks
--- a/SECURITY.md
+++ b/SECURITY.md
@ -1,13 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Only the latest version will be supported with security updates. We will not maintain old branches.
-For this reason, you should attempt to always use the latest released version.
-
-## Reporting a Vulnerability
-
-To privately report a vulnerability in oxipng, please visit [our advisories page](https://github.com/oxipng/oxipng/security/advisories) and use the button to report a vulnerability.
-We will review it as soon as possible.
-
-For vulnerabilities in dependencies, please open a pull request updating the dependency to a patched version.
--- a/benches/deflate.rs
+++ b/benches/deflate.rs
@ -4,24 +4,30 @@ extern crate oxipng;
 extern crate test;

 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;

+use oxipng::internal_tests::*;
+
 #[bench]
 fn deflate_16_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| deflate(png.raw.data.as_ref(), 12, None));
+    b.iter(|| {
+        let min = AtomicMin::new(None);
+        deflate(png.raw.data.as_ref(), 12, &min)
+    });
 }

 #[bench]
 fn deflate_8_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| deflate(png.raw.data.as_ref(), 12, None));
+    b.iter(|| {
+        let min = AtomicMin::new(None);
+        deflate(png.raw.data.as_ref(), 12, &min)
+    });
 }

 #[bench]
@ -29,9 +35,12 @@ fn deflate_4_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| deflate(png.raw.data.as_ref(), 12, None));
+    b.iter(|| {
+        let min = AtomicMin::new(None);
+        deflate(png.raw.data.as_ref(), 12, &min)
+    });
 }

 #[bench]
@ -39,9 +48,12 @@ fn deflate_2_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| deflate(png.raw.data.as_ref(), 12, None));
+    b.iter(|| {
+        let min = AtomicMin::new(None);
+        deflate(png.raw.data.as_ref(), 12, &min)
+    });
 }

 #[bench]
@ -49,15 +61,18 @@ fn deflate_1_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| deflate(png.raw.data.as_ref(), 12, None));
+    b.iter(|| {
+        let min = AtomicMin::new(None);
+        deflate(png.raw.data.as_ref(), 12, &min)
+    });
 }

 #[bench]
 fn inflate_generic(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

    b.iter(|| inflate(png.idat_data.as_ref(), png.raw.ihdr.raw_data_size()));
 }
--- a/benches/filters.rs
+++ b/benches/filters.rs
@ -3,25 +3,28 @@
 extern crate oxipng;
 extern crate test;

+use oxipng::{internal_tests::*, RowFilter};
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;

 #[bench]
 fn filters_16_bits_filter_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }

 #[bench]
 fn filters_8_bits_filter_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }

 #[bench]
@ -29,9 +32,11 @@ fn filters_4_bits_filter_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }

 #[bench]
@ -39,9 +44,11 @@ fn filters_2_bits_filter_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }

 #[bench]
@ -49,25 +56,31 @@ fn filters_1_bits_filter_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }

 #[bench]
 fn filters_16_bits_filter_1(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }

 #[bench]
 fn filters_8_bits_filter_1(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }

 #[bench]
@ -75,9 +88,11 @@ fn filters_4_bits_filter_1(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }

 #[bench]
@ -85,9 +100,11 @@ fn filters_2_bits_filter_1(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }

 #[bench]
@ -95,25 +112,31 @@ fn filters_1_bits_filter_1(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }

 #[bench]
 fn filters_16_bits_filter_2(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }

 #[bench]
 fn filters_8_bits_filter_2(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }

 #[bench]
@ -121,9 +144,11 @@ fn filters_4_bits_filter_2(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }

 #[bench]
@ -131,9 +156,11 @@ fn filters_2_bits_filter_2(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }

 #[bench]
@ -141,25 +168,31 @@ fn filters_1_bits_filter_2(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }

 #[bench]
 fn filters_16_bits_filter_3(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }

 #[bench]
 fn filters_8_bits_filter_3(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }

 #[bench]
@ -167,9 +200,11 @@ fn filters_4_bits_filter_3(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }

 #[bench]
@ -177,9 +212,11 @@ fn filters_2_bits_filter_3(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }

 #[bench]
@ -187,25 +224,31 @@ fn filters_1_bits_filter_3(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }

 #[bench]
 fn filters_16_bits_filter_4(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }

 #[bench]
 fn filters_8_bits_filter_4(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }

 #[bench]
@ -213,9 +256,11 @@ fn filters_4_bits_filter_4(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }

 #[bench]
@ -223,9 +268,11 @@ fn filters_2_bits_filter_4(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }

 #[bench]
@ -233,25 +280,31 @@ fn filters_1_bits_filter_4(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }

 #[bench]
 fn filters_16_bits_filter_5(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }

 #[bench]
 fn filters_8_bits_filter_5(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }

 #[bench]
@ -259,9 +312,11 @@ fn filters_4_bits_filter_5(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }

 #[bench]
@ -269,9 +324,11 @@ fn filters_2_bits_filter_5(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }

 #[bench]
@ -279,7 +336,9 @@ fn filters_1_bits_filter_5(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }
--- a/benches/interlacing.rs
+++ b/benches/interlacing.rs
@ -3,25 +3,24 @@
 extern crate oxipng;
 extern crate test;

+use oxipng::{internal_tests::*, Interlacing};
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;

 #[bench]
 fn interlacing_16_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }

 #[bench]
 fn interlacing_8_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }

 #[bench]
@ -29,9 +28,9 @@ fn interlacing_4_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }

 #[bench]
@ -39,9 +38,9 @@ fn interlacing_2_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }

 #[bench]
@ -49,9 +48,9 @@ fn interlacing_1_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }

 #[bench]
@ -59,9 +58,9 @@ fn deinterlacing_16_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/interlaced_rgb_16_should_be_rgb_16.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }

 #[bench]
@ -69,9 +68,9 @@ fn deinterlacing_8_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/interlaced_rgb_8_should_be_rgb_8.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }

 #[bench]
@ -79,9 +78,9 @@ fn deinterlacing_4_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/interlaced_palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }

 #[bench]
@ -89,9 +88,9 @@ fn deinterlacing_2_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/interlaced_palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }

 #[bench]
@ -99,7 +98,7 @@ fn deinterlacing_1_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/interlaced_palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }
--- a/benches/reductions.rs
+++ b/benches/reductions.rs
@ -3,25 +3,16 @@
 extern crate oxipng;
 extern crate test;

+use oxipng::internal_tests::*;
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;

 #[bench]
 fn reductions_16_to_8_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| bit_depth::reduced_bit_depth_16_to_8(&png.raw, false));
-}
-
-#[bench]
-fn reductions_16_to_8_bits_scaled(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| bit_depth::reduced_bit_depth_16_to_8(&png.raw, true));
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
 }

 #[bench]
@ -29,9 +20,9 @@ fn reductions_8_to_4_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_8_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
 }

 #[bench]
@ -39,9 +30,9 @@ fn reductions_8_to_2_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_8_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
 }

 #[bench]
@ -49,9 +40,39 @@ fn reductions_8_to_1_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_8_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
+}
+
+#[bench]
+fn reductions_4_to_2_bits(b: &mut Bencher) {
+    let input = test::black_box(PathBuf::from(
+        "tests/files/palette_4_should_be_palette_2.png",
+    ));
+    let png = PngData::new(&input, false).unwrap();
+
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
+}
+
+#[bench]
+fn reductions_4_to_1_bits(b: &mut Bencher) {
+    let input = test::black_box(PathBuf::from(
+        "tests/files/palette_4_should_be_palette_1.png",
+    ));
+    let png = PngData::new(&input, false).unwrap();
+
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
+}
+
+#[bench]
+fn reductions_2_to_1_bits(b: &mut Bencher) {
+    let input = test::black_box(PathBuf::from(
+        "tests/files/palette_2_should_be_palette_1.png",
+    ));
+    let png = PngData::new(&input, false).unwrap();
+
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
 }

 #[bench]
@ -59,9 +80,9 @@ fn reductions_grayscale_8_to_4_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/grayscale_8_should_be_grayscale_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
 }

 #[bench]
@ -69,9 +90,9 @@ fn reductions_grayscale_8_to_2_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/grayscale_8_should_be_grayscale_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
 }

 #[bench]
@ -79,33 +100,55 @@ fn reductions_grayscale_8_to_1_bits(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/grayscale_8_should_be_grayscale_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
+}
+
+#[bench]
+fn reductions_grayscale_4_to_2_bits(b: &mut Bencher) {
+    let input = test::black_box(PathBuf::from(
+        "tests/files/grayscale_4_should_be_grayscale_2.png",
+    ));
+    let png = PngData::new(&input, false).unwrap();
+
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
+}
+
+#[bench]
+fn reductions_grayscale_4_to_1_bits(b: &mut Bencher) {
+    let input = test::black_box(PathBuf::from(
+        "tests/files/grayscale_4_should_be_grayscale_1.png",
+    ));
+    let png = PngData::new(&input, false).unwrap();
+
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
+}
+
+#[bench]
+fn reductions_grayscale_2_to_1_bits(b: &mut Bencher) {
+    let input = test::black_box(PathBuf::from(
+        "tests/files/grayscale_2_should_be_grayscale_1.png",
+    ));
+    let png = PngData::new(&input, false).unwrap();
+
+    b.iter(|| bit_depth::reduce_bit_depth(&png.raw, 1));
 }

 #[bench]
 fn reductions_rgba_to_rgb_16(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgba_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| alpha::reduced_alpha_channel(&png.raw, true));
+    b.iter(|| reduce_color_type(&png.raw, true, false));
 }

 #[bench]
 fn reductions_rgba_to_rgb_8(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgba_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| alpha::reduced_alpha_channel(&png.raw, true));
-}
-
-#[bench]
-fn reductions_rgba_to_rgb_trns_8(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from("tests/files/rgba_8_should_be_rgb_trns_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| alpha::reduced_alpha_channel(&png.raw, true));
+    b.iter(|| reduce_color_type(&png.raw, true, false));
 }

 #[bench]
@ -113,9 +156,9 @@ fn reductions_rgba_to_grayscale_alpha_16(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/rgba_16_should_be_grayscale_alpha_16.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| color::reduced_rgb_to_grayscale(&png.raw));
+    b.iter(|| reduce_color_type(&png.raw, true, false));
 }

 #[bench]
@ -123,9 +166,29 @@ fn reductions_rgba_to_grayscale_alpha_8(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/rgba_8_should_be_grayscale_alpha_8.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| color::reduced_rgb_to_grayscale(&png.raw));
+    b.iter(|| reduce_color_type(&png.raw, true, false));
+}
+
+#[bench]
+fn reductions_rgba_to_grayscale_16(b: &mut Bencher) {
+    let input = test::black_box(PathBuf::from(
+        "tests/files/rgba_16_should_be_grayscale_16.png",
+    ));
+    let png = PngData::new(&input, false).unwrap();
+
+    b.iter(|| reduce_color_type(&png.raw, true, false));
+}
+
+#[bench]
+fn reductions_rgba_to_grayscale_8(b: &mut Bencher) {
+    let input = test::black_box(PathBuf::from(
+        "tests/files/rgba_8_should_be_grayscale_8.png",
+    ));
+    let png = PngData::new(&input, false).unwrap();
+
+    b.iter(|| reduce_color_type(&png.raw, true, false));
 }

 #[bench]
@ -133,83 +196,33 @@ fn reductions_rgb_to_grayscale_16(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/rgb_16_should_be_grayscale_16.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| color::reduced_rgb_to_grayscale(&png.raw));
+    b.iter(|| reduce_color_type(&png.raw, true, false));
 }

 #[bench]
 fn reductions_rgb_to_grayscale_8(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_grayscale_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| color::reduced_rgb_to_grayscale(&png.raw));
+    b.iter(|| reduce_color_type(&png.raw, true, false));
 }

 #[bench]
 fn reductions_rgba_to_palette_8(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgba_8_should_be_palette_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| color::reduced_to_indexed(&png.raw, true));
+    b.iter(|| reduce_color_type(&png.raw, true, false));
 }

 #[bench]
 fn reductions_rgb_to_palette_8(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_palette_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| color::reduced_to_indexed(&png.raw, true));
-}
-
-#[bench]
-fn reductions_grayscale_alpha_to_grayscale_16(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from(
-        "tests/files/grayscale_alpha_16_should_be_grayscale_16.png",
-    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| alpha::reduced_alpha_channel(&png.raw, true));
-}
-
-#[bench]
-fn reductions_grayscale_alpha_to_grayscale_8(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from(
-        "tests/files/grayscale_alpha_8_should_be_grayscale_8.png",
-    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| alpha::reduced_alpha_channel(&png.raw, true));
-}
-
-#[bench]
-fn reductions_grayscale_alpha_to_grayscale_trns_8(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from(
-        "tests/files/grayscale_alpha_8_should_be_grayscale_trns_8.png",
-    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| alpha::reduced_alpha_channel(&png.raw, true));
-}
-
-#[bench]
-fn reductions_grayscale_8_to_palette_8(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from(
-        "tests/files/grayscale_8_should_be_palette_8.png",
-    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| color::reduced_to_indexed(&png.raw, true));
-}
-
-#[bench]
-fn reductions_palette_8_to_grayscale_8(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from(
-        "tests/files/palette_8_should_be_grayscale_8.png",
-    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| color::indexed_to_channels(&png.raw, true, false));
+    b.iter(|| reduce_color_type(&png.raw, true, false));
 }

 #[bench]
@ -217,9 +230,9 @@ fn reductions_palette_duplicate_reduction(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_should_be_reduced_with_dupes.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| palette::reduced_palette(&png.raw, false));
+    b.iter(|| reduced_palette(&png.raw, false));
 }

 #[bench]
@ -227,9 +240,9 @@ fn reductions_palette_unused_reduction(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_should_be_reduced_with_unused.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| palette::reduced_palette(&png.raw, false));
+    b.iter(|| reduced_palette(&png.raw, false));
 }

 #[bench]
@ -237,45 +250,15 @@ fn reductions_palette_full_reduction(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_should_be_reduced_with_both.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| palette::reduced_palette(&png.raw, false));
-}
-
-#[bench]
-fn reductions_palette_sort(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from(
-        "tests/files/palette_8_should_be_palette_8.png",
-    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| palette::sorted_palette(&png.raw));
-}
-
-#[bench]
-fn reductions_palette_sort_mzeng(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from(
-        "tests/files/palette_8_should_be_palette_8.png",
-    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| palette::sorted_palette_mzeng(&png.raw));
-}
-
-#[bench]
-fn reductions_palette_sort_battiato(b: &mut Bencher) {
-    let input = test::black_box(PathBuf::from(
-        "tests/files/palette_8_should_be_palette_8.png",
-    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
-
-    b.iter(|| palette::sorted_palette_battiato(&png.raw));
+    b.iter(|| reduced_palette(&png.raw, false));
 }

 #[bench]
 fn reductions_alpha(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgba_8_reduce_alpha.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

    b.iter(|| alpha::cleaned_alpha_channel(&png.raw));
 }
--- a/benches/strategies.rs
+++ b/benches/strategies.rs
@ -3,55 +3,56 @@
 extern crate oxipng;
 extern crate test;

+use oxipng::{internal_tests::*, RowFilter};
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;

 #[bench]
 fn filters_minsum(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }

 #[bench]
 fn filters_entropy(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::Entropy, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Entropy, false);
+    });
 }

 #[bench]
 fn filters_bigrams(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::Bigrams, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Bigrams, false);
+    });
 }

 #[bench]
 fn filters_bigent(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

-    b.iter(|| png.raw.filter_image(FilterStrategy::BigEnt, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::BigEnt, false);
+    });
 }

 #[bench]
 fn filters_brute(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

    b.iter(|| {
-        png.raw.filter_image(
-            FilterStrategy::Brute {
-                num_lines: 4,
-                level: 1,
-            },
-            false,
-        )
+        png.raw.filter_image(RowFilter::Brute, false);
    });
 }
--- a/benches/zopfli.rs
+++ b/benches/zopfli.rs
@ -3,28 +3,31 @@
 extern crate oxipng;
 extern crate test;

+use oxipng::internal_tests::*;
+use std::num::NonZeroU8;
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;

+// SAFETY: trivially safe. Stopgap solution until const unwrap is stabilized.
+const DEFAULT_ZOPFLI_ITERATIONS: NonZeroU8 = unsafe { NonZeroU8::new_unchecked(15) };
+
 #[bench]
 fn zopfli_16_bits_strategy_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_16_should_be_rgb_16.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

    b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
    });
 }

 #[bench]
 fn zopfli_8_bits_strategy_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from("tests/files/rgb_8_should_be_rgb_8.png"));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

    b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
    });
 }

@ -33,10 +36,10 @@ fn zopfli_4_bits_strategy_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_4_should_be_palette_4.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

    b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
    });
 }

@ -45,10 +48,10 @@ fn zopfli_2_bits_strategy_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_2_should_be_palette_2.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

    b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
    });
 }

@ -57,9 +60,9 @@ fn zopfli_1_bits_strategy_0(b: &mut Bencher) {
    let input = test::black_box(PathBuf::from(
        "tests/files/palette_1_should_be_palette_1.png",
    ));
-    let png = PngData::new(&input, &Options::default()).unwrap();
+    let png = PngData::new(&input, false).unwrap();

    b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
    });
 }
--- a/index.html
+++ b/index.html
@ -0,0 +1 @@
+<script>(function() {window.location.assign(window.location.href + "doc/oxipng/");})();</script>
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -0,0 +1,26 @@
+{
+  "name": "oxipng",
+  "version": "1.0.0",
+  "description": "[![Build Status](https://travis-ci.org/shssoichiro/oxipng.svg?branch=master)](https://travis-ci.org/shssoichiro/oxipng) [![Version](https://img.shields.io/crates/v/oxipng.svg)](https://crates.io/crates/oxipng) [![License](https://img.shields.io/crates/l/oxipng.svg)](https://github.com/shssoichiro/oxipng/blob/master/LICENSE)",
+  "main": "index.js",
+  "private": true,
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shssoichiro/oxipng.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/shssoichiro/oxipng/issues"
+  },
+  "homepage": "https://github.com/shssoichiro/oxipng#readme",
+  "devDependencies": {
+    "strip-ansi-cli": "^3.0.0"
+  }
+}
--- a/scripts/compare.sh
+++ b/scripts/compare.sh
@ -1,19 +1,17 @@
 #!/bin/bash
 cargo build --release
-sed -i.bak '/## Benchmarks/,$d' README.md
-rm README.md.bak
+cp README.template.md README.md

 CORES=$(sysctl -n hw.ncpu 2>/dev/null || grep -c ^processor /proc/cpuinfo)
 CPU=$(sysctl -n machdep.cpu.brand_string 2>/dev/null || grep '^model name' /proc/cpuinfo | sed 's/model name.\+: //g' | head -n 1)
 OXIPNG_VERSION=$(./target/release/oxipng -V)
 OPTIPNG_VERSION=$(optipng -v | head -n 1)
 RUST_VERSION=$(rustc -V)
-echo -e '## Benchmarks\n' >> README.md
 echo "Tested $OXIPNG_VERSION (compiled on $RUST_VERSION) against $OPTIPNG_VERSION on $CPU with $CORES logical cores" >> README.md
-echo -e '\n```\n' >> README.md
+echo -e '\n\n```\n' >> README.md

-hyperfine --style basic --warmup 5 './target/release/oxipng -P ./tests/files/rgb_16_should_be_grayscale_8.png' 'optipng -simulate ./tests/files/rgb_16_should_be_grayscale_8.png' >> README.md
+hyperfine --warmup 5 './target/release/oxipng -P ./tests/files/rgb_16_should_be_grayscale_8.png' 'optipng -simulate ./tests/files/rgb_16_should_be_grayscale_8.png' | ./node_modules/.bin/strip-ansi >> README.md
 echo -e '\n\n' >> README.md
-hyperfine --style basic --warmup 5 './target/release/oxipng -o4 -P ./tests/files/rgb_16_should_be_grayscale_8.png' 'optipng -o 4 -simulate ./tests/files/rgb_16_should_be_grayscale_8.png' >> README.md
+hyperfine --warmup 5 './target/release/oxipng -o4 -P ./tests/files/rgb_16_should_be_grayscale_8.png' 'optipng -o 4 -simulate ./tests/files/rgb_16_should_be_grayscale_8.png' | ./node_modules/.bin/strip-ansi >> README.md

-echo -e '\n```' >> README.md
+echo -e '\n```\n' >> README.md
--- a/scripts/manual.sh
+++ b/scripts/manual.sh
@ -1,7 +0,0 @@
-#!/bin/sh -eu
-cargo build
-cargo xtask mangen
-
-./target/debug/oxipng -V > MANUAL.txt
-#Redirect all streams to prevent detection of the terminal width and force an internal default of 100
-./target/debug/oxipng --help >> MANUAL.txt 2>/dev/null </dev/null
--- a/src/apng.rs
+++ b/src/apng.rs
@ -1,72 +0,0 @@
-use crate::{
-    PngResult,
-    error::PngError,
-    headers::{read_be_u16, read_be_u32},
-};
-
-#[derive(Debug, Clone)]
-/// Animated PNG frame
-pub struct Frame {
-    /// Width of the frame
-    pub width: u32,
-    /// Height of the frame
-    pub height: u32,
-    /// X offset of the frame
-    pub x_offset: u32,
-    /// Y offset of the frame
-    pub y_offset: u32,
-    /// Frame delay numerator
-    pub delay_num: u16,
-    /// Frame delay denominator
-    pub delay_den: u16,
-    /// Frame disposal operation
-    pub dispose_op: u8,
-    /// Frame blend operation
-    pub blend_op: u8,
-    /// Frame data, from fdAT chunks
-    pub data: Vec<u8>,
-}
-
-impl Frame {
-    /// Construct a new Frame from the data in a fcTL chunk
-    pub fn from_fctl_data(byte_data: &[u8]) -> PngResult<Self> {
-        if byte_data.len() < 26 {
-            return Err(PngError::TruncatedData);
-        }
-        Ok(Self {
-            width: read_be_u32(&byte_data[4..8]),
-            height: read_be_u32(&byte_data[8..12]),
-            x_offset: read_be_u32(&byte_data[12..16]),
-            y_offset: read_be_u32(&byte_data[16..20]),
-            delay_num: read_be_u16(&byte_data[20..22]),
-            delay_den: read_be_u16(&byte_data[22..24]),
-            dispose_op: byte_data[24],
-            blend_op: byte_data[25],
-            data: vec![],
-        })
-    }
-
-    /// Construct the data for a fcTL chunk using the given sequence number
-    #[must_use]
-    pub fn fctl_data(&self, sequence_number: u32) -> Vec<u8> {
-        let mut byte_data = Vec::with_capacity(26);
-        byte_data.extend_from_slice(&sequence_number.to_be_bytes());
-        byte_data.extend_from_slice(&self.width.to_be_bytes());
-        byte_data.extend_from_slice(&self.height.to_be_bytes());
-        byte_data.extend_from_slice(&self.x_offset.to_be_bytes());
-        byte_data.extend_from_slice(&self.y_offset.to_be_bytes());
-        byte_data.extend_from_slice(&self.delay_num.to_be_bytes());
-        byte_data.extend_from_slice(&self.delay_den.to_be_bytes());
-        byte_data.extend_from_slice(&[self.dispose_op, self.blend_op]);
-        byte_data
-    }
-
-    /// Construct the data for a fdAT chunk using the given sequence number
-    #[must_use]
-    pub fn fdat_data(&self, sequence_number: u32) -> Vec<u8> {
-        let mut byte_data = Vec::with_capacity(4 + self.data.len());
-        byte_data.extend_from_slice(&sequence_number.to_be_bytes());
-        byte_data.extend_from_slice(&self.data);
-        byte_data
-    }
-}
--- a/src/atomicmin.rs
+++ b/src/atomicmin.rs
@ -1,4 +1,5 @@
-use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::SeqCst;

 #[derive(Debug)]
 pub struct AtomicMin {
@ -6,7 +7,6 @@ pub struct AtomicMin {
 }

 impl AtomicMin {
-    #[must_use]
    pub fn new(init: Option<usize>) -> Self {
        Self {
            val: AtomicUsize::new(init.unwrap_or(usize::MAX)),
@ -15,7 +15,16 @@ impl AtomicMin {

    pub fn get(&self) -> Option<usize> {
        let val = self.val.load(SeqCst);
-        if val == usize::MAX { None } else { Some(val) }
+        if val == usize::MAX {
+            None
+        } else {
+            Some(val)
+        }
+    }
+
+    /// Unset value is usize_max
+    pub fn as_atomic_usize(&self) -> &AtomicUsize {
+        &self.val
    }

    /// Try a new value, returning true if it is the new minimum
--- a/src/cli.rs
+++ b/src/cli.rs
@ -1,450 +0,0 @@
-use std::{num::NonZeroU64, path::PathBuf};
-
-use clap::builder::Styles;
-use clap::builder::styling::{AnsiColor, Effects};
-use clap::{Arg, ArgAction, Command, builder::ArgPredicate, value_parser};
-use parse_size::parse_size;
-
-include!("display_chunks.rs");
-
-const STYLES: Styles = Styles::styled()
-    .header(AnsiColor::Green.on_default().effects(Effects::BOLD))
-    .usage(AnsiColor::Green.on_default().effects(Effects::BOLD))
-    .literal(AnsiColor::Cyan.on_default().effects(Effects::BOLD))
-    .placeholder(AnsiColor::Cyan.on_default());
-
-pub fn build_command() -> Command {
-    // Note: clap 'wrap_help' is enabled to automatically wrap lines according to terminal width.
-    // To keep things tidy though, short help descriptions should be no more than 54 characters,
-    // so that they can fit on a single line in an 80 character terminal.
-    // Long help descriptions are soft wrapped here at 90 characters (column 91) but this does not
-    // affect output, it simply matches what is rendered when help is output to a file.
-    Command::new("oxipng")
-        .version(env!("CARGO_PKG_VERSION"))
-        .author("Joshua Holmer <jholmer.in@gmail.com>")
-        .about("Losslessly improve compression of PNG files")
-        .styles(STYLES)
-        .arg(
-            Arg::new("files")
-                .help("File(s) to compress (use '-' for stdin)")
-                .index(1)
-                .num_args(1..)
-                .use_value_delimiter(false)
-                .required(true)
-                .value_parser(value_parser!(PathBuf)),
-        )
-        .arg(
-            Arg::new("optimization")
-                .help("Optimization level (0-6, or max)")
-                .long_help("\
-Set the optimization level preset. The default level 2 is quite fast and provides good \
-compression. Lower levels are faster, higher levels provide better compression, though \
-with increasingly diminishing returns.
-
-    0   => --zc 5  --fast              (filter chosen heuristically)
-    1   => --zc 10 --fast              (filter chosen heuristically)
-    2   => --zc 11 -f 0,1,6,7 --fast
-    3   => --zc 11 -f 0,7,8,9         --brute-level 1 --brute-lines 3
-    4   => --zc 12 -f 0,7,8,9         --brute-level 1 --brute-lines 4
-    5   => --zc 12 -f 0,1,2,5,6,7,8,9 --brute-level 4 --brute-lines 4
-    6   => --zc 12 -f 0-9             --brute-level 5 --brute-lines 8
-    max => (stable alias for the maximum level)
-
-Manually specifying a compression option (zc, f, etc.) will override the optimization \
-preset, regardless of the order you write the arguments.")
-                .short('o')
-                .long("opt")
-                .value_name("level")
-                .default_value("2")
-                .value_parser(["0", "1", "2", "3", "4", "5", "6", "max"])
-                .hide_possible_values(true),
-        )
-        .arg(
-            Arg::new("recursive")
-                .help("Recurse input directories, optimizing all PNG files")
-                .long_help("\
-When directories are given as input, traverse the directory trees and optimize all PNG \
-files found (files with “.png” or “.apng” extension).")
-                .short('r')
-                .long("recursive")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("output_dir")
-                .help("Write output file(s) to <directory>")
-                .long_help("\
-Write output file(s) to <directory>. If the directory does not exist, it will be created. \
-Note that this will not preserve the directory structure of the input files when used with \
-'--recursive'.")
-                .long("dir")
-                .value_name("directory")
-                .value_parser(value_parser!(PathBuf))
-                .conflicts_with("output_file")
-                .conflicts_with("stdout"),
-        )
-        .arg(
-            Arg::new("output_file")
-                .help("Write output file to <file>")
-                .long("out")
-                .value_name("file")
-                .value_parser(value_parser!(PathBuf))
-                .conflicts_with("output_dir")
-                .conflicts_with("stdout"),
-        )
-        .arg(
-            Arg::new("stdout")
-                .help("Write output to stdout")
-                .long("stdout")
-                .action(ArgAction::SetTrue)
-                .conflicts_with("output_dir")
-                .conflicts_with("output_file"),
-        )
-        .arg(
-            Arg::new("preserve")
-                .help("Preserve file permissions and timestamps if possible")
-                .short('p')
-                .long("preserve")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("dry-run")
-                .help("Do not write any files, only show compression results")
-                .short('d')
-                .long("dry-run")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("strip-safe")
-                .help("Strip safely-removable chunks, same as '--strip safe'")
-                .short('s')
-                .action(ArgAction::SetTrue)
-                .conflicts_with("strip"),
-        )
-        .arg(
-            Arg::new("strip")
-                .help("Strip metadata (safe, all, or comma-separated list)\nCAUTION: 'all' will convert APNGs to standard PNGs")
-                .long_help(format!("\
-Strip metadata chunks, where <mode> is one of:
-
-    safe    =>  Strip all non-critical chunks, except for the following:
-                    {}
-    all     =>  Strip all non-critical chunks
-    <list>  =>  Strip chunks in the comma-separated list, e.g. 'bKGD,cHRM'
-
-CAUTION: 'all' will convert APNGs to standard PNGs.
-
-Please note that regardless of any options set, some chunks will necessarily be stripped \
-when invalidated by the optimization:
-    bKGD, sBIT, hIST: Stripped if the color type or bit depth changes.
-    iDOT: Always stripped.
-    caBX: Stripped if it contains C2PA metadata. If explicitly retained by `--keep`, \
-    optimization will be aborted.
-
-The default when --strip is not passed is to keep all chunks that remain valid.",
-                       DISPLAY_CHUNKS
-                           .iter()
-                           .map(|c| String::from_utf8_lossy(c))
-                           .collect::<Vec<_>>()
-                           .join(", ")))
-                .long("strip")
-                .value_name("mode")
-                .conflicts_with("strip-safe"),
-        )
-        .arg(
-            Arg::new("keep")
-                .help("Strip all metadata except in the comma-separated list")
-                .long_help("\
-Strip all metadata chunks except those in the comma-separated list. The special value \
-'display' includes chunks that affect the image appearance, equivalent to '--strip safe'.
-
-E.g. '--keep eXIf,display' will strip chunks, keeping only eXIf and those that affect the \
-image appearance.")
-                .long("keep")
-                .value_name("list")
-                .conflicts_with("strip")
-                .conflicts_with("strip-safe"),
-        )
-        .arg(
-            Arg::new("alpha")
-                .help("Perform additional alpha channel optimization")
-                .long_help("\
-Perform additional optimization on images with an alpha channel, by altering the color \
-values of fully transparent pixels. This is generally recommended for better compression, \
-but take care as while this is “visually lossless”, it is technically a lossy \
-transformation and may be unsuitable for some applications.")
-                .short('a')
-                .long("alpha")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("interlace")
-                .help("Set PNG interlacing (off, on, keep)")
-                .long_help("\
-Set the PNG interlacing mode, where <mode> is one of:
-
-    off   =>  Remove interlacing from all images that are processed
-    on    =>  Apply Adam7 interlacing on all images that are processed
-    keep  =>  Keep the existing interlacing mode of each image
-
-Note that interlacing can add 25-50% to the size of an optimized image. Only use it if you \
-believe the benefits outweigh the costs for your use case.")
-                .short('i')
-                .long("interlace")
-                .value_name("mode")
-                .value_parser(["off", "on", "keep", "0", "1"])
-                .default_value("off")
-                .default_value_if("no-reductions", ArgPredicate::IsPresent, "keep")
-                .hide_possible_values(true),
-        )
-        .arg(
-            Arg::new("scale16")
-                .help("Forcibly reduce 16-bit images to 8-bit (lossy)")
-                .long_help("\
-Forcibly reduce images with 16 bits per channel to 8 bits per channel. This is a lossy \
-operation but can provide significant savings when you have no need for higher depth. \
-Reduction is performed by scaling the values such that, e.g. 0x00FF is reduced to 0x01 \
-rather than 0x00.
-
-Without this flag, 16-bit images will only be reduced in depth if it can be done \
-losslessly.")
-                .long("scale16")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("verbose")
-                .help("Show per-file info (use multiple times for more detail)")
-                .short('v')
-                .long("verbose")
-                .action(ArgAction::Count)
-                .conflicts_with("quiet"),
-        )
-        .arg(
-            Arg::new("quiet")
-                .help("Suppress all output messages")
-                .short('q')
-                .long("quiet")
-                .action(ArgAction::SetTrue)
-                .conflicts_with("verbose"),
-        )
-        .arg(
-            Arg::new("json")
-                .help("Print results as JSON")
-                .short('j')
-                .long("json")
-                .action(ArgAction::SetTrue)
-                .conflicts_with("stdout"),
-        )
-        .arg(
-            Arg::new("filters")
-                .help("Filters to try (0-9; see '--help' for details)")
-                .long_help("\
-Perform compression trials with each of the given filter types. You can specify a \
-comma-separated list, or a range of values. E.g. '-f 0-3' is the same as '-f 0,1,2,3'.
-
-PNG delta filters (apply the same filter to every line)
-    0  =>  None      (recommended to always include this filter)
-    1  =>  Sub
-    2  =>  Up
-    3  =>  Average
-    4  =>  Paeth
-
-Heuristic strategies (try to find the best delta filter for each line)
-    5  =>  MinSum    Minimum sum of absolute differences
-    6  =>  Entropy   Smallest Shannon entropy
-    7  =>  Bigrams   Lowest count of distinct bigrams
-    8  =>  BigEnt    Smallest Shannon entropy of bigrams
-    9  =>  Brute     Smallest compressed size (slow)
-
-The default value depends on the optimization level preset.")
-                .short('f')
-                .long("filters")
-                .value_name("list"),
-        )
-        .arg(
-            Arg::new("fast")
-                .help("Use fast filter evaluation")
-                .long_help("\
-Perform a fast compression evaluation of each enabled filter, followed by a single main \
-compression trial of the best result. Recommended if you have more filters enabled than \
-CPU cores.")
-                .long("fast")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("compression")
-                .help("Deflate compression level (0-12)")
-                .long_help("\
-Deflate compression level (0-12) for main compression trials. The levels here are defined \
-by the libdeflate compression library.
-
-The default value depends on the optimization level preset.")
-                .long("zc")
-                .value_name("level")
-                .value_parser(0..=12)
-                .conflicts_with("zopfli"),
-        )
-        .arg(
-            Arg::new("no-bit-reduction")
-                .help("Do not change bit depth")
-                .long("nb")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("no-color-reduction")
-                .help("Do not change color type")
-                .long("nc")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("no-palette-reduction")
-                .help("Do not change color palette")
-                .long_help("\
-Do not convert to indexed and do not modify an existing color palette.")
-                .long("np")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("no-grayscale-reduction")
-                .help("Do not change to or from grayscale")
-                .long("ng")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("no-reductions")
-                .help("Do not perform any transformations")
-                .long_help("\
-Do not perform any transformations and do not deinterlace by default.")
-                .long("nx")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("no-recoding")
-                .help("Do not recompress unless transformations occur")
-                .long_help("\
-Do not recompress IDAT unless required due to transformations. Recompression of other \
-compressed chunks (such as iCCP) will also be disabled. Note that the combination of \
-'--nx' and '--nz' will fully disable all optimization.")
-                .long("nz")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("fix")
-                .help("Disable checksum validation")
-                .long_help("\
-Do not perform checksum validation of PNG chunks. This may allow some files with errors to \
-be processed successfully. The output will always have correct checksums.")
-                .long("fix")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("force")
-                .help("Write the output even if it is larger than the input")
-                .long("force")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("zopfli")
-                .help("Use the much slower but stronger Zopfli compressor")
-                .long_help("\
-Use the much slower but stronger Zopfli compressor for main compression trials. \
-Recommended use is with '-o max' and '--fast'.")
-                .short('z')
-                .short_alias('Z') // Kept for backwards compatibility
-                .long("zopfli")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("iterations")
-                .help("Number of Zopfli iterations")
-                .long_help("\
-Set the number of iterations to use for Zopfli compression. Using fewer iterations may \
-speed up compression for large files. This option requires '--zopfli' to be set.")
-                .long("zi")
-                .value_name("iterations")
-                .default_value("15")
-                .value_parser(value_parser!(NonZeroU64))
-                .requires("zopfli"),
-        )
-        .arg(
-            Arg::new("iterations-without-improvement")
-                .hide_short_help(true)
-                .long_help("\
-Stop Zopfli compression after this number of iterations without improvement. Use this in \
-conjunction with a high value for '--zi' to achieve better compression in reasonable time.")
-                .long("ziwi")
-                .value_name("iterations")
-                .value_parser(value_parser!(NonZeroU64))
-                .requires("zopfli"),
-        )
-        .arg(
-            Arg::new("brute-level")
-                .hide_short_help(true)
-                .long_help("\
-Set the libdeflate compression level to use with the Brute filter strategy. Sane values \
-are 1-5. Higher values are not necessarily better.")
-                .long("brute-level")
-                .value_name("level")
-                .value_parser(1..=12),
-        )
-        .arg(
-            Arg::new("brute-lines")
-                .hide_short_help(true)
-                .long_help("\
-Set the number of lines to compress at once with the Brute filter strategy. Sane values \
-are 2-16. Higher values are not necessarily better.")
-                .long("brute-lines")
-                .value_name("lines")
-                .value_parser(value_parser!(usize)),
-        )
-        .arg(
-            Arg::new("timeout")
-                .help("Maximum amount of time to spend on optimizations")
-                .long_help("\
-Maximum amount of time, in seconds, to spend on optimizations. Oxipng will check the \
-timeout before each transformation or compression trial, and will stop trying to optimize \
-the file if the timeout is exceeded. Note that this does not cut short any operations that \
-are already in progress, so it is currently of limited effectiveness for large files with \
-high compression levels.")
-                .long("timeout")
-                .value_name("secs")
-                .value_parser(value_parser!(u64)),
-        )
-        .arg(
-            Arg::new("max-size")
-                .help("Skip image if the decompressed size exceeds this limit")
-                .long_help("\
-Maximum size to allow for the input image. If the raw, decompressed image data (or the \
-file size) of the image exceeds this size, it will be skipped. This is useful for limiting \
-memory usage or avoiding long processing times on large images. The value may be specified \
-with a unit suffix such as k, KB, m, MB, etc.
-
-The decompressed size of an image is roughly equal to width * height * bit-depth / 8. E.g. \
-a 1920x1080 image with 24-bit color depth would be roughly 6MB.")
-                .long("max-raw-size")
-                .value_name("bytes")
-                .value_parser(|s: &str| parse_size(s)),
-        )
-        .arg(
-            Arg::new("threads")
-                .help("Number of threads to use [default: num logical CPUs]")
-                .long_help("\
-Set the maximum number of threads to use. Oxipng uses multithreading to evaluate multiple \
-optimizations on the same file in parallel as well as process multiple files in parallel. \
-You can set this to a lower value if you need to limit memory or CPU usage.
-
-[default: num logical CPUs]")
-                .short('t')
-                .long("threads")
-                .value_name("num")
-                .value_parser(value_parser!(usize)),
-        )
-        .arg(
-            Arg::new("parallel-files")
-                .help("Process multiple files sequentially")
-                .long_help("\
-Process multiple files sequentially rather than in parallel. Use this if you need \
-determinism in the processing order. Note this is not necessary if using '--threads 1'.")
-                .long("sequential")
-                .action(ArgAction::SetFalse),
-        )
-}
--- a/src/colors.rs
+++ b/src/colors.rs
@ -1,129 +1,119 @@
-use std::{fmt, fmt::Display};
+use std::fmt;

-use rgb::{RGB16, RGBA8};
-
-use crate::PngError;
-
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 /// The color type used to represent this image
 pub enum ColorType {
    /// Grayscale, with one color channel
-    Grayscale {
-        /// Optional shade of gray that should be rendered as transparent
-        transparent_shade: Option<u16>,
-    },
+    Grayscale,
    /// RGB, with three color channels
-    RGB {
-        /// Optional color value that should be rendered as transparent
-        transparent_color: Option<RGB16>,
-    },
-    /// Indexed, with one byte per pixel representing a color from the palette
-    Indexed {
-        /// The palette containing the colors used, up to 256 entries
-        palette: Vec<RGBA8>,
-    },
+    RGB,
+    /// Indexed, with one byte per pixel representing one of up to 256 colors in the image
+    Indexed,
    /// Grayscale + Alpha, with two color channels
    GrayscaleAlpha,
    /// RGBA, with four color channels
    RGBA,
 }

-impl Display for ColorType {
+impl fmt::Display for ColorType {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Grayscale { .. } => write!(f, "Grayscale"),
-            Self::RGB { .. } => write!(f, "RGB"),
-            Self::Indexed { palette } => write!(f, "Indexed ({} colors)", palette.len()),
-            Self::GrayscaleAlpha => write!(f, "Grayscale + Alpha"),
-            Self::RGBA => write!(f, "RGB + Alpha"),
-        }
+        write!(
+            f,
+            "{}",
+            match *self {
+                ColorType::Grayscale => "Grayscale",
+                ColorType::RGB => "RGB",
+                ColorType::Indexed => "Indexed",
+                ColorType::GrayscaleAlpha => "Grayscale + Alpha",
+                ColorType::RGBA => "RGB + Alpha",
+            }
+        )
    }
 }

 impl ColorType {
    /// Get the code used by the PNG specification to denote this color type
    #[inline]
-    #[must_use]
-    pub const fn png_header_code(&self) -> u8 {
+    pub fn png_header_code(self) -> u8 {
        match self {
-            Self::Grayscale { .. } => 0,
-            Self::RGB { .. } => 2,
-            Self::Indexed { .. } => 3,
-            Self::GrayscaleAlpha => 4,
-            Self::RGBA => 6,
+            ColorType::Grayscale => 0,
+            ColorType::RGB => 2,
+            ColorType::Indexed => 3,
+            ColorType::GrayscaleAlpha => 4,
+            ColorType::RGBA => 6,
        }
    }

    #[inline]
-    pub(crate) const fn channels_per_pixel(&self) -> u8 {
+    pub fn channels_per_pixel(self) -> u8 {
        match self {
-            Self::Grayscale { .. } | Self::Indexed { .. } => 1,
-            Self::GrayscaleAlpha => 2,
-            Self::RGB { .. } => 3,
-            Self::RGBA => 4,
-        }
-    }
-
-    #[inline]
-    pub(crate) const fn is_rgb(&self) -> bool {
-        matches!(self, Self::RGB { .. } | Self::RGBA)
-    }
-
-    #[inline]
-    pub(crate) const fn is_gray(&self) -> bool {
-        matches!(self, Self::Grayscale { .. } | Self::GrayscaleAlpha)
-    }
-
-    #[inline]
-    pub(crate) const fn has_alpha(&self) -> bool {
-        matches!(self, Self::GrayscaleAlpha | Self::RGBA)
-    }
-
-    #[inline]
-    pub(crate) const fn has_trns(&self) -> bool {
-        match self {
-            Self::Grayscale { transparent_shade } => transparent_shade.is_some(),
-            Self::RGB { transparent_color } => transparent_color.is_some(),
-            _ => false,
+            ColorType::Grayscale | ColorType::Indexed => 1,
+            ColorType::GrayscaleAlpha => 2,
+            ColorType::RGB => 3,
+            ColorType::RGBA => 4,
        }
    }
 }

-#[repr(u8)]
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 /// The number of bits to be used per channel per pixel
 pub enum BitDepth {
    /// One bit per channel per pixel
-    One = 1,
+    One,
    /// Two bits per channel per pixel
-    Two = 2,
+    Two,
    /// Four bits per channel per pixel
-    Four = 4,
+    Four,
    /// Eight bits per channel per pixel
-    Eight = 8,
+    Eight,
    /// Sixteen bits per channel per pixel
-    Sixteen = 16,
+    Sixteen,
 }

-impl TryFrom<u8> for BitDepth {
-    type Error = PngError;
+impl fmt::Display for BitDepth {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}",
+            match *self {
+                BitDepth::One => "1",
+                BitDepth::Two => "2",
+                BitDepth::Four => "4",
+                BitDepth::Eight => "8",
+                BitDepth::Sixteen => "16",
+            }
+        )
+    }
+}

-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            1 => Ok(Self::One),
-            2 => Ok(Self::Two),
-            4 => Ok(Self::Four),
-            8 => Ok(Self::Eight),
-            16 => Ok(Self::Sixteen),
-            _ => Err(PngError::InvalidData),
+impl BitDepth {
+    /// Retrieve the number of bits per channel per pixel as a `u8`
+    #[inline]
+    pub fn as_u8(self) -> u8 {
+        match self {
+            BitDepth::One => 1,
+            BitDepth::Two => 2,
+            BitDepth::Four => 4,
+            BitDepth::Eight => 8,
+            BitDepth::Sixteen => 16,
+        }
+    }
+    /// Parse a number of bits per channel per pixel into a `BitDepth`
+    ///
+    /// # Panics
+    ///
+    /// If depth is unsupported
+    #[inline]
+    pub fn from_u8(depth: u8) -> BitDepth {
+        match depth {
+            1 => BitDepth::One,
+            2 => BitDepth::Two,
+            4 => BitDepth::Four,
+            8 => BitDepth::Eight,
+            16 => BitDepth::Sixteen,
+            _ => panic!("Unsupported bit depth"),
        }
    }
 }
-
-impl Display for BitDepth {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Display::fmt(&(*self as u8).to_string(), f)
-    }
-}
--- a/src/deflate/deflater.rs
+++ b/src/deflate/deflater.rs
@ -1,16 +1,25 @@
+use crate::atomicmin::AtomicMin;
+use crate::{PngError, PngResult};
 use libdeflater::*;

-use crate::{PngError, PngResult};
-
-pub fn deflate(data: &[u8], level: u8, max_size: Option<usize>) -> PngResult<Vec<u8>> {
+pub fn deflate(data: &[u8], level: u8, max_size: &AtomicMin) -> PngResult<Vec<u8>> {
    let mut compressor = Compressor::new(CompressionLvl::new(level.into()).unwrap());
-    let capacity = max_size.unwrap_or_else(|| compressor.zlib_compress_bound(data.len()));
+    // If adhering to a max_size we need to include at least 9 extra bytes of slack space (as specified in docs).
+    let capacity = max_size
+        .get()
+        .unwrap_or_else(|| compressor.zlib_compress_bound(data.len()))
+        + 9;
    let mut dest = vec![0; capacity];
    let len = compressor
        .zlib_compress(data, &mut dest)
        .map_err(|err| match err {
            CompressionError::InsufficientSpace => PngError::DeflatedDataTooLong(capacity),
        })?;
+    if let Some(max) = max_size.get() {
+        if len > max {
+            return Err(PngError::DeflatedDataTooLong(max));
+        }
+    }
    dest.truncate(len);
    Ok(dest)
 }
@ -22,13 +31,12 @@ pub fn inflate(data: &[u8], out_size: usize) -> PngResult<Vec<u8>> {
        .zlib_decompress(data, &mut dest)
        .map_err(|err| match err {
            DecompressionError::BadData => PngError::InvalidData,
-            DecompressionError::InsufficientSpace => PngError::InflatedDataTooLong(out_size),
+            DecompressionError::InsufficientSpace => PngError::new("inflated data too long"),
        })?;
    dest.truncate(len);
    Ok(dest)
 }

-#[must_use]
 pub fn crc32(data: &[u8]) -> u32 {
    let mut crc = Crc::new();
    crc.update(data);
--- a/src/deflate/mod.rs
+++ b/src/deflate/mod.rs
@ -1,53 +1,29 @@
 mod deflater;
-use std::{fmt, fmt::Display};
-
-pub use deflater::{crc32, deflate, inflate};
-
-use crate::{PngError, PngResult};
+pub use deflater::crc32;
+pub use deflater::deflate;
+pub use deflater::inflate;

+#[cfg(feature = "zopfli")]
+use std::num::NonZeroU8;
 #[cfg(feature = "zopfli")]
 mod zopfli_oxipng;
 #[cfg(feature = "zopfli")]
-pub use zopfli::Options as ZopfliOptions;
-#[cfg(feature = "zopfli")]
 pub use zopfli_oxipng::deflate as zopfli_deflate;

-/// DEFLATE algorithms supported by oxipng (for use in [`Options`][crate::Options])
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Deflater {
+/// DEFLATE algorithms supported by oxipng
+pub enum Deflaters {
    /// Use libdeflater.
    Libdeflater {
-        /// Which compression level to use on the file (0-12)
+        /// Which compression level to use on the file (1-12)
        compression: u8,
    },
    #[cfg(feature = "zopfli")]
    /// Use the better but slower Zopfli implementation
-    Zopfli(ZopfliOptions),
-}
-
-impl Deflater {
-    pub(crate) fn deflate(self, data: &[u8], max_size: Option<usize>) -> PngResult<Vec<u8>> {
-        let compressed = match self {
-            Self::Libdeflater { compression } => deflate(data, compression, max_size)?,
-            #[cfg(feature = "zopfli")]
-            Self::Zopfli(options) => zopfli_deflate(data, options)?,
-        };
-        if let Some(max) = max_size {
-            if compressed.len() > max {
-                return Err(PngError::DeflatedDataTooLong(max));
-            }
-        }
-        Ok(compressed)
-    }
-}
-
-impl Display for Deflater {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Libdeflater { compression } => write!(f, "zc = {compression}"),
-            #[cfg(feature = "zopfli")]
-            Self::Zopfli(options) => write!(f, "zopfli, zi = {}", options.iteration_count),
-        }
-    }
+    Zopfli {
+        /// The number of compression iterations to do. 15 iterations are fine
+        /// for small files, but bigger files will need to be compressed with
+        /// less iterations, or else they will be too slow.
+        iterations: NonZeroU8,
+    },
 }
--- a/src/deflate/zopfli_oxipng.rs
+++ b/src/deflate/zopfli_oxipng.rs
@ -1,13 +1,18 @@
 use crate::{PngError, PngResult};
+use std::num::NonZeroU8;

-pub fn deflate(data: &[u8], options: zopfli::Options) -> PngResult<Vec<u8>> {
-    let mut output = Vec::with_capacity(data.len());
-    // Since Rust v1.74, passing &[u8] directly into zopfli causes a regression in compressed size
-    // for some files. Wrapping the slice in another Read implementer such as Box fixes it for now.
-    match zopfli::compress(options, zopfli::Format::Zlib, Box::new(data), &mut output) {
-        Ok(()) => (),
+pub fn deflate(data: &[u8], iterations: NonZeroU8) -> PngResult<Vec<u8>> {
+    use std::cmp::max;
+
+    let mut output = Vec::with_capacity(max(1024, data.len() / 20));
+    let options = zopfli::Options {
+        iteration_count: iterations,
+        ..Default::default()
+    };
+    match zopfli::compress(&options, &zopfli::Format::Zlib, data, &mut output) {
+        Ok(_) => (),
        Err(_) => return Err(PngError::new("Failed to compress in zopfli")),
-    }
+    };
    output.shrink_to_fit();
    Ok(output)
 }
--- a/src/display_chunks.rs
+++ b/src/display_chunks.rs
@ -1,4 +0,0 @@
-/// List of chunks that affect image display and will be kept when using the `Safe` chunk strip option
-pub const DISPLAY_CHUNKS: [[u8; 4]; 7] = [
-    *b"cICP", *b"iCCP", *b"sRGB", *b"pHYs", *b"acTL", *b"fcTL", *b"fdAT",
-];
--- a/src/error.rs
+++ b/src/error.rs
@ -1,23 +1,16 @@
-use std::{error::Error, fmt};
+use std::error::Error;
+use std::fmt;

-use crate::colors::{BitDepth, ColorType};
-
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[non_exhaustive]
 pub enum PngError {
-    APNGOutOfOrder,
-    C2PAMetadataPreventsChanges,
-    ChunkMissing(&'static str),
-    CRCMismatch([u8; 4]),
    DeflatedDataTooLong(usize),
-    IncorrectDataLength(usize, usize),
-    InflatedDataTooLong(usize),
-    InvalidData,
-    InvalidDepthForType(BitDepth, ColorType),
+    TimedOut,
    NotPNG,
-    ReadFailed(String, std::io::Error),
+    APNGNotSupported,
+    InvalidData,
    TruncatedData,
-    WriteFailed(String, std::io::Error),
+    ChunkMissing(&'static str),
    Other(Box<str>),
 }

@ -28,42 +21,23 @@ impl fmt::Display for PngError {
    #[cold]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
-            Self::APNGOutOfOrder => f.write_str("APNG chunks are out of order"),
-            Self::C2PAMetadataPreventsChanges => f.write_str(
-                "The image contains C2PA manifest that would be invalidated by any file changes",
-            ),
-            Self::ChunkMissing(s) => write!(f, "Chunk {s} missing or empty"),
-            Self::CRCMismatch(ref c) => write!(
-                f,
-                "CRC mismatch in {} chunk; May be recoverable by using --fix",
-                String::from_utf8_lossy(c)
-            ),
-            Self::DeflatedDataTooLong(_) => f.write_str("Deflated data too long"),
-            Self::IncorrectDataLength(l1, l2) => write!(
-                f,
-                "Data length {l1} does not match the expected length {l2}"
-            ),
-            Self::InflatedDataTooLong(max) => write!(
-                f,
-                "Inflated data would exceed the maximum size ({max} bytes)"
-            ),
-            Self::InvalidData => f.write_str("Invalid data found; unable to read PNG file"),
-            Self::InvalidDepthForType(d, ref c) => {
-                write!(f, "Invalid bit depth {d} for color type {c}")
+            PngError::DeflatedDataTooLong(_) => f.write_str("deflated data too long"),
+            PngError::TimedOut => f.write_str("timed out"),
+            PngError::NotPNG => f.write_str("Invalid header detected; Not a PNG file"),
+            PngError::InvalidData => f.write_str("Invalid data found; unable to read PNG file"),
+            PngError::TruncatedData => {
+                f.write_str("Missing data in the file; the file is truncated")
            }
-            Self::NotPNG => f.write_str("Invalid header detected; Not a PNG file"),
-            Self::ReadFailed(ref s, ref e) => write!(f, "Failed to read from {s}: {e}"),
-            Self::TruncatedData => f.write_str("Missing data in the file; the file is truncated"),
-            Self::WriteFailed(ref s, ref e) => write!(f, "Failed to write to {s}: {e}"),
-            Self::Other(ref s) => f.write_str(s),
+            PngError::APNGNotSupported => f.write_str("APNG files are not (yet) supported"),
+            PngError::ChunkMissing(s) => write!(f, "Chunk {} missing or empty", s),
+            PngError::Other(ref s) => f.write_str(s),
        }
    }
 }

 impl PngError {
    #[cold]
-    #[must_use]
-    pub fn new(description: &str) -> Self {
-        Self::Other(description.into())
+    pub fn new(description: &str) -> PngError {
+        PngError::Other(description.into())
    }
 }
--- a/src/evaluate.rs
+++ b/src/evaluate.rs
@ -1,47 +1,40 @@
 //! Check if a reduction makes file smaller, and keep best reductions.
 //! Works asynchronously when possible

-#[cfg(not(feature = "parallel"))]
-use std::cell::RefCell;
-use std::sync::{
-    Arc,
-    atomic::{AtomicUsize, Ordering::*},
-};
-
-use deflate::Deflater;
-use indexmap::IndexSet;
-use log::trace;
-use rayon::prelude::*;
-#[cfg(feature = "parallel")]
-use std::sync::mpsc::{Receiver, Sender, channel};
-
+use crate::atomicmin::AtomicMin;
+use crate::deflate;
+use crate::filters::RowFilter;
+use crate::png::PngData;
+use crate::png::PngImage;
 #[cfg(not(feature = "parallel"))]
 use crate::rayon;
-use crate::{
-    Deadline, PngError, atomicmin::AtomicMin, deflate, filters::FilterStrategy, png::PngImage,
-};
+use crate::Deadline;
+#[cfg(feature = "parallel")]
+use crossbeam_channel::{unbounded, Receiver, Sender};
+use indexmap::IndexSet;
+use rayon::prelude::*;
+#[cfg(not(feature = "parallel"))]
+use std::cell::RefCell;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::SeqCst;
+use std::sync::Arc;

-pub(crate) struct Candidate {
-    pub image: Arc<PngImage>,
-    pub idat_data: Option<Vec<u8>>,
-    pub estimated_output_size: usize,
-    /// The input filter, which is retained for printing and for APNG frames.
-    pub filter: FilterStrategy,
-    /// The filter returned by the filter function, which may be Predefined.
-    /// Use this for the next round to avoid recomputing the filter.
-    pub filter_used: FilterStrategy,
-    /// For determining tie-breaker
+pub struct Candidate {
+    pub image: PngData,
+    pub filter: RowFilter,
+    pub is_reduction: bool,
+    // first wins tie-breaker
    nth: usize,
 }

 impl Candidate {
-    fn cmp_key(&self) -> impl Ord + use<> {
+    fn cmp_key(&self) -> impl Ord {
        (
-            self.estimated_output_size,
-            self.image.data.len(),
-            self.filter.clone(),
-            // Prefer the later image added (e.g. baseline, which is always added last)
-            usize::MAX - self.nth,
+            self.image.idat_data.len(),
+            self.image.raw.data.len(),
+            self.image.raw.ihdr.bit_depth,
+            self.filter,
+            self.nth,
        )
    }
 }
@ -49,12 +42,10 @@ impl Candidate {
 /// Collect image versions and pick one that compresses best
 pub(crate) struct Evaluator {
    deadline: Arc<Deadline>,
-    filters: IndexSet<FilterStrategy>,
-    deflater: Deflater,
+    filters: IndexSet<RowFilter>,
+    compression: u8,
    optimize_alpha: bool,
-    final_round: bool,
    nth: AtomicUsize,
-    executed: Arc<AtomicUsize>,
    best_candidate_size: Arc<AtomicMin>,
    /// images are sent to the caller thread for evaluation
    #[cfg(feature = "parallel")]
@ -67,22 +58,19 @@ pub(crate) struct Evaluator {
 impl Evaluator {
    pub fn new(
        deadline: Arc<Deadline>,
-        filters: IndexSet<FilterStrategy>,
-        deflater: Deflater,
+        filters: IndexSet<RowFilter>,
+        compression: u8,
        optimize_alpha: bool,
-        final_round: bool,
    ) -> Self {
        #[cfg(feature = "parallel")]
-        let eval_channel = channel();
+        let eval_channel = unbounded();
        Self {
            deadline,
            filters,
-            deflater,
+            compression,
            optimize_alpha,
-            final_round,
-            nth: AtomicUsize::new(0),
-            executed: Arc::new(AtomicUsize::new(0)),
            best_candidate_size: Arc::new(AtomicMin::new(None)),
+            nth: AtomicUsize::new(0),
            #[cfg(feature = "parallel")]
            eval_channel,
            #[cfg(not(feature = "parallel"))]
@ -91,18 +79,11 @@ impl Evaluator {
    }

    /// Wait for all evaluations to finish and return smallest reduction
-    /// Or `None` if the queue is empty.
+    /// Or `None` if all reductions were worse than baseline.
    #[cfg(feature = "parallel")]
    pub fn get_best_candidate(self) -> Option<Candidate> {
        let (eval_send, eval_recv) = self.eval_channel;
-        // Disconnect the sender, breaking the loop in the thread
-        drop(eval_send);
-        let nth = self.nth.load(SeqCst);
-        // Yield to ensure all evaluations are executed
-        // This can prevent deadlocks when run within an existing rayon thread pool
-        while self.executed.load(Relaxed) < nth {
-            rayon::yield_local();
-        }
+        drop(eval_send); // disconnect the sender, breaking the loop in the thread
        eval_recv.into_iter().min_by_key(Candidate::cmp_key)
    }

@ -111,6 +92,11 @@ impl Evaluator {
        self.eval_best_candidate.into_inner()
    }

+    /// Set baseline image. It will be used only to measure minimum compression level required
+    pub fn set_baseline(&self, image: Arc<PngImage>) {
+        self.try_image_inner(image, false)
+    }
+
    /// Set best size, if known in advance
    pub fn set_best_size(&self, size: usize) {
        self.best_candidate_size.set_min(size);
@ -118,65 +104,47 @@ impl Evaluator {

    /// Check if the image is smaller than others
    pub fn try_image(&self, image: Arc<PngImage>) {
-        let description = image.ihdr.color_type.to_string();
-        self.try_image_with_description(image, &description);
+        self.try_image_inner(image, true)
    }

-    /// Check if the image is smaller than others, with a description for verbose mode
-    pub fn try_image_with_description(&self, image: Arc<PngImage>, description: &str) {
+    fn try_image_inner(&self, image: Arc<PngImage>, is_reduction: bool) {
        let nth = self.nth.fetch_add(1, SeqCst);
        // These clones are only cheap refcounts
        let deadline = self.deadline.clone();
        let filters = self.filters.clone();
-        let deflater = self.deflater;
+        let compression = self.compression;
        let optimize_alpha = self.optimize_alpha;
-        let final_round = self.final_round;
-        let executed = self.executed.clone();
        let best_candidate_size = self.best_candidate_size.clone();
-        let description = description.to_string();
        // sends it off asynchronously for compression,
        // but results will be collected via the message queue
        #[cfg(feature = "parallel")]
        let eval_send = self.eval_channel.0.clone();
        rayon::spawn(move || {
-            executed.fetch_add(1, Relaxed);
            let filters_iter = filters.par_iter().with_max_len(1);

            // Updating of best result inside the parallel loop would require locks,
            // which are dangerous to do in side Rayon's loop.
            // Instead, only update (atomic) best size in real time,
            // and the best result later without need for locks.
-            filters_iter.for_each(|filter| {
+            filters_iter.for_each(|&filter| {
                if deadline.passed() {
                    return;
                }
-                let (filtered, filter_used) = image.filter_image(filter.clone(), optimize_alpha);
-                let idat_data = deflater.deflate(&filtered, best_candidate_size.get());
-                if let Ok(idat_data) = idat_data {
-                    let estimated_output_size = image.estimated_output_size(&idat_data);
-                    trace!(
-                        "Eval: {}-bit {:23} {:8}   {} bytes",
-                        image.ihdr.bit_depth, description, filter, estimated_output_size
-                    );
-
-                    // Skip if it exceeds best known size. (This is important to ensure
-                    // the evaluator returns no result when all candidates are too large.)
-                    if let Some(max) = best_candidate_size.get() {
-                        if estimated_output_size > max {
-                            return;
-                        }
-                    }
-
-                    // We only need to retain the IDAT data in the final round
+                let filtered = image.filter_image(filter, optimize_alpha);
+                if let Ok(idat_data) =
+                    deflate::deflate(&filtered, compression, &best_candidate_size)
+                {
+                    best_candidate_size.set_min(idat_data.len());
                    let new = Candidate {
-                        image: image.clone(),
-                        idat_data: if final_round { Some(idat_data) } else { None },
-                        estimated_output_size,
-                        filter: filter.clone(),
-                        filter_used,
+                        image: PngData {
+                            idat_data,
+                            filtered,
+                            raw: Arc::clone(&image),
+                        },
+                        filter,
+                        is_reduction,
                        nth,
                    };
-                    best_candidate_size.set_min(estimated_output_size);

                    #[cfg(feature = "parallel")]
                    {
@ -190,11 +158,6 @@ impl Evaluator {
                            best => *best = Some(new),
                        }
                    }
-                } else if let Err(PngError::DeflatedDataTooLong(size)) = idat_data {
-                    trace!(
-                        "Eval: {}-bit {:23} {:8}  >{} bytes",
-                        image.ihdr.bit_depth, description, filter, size
-                    );
                }
            });
        });
--- a/src/filters.rs
+++ b/src/filters.rs
@ -1,67 +1,29 @@
-use std::{fmt, fmt::Display, mem::transmute};
+use std::{fmt::Display, mem::transmute};

-/// Filtering strategy for use in [`Options`][crate::Options]
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Hash)]
-pub enum FilterStrategy {
-    /// Same filter for all rows
-    Basic(RowFilter),
-    /// Minimum sum of absolute differences
-    MinSum,
-    /// Shannon entropy
-    Entropy,
-    /// Count of distinct bigrams
-    Bigrams,
-    /// Shannon entropy of bigrams
-    BigEnt,
-    /// Deflate compression
-    Brute {
-        /// The number of lines to compress at once
-        num_lines: usize,
-        /// The compression level to use (1-12)
-        level: u8,
-    },
-    /// Predefined filter for each row
-    Predefined(Vec<RowFilter>),
-}
+use crate::error::PngError;

-impl FilterStrategy {
-    pub const NONE: Self = Self::Basic(RowFilter::None);
-    pub const SUB: Self = Self::Basic(RowFilter::Sub);
-    pub const UP: Self = Self::Basic(RowFilter::Up);
-    pub const AVERAGE: Self = Self::Basic(RowFilter::Average);
-    pub const PAETH: Self = Self::Basic(RowFilter::Paeth);
-}
-
-impl Display for FilterStrategy {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Basic(filter) => filter.fmt(f),
-            Self::MinSum => "MinSum".fmt(f),
-            Self::Entropy => "Entropy".fmt(f),
-            Self::Bigrams => "Bigrams".fmt(f),
-            Self::BigEnt => "BigEnt".fmt(f),
-            Self::Brute { .. } => "Brute".fmt(f),
-            Self::Predefined(_) => "Predefined".fmt(f),
-        }
-    }
-}
-
-/// PNG delta filters
 #[repr(u8)]
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
 pub enum RowFilter {
+    // Standard filter types
    None,
    Sub,
    Up,
    Average,
    Paeth,
+    // Heuristic strategies
+    MinSum,
+    Entropy,
+    Bigrams,
+    BigEnt,
+    Brute,
 }

 impl TryFrom<u8> for RowFilter {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        if value > 4 {
+        if value > Self::LAST {
            return Err(());
        }
        unsafe { transmute(value as i8) }
@ -69,25 +31,32 @@ impl TryFrom<u8> for RowFilter {
 }

 impl Display for RowFilter {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Display::fmt(
-            match self {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{:8}",
+            match *self {
                Self::None => "None",
                Self::Sub => "Sub",
                Self::Up => "Up",
                Self::Average => "Average",
                Self::Paeth => "Paeth",
-            },
-            f,
+                Self::MinSum => "MinSum",
+                Self::Entropy => "Entropy",
+                Self::Bigrams => "Bigrams",
+                Self::BigEnt => "BigEnt",
+                Self::Brute => "Brute",
+            }
        )
    }
 }

 impl RowFilter {
-    pub(crate) const ALL: [Self; 5] = [Self::None, Self::Sub, Self::Up, Self::Average, Self::Paeth];
-    pub(crate) const SINGLE_LINE: [Self; 2] = [Self::None, Self::Sub];
+    pub const LAST: u8 = Self::Brute as u8;
+    pub const STANDARD: [Self; 5] = [Self::None, Self::Sub, Self::Up, Self::Average, Self::Paeth];
+    pub const SINGLE_LINE: [Self; 2] = [Self::None, Self::Sub];

-    pub(crate) fn filter_line(
+    pub fn filter_line(
        self,
        bpp: usize,
        data: &mut [u8],
@ -127,20 +96,25 @@ impl RowFilter {
            }
            Self::Average => {
                for (i, byte) in data.iter().enumerate() {
-                    buf.push(byte.wrapping_sub(i.checked_sub(bpp).map_or_else(
-                        || prev_line[i] >> 1,
-                        |x| ((u16::from(data[x]) + u16::from(prev_line[i])) >> 1) as u8,
-                    )));
+                    buf.push(match i.checked_sub(bpp) {
+                        Some(x) => byte.wrapping_sub(
+                            ((u16::from(data[x]) + u16::from(prev_line[i])) >> 1) as u8,
+                        ),
+                        None => byte.wrapping_sub(prev_line[i] >> 1),
+                    });
                }
            }
            Self::Paeth => {
                for (i, byte) in data.iter().enumerate() {
-                    buf.push(byte.wrapping_sub(i.checked_sub(bpp).map_or_else(
-                        || prev_line[i],
-                        |x| paeth_predictor(data[x], prev_line[i], prev_line[x]),
-                    )));
+                    buf.push(match i.checked_sub(bpp) {
+                        Some(x) => {
+                            byte.wrapping_sub(paeth_predictor(data[x], prev_line[i], prev_line[x]))
+                        }
+                        None => byte.wrapping_sub(prev_line[i]),
+                    });
                }
            }
+            _ => unreachable!(),
        }
    }

@ -151,8 +125,8 @@ impl RowFilter {
            return;
        }

-        let mut pixels: Vec<_> = data.chunks_exact_mut(bpp).collect();
-        let prev_pixels: Vec<_> = prev_line.chunks_exact(bpp).collect();
+        let mut pixels: Vec<_> = data.chunks_mut(bpp).collect();
+        let prev_pixels: Vec<_> = prev_line.chunks(bpp).collect();
        for i in 0..pixels.len() {
            if pixels[i].iter().skip(color_bytes).all(|b| *b == 0) {
                // If the first pixel in the row is transparent, find the next non-transparent pixel and pretend
@ -164,28 +138,10 @@ impl RowFilter {
                        .unwrap_or(i),
                    _ => i - 1,
                };
-
-                // These assertions help eliminate a few bounds checks in the slice accesses below
-                assert!(prev < pixels.len());
-                assert!(i < prev_pixels.len());
-
                match self {
-                    Self::None => unreachable!(),
                    Self::Sub => {
-                        // The code below is roughly equivalent to pixels[i][0..color_bytes].copy_from_slice(&pixels[prev][0..color_bytes]),
-                        // if such a thing was possible to do without violating Rust aliasing rules. See:
-                        // https://users.rust-lang.org/t/problem-borrowing-two-elements-of-vec-mutably/21446/2
-
-                        if prev < i {
-                            let (pixels_head, pixels_tail) = pixels.split_at_mut(prev + 1);
-                            pixels_tail[i - prev - 1][0..color_bytes]
-                                .copy_from_slice(&pixels_head[prev][0..color_bytes]);
-                        } else if prev > i {
-                            let (pixels_head, pixels_tail) = pixels.split_at_mut(i + 1);
-                            pixels_head[i][0..color_bytes]
-                                .copy_from_slice(&pixels_tail[prev - i - 1][0..color_bytes]);
-                        } else {
-                            // If prev == i, we'd be copying the pixels onto themselves, which is useless
+                        for j in 0..color_bytes {
+                            pixels[i][j] = pixels[prev][j];
                        }
                    }
                    Self::Up => {
@ -214,18 +170,19 @@ impl RowFilter {
                            };
                        }
                    }
+                    _ => unreachable!(),
                }
            }
        }
    }

-    pub(crate) fn unfilter_line(
+    pub fn unfilter_line(
        self,
        bpp: usize,
        data: &[u8],
        prev_line: &[u8],
        buf: &mut Vec<u8>,
-    ) {
+    ) -> Result<(), PngError> {
        buf.clear();
        buf.reserve(data.len());
        assert!(data.len() >= bpp);
@ -237,7 +194,10 @@ impl RowFilter {
            Self::Sub => {
                for (i, &cur) in data.iter().enumerate() {
                    let prev_byte = i.checked_sub(bpp).and_then(|x| buf.get(x).copied());
-                    buf.push(prev_byte.map_or(cur, |b| cur.wrapping_add(b)));
+                    buf.push(match prev_byte {
+                        Some(b) => cur.wrapping_add(b),
+                        None => cur,
+                    });
                }
            }
            Self::Up => {
@ -250,10 +210,10 @@ impl RowFilter {
            Self::Average => {
                for (i, (&cur, &last)) in data.iter().zip(prev_line).enumerate() {
                    let prev_byte = i.checked_sub(bpp).and_then(|x| buf.get(x).copied());
-                    buf.push(cur.wrapping_add(prev_byte.map_or_else(
-                        || last >> 1,
-                        |b| ((u16::from(b) + u16::from(last)) >> 1) as u8,
-                    )));
+                    buf.push(match prev_byte {
+                        Some(b) => cur.wrapping_add(((u16::from(b) + u16::from(last)) >> 1) as u8),
+                        None => cur.wrapping_add(last >> 1),
+                    });
                }
            }
            Self::Paeth => {
@ -271,7 +231,9 @@ impl RowFilter {
                    );
                }
            }
+            _ => return Err(PngError::InvalidData),
        }
+        Ok(())
    }
 }

--- a/src/headers.rs
+++ b/src/headers.rs
@ -1,16 +1,13 @@
+use crate::colors::{BitDepth, ColorType};
+use crate::deflate::crc32;
+use crate::error::PngError;
+use crate::interlace::Interlacing;
+use crate::PngResult;
 use indexmap::IndexSet;
-use log::{debug, trace, warn};
-use rgb::{RGB16, RGBA8};
+use std::io;
+use std::io::{Cursor, Read};

-use crate::{
-    Deflater, Options, PngResult,
-    colors::{BitDepth, ColorType},
-    deflate::{crc32, inflate},
-    display_chunks::DISPLAY_CHUNKS,
-    error::PngError,
-};
-
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 /// Headers from the IHDR chunk of the image
 pub struct IhdrData {
    /// The width of the image in pixels
@ -21,30 +18,36 @@ pub struct IhdrData {
    pub color_type: ColorType,
    /// The bit depth of the image
    pub bit_depth: BitDepth,
-    /// Whether the image is interlaced
-    pub interlaced: bool,
+    /// The compression method used for this image (0 for DEFLATE)
+    pub compression: u8,
+    /// The filter mode used for this image (currently only 0 is valid)
+    pub filter: u8,
+    /// The interlacing mode of the image
+    pub interlaced: Interlacing,
 }

 impl IhdrData {
    /// Bits per pixel
    #[must_use]
    #[inline]
-    pub const fn bpp(&self) -> usize {
-        self.bit_depth as usize * self.color_type.channels_per_pixel() as usize
+    pub fn bpp(&self) -> u8 {
+        self.bit_depth.as_u8() * self.color_type.channels_per_pixel()
    }

    /// Byte length of IDAT that is correct for this IHDR
    #[must_use]
-    pub const fn raw_data_size(&self) -> usize {
+    pub fn raw_data_size(&self) -> usize {
        let w = self.width as usize;
        let h = self.height as usize;
        let bpp = self.bpp();

-        const fn bitmap_size(bpp: usize, w: usize, h: usize) -> usize {
-            (w * bpp).div_ceil(8) * h
+        fn bitmap_size(bpp: u8, w: usize, h: usize) -> usize {
+            (((w / 8) * bpp as usize) + ((w & 7) * bpp as usize + 7) / 8) * h
        }

-        if self.interlaced {
+        if self.interlaced == Interlacing::None {
+            bitmap_size(bpp, w, h) + h
+        } else {
            let mut size = bitmap_size(bpp, (w + 7) >> 3, (h + 7) >> 3) + ((h + 7) >> 3);
            if w > 4 {
                size += bitmap_size(bpp, (w + 3) >> 3, (h + 7) >> 3) + ((h + 7) >> 3);
@ -58,47 +61,25 @@ impl IhdrData {
                size += bitmap_size(bpp, w >> 1, (h + 1) >> 1) + ((h + 1) >> 1);
            }
            size + bitmap_size(bpp, w, h >> 1) + (h >> 1)
-        } else {
-            bitmap_size(bpp, w, h) + h
        }
    }
 }

-#[derive(Debug, Clone)]
-pub struct Chunk {
-    pub name: [u8; 4],
-    pub data: Vec<u8>,
-}
-
-/// [`Options`][crate::Options] to use when stripping chunks (metadata)
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub enum StripChunks {
+/// Options to use for performing operations on headers (such as stripping)
+pub enum Headers {
    /// None
-    ///
-    /// ...except caBX chunk if it contains a C2PA.org signature.
    None,
    /// Remove specific chunks
-    Strip(IndexSet<[u8; 4]>),
-    /// Remove all chunks that won't affect image display
+    Strip(Vec<String>),
+    /// Headers that won't affect rendering (all but cICP, iCCP, sBIT, sRGB, pHYs)
    Safe,
    /// Remove all non-critical chunks except these
-    Keep(IndexSet<[u8; 4]>),
-    /// All non-critical chunks
+    Keep(IndexSet<String>),
+    /// All non-critical headers
    All,
 }

-impl StripChunks {
-    pub(crate) fn keep(&self, name: &[u8; 4]) -> bool {
-        match &self {
-            Self::None => true,
-            Self::Keep(names) => names.contains(name),
-            Self::Strip(names) => !names.contains(name),
-            Self::Safe => DISPLAY_CHUNKS.contains(name),
-            Self::All => false,
-        }
-    }
-}
-
 #[inline]
 pub fn file_header_is_valid(bytes: &[u8]) -> bool {
    let expected_header: [u8; 8] = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
@ -107,319 +88,93 @@ pub fn file_header_is_valid(bytes: &[u8]) -> bool {
 }

 #[derive(Debug, Clone, Copy)]
-pub struct RawChunk<'a> {
+pub struct RawHeader<'a> {
    pub name: [u8; 4],
    pub data: &'a [u8],
 }

-impl RawChunk<'_> {
-    // Is it a chunk for C2PA/CAI JUMBF metadata
-    pub(crate) fn is_c2pa(&self) -> bool {
-        if self.name == *b"caBX" {
-            if let Some((b"jumb", data)) = parse_jumbf_box(self.data) {
-                if let Some((b"jumd", data)) = parse_jumbf_box(data) {
-                    if data.get(..4) == Some(b"c2pa") {
-                        return true;
-                    }
-                }
-            }
-        }
-        false
-    }
-}
-
-fn parse_jumbf_box(data: &[u8]) -> Option<(&[u8], &[u8])> {
-    if data.len() < 8 {
-        return None;
-    }
-    let (len, rest) = data.split_at(4);
-    let len = read_be_u32(len) as usize;
-    if len < 8 || len > data.len() {
-        return None;
-    }
-    let (box_name, data) = rest.split_at(4);
-    let data = data.get(..len - 8)?;
-    Some((box_name, data))
-}
-
-pub fn parse_next_chunk<'a>(
+pub fn parse_next_header<'a>(
    byte_data: &'a [u8],
    byte_offset: &mut usize,
    fix_errors: bool,
-) -> PngResult<Option<RawChunk<'a>>> {
-    let length = read_be_u32(
+) -> PngResult<Option<RawHeader<'a>>> {
+    let mut rdr = Cursor::new(
        byte_data
            .get(*byte_offset..*byte_offset + 4)
            .ok_or(PngError::TruncatedData)?,
    );
-    if byte_data.len() < *byte_offset + 12 + length as usize {
-        return Err(PngError::TruncatedData);
-    }
+    let length = read_be_u32(&mut rdr).unwrap();
    *byte_offset += 4;

-    let chunk_start = *byte_offset;
-    let chunk_name = &byte_data[chunk_start..chunk_start + 4];
+    let header_start = *byte_offset;
+    let chunk_name = byte_data
+        .get(header_start..header_start + 4)
+        .ok_or(PngError::TruncatedData)?;
    if chunk_name == b"IEND" {
        // End of data
        return Ok(None);
    }
    *byte_offset += 4;

-    let data = &byte_data[*byte_offset..*byte_offset + length as usize];
+    let data = byte_data
+        .get(*byte_offset..*byte_offset + length as usize)
+        .ok_or(PngError::TruncatedData)?;
    *byte_offset += length as usize;
-    let crc = read_be_u32(&byte_data[*byte_offset..*byte_offset + 4]);
+    let mut rdr = Cursor::new(
+        byte_data
+            .get(*byte_offset..*byte_offset + 4)
+            .ok_or(PngError::TruncatedData)?,
+    );
+    let crc = read_be_u32(&mut rdr).unwrap();
    *byte_offset += 4;

-    let chunk_bytes = &byte_data[chunk_start..chunk_start + 4 + length as usize];
-    if !fix_errors && crc32(chunk_bytes) != crc {
-        return Err(PngError::CRCMismatch(chunk_name.try_into().unwrap()));
+    let header_bytes = byte_data
+        .get(header_start..header_start + 4 + length as usize)
+        .ok_or(PngError::TruncatedData)?;
+    if !fix_errors && crc32(header_bytes) != crc {
+        return Err(PngError::new(&format!(
+            "CRC Mismatch in {} header; May be recoverable by using --fix",
+            String::from_utf8_lossy(chunk_name)
+        )));
    }

-    let name: [u8; 4] = chunk_name.try_into().unwrap();
-    Ok(Some(RawChunk { name, data }))
+    let mut name = [0_u8; 4];
+    name.copy_from_slice(chunk_name);
+    Ok(Some(RawHeader { name, data }))
 }

-pub fn parse_ihdr_chunk(
-    byte_data: &[u8],
-    palette_data: Option<Vec<u8>>,
-    trns_data: Option<Vec<u8>>,
-) -> PngResult<IhdrData> {
+pub fn parse_ihdr_header(byte_data: &[u8]) -> PngResult<IhdrData> {
    // This eliminates bounds checks for the rest of the function
    let interlaced = byte_data.get(12).copied().ok_or(PngError::TruncatedData)?;
+    let mut rdr = Cursor::new(&byte_data[0..8]);
    Ok(IhdrData {
        color_type: match byte_data[9] {
-            0 => ColorType::Grayscale {
-                transparent_shade: trns_data
-                    .filter(|t| t.len() >= 2)
-                    .map(|t| read_be_u16(&t[0..2])),
-            },
-            2 => ColorType::RGB {
-                transparent_color: trns_data.filter(|t| t.len() >= 6).map(|t| RGB16 {
-                    r: read_be_u16(&t[0..2]),
-                    g: read_be_u16(&t[2..4]),
-                    b: read_be_u16(&t[4..6]),
-                }),
-            },
-            3 => ColorType::Indexed {
-                palette: palette_to_rgba(palette_data, trns_data).unwrap_or_default(),
-            },
+            0 => ColorType::Grayscale,
+            2 => ColorType::RGB,
+            3 => ColorType::Indexed,
            4 => ColorType::GrayscaleAlpha,
            6 => ColorType::RGBA,
-            _ => return Err(PngError::InvalidData),
+            _ => return Err(PngError::new("Unexpected color type in header")),
        },
-        bit_depth: byte_data[8].try_into()?,
-        width: read_be_u32(&byte_data[0..4]),
-        height: read_be_u32(&byte_data[4..8]),
-        interlaced: match interlaced {
-            0 => false,
-            1 => true,
-            _ => return Err(PngError::InvalidData),
+        bit_depth: match byte_data[8] {
+            1 => BitDepth::One,
+            2 => BitDepth::Two,
+            4 => BitDepth::Four,
+            8 => BitDepth::Eight,
+            16 => BitDepth::Sixteen,
+            _ => return Err(PngError::new("Unexpected bit depth in header")),
        },
+        width: read_be_u32(&mut rdr).map_err(|_| PngError::TruncatedData)?,
+        height: read_be_u32(&mut rdr).map_err(|_| PngError::TruncatedData)?,
+        compression: byte_data[10],
+        filter: byte_data[11],
+        interlaced: interlaced.try_into()?,
    })
 }

-/// Construct an RGBA palette from the raw palette and transparency data
-fn palette_to_rgba(
-    palette_data: Option<Vec<u8>>,
-    trns_data: Option<Vec<u8>>,
-) -> Result<Vec<RGBA8>, PngError> {
-    let palette_data = palette_data.ok_or(PngError::ChunkMissing("PLTE"))?;
-    let mut palette: Vec<_> = palette_data
-        .chunks_exact(3)
-        .map(|color| RGBA8::new(color[0], color[1], color[2], 255))
-        .collect();
-
-    if let Some(trns_data) = trns_data {
-        for (color, trns) in palette.iter_mut().zip(trns_data) {
-            color.a = trns;
-        }
-    }
-    Ok(palette)
-}
-
 #[inline]
-pub fn read_be_u16(bytes: &[u8]) -> u16 {
-    u16::from_be_bytes(bytes.try_into().unwrap())
-}
-
-#[inline]
-pub fn read_be_u32(bytes: &[u8]) -> u32 {
-    u32::from_be_bytes(bytes.try_into().unwrap())
-}
-
-/// Extract and decompress the ICC profile from an iCCP chunk
-pub fn extract_icc(iccp: &Chunk, max_size: Option<usize>) -> Option<Vec<u8>> {
-    // Skip (useless) profile name
-    let mut data = iccp.data.as_slice();
-    loop {
-        let (&n, rest) = data.split_first()?;
-        data = rest;
-        if n == 0 {
-            break;
-        }
-    }
-
-    let (&compression_method, compressed_data) = data.split_first()?;
-    if compression_method != 0 {
-        return None; // The profile is supposed to be compressed (method 0)
-    }
-    // Libdeflate works with a fixed size buffer. Since the decompressed size is unknown we have to
-    // guess the required buffer size. We allow a fairly generous 10x factor with a minimum of 1000.
-    let mut out_size = (compressed_data.len() * 10).max(1000);
-    // For sanity, impose a default limit of 1MB.
-    out_size = out_size.min(max_size.unwrap_or(1_000_000));
-    match inflate(compressed_data, out_size) {
-        Ok(icc) => Some(icc),
-        Err(e) => {
-            // Log the error so we can know if the buffer size needs to be adjusted
-            warn!("Failed to decompress icc: {e}");
-            None
-        }
-    }
-}
-
-/// Make an iCCP chunk by compressing the ICC profile
-pub fn make_iccp(icc: &[u8], deflater: Deflater, max_size: Option<usize>) -> PngResult<Chunk> {
-    let mut compressed = deflater.deflate(icc, max_size)?;
-    let mut data = Vec::with_capacity(compressed.len() + 5);
-    data.extend(b"icc"); // Profile name - generally unused, can be anything
-    data.extend([0, 0]); // Null separator, zlib compression method
-    data.append(&mut compressed);
-    Ok(Chunk {
-        name: *b"iCCP",
-        data,
-    })
-}
-
-/// If the profile is sRGB, extracts the rendering intent value from it
-pub fn srgb_rendering_intent(icc_data: &[u8]) -> Option<u8> {
-    let rendering_intent = *icc_data.get(67)?;
-
-    // The known profiles are the same as in libpng's `png_sRGB_checks`.
-    // The Profile ID header of ICC has a fixed layout,
-    // and is supposed to contain MD5 of profile data at this offset
-    match icc_data.get(84..100)? {
-        b"\x29\xf8\x3d\xde\xaf\xf2\x55\xae\x78\x42\xfa\xe4\xca\x83\x39\x0d"
-        | b"\xc9\x5b\xd6\x37\xe9\x5d\x8a\x3b\x0d\xf3\x8f\x99\xc1\x32\x03\x89"
-        | b"\xfc\x66\x33\x78\x37\xe2\x88\x6b\xfd\x72\xe9\x83\x82\x28\xf1\xb8"
-        | b"\x34\x56\x2a\xbf\x99\x4c\xcd\x06\x6d\x2c\x57\x21\xd0\xd6\x8c\x5d" => {
-            Some(rendering_intent)
-        }
-        b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" => {
-            // Known-bad profiles are identified by their CRC
-            match (crc32(icc_data), icc_data.len()) {
-                (0x5d51_29ce, 3024) | (0x182e_a552, 3144) | (0xf29e_526d, 3144) => {
-                    Some(rendering_intent)
-                }
-                _ => None,
-            }
-        }
-        _ => None,
-    }
-}
-
-/// Process aux chunks and potentially adjust options before optimizing
-pub fn preprocess_chunks(aux_chunks: &mut Vec<Chunk>, opts: &mut Options) {
-    let has_srgb = aux_chunks.iter().any(|c| &c.name == b"sRGB");
-    // Grayscale conversion should not be performed if the image is not in the sRGB colorspace
-    // An sRGB profile would need to be stripped on conversion, so disallow if stripping is disabled
-    let mut allow_grayscale = !has_srgb || opts.strip != StripChunks::None;
-
-    if let Some(iccp_idx) = aux_chunks.iter().position(|c| &c.name == b"iCCP") {
-        allow_grayscale = false;
-        // See if we can replace an iCCP chunk with an sRGB chunk
-        let may_replace_iccp = opts.strip != StripChunks::None && opts.strip.keep(b"sRGB");
-        if may_replace_iccp && has_srgb {
-            // Files aren't supposed to have both chunks, so we chose to honor sRGB
-            trace!("Removing iCCP chunk due to conflict with sRGB chunk");
-            aux_chunks.remove(iccp_idx);
-            allow_grayscale = true;
-        } else if let Some(icc) = extract_icc(&aux_chunks[iccp_idx], opts.max_decompressed_size) {
-            let intent = if may_replace_iccp {
-                srgb_rendering_intent(&icc)
-            } else {
-                None
-            };
-            // sRGB-like profile can be replaced with an sRGB chunk with the same rendering intent
-            if let Some(intent) = intent {
-                trace!("Replacing iCCP chunk with equivalent sRGB chunk");
-                aux_chunks[iccp_idx] = Chunk {
-                    name: *b"sRGB",
-                    data: vec![intent],
-                };
-                allow_grayscale = true;
-            } else if opts.idat_recoding {
-                // Try recompressing the profile
-                let cur_len = aux_chunks[iccp_idx].data.len();
-                if let Ok(iccp) = make_iccp(&icc, opts.deflater, Some(cur_len - 1)) {
-                    debug!(
-                        "Recompressed iCCP chunk: {} ({} bytes decrease)",
-                        iccp.data.len(),
-                        cur_len - iccp.data.len()
-                    );
-                    aux_chunks[iccp_idx] = iccp;
-                }
-            }
-        }
-    }
-
-    if !allow_grayscale && opts.grayscale_reduction {
-        debug!("Disabling grayscale reduction due to presence of sRGB or iCCP chunk");
-        opts.grayscale_reduction = false;
-    }
-
-    // Check for APNG by presence of acTL chunk
-    if aux_chunks.iter().any(|c| &c.name == b"acTL") {
-        warn!("APNG detected, disabling all reductions");
-        opts.interlace = None;
-        opts.bit_depth_reduction = false;
-        opts.color_type_reduction = false;
-        opts.palette_reduction = false;
-        opts.grayscale_reduction = false;
-    }
-}
-
-/// Perform cleanup of certain aux chunks after optimization has been completed
-pub fn postprocess_chunks(aux_chunks: &mut Vec<Chunk>, ihdr: &IhdrData, orig_ihdr: &IhdrData) {
-    // If the depth/color type has changed, some chunks may be invalid and should be dropped
-    // While these could potentially be converted, they have no known use case today and are
-    // generally more trouble than they're worth
-    if orig_ihdr.bit_depth != ihdr.bit_depth || orig_ihdr.color_type != ihdr.color_type {
-        aux_chunks.retain(|c| {
-            let invalid = &c.name == b"bKGD" || &c.name == b"sBIT" || &c.name == b"hIST";
-            if invalid {
-                warn!(
-                    "Removing {} chunk as it no longer matches the image data",
-                    std::str::from_utf8(&c.name).unwrap()
-                );
-            }
-            !invalid
-        });
-    }
-
-    // Remove any sRGB or iCCP chunks if the image was converted to or from grayscale
-    if orig_ihdr.color_type.is_gray() != ihdr.color_type.is_gray() {
-        aux_chunks.retain(|c| {
-            let invalid = &c.name == b"sRGB" || &c.name == b"iCCP";
-            if invalid {
-                trace!(
-                    "Removing {} chunk as it no longer matches the color type",
-                    std::str::from_utf8(&c.name).unwrap()
-                );
-            }
-            !invalid
-        });
-    }
-
-    // Remove iDOT which will necessarily be invalid after successful optimization
-    aux_chunks.retain(|c| {
-        let invalid = &c.name == b"iDOT";
-        if invalid {
-            trace!(
-                "Removing {} chunk as it no longer matches the IDAT",
-                std::str::from_utf8(&c.name).unwrap()
-            );
-        }
-        !invalid
-    });
+fn read_be_u32<T: AsRef<[u8]>>(rdr: &mut Cursor<T>) -> Result<u32, io::Error> {
+    let mut int_buf = [0; 4];
+    rdr.read_exact(&mut int_buf)?;
+    Ok(u32::from_be_bytes(int_buf))
 }
--- a/src/interlace.rs
+++ b/src/interlace.rs
@ -1,6 +1,41 @@
+use std::fmt::Display;
+
+use crate::headers::IhdrData;
+use crate::png::PngImage;
+use crate::PngError;
 use bitvec::prelude::*;

-use crate::{headers::IhdrData, png::PngImage};
+#[repr(u8)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum Interlacing {
+    None,
+    Adam7,
+}
+
+impl TryFrom<u8> for Interlacing {
+    type Error = PngError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::None),
+            1 => Ok(Self::Adam7),
+            _ => Err(PngError::new("Unexpected interlacing in header")),
+        }
+    }
+}
+
+impl Display for Interlacing {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match *self {
+                Self::None => "non-interlaced",
+                Self::Adam7 => "interlaced",
+            }
+        )
+    }
+}

 #[must_use]
 pub fn interlace_image(png: &PngImage) -> PngImage {
@ -10,11 +45,11 @@ pub fn interlace_image(png: &PngImage) -> PngImage {
        let bit_vec = line.data.view_bits::<Msb0>();
        for (i, bit) in bit_vec.iter().by_vals().enumerate() {
            // Avoid moving padded 0's into new image
-            if i >= (png.ihdr.width as usize * bits_per_pixel) {
+            if i >= (png.ihdr.width * u32::from(bits_per_pixel)) as usize {
                break;
            }
            // Copy pixels into interlaced passes
-            let pix_modulo = (i / bits_per_pixel) % 8;
+            let pix_modulo = (i / bits_per_pixel as usize) % 8;
            match index % 8 {
                0 => match pix_modulo {
                    0 => passes[0].push(bit),
@ -52,10 +87,12 @@ pub fn interlace_image(png: &PngImage) -> PngImage {
    PngImage {
        data: output,
        ihdr: IhdrData {
-            color_type: png.ihdr.color_type.clone(),
-            interlaced: true,
+            interlaced: Interlacing::Adam7,
            ..png.ihdr
        },
+        aux_headers: png.aux_headers.clone(),
+        palette: png.palette.clone(),
+        transparency_pixel: png.transparency_pixel.clone(),
    }
 }

@ -66,17 +103,19 @@ pub fn deinterlace_image(png: &PngImage) -> PngImage {
            _ => deinterlace_bits(png),
        },
        ihdr: IhdrData {
-            color_type: png.ihdr.color_type.clone(),
-            interlaced: false,
+            interlaced: Interlacing::None,
            ..png.ihdr
        },
+        aux_headers: png.aux_headers.clone(),
+        palette: png.palette.clone(),
+        transparency_pixel: png.transparency_pixel.clone(),
    }
 }

 /// Deinterlace by bits, for images with less than 8bpp
 fn deinterlace_bits(png: &PngImage) -> Vec<u8> {
    let bits_per_pixel = png.ihdr.bpp();
-    let bits_per_line = bits_per_pixel * png.ihdr.width as usize;
+    let bits_per_line = bits_per_pixel as usize * png.ihdr.width as usize;
    // Initialize each output line with blank data
    let mut lines: Vec<BitVec<u8, Msb0>> =
        vec![bitvec![u8, Msb0; 0; bits_per_line]; png.ihdr.height as usize];
@ -85,24 +124,26 @@ fn deinterlace_bits(png: &PngImage) -> Vec<u8> {
    let mut current_y: usize = pass_constants.y_shift as usize;
    for line in png.scan_lines(false) {
        let bit_vec = line.data.view_bits::<Msb0>();
-        let bits_in_line = (png.ihdr.width - u32::from(pass_constants.x_shift))
-            .div_ceil(u32::from(pass_constants.x_step)) as usize
-            * bits_per_pixel;
+        let bits_in_line = ((png.ihdr.width - u32::from(pass_constants.x_shift)
+            + u32::from(pass_constants.x_step)
+            - 1)
+            / u32::from(pass_constants.x_step)) as usize
+            * bits_per_pixel as usize;
        for (i, bit) in bit_vec.iter().by_vals().enumerate() {
            // Avoid moving padded 0's into new image
            if i >= bits_in_line {
                break;
            }
            let current_x: usize = pass_constants.x_shift as usize
-                + (i / bits_per_pixel) * pass_constants.x_step as usize;
+                + (i / bits_per_pixel as usize) * pass_constants.x_step as usize;
            // Copy this bit into the output line
-            let index = (i % bits_per_pixel) + current_x * bits_per_pixel;
+            let index = (i % bits_per_pixel as usize) + current_x * bits_per_pixel as usize;
            lines[current_y].set(index, bit);
        }
        // Calculate the next line and move to next pass if necessary
        current_y += pass_constants.y_step as usize;
        if current_y >= png.ihdr.height as usize {
-            if !increment_pass(&mut current_pass, &png.ihdr) {
+            if !increment_pass(&mut current_pass, png.ihdr) {
                break;
            }
            pass_constants = interlaced_constants(current_pass);
@ -122,7 +163,7 @@ fn deinterlace_bits(png: &PngImage) -> Vec<u8> {
 /// Deinterlace by bytes, for images with at least 8bpp
 fn deinterlace_bytes(png: &PngImage) -> Vec<u8> {
    let bytes_per_pixel = png.ihdr.bpp() / 8;
-    let bytes_per_line = bytes_per_pixel * png.ihdr.width as usize;
+    let bytes_per_line = bytes_per_pixel as usize * png.ihdr.width as usize;
    // Initialize each output line with some blank data
    let mut lines: Vec<Vec<u8>> = vec![vec![0; bytes_per_line]; png.ihdr.height as usize];
    let mut current_pass = 1;
@ -131,15 +172,15 @@ fn deinterlace_bytes(png: &PngImage) -> Vec<u8> {
    for line in png.scan_lines(false) {
        for (i, byte) in line.data.iter().enumerate() {
            let current_x: usize = pass_constants.x_shift as usize
-                + (i / bytes_per_pixel) * pass_constants.x_step as usize;
+                + (i / bytes_per_pixel as usize) * pass_constants.x_step as usize;
            // Copy this byte into the output line
-            let index = (i % bytes_per_pixel) + current_x * bytes_per_pixel;
+            let index = (i % bytes_per_pixel as usize) + current_x * bytes_per_pixel as usize;
            lines[current_y][index] = *byte;
        }
        // Calculate the next line and move to next pass if necessary
        current_y += pass_constants.y_step as usize;
        if current_y >= png.ihdr.height as usize {
-            if !increment_pass(&mut current_pass, &png.ihdr) {
+            if !increment_pass(&mut current_pass, png.ihdr) {
                break;
            }
            pass_constants = interlaced_constants(current_pass);
@ -149,7 +190,7 @@ fn deinterlace_bytes(png: &PngImage) -> Vec<u8> {
    lines.concat()
 }

-const fn increment_pass(current_pass: &mut u8, ihdr: &IhdrData) -> bool {
+fn increment_pass(current_pass: &mut u8, ihdr: IhdrData) -> bool {
    if *current_pass == 7 {
        return false;
    }
--- a/src/lib.rs
+++ b/src/lib.rs
--- a/src/main.rs
+++ b/src/main.rs
--- a/src/options.rs
+++ b/src/options.rs
@ -1,303 +0,0 @@
-use std::{
-    fmt,
-    path::{Path, PathBuf},
-    time::Duration,
-};
-
-use indexmap::{IndexSet, indexset};
-use log::warn;
-
-use crate::{deflate::Deflater, filters::FilterStrategy, headers::StripChunks};
-
-/// Write destination for [`optimize`][crate::optimize].
-/// You can use [`optimize_from_memory`](crate::optimize_from_memory) to avoid external I/O.
-#[derive(Clone, Debug)]
-pub enum OutFile {
-    /// Don't actually write any output, just calculate the best results.
-    None,
-    /// Write output to a file.
-    ///
-    /// * `path`: Path to write the output file. `None` means same as input.
-    /// * `preserve_attrs`: Ensure the output file has the same permissions & timestamps as the input file.
-    Path {
-        path: Option<PathBuf>,
-        preserve_attrs: bool,
-    },
-    /// Write to standard output.
-    StdOut,
-}
-
-impl OutFile {
-    /// Construct a new `OutFile` with the given path.
-    ///
-    /// This is a convenience method for `OutFile::Path { path: Some(path), preserve_attrs: false }`.
-    #[must_use]
-    pub const fn from_path(path: PathBuf) -> Self {
-        Self::Path {
-            path: Some(path),
-            preserve_attrs: false,
-        }
-    }
-
-    #[must_use]
-    pub fn path(&self) -> Option<&Path> {
-        match *self {
-            Self::Path {
-                path: Some(ref p), ..
-            } => Some(p.as_path()),
-            _ => None,
-        }
-    }
-}
-
-/// Where to read images from in [`optimize`][crate::optimize].
-/// You can use [`optimize_from_memory`](crate::optimize_from_memory) to avoid external I/O.
-#[derive(Clone, Debug)]
-pub enum InFile {
-    Path(PathBuf),
-    StdIn,
-}
-
-impl InFile {
-    #[must_use]
-    pub fn path(&self) -> Option<&Path> {
-        match *self {
-            Self::Path(ref p) => Some(p.as_path()),
-            Self::StdIn => None,
-        }
-    }
-}
-
-impl fmt::Display for InFile {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            Self::Path(ref p) => write!(f, "{}", p.display()),
-            Self::StdIn => f.write_str("stdin"),
-        }
-    }
-}
-
-impl<T: Into<PathBuf>> From<T> for InFile {
-    fn from(s: T) -> Self {
-        Self::Path(s.into())
-    }
-}
-
-#[derive(Clone, Debug)]
-/// Options controlling the output of the `optimize` function
-pub struct Options {
-    /// Attempt to fix errors when decoding the input file rather than returning an `Err`.
-    ///
-    /// Default: `false`
-    pub fix_errors: bool,
-    /// Write to output even if there was no improvement in compression.
-    ///
-    /// Default: `false`
-    pub force: bool,
-    /// Which `FilterStrategy` to try on the file
-    ///
-    /// Default: `None,Sub,Entropy,Bigrams`
-    pub filters: IndexSet<FilterStrategy>,
-    /// Whether to change the interlacing of the file.
-    ///
-    /// - `None` will not change the current interlacing.
-    /// - `Some(x)` will turn interlacing on or off.
-    ///
-    /// Default: `Some(false)`
-    pub interlace: Option<bool>,
-    /// Whether to allow transparent pixels to be altered to improve compression.
-    ///
-    /// Default: `false`
-    pub optimize_alpha: bool,
-    /// Whether to attempt bit depth reduction
-    ///
-    /// Default: `true`
-    pub bit_depth_reduction: bool,
-    /// Whether to attempt color type reduction
-    ///
-    /// Default: `true`
-    pub color_type_reduction: bool,
-    /// Whether to attempt palette reduction
-    ///
-    /// Default: `true`
-    pub palette_reduction: bool,
-    /// Whether to attempt grayscale reduction
-    ///
-    /// Default: `true`
-    pub grayscale_reduction: bool,
-    /// Whether to perform recoding of IDAT and other compressed chunks
-    ///
-    /// If any type of reduction is performed, IDAT recoding will be performed
-    /// regardless of this setting
-    ///
-    /// Default: `true`
-    pub idat_recoding: bool,
-    /// Whether to forcibly reduce 16-bit to 8-bit by scaling
-    ///
-    /// Default: `false`
-    pub scale_16: bool,
-    /// Which chunks to strip from the PNG file, if any
-    ///
-    /// Default: `None`
-    pub strip: StripChunks,
-    /// Which DEFLATE (zlib) algorithm to use
-    #[cfg_attr(feature = "zopfli", doc = "(e.g. Zopfli)")]
-    ///
-    /// Default: `Libdeflater`
-    pub deflater: Deflater,
-    /// Whether to use fast evaluation to pick the best filter
-    ///
-    /// Default: `true`
-    pub fast_evaluation: bool,
-    /// Maximum amount of time to spend on optimizations.
-    /// Further potential optimizations are skipped if the timeout is exceeded.
-    ///
-    /// Default: `None`
-    pub timeout: Option<Duration>,
-    /// Maximum decompressed size of the input IDAT.
-    /// If decompression would exceed this size, it will be rejected.
-    ///
-    /// Default: `None`
-    pub max_decompressed_size: Option<usize>,
-}
-
-impl Options {
-    #[must_use]
-    pub fn from_preset(level: u8) -> Self {
-        let opts = Self::default();
-        match level {
-            0 => opts.apply_preset_0(),
-            1 => opts.apply_preset_1(),
-            2 => opts.apply_preset_2(),
-            3 => opts.apply_preset_3(),
-            4 => opts.apply_preset_4(),
-            5 => opts.apply_preset_5(),
-            6 => opts.apply_preset_6(),
-            _ => {
-                warn!("Level 7 and above don't exist yet and are identical to level 6");
-                opts.apply_preset_6()
-            }
-        }
-    }
-
-    #[must_use]
-    pub fn max_compression() -> Self {
-        Self::from_preset(6)
-    }
-
-    // The following methods make assumptions that they are operating
-    // on an `Options` struct generated by the `default` method.
-    fn apply_preset_0(mut self) -> Self {
-        self.filters.clear();
-        self.deflater = Deflater::Libdeflater { compression: 5 };
-        self
-    }
-
-    fn apply_preset_1(mut self) -> Self {
-        self.filters.clear();
-        self.deflater = Deflater::Libdeflater { compression: 10 };
-        self
-    }
-
-    const fn apply_preset_2(self) -> Self {
-        self
-    }
-
-    fn apply_preset_3(mut self) -> Self {
-        self.fast_evaluation = false;
-        self.filters = indexset! {
-            FilterStrategy::NONE,
-            FilterStrategy::Bigrams,
-            FilterStrategy::BigEnt,
-            FilterStrategy::Brute {
-                num_lines: 3,
-                level: 1,
-            },
-        };
-        self
-    }
-
-    fn apply_preset_4(mut self) -> Self {
-        self.fast_evaluation = false;
-        self.filters = indexset! {
-            FilterStrategy::NONE,
-            FilterStrategy::Bigrams,
-            FilterStrategy::BigEnt,
-            FilterStrategy::Brute {
-                num_lines: 4,
-                level: 1,
-            },
-        };
-        self.deflater = Deflater::Libdeflater { compression: 12 };
-        self
-    }
-
-    fn apply_preset_5(mut self) -> Self {
-        self.fast_evaluation = false;
-        self.filters = indexset! {
-            FilterStrategy::NONE,
-            FilterStrategy::SUB,
-            FilterStrategy::UP,
-            FilterStrategy::MinSum,
-            FilterStrategy::Entropy,
-            FilterStrategy::Bigrams,
-            FilterStrategy::BigEnt,
-            FilterStrategy::Brute {
-                num_lines: 4,
-                level: 4,
-            },
-        };
-        self.deflater = Deflater::Libdeflater { compression: 12 };
-        self
-    }
-
-    fn apply_preset_6(mut self) -> Self {
-        self.fast_evaluation = false;
-        self.filters = indexset! {
-            FilterStrategy::NONE,
-            FilterStrategy::SUB,
-            FilterStrategy::UP,
-            FilterStrategy::AVERAGE,
-            FilterStrategy::PAETH,
-            FilterStrategy::MinSum,
-            FilterStrategy::Entropy,
-            FilterStrategy::Bigrams,
-            FilterStrategy::BigEnt,
-            FilterStrategy::Brute {
-                num_lines: 8,
-                level: 5,
-            },
-        };
-        self.deflater = Deflater::Libdeflater { compression: 12 };
-        self
-    }
-}
-
-impl Default for Options {
-    fn default() -> Self {
-        // Default settings based on -o 2 from the CLI interface
-        Self {
-            fix_errors: false,
-            force: false,
-            filters: indexset! {
-                FilterStrategy::NONE,
-                FilterStrategy::SUB,
-                FilterStrategy::Entropy,
-                FilterStrategy::Bigrams
-            },
-            interlace: Some(false),
-            optimize_alpha: false,
-            bit_depth_reduction: true,
-            color_type_reduction: true,
-            palette_reduction: true,
-            grayscale_reduction: true,
-            idat_recoding: true,
-            scale_16: false,
-            strip: StripChunks::None,
-            deflater: Deflater::Libdeflater { compression: 11 },
-            fast_evaluation: true,
-            timeout: None,
-            max_decompressed_size: None,
-        }
-    }
-}
--- a/src/png/mod.rs
+++ b/src/png/mod.rs
@ -1,30 +1,43 @@
-use std::{fs, path::Path, sync::Arc};
-
+use crate::colors::ColorType;
+use crate::deflate;
+use crate::error::PngError;
+use crate::filters::*;
+use crate::headers::*;
+use crate::interlace::{deinterlace_image, interlace_image, Interlacing};
+use bitvec::bitarr;
+use indexmap::IndexMap;
 use libdeflater::{CompressionLvl, Compressor};
-use log::warn;
+use rgb::ComponentSlice;
+use rgb::RGBA8;
 use rustc_hash::FxHashMap;
-
-use crate::{
-    Options, PngResult,
-    apng::*,
-    colors::{BitDepth, ColorType},
-    deflate,
-    error::PngError,
-    filters::*,
-    headers::*,
-    interlace::{deinterlace_image, interlace_image},
-};
+use std::fs::File;
+use std::io::{BufReader, Read, Write};
+use std::iter::Iterator;
+use std::path::Path;
+use std::sync::Arc;

 pub(crate) mod scan_lines;

 use self::scan_lines::ScanLines;

+/// Compression level to use for the Brute filter strategy
+const BRUTE_LEVEL: i32 = 1; // 1 is fastest, 2-4 are not useful, 5 is slower but more effective
+/// Number of lines to compress with the Brute filter strategy
+const BRUTE_LINES: usize = 4; // Values over 8 are generally not useful
+
 #[derive(Debug, Clone)]
 pub struct PngImage {
    /// The headers stored in the IHDR chunk
    pub ihdr: IhdrData,
    /// The uncompressed, unfiltered data from the IDAT chunk
    pub data: Vec<u8>,
+    /// The palette containing colors used in an Indexed image
+    /// Contains 3 bytes per color (R+G+B), up to 768
+    pub palette: Option<Vec<RGBA8>>,
+    /// The pixel value that should be rendered as transparent
+    pub transparency_pixel: Option<Vec<u8>>,
+    /// All non-critical headers from the PNG are stored here
+    pub aux_headers: IndexMap<[u8; 4], Vec<u8>>,
 }

 /// Contains all data relevant to a PNG image
@ -34,27 +47,48 @@ pub struct PngData {
    pub raw: Arc<PngImage>,
    /// The filtered and compressed data of the IDAT chunk
    pub idat_data: Vec<u8>,
-    /// All non-critical chunks from the PNG are stored here
-    pub aux_chunks: Vec<Chunk>,
-    /// APNG frames
-    pub frames: Vec<Frame>,
+    /// The filtered, uncompressed data of the IDAT chunk
+    pub filtered: Vec<u8>,
 }

+type PaletteWithTrns = (Option<Vec<RGBA8>>, Option<Vec<u8>>);
+
 impl PngData {
    /// Create a new `PngData` struct by opening a file
    #[inline]
-    pub fn new(filepath: &Path, opts: &Options) -> PngResult<Self> {
+    pub fn new(filepath: &Path, fix_errors: bool) -> Result<Self, PngError> {
        let byte_data = Self::read_file(filepath)?;

-        Self::from_slice(&byte_data, opts)
+        Self::from_slice(&byte_data, fix_errors)
    }

-    pub fn read_file(filepath: &Path) -> PngResult<Vec<u8>> {
-        fs::read(filepath).map_err(|e| PngError::ReadFailed(filepath.display().to_string(), e))
+    pub fn read_file(filepath: &Path) -> Result<Vec<u8>, PngError> {
+        let file = match File::open(filepath) {
+            Ok(f) => f,
+            Err(_) => return Err(PngError::new("Failed to open file for reading")),
+        };
+        let file_len = file.metadata().map(|m| m.len() as usize).unwrap_or(0);
+        let mut reader = BufReader::new(file);
+        // Check file for PNG header
+        let mut header = [0; 8];
+        if reader.read_exact(&mut header).is_err() {
+            return Err(PngError::new("Not a PNG file: too small"));
+        }
+        if !file_header_is_valid(&header) {
+            return Err(PngError::new("Invalid PNG header detected"));
+        }
+        // Read raw png data into memory
+        let mut byte_data: Vec<u8> = Vec::with_capacity(file_len);
+        byte_data.extend_from_slice(&header);
+        match reader.read_to_end(&mut byte_data) {
+            Ok(_) => (),
+            Err(_) => return Err(PngError::new("Failed to read from file")),
+        }
+        Ok(byte_data)
    }

    /// Create a new `PngData` struct by reading a slice
-    pub fn from_slice(byte_data: &[u8], opts: &Options) -> PngResult<Self> {
+    pub fn from_slice(byte_data: &[u8], fix_errors: bool) -> Result<Self, PngError> {
        let mut byte_offset: usize = 0;
        // Test that png header is valid
        let header = byte_data.get(0..8).ok_or(PngError::TruncatedData)?;
@ -62,182 +96,154 @@ impl PngData {
            return Err(PngError::NotPNG);
        }
        byte_offset += 8;
-
-        // Read the data chunks
-        let mut idat_data: Vec<u8> = Vec::new();
-        let mut key_chunks: FxHashMap<[u8; 4], Vec<u8>> = FxHashMap::default();
-        let mut aux_chunks: Vec<Chunk> = Vec::new();
-        let mut frames: Vec<Frame> = Vec::new();
-        let mut sequence_number = 0;
-        while let Some(chunk) = parse_next_chunk(byte_data, &mut byte_offset, opts.fix_errors)? {
-            match &chunk.name {
-                b"IDAT" => {
-                    if idat_data.is_empty() {
-                        // Keep track of where the first IDAT sits relative to other chunks
-                        aux_chunks.push(Chunk {
-                            name: chunk.name,
-                            data: Vec::new(),
-                        });
-                    }
-                    idat_data.extend_from_slice(chunk.data);
+        // Read the data headers
+        let mut aux_headers: IndexMap<[u8; 4], Vec<u8>> = IndexMap::new();
+        let mut idat_headers: Vec<u8> = Vec::new();
+        while let Some(header) = parse_next_header(byte_data, &mut byte_offset, fix_errors)? {
+            match &header.name {
+                b"IDAT" => idat_headers.extend_from_slice(header.data),
+                b"acTL" => return Err(PngError::APNGNotSupported),
+                _ => {
+                    aux_headers.insert(header.name, header.data.to_owned());
                }
-                b"IHDR" | b"PLTE" | b"tRNS" => {
-                    key_chunks.insert(chunk.name, chunk.data.to_owned());
-                }
-                _ if opts.strip.keep(&chunk.name) => {
-                    if chunk.is_c2pa() {
-                        // StripChunks::None is the default value, so to keep optimizing by default,
-                        // interpret it as stripping the C2PA metadata.
-                        // The C2PA metadata is invalidated if the file changes, so it shouldn't be kept.
-                        if opts.strip == StripChunks::None {
-                            continue;
-                        }
-                        return Err(PngError::C2PAMetadataPreventsChanges);
-                    }
-                    if chunk.name == *b"fcTL" || chunk.name == *b"fdAT" {
-                        // Validate the sequence number
-                        if read_be_u32(&chunk.data[0..4]) != sequence_number {
-                            return Err(PngError::APNGOutOfOrder);
-                        }
-                        sequence_number += 1;
-                        if chunk.name == *b"fcTL" && !idat_data.is_empty() {
-                            // Only create a Frame if it's after the IDAT (else store it as an aux chunk)
-                            frames.push(Frame::from_fctl_data(chunk.data)?);
-                            continue;
-                        } else if chunk.name == *b"fdAT" {
-                            // Append the data to the last frame
-                            frames
-                                .last_mut()
-                                .ok_or(PngError::APNGOutOfOrder)?
-                                .data
-                                .extend_from_slice(&chunk.data[4..]);
-                            continue;
-                        }
-                    }
-                    // Regular ancillary chunk
-                    aux_chunks.push(Chunk {
-                        name: chunk.name,
-                        data: chunk.data.to_owned(),
-                    });
-                }
-                b"acTL" => {
-                    warn!("Stripping animation data from APNG - image will become standard PNG");
-                }
-                _ => (),
            }
        }
-
-        // Parse the chunks into our PngData
-        if idat_data.is_empty() {
+        // Parse the headers into our PngData
+        if idat_headers.is_empty() {
            return Err(PngError::ChunkMissing("IDAT"));
        }
-        let Some(ihdr_chunk) = key_chunks.remove(b"IHDR") else {
-            return Err(PngError::ChunkMissing("IHDR"));
+        let ihdr = match aux_headers.remove(b"IHDR") {
+            Some(ihdr) => ihdr,
+            None => return Err(PngError::ChunkMissing("IHDR")),
        };
-        let ihdr = parse_ihdr_chunk(
-            &ihdr_chunk,
-            key_chunks.remove(b"PLTE"),
-            key_chunks.remove(b"tRNS"),
-        )?;
-        if let Some(max) = opts.max_decompressed_size {
-            if ihdr.raw_data_size() > max {
-                return Err(PngError::InflatedDataTooLong(max));
-            }
+        let ihdr_header = parse_ihdr_header(&ihdr)?;
+        let raw_data = deflate::inflate(idat_headers.as_ref(), ihdr_header.raw_data_size())?;
+
+        // Reject files with incorrect width/height or truncated data
+        if raw_data.len() != ihdr_header.raw_data_size() {
+            return Err(PngError::TruncatedData);
        }

-        let raw = PngImage::new(ihdr, &idat_data)?;
+        let (palette, transparency_pixel) = Self::palette_to_rgba(
+            ihdr_header.color_type,
+            aux_headers.remove(b"PLTE"),
+            aux_headers.remove(b"tRNS"),
+        )?;

+        let mut raw = PngImage {
+            ihdr: ihdr_header,
+            data: raw_data,
+            palette,
+            transparency_pixel,
+            aux_headers,
+        };
+        let unfiltered = raw.unfilter_image()?;
        // Return the PngData
        Ok(Self {
-            idat_data,
+            idat_data: idat_headers,
+            filtered: std::mem::replace(&mut raw.data, unfiltered),
            raw: Arc::new(raw),
-            aux_chunks,
-            frames,
        })
    }

+    /// Handle transparency header
+    fn palette_to_rgba(
+        color_type: ColorType,
+        palette_data: Option<Vec<u8>>,
+        trns_data: Option<Vec<u8>>,
+    ) -> Result<PaletteWithTrns, PngError> {
+        if color_type == ColorType::Indexed {
+            let palette_data =
+                palette_data.ok_or_else(|| PngError::new("no palette in indexed image"))?;
+            let mut palette: Vec<_> = palette_data
+                .chunks(3)
+                .map(|color| RGBA8::new(color[0], color[1], color[2], 255))
+                .collect();
+
+            if let Some(trns_data) = trns_data {
+                for (color, trns) in palette.iter_mut().zip(trns_data) {
+                    color.a = trns;
+                }
+            }
+            Ok((Some(palette), None))
+        } else {
+            Ok((None, trns_data))
+        }
+    }
+
    /// Format the `PngData` struct into a valid PNG bytestream
-    #[must_use]
    pub fn output(&self) -> Vec<u8> {
        // PNG header
        let mut output = vec![0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
        // IHDR
        let mut ihdr_data = Vec::with_capacity(13);
-        ihdr_data.extend_from_slice(&self.raw.ihdr.width.to_be_bytes());
-        ihdr_data.extend_from_slice(&self.raw.ihdr.height.to_be_bytes());
-        ihdr_data.extend_from_slice(&[self.raw.ihdr.bit_depth as u8]);
-        ihdr_data.extend_from_slice(&[
-            self.raw.ihdr.color_type.png_header_code(),
-            0, // Compression -- deflate
-            0, // Filter method -- 5-way adaptive filtering
-            self.raw.ihdr.interlaced as u8,
-        ]);
+        ihdr_data.write_all(&self.raw.ihdr.width.to_be_bytes()).ok();
+        ihdr_data
+            .write_all(&self.raw.ihdr.height.to_be_bytes())
+            .ok();
+        ihdr_data.write_all(&[self.raw.ihdr.bit_depth.as_u8()]).ok();
+        ihdr_data
+            .write_all(&[self.raw.ihdr.color_type.png_header_code()])
+            .ok();
+        ihdr_data.write_all(&[0]).ok(); // Compression -- deflate
+        ihdr_data.write_all(&[0]).ok(); // Filter method -- 5-way adaptive filtering
+        ihdr_data.write_all(&[self.raw.ihdr.interlaced as u8]).ok();
        write_png_block(b"IHDR", &ihdr_data, &mut output);
-        // Ancillary chunks - split into those that come before IDAT and those that come after
-        let mut aux_split = self.aux_chunks.split(|c| &c.name == b"IDAT");
-        let aux_pre = aux_split.next().unwrap();
-        // Many chunks need to be before PLTE, so write all except those that explicitly need to be after
-        // Note: the PNG spec does not say that fcTL needs to be after PLTE, but some decoders expect
-        //       that (see issue #625)
-        for chunk in aux_pre
+        // Ancillary headers
+        for (key, header) in self
+            .raw
+            .aux_headers
            .iter()
-            .filter(|c| !matches!(&c.name, b"bKGD" | b"hIST" | b"tRNS" | b"fcTL"))
+            .filter(|&(key, _)| !(key == b"bKGD" || key == b"hIST" || key == b"tRNS"))
        {
-            write_png_block(&chunk.name, &chunk.data, &mut output);
+            write_png_block(key, header, &mut output);
        }
-        // Palette and transparency
-        match &self.raw.ihdr.color_type {
-            ColorType::Indexed { palette } => {
-                let mut palette_data = Vec::with_capacity(palette.len() * 3);
-                for px in palette {
-                    palette_data.extend_from_slice(px.rgb().as_ref());
-                }
-                write_png_block(b"PLTE", &palette_data, &mut output);
-                if let Some(last_trns) = palette.iter().rposition(|px| px.a != 255) {
-                    let trns_data: Vec<_> = palette[0..=last_trns].iter().map(|px| px.a).collect();
-                    write_png_block(b"tRNS", &trns_data, &mut output);
-                }
+        // Palette
+        if let Some(ref palette) = self.raw.palette {
+            let mut palette_data = Vec::with_capacity(palette.len() * 3);
+            let mut max_palette_size = 1 << (self.raw.ihdr.bit_depth.as_u8() as usize);
+            // Ensure bKGD color doesn't get truncated from palette
+            if let Some(&idx) = self.raw.aux_headers.get(b"bKGD").and_then(|b| b.first()) {
+                max_palette_size = max_palette_size.max(idx as usize + 1);
            }
-            ColorType::Grayscale {
-                transparent_shade: Some(trns),
-            } => {
-                // Transparency pixel - 2 byte u16
-                write_png_block(b"tRNS", &trns.to_be_bytes(), &mut output);
+            for px in palette.iter().take(max_palette_size) {
+                palette_data.extend_from_slice(px.rgb().as_slice());
            }
-            ColorType::RGB {
-                transparent_color: Some(trns),
-            } => {
-                // Transparency pixel - 6 byte RGB16
-                let trns_data: Vec<_> = trns.iter().flat_map(u16::to_be_bytes).collect();
+            write_png_block(b"PLTE", &palette_data, &mut output);
+            let num_transparent =
+                palette
+                    .iter()
+                    .take(max_palette_size)
+                    .enumerate()
+                    .fold(
+                        0,
+                        |prev, (index, px)| {
+                            if px.a == 255 {
+                                prev
+                            } else {
+                                index + 1
+                            }
+                        },
+                    );
+            if num_transparent > 0 {
+                let trns_data: Vec<_> = palette[0..num_transparent].iter().map(|px| px.a).collect();
                write_png_block(b"tRNS", &trns_data, &mut output);
            }
-            _ => {}
+        } else if let Some(ref transparency_pixel) = self.raw.transparency_pixel {
+            // Transparency pixel
+            write_png_block(b"tRNS", transparency_pixel, &mut output);
        }
-        // Special ancillary chunks that need to come after PLTE but before IDAT
-        let mut sequence_number = 0;
-        for chunk in aux_pre
+        // Special ancillary headers that need to come after PLTE but before IDAT
+        for (key, header) in self
+            .raw
+            .aux_headers
            .iter()
-            .filter(|c| matches!(&c.name, b"bKGD" | b"hIST" | b"tRNS" | b"fcTL"))
+            .filter(|&(key, _)| key == b"bKGD" || key == b"hIST" || key == b"tRNS")
        {
-            write_png_block(&chunk.name, &chunk.data, &mut output);
-            if &chunk.name == b"fcTL" {
-                sequence_number += 1;
-            }
+            write_png_block(key, header, &mut output);
        }
        // IDAT data
        write_png_block(b"IDAT", &self.idat_data, &mut output);
-        // APNG frames
-        for frame in self.frames.iter() {
-            write_png_block(b"fcTL", &frame.fctl_data(sequence_number), &mut output);
-            write_png_block(b"fdAT", &frame.fdat_data(sequence_number + 1), &mut output);
-            sequence_number += 2;
-        }
-        // Ancillary chunks that come after IDAT
-        for aux_post in aux_split {
-            for chunk in aux_post {
-                write_png_block(&chunk.name, &chunk.data, &mut output);
-            }
-        }
        // Stream end
        write_png_block(b"IEND", &[], &mut output);

@ -246,33 +252,18 @@ impl PngData {
 }

 impl PngImage {
-    pub fn new(ihdr: IhdrData, compressed_data: &[u8]) -> PngResult<Self> {
-        let raw_data = deflate::inflate(compressed_data, ihdr.raw_data_size())?;
-
-        // Reject files with incorrect width/height or truncated data
-        if raw_data.len() != ihdr.raw_data_size() {
-            return Err(PngError::TruncatedData);
-        }
-
-        let mut image = Self {
-            ihdr,
-            data: raw_data,
-        };
-        image.data = image.unfilter_image()?;
-        Ok(image)
-    }
-
-    /// Enable or disable interlacing
-    /// Returns the new image if the interlacing was changed, None otherwise
+    /// Convert the image to the specified interlacing type
+    /// Returns true if the interlacing was changed, false otherwise
+    /// The `interlace` parameter specifies the *new* interlacing mode
    /// Assumes that the data has already been de-filtered
    #[inline]
    #[must_use]
-    pub fn change_interlacing(&self, interlace: bool) -> Option<Self> {
+    pub fn change_interlacing(&self, interlace: Interlacing) -> Option<PngImage> {
        if interlace == self.ihdr.interlaced {
            return None;
        }

-        Some(if interlace {
+        Some(if interlace == Interlacing::Adam7 {
            // Convert progressive to interlaced data
            interlace_image(self)
        } else {
@ -283,56 +274,20 @@ impl PngImage {

    /// Return the number of channels in the image, based on color type
    #[inline]
-    #[must_use]
-    pub const fn channels_per_pixel(&self) -> usize {
-        self.ihdr.color_type.channels_per_pixel() as usize
-    }
-
-    /// Return the number of bytes per channel in the image
-    #[inline]
-    #[must_use]
-    pub const fn bytes_per_channel(&self) -> usize {
-        match self.ihdr.bit_depth {
-            BitDepth::Sixteen => 2,
-            // Depths lower than 8 will round up to 1 byte
-            _ => 1,
-        }
-    }
-
-    /// Calculate the size of the PLTE and tRNS chunks
-    #[must_use]
-    pub fn key_chunks_size(&self) -> usize {
-        match &self.ihdr.color_type {
-            ColorType::Indexed { palette } => {
-                let plte = 12 + palette.len() * 3;
-                palette
-                    .iter()
-                    .rposition(|p| p.a != 255)
-                    .map_or(plte, |trns| plte + 12 + trns + 1)
-            }
-            ColorType::Grayscale { transparent_shade } if transparent_shade.is_some() => 12 + 2,
-            ColorType::RGB { transparent_color } if transparent_color.is_some() => 12 + 6,
-            _ => 0,
-        }
-    }
-
-    /// Return an estimate of the output size which can help with evaluation of very small data
-    #[must_use]
-    pub fn estimated_output_size(&self, idat_data: &[u8]) -> usize {
-        idat_data.len() + self.key_chunks_size()
+    pub fn channels_per_pixel(&self) -> u8 {
+        self.ihdr.color_type.channels_per_pixel()
    }

    /// Return an iterator over the scanlines of the image
    #[inline]
-    #[must_use]
    pub fn scan_lines(&self, has_filter: bool) -> ScanLines<'_> {
        ScanLines::new(self, has_filter)
    }

    /// Reverse all filters applied on the image, returning an unfiltered IDAT bytestream
-    fn unfilter_image(&self) -> PngResult<Vec<u8>> {
+    fn unfilter_image(&self) -> Result<Vec<u8>, PngError> {
        let mut unfiltered = Vec::with_capacity(self.data.len());
-        let bpp = self.bytes_per_channel() * self.channels_per_pixel();
+        let bpp = ((self.ihdr.bit_depth.as_u8() * self.channels_per_pixel() + 7) / 8) as usize;
        let mut last_line: Vec<u8> = Vec::new();
        let mut last_pass = None;
        let mut unfiltered_buf = Vec::new();
@ -342,8 +297,8 @@ impl PngImage {
                last_pass = line.pass;
            }
            last_line.resize(line.data.len(), 0);
-            let filter = RowFilter::try_from(line.filter).map_err(|()| PngError::InvalidData)?;
-            filter.unfilter_line(bpp, line.data, &last_line, &mut unfiltered_buf);
+            let filter = RowFilter::try_from(line.filter).map_err(|_| PngError::InvalidData)?;
+            filter.unfilter_line(bpp, line.data, &last_line, &mut unfiltered_buf)?;
            unfiltered.extend_from_slice(&unfiltered_buf);
            std::mem::swap(&mut last_line, &mut unfiltered_buf);
            unfiltered_buf.clear();
@ -352,76 +307,49 @@ impl PngImage {
    }

    /// Apply the specified filter type to all rows in the image
-    #[must_use]
-    pub fn filter_image(
-        &self,
-        strategy: FilterStrategy,
-        optimize_alpha: bool,
-    ) -> (Vec<u8>, FilterStrategy) {
+    pub fn filter_image(&self, filter: RowFilter, optimize_alpha: bool) -> Vec<u8> {
        let mut filtered = Vec::with_capacity(self.data.len());
-        let bpp = self.bytes_per_channel() * self.channels_per_pixel();
+        let bpp = ((self.ihdr.bit_depth.as_u8() * self.channels_per_pixel() + 7) / 8) as usize;
        // If alpha optimization is enabled, determine how many bytes of alpha there are per pixel
-        let alpha_bytes = if optimize_alpha && self.ihdr.color_type.has_alpha() {
-            self.bytes_per_channel()
-        } else {
-            0
+        let alpha_bytes = match self.ihdr.color_type {
+            ColorType::RGBA | ColorType::GrayscaleAlpha if optimize_alpha => {
+                (self.ihdr.bit_depth.as_u8() / 8) as usize
+            }
+            _ => 0,
        };

        let mut prev_line = Vec::new();
        let mut prev_pass: Option<u8> = None;
        let mut f_buf = Vec::new();
-        // For heuristic strategies, keep track of the actual filter used for each line
-        let mut filters_used = Vec::new();
-        // Pre-allocate buffers for the Bigrams strategy to avoid per-line allocations
-        let (mut bigram_seen, mut bigram_touched) = if matches!(strategy, FilterStrategy::Bigrams) {
-            (vec![false; 0x10000], Vec::<u16>::new())
-        } else {
-            (Vec::new(), Vec::new())
-        };
-        for (i, line) in self.scan_lines(false).enumerate() {
+        for line in self.scan_lines(false) {
            if prev_pass != line.pass || line.data.len() != prev_line.len() {
                prev_line = vec![0; line.data.len()];
            }
            // Alpha optimisation may alter the line data, so we need a mutable copy of it
            let mut line_data = line.data.to_vec();

-            if let FilterStrategy::Basic(mut filter) = strategy {
+            if filter <= RowFilter::Paeth {
                // Standard filters
-                if prev_pass != line.pass && filter > RowFilter::Sub {
-                    filter = RowFilter::None;
-                }
-                filter.filter_line(bpp, &mut line_data, &prev_line, &mut f_buf, alpha_bytes);
-                filtered.extend_from_slice(&f_buf);
-                prev_line = line_data;
-            } else if let FilterStrategy::Predefined(lines) = &strategy {
-                // Predefined filter for each line
-                let filter = lines.get(i).unwrap_or(&RowFilter::None);
+                let filter = if prev_pass == line.pass || filter <= RowFilter::Sub {
+                    filter
+                } else {
+                    RowFilter::None
+                };
                filter.filter_line(bpp, &mut line_data, &prev_line, &mut f_buf, alpha_bytes);
                filtered.extend_from_slice(&f_buf);
                prev_line = line_data;
            } else {
                // Heuristic filter selection strategies
-
-                let mut best_filter = RowFilter::None;
-                if line_data.iter().all(|&x| x == 0) {
-                    // Assume None if the line is all zeros
-                    filtered.push(best_filter as u8);
-                    filtered.extend_from_slice(&line_data);
-                    prev_line = line_data;
-                    filters_used.push(best_filter);
-                    continue;
-                }
-
                let mut best_line = Vec::new();
                let mut best_line_raw = Vec::new();
                // Avoid vertical filtering on first line of each interlacing pass
                let try_filters = if prev_pass == line.pass {
-                    RowFilter::ALL.iter()
+                    RowFilter::STANDARD.iter()
                } else {
                    RowFilter::SINGLE_LINE.iter()
                };
-                match strategy {
-                    FilterStrategy::MinSum => {
+                match filter {
+                    RowFilter::MinSum => {
                        // MSAD algorithm mentioned in libpng reference docs
                        // http://www.libpng.org/pub/png/book/chapter09.html
                        let mut best_size = usize::MAX;
@ -434,19 +362,18 @@ impl PngImage {
                            if size < best_size {
                                best_size = size;
                                std::mem::swap(&mut best_line, &mut f_buf);
-                                best_line_raw.clone_from(&line_data);
-                                best_filter = *f;
+                                best_line_raw = line_data.clone();
                            }
                        }
                    }
-                    FilterStrategy::Entropy => {
+                    RowFilter::Entropy => {
                        // Shannon entropy algorithm, from LodePNG
                        // https://github.com/lvandeve/lodepng
                        let mut best_size = i32::MIN;
                        for f in try_filters {
                            f.filter_line(bpp, &mut line_data, &prev_line, &mut f_buf, alpha_bytes);
                            let mut counts = vec![0; 0x100];
-                            for &i in &f_buf {
+                            for &i in f_buf.iter() {
                                counts[i as usize] += 1;
                            }
                            let size = counts.into_iter().fold(0, |acc, x| {
@ -458,43 +385,30 @@ impl PngImage {
                            if size > best_size {
                                best_size = size;
                                std::mem::swap(&mut best_line, &mut f_buf);
-                                best_line_raw.clone_from(&line_data);
-                                best_filter = *f;
+                                best_line_raw = line_data.clone();
                            }
                        }
                    }
-                    FilterStrategy::Bigrams => {
+                    RowFilter::Bigrams => {
                        // Count distinct bigrams, from pngwolf
                        // https://bjoern.hoehrmann.de/pngwolf/
                        let mut best_size = usize::MAX;
                        for f in try_filters {
                            f.filter_line(bpp, &mut line_data, &prev_line, &mut f_buf, alpha_bytes);
-                            let mut count = 0;
+                            let mut set = bitarr![0; 0x10000];
                            for pair in f_buf.windows(2) {
-                                let bigram = ((pair[0] as usize) << 8) | pair[1] as usize;
-                                if !bigram_seen[bigram] {
-                                    count += 1;
-                                    if count >= best_size {
-                                        break;
-                                    }
-                                    bigram_seen[bigram] = true;
-                                    bigram_touched.push(bigram as u16);
-                                }
+                                let bigram = (pair[0] as usize) << 8 | pair[1] as usize;
+                                set.set(bigram, true);
                            }
-                            if count < best_size {
-                                best_size = count;
+                            let size = set.count_ones();
+                            if size < best_size {
+                                best_size = size;
                                std::mem::swap(&mut best_line, &mut f_buf);
-                                best_line_raw.clone_from(&line_data);
-                                best_filter = *f;
+                                best_line_raw = line_data.clone();
                            }
-                            // Clear only the entries that were touched
-                            for &idx in &bigram_touched {
-                                bigram_seen[idx as usize] = false;
-                            }
-                            bigram_touched.clear();
                        }
                    }
-                    FilterStrategy::BigEnt => {
+                    RowFilter::BigEnt => {
                        // Bigram entropy, combined from Entropy and Bigrams filters
                        let mut best_size = i32::MIN;
                        // FxHasher is the fastest rust hasher currently available for this purpose
@ -503,41 +417,39 @@ impl PngImage {
                            f.filter_line(bpp, &mut line_data, &prev_line, &mut f_buf, alpha_bytes);
                            counts.clear();
                            for pair in f_buf.windows(2) {
-                                let bigram = (u16::from(pair[0]) << 8) | u16::from(pair[1]);
+                                let bigram = (pair[0] as u16) << 8 | pair[1] as u16;
                                counts.entry(bigram).and_modify(|e| *e += 1).or_insert(1);
                            }
                            let size = counts.values().fold(0, |acc, &x| acc + ilog2i(x)) as i32;
                            if size > best_size {
                                best_size = size;
                                std::mem::swap(&mut best_line, &mut f_buf);
-                                best_line_raw.clone_from(&line_data);
-                                best_filter = *f;
+                                best_line_raw = line_data.clone();
                            }
                        }
                    }
-                    FilterStrategy::Brute { num_lines, level } => {
+                    RowFilter::Brute => {
                        // Brute force by compressing each filter attempt
                        // Similar to that of LodePNG but includes some previous lines for context
                        let mut best_size = usize::MAX;
                        let line_start = filtered.len();
                        filtered.resize(filtered.len() + line.data.len() + 1, 0);
                        let mut compressor =
-                            Compressor::new(CompressionLvl::new(level.into()).unwrap());
-                        let limit = filtered.len().min((line.data.len() + 1) * num_lines);
-                        let capacity = compressor.deflate_compress_bound(limit);
+                            Compressor::new(CompressionLvl::new(BRUTE_LEVEL).unwrap());
+                        let limit = filtered.len().min((line.data.len() + 1) * BRUTE_LINES);
+                        let capacity = compressor.zlib_compress_bound(limit);
                        let mut dest = vec![0; capacity];

                        for f in try_filters {
                            f.filter_line(bpp, &mut line_data, &prev_line, &mut f_buf, alpha_bytes);
                            filtered[line_start..].copy_from_slice(&f_buf);
                            let size = compressor
-                                .deflate_compress(&filtered[filtered.len() - limit..], &mut dest)
+                                .zlib_compress(&filtered[filtered.len() - limit..], &mut dest)
                                .unwrap_or(usize::MAX);
                            if size < best_size {
                                best_size = size;
                                std::mem::swap(&mut best_line, &mut f_buf);
-                                best_line_raw.clone_from(&line_data);
-                                best_filter = *f;
+                                best_line_raw = line_data.clone();
                            }
                        }
                        filtered.resize(line_start, 0);
@ -546,33 +458,26 @@ impl PngImage {
                }
                filtered.extend_from_slice(&best_line);
                prev_line = best_line_raw;
-                filters_used.push(best_filter);
            }

            prev_pass = line.pass;
        }
-
-        if filters_used.is_empty() {
-            (filtered, strategy)
-        } else {
-            (filtered, FilterStrategy::Predefined(filters_used))
-        }
+        filtered
    }
 }
-
-fn write_png_block(key: &[u8], chunk: &[u8], output: &mut Vec<u8>) {
-    let mut chunk_data = Vec::with_capacity(chunk.len() + 4);
-    chunk_data.extend_from_slice(key);
-    chunk_data.extend_from_slice(chunk);
-    output.reserve(chunk_data.len() + 8);
-    output.extend_from_slice(&(chunk_data.len() as u32 - 4).to_be_bytes());
-    let crc = deflate::crc32(&chunk_data);
-    output.append(&mut chunk_data);
+fn write_png_block(key: &[u8], header: &[u8], output: &mut Vec<u8>) {
+    let mut header_data = Vec::with_capacity(header.len() + 4);
+    header_data.extend_from_slice(key);
+    header_data.extend_from_slice(header);
+    output.reserve(header_data.len() + 8);
+    output.extend_from_slice(&(header_data.len() as u32 - 4).to_be_bytes());
+    let crc = deflate::crc32(&header_data);
+    output.append(&mut header_data);
    output.extend_from_slice(&crc.to_be_bytes());
 }

 // Integer approximation for i * log2(i) - much faster than float calculations
-const fn ilog2i(i: u32) -> u32 {
+fn ilog2i(i: u32) -> u32 {
    let log = 32 - i.leading_zeros() - 1;
    i * log + ((i - (1 << log)) << 1)
 }
--- a/src/png/scan_lines.rs
+++ b/src/png/scan_lines.rs
@ -1,3 +1,4 @@
+use crate::interlace::Interlacing;
 use crate::png::PngImage;

 /// An iterator over the scan lines of a PNG image
@ -11,7 +12,6 @@ pub struct ScanLines<'a> {
 }

 impl<'a> ScanLines<'a> {
-    #[must_use]
    pub fn new(png: &'a PngImage, has_filter: bool) -> Self {
        Self {
            iter: ScanLineRanges::new(png, has_filter),
@ -23,29 +23,17 @@ impl<'a> ScanLines<'a> {

 impl<'a> Iterator for ScanLines<'a> {
    type Item = ScanLine<'a>;
-
    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
-        let (len, pass, num_pixels) = self.iter.next()?;
-        debug_assert!(self.raw_data.len() >= len);
-        debug_assert!(!self.has_filter || len > 1);
-        // The data length should always be correct here but this check assures
-        // the compiler that it doesn't need to account for a potential panic
-        if self.raw_data.len() < len {
-            return None;
-        }
-        let (data, rest) = self.raw_data.split_at(len);
-        self.raw_data = rest;
-        let (&filter, data) = if self.has_filter {
-            data.split_first().unwrap()
-        } else {
-            (&0, data)
-        };
-        Some(ScanLine {
-            filter,
-            data,
-            pass,
-            num_pixels,
+        self.iter.next().map(|(len, pass)| {
+            let (data, rest) = self.raw_data.split_at(len);
+            self.raw_data = rest;
+            let (&filter, data) = if self.has_filter {
+                data.split_first().unwrap()
+            } else {
+                (&0, data)
+            };
+            ScanLine { filter, data, pass }
        })
    }
 }
@ -55,7 +43,7 @@ impl<'a> Iterator for ScanLines<'a> {
 struct ScanLineRanges {
    /// Current pass number, and 0-indexed row within the pass
    pass: Option<(u8, u32)>,
-    bits_per_pixel: usize,
+    bits_per_pixel: u8,
    width: u32,
    height: u32,
    left: usize,
@ -65,11 +53,11 @@ struct ScanLineRanges {
 impl ScanLineRanges {
    pub fn new(png: &PngImage, has_filter: bool) -> Self {
        Self {
-            bits_per_pixel: png.ihdr.bpp(),
+            bits_per_pixel: png.ihdr.bit_depth.as_u8() * png.channels_per_pixel(),
            width: png.ihdr.width,
            height: png.ihdr.height,
            left: png.data.len(),
-            pass: if png.ihdr.interlaced {
+            pass: if png.ihdr.interlaced == Interlacing::Adam7 {
                Some((1, 0))
            } else {
                None
@ -80,8 +68,7 @@ impl ScanLineRanges {
 }

 impl Iterator for ScanLineRanges {
-    type Item = (usize, Option<u8>, usize);
-
+    type Item = (usize, Option<u8>);
    fn next(&mut self) -> Option<Self::Item> {
        if self.left == 0 {
            return None;
@ -138,7 +125,7 @@ impl Iterator for ScanLineRanges {
                    pixels_per_line += 1;
                }
                _ => (),
-            }
+            };
            let current_pass = Some(pass.0);
            if pass.1 + y_steps >= self.height {
                pass.0 += 1;
@ -156,13 +143,13 @@ impl Iterator for ScanLineRanges {
            // Standard, non-interlaced PNG scanlines
            (self.width, None)
        };
-        let bits_per_line = pixels_per_line as usize * self.bits_per_pixel;
-        let mut len = bits_per_line.div_ceil(8);
+        let bits_per_line = pixels_per_line * u32::from(self.bits_per_pixel);
+        let mut len = ((bits_per_line + 7) / 8) as usize;
        if self.has_filter {
            len += 1;
        }
        self.left = self.left.checked_sub(len)?;
-        Some((len, current_pass, pixels_per_line as usize))
+        Some((len, current_pass))
    }
 }

@ -175,6 +162,4 @@ pub struct ScanLine<'a> {
    pub data: &'a [u8],
    /// The current pass if the image is interlaced
    pub pass: Option<u8>,
-    /// The number of pixels in the current scan line
-    pub num_pixels: usize,
 }
--- a/src/rayon.rs
+++ b/src/rayon.rs
@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 pub mod prelude {
    pub use super::*;
 }
@ -28,12 +26,6 @@ pub trait IntoParallelRefIterator<'data> {
    fn par_iter(&'data self) -> Self::Iter;
 }

-pub trait IntoParallelRefMutIterator<'data> {
-    type Iter: ParallelIterator<Item = Self::Item>;
-    type Item: Send + 'data;
-    fn par_iter_mut(&'data mut self) -> Self::Iter;
-}
-
 impl<I: IntoIterator> IntoParallelIterator for I
 where
    I::Item: Send,
@ -58,18 +50,6 @@ where
    }
 }

-impl<'data, I: 'data + ?Sized> IntoParallelRefMutIterator<'data> for I
-where
-    &'data mut I: IntoParallelIterator,
-{
-    type Iter = <&'data mut I as IntoParallelIterator>::Iter;
-    type Item = <&'data mut I as IntoParallelIterator>::Item;
-
-    fn par_iter_mut(&'data mut self) -> Self::Iter {
-        self.into_par_iter()
-    }
-}
-
 impl<I: Iterator> ParallelIterator for I {}

 pub fn join<A, B>(a: impl FnOnce() -> A, b: impl FnOnce() -> B) -> (A, B) {
--- a/src/reduction/alpha.rs
+++ b/src/reduction/alpha.rs
@ -1,24 +1,23 @@
-use rgb::RGB16;
-
-use crate::{
-    colors::{BitDepth, ColorType},
-    headers::IhdrData,
-    png::PngImage,
-};
+use crate::colors::{BitDepth, ColorType};
+use crate::headers::IhdrData;
+use crate::png::PngImage;

 /// Clean the alpha channel by setting the color of all fully transparent pixels to black
-#[must_use]
 pub fn cleaned_alpha_channel(png: &PngImage) -> Option<PngImage> {
-    if !png.ihdr.color_type.has_alpha() {
-        return None;
-    }
-    let byte_depth = png.bytes_per_channel();
-    let bpp = png.channels_per_pixel() * byte_depth;
-    let colored_bytes = bpp - byte_depth;
+    let (bpc, bpp) = match png.ihdr.color_type {
+        ColorType::RGBA | ColorType::GrayscaleAlpha => {
+            let cpp = png.channels_per_pixel();
+            let bpc = png.ihdr.bit_depth.as_u8() / 8;
+            (bpc as usize, (bpc * cpp) as usize)
+        }
+        _ => {
+            return None;
+        }
+    };

    let mut reduced = Vec::with_capacity(png.data.len());
-    for pixel in png.data.chunks_exact(bpp) {
-        if pixel.iter().skip(colored_bytes).all(|b| *b == 0) {
+    for pixel in png.data.chunks(bpp) {
+        if pixel.iter().skip(bpp - bpc).all(|b| *b == 0) {
            reduced.resize(reduced.len() + bpp, 0);
        } else {
            reduced.extend_from_slice(pixel);
@ -27,17 +26,23 @@ pub fn cleaned_alpha_channel(png: &PngImage) -> Option<PngImage> {

    Some(PngImage {
        data: reduced,
-        ihdr: png.ihdr.clone(),
+        ihdr: png.ihdr,
+        palette: png.palette.clone(),
+        transparency_pixel: png.transparency_pixel.clone(),
+        aux_headers: png.aux_headers.clone(),
    })
 }

 #[must_use]
 pub fn reduced_alpha_channel(png: &PngImage, optimize_alpha: bool) -> Option<PngImage> {
-    if !png.ihdr.color_type.has_alpha() {
-        return None;
-    }
-    let byte_depth = png.bytes_per_channel();
-    let bpp = png.channels_per_pixel() * byte_depth;
+    let target_color_type = match png.ihdr.color_type {
+        ColorType::GrayscaleAlpha => ColorType::Grayscale,
+        ColorType::RGBA => ColorType::RGB,
+        _ => return None,
+    };
+    let byte_depth = (png.ihdr.bit_depth.as_u8() >> 3) as usize;
+    let channels = png.channels_per_pixel() as usize;
+    let bpp = channels * byte_depth;
    let colored_bytes = bpp - byte_depth;

    // If alpha optimisation is enabled, see if the image contains only fully opaque and fully transparent pixels.
@ -46,7 +51,7 @@ pub fn reduced_alpha_channel(png: &PngImage, optimize_alpha: bool) -> Option<Png
    let mut has_transparency = false;
    let mut used_colors = vec![false; 256];

-    for pixel in png.data.chunks_exact(bpp) {
+    for pixel in png.data.chunks(bpp) {
        if optimize_alpha && pixel.iter().skip(colored_bytes).all(|b| *b == 0) {
            // Fully transparent, we may be able to reduce with tRNS
            has_transparency = true;
@ -60,43 +65,35 @@ pub fn reduced_alpha_channel(png: &PngImage, optimize_alpha: bool) -> Option<Png
    }

    let transparency_pixel = if has_transparency {
-        // For grayscale, start by checking 4 specific values in the hope that we may reduce depth
-        let unused = match png.ihdr.color_type {
-            ColorType::GrayscaleAlpha => [0x00, 0xFF, 0x55, 0xAA]
-                .into_iter()
-                .find(|&v| !used_colors[v as usize]),
-            _ => None,
-        }
-        .or_else(|| used_colors.iter().position(|&u| !u).map(|v| v as u8));
        // If no unused color was found we will have to fail here
-        Some(unused?)
+        // Otherwise, proceed to construct the tRNS chunk
+        let unused_color = used_colors.iter().position(|b| !*b)? as u8;
+        Some(match png.ihdr.bit_depth {
+            BitDepth::Sixteen => vec![unused_color; colored_bytes],
+            // 8-bit is still stored as 16-bit, with the high byte set to 0
+            _ => [0, unused_color].repeat(colored_bytes),
+        })
    } else {
        None
    };

    let mut raw_data = Vec::with_capacity(png.data.len());
-    for pixel in png.data.chunks_exact(bpp) {
+    for pixel in png.data.chunks(bpp) {
        match transparency_pixel {
-            Some(trns) if pixel.iter().skip(colored_bytes).all(|b| *b == 0) => {
-                raw_data.resize(raw_data.len() + colored_bytes, trns);
+            Some(ref trns) if pixel.iter().skip(colored_bytes).all(|b| *b == 0) => {
+                raw_data.resize(raw_data.len() + colored_bytes, trns[1]);
            }
            _ => raw_data.extend_from_slice(&pixel[0..colored_bytes]),
-        }
+        };
    }

-    // Construct the color type with appropriate transparency data
-    let transparent = transparency_pixel.map(|trns| match png.ihdr.bit_depth {
-        BitDepth::Sixteen => (u16::from(trns) << 8) | u16::from(trns),
-        _ => u16::from(trns),
-    });
-    let target_color_type = match png.ihdr.color_type {
-        ColorType::GrayscaleAlpha => ColorType::Grayscale {
-            transparent_shade: transparent,
-        },
-        _ => ColorType::RGB {
-            transparent_color: transparent.map(|t| RGB16::new(t, t, t)),
-        },
-    };
+    let mut aux_headers = png.aux_headers.clone();
+    // sBIT contains information about alpha channel's original depth,
+    // and alpha has just been removed
+    if let Some(sbit_header) = png.aux_headers.get(b"sBIT") {
+        // Some programs save the sBIT header as RGB even if the image is RGBA.
+        aux_headers.insert(*b"sBIT", sbit_header.iter().cloned().take(3).collect());
+    }

    Some(PngImage {
        data: raw_data,
@ -104,5 +101,8 @@ pub fn reduced_alpha_channel(png: &PngImage, optimize_alpha: bool) -> Option<Png
            color_type: target_color_type,
            ..png.ihdr
        },
+        aux_headers,
+        transparency_pixel,
+        palette: None,
    })
 }
--- a/src/reduction/bit_depth.rs
+++ b/src/reduction/bit_depth.rs
@ -1,230 +1,164 @@
-use crate::{
-    colors::{BitDepth, ColorType},
-    headers::IhdrData,
-    png::PngImage,
-};
+use crate::colors::{BitDepth, ColorType};
+use crate::headers::IhdrData;
+use crate::png::PngImage;

-/// Attempt to reduce a 16-bit image to 8-bit, returning the reduced image if successful
+/// Attempt to reduce the bit depth of the image
+/// Returns true if the bit depth was reduced, false otherwise
 #[must_use]
-pub fn reduced_bit_depth_16_to_8(png: &PngImage, force_scale: bool) -> Option<PngImage> {
+pub fn reduce_bit_depth(png: &PngImage, minimum_bits: usize) -> Option<PngImage> {
    if png.ihdr.bit_depth != BitDepth::Sixteen {
+        if png.ihdr.color_type == ColorType::Indexed || png.ihdr.color_type == ColorType::Grayscale
+        {
+            return reduce_bit_depth_8_or_less(png, minimum_bits);
+        }
        return None;
    }

-    if force_scale {
-        return scaled_bit_depth_16_to_8(png);
-    }
-
    // Reduce from 16 to 8 bits per channel per pixel
-    if png.data.chunks_exact(2).any(|pair| pair[0] != pair[1]) {
+    if png.data.chunks(2).any(|pair| pair[0] != pair[1]) {
        // Can't reduce
        return None;
    }

    Some(PngImage {
-        data: png.data.chunks_exact(2).map(|pair| pair[0]).collect(),
+        data: png.data.iter().step_by(2).cloned().collect(),
        ihdr: IhdrData {
-            color_type: png.ihdr.color_type.clone(),
            bit_depth: BitDepth::Eight,
            ..png.ihdr
        },
+        palette: None,
+        transparency_pixel: png.transparency_pixel.clone(),
+        aux_headers: png.aux_headers.clone(),
    })
 }

-/// Forcibly reduce a 16-bit image to 8-bit by scaling, returning the reduced image if successful
 #[must_use]
-pub fn scaled_bit_depth_16_to_8(png: &PngImage) -> Option<PngImage> {
-    if png.ihdr.bit_depth != BitDepth::Sixteen {
+pub fn reduce_bit_depth_8_or_less(png: &PngImage, mut minimum_bits: usize) -> Option<PngImage> {
+    assert!((1..8).contains(&minimum_bits));
+    let bit_depth: usize = png.ihdr.bit_depth.as_u8() as usize;
+    if minimum_bits >= bit_depth || bit_depth > 8 {
        return None;
    }
+    // Calculate the current number of pixels per byte
+    let ppb = 8 / bit_depth;

-    // Reduce from 16 to 8 bits per channel per pixel by scaling when necessary
-    let data = png
-        .data
-        .chunks_exact(2)
-        .map(|pair| {
-            if pair[0] == pair[1] {
-                return pair[0];
+    if png.ihdr.color_type == ColorType::Indexed {
+        for line in png.scan_lines(false) {
+            let line_max = line
+                .data
+                .iter()
+                .map(|&byte| match png.ihdr.bit_depth {
+                    BitDepth::Two => (byte & 0x3)
+                        .max((byte >> 2) & 0x3)
+                        .max((byte >> 4) & 0x3)
+                        .max(byte >> 6),
+                    BitDepth::Four => (byte & 0xF).max(byte >> 4),
+                    _ => byte,
+                })
+                .max()
+                .unwrap_or(0);
+            let required_bits = match line_max {
+                x if x > 0x0F => 8,
+                x if x > 0x03 => 4,
+                x if x > 0x01 => 2,
+                _ => 1,
+            };
+            if required_bits > minimum_bits {
+                minimum_bits = required_bits;
+                if minimum_bits >= bit_depth {
+                    // Not reducable
+                    return None;
+                }
            }
-            // See: http://www.libpng.org/pub/png/spec/1.2/PNG-Decoders.html#D.Sample-depth-rescaling
-            // This allows values such as 0x00FF to be rounded to 0x01 rather than truncated to 0x00
-            let val = f32::from(u16::from_be_bytes([pair[0], pair[1]]));
-            (val * (255.0 / 65535.0)).round() as u8
-        })
-        .collect();
-
-    Some(PngImage {
-        data,
-        ihdr: IhdrData {
-            color_type: png.ihdr.color_type.clone(),
-            bit_depth: BitDepth::Eight,
-            ..png.ihdr
-        },
-    })
-}
-
-/// Attempt to reduce an 8-bit image to a lower bit depth, returning the reduced image if successful
-#[must_use]
-pub fn reduced_bit_depth_8_or_less(png: &PngImage) -> Option<PngImage> {
-    if png.ihdr.bit_depth != BitDepth::Eight || png.channels_per_pixel() != 1 {
-        return None;
-    }
-
-    let minimum_bits = if let ColorType::Indexed { palette } = &png.ihdr.color_type {
-        // We can easily determine minimum depth by the palette size
-        match palette.len() {
-            0..=2 => 1,
-            3..=4 => 2,
-            5..=16 => 4,
-            _ => return None,
        }
    } else {
-        let mut minimum_bits = 1;
-
-        // Finding minimum depth for grayscale is much more complicated
-        let mut mask = 1;
-        let mut divisions = 1..8;
+        // Checking for grayscale depth reduction is quite different than for indexed
+        // Note: In rare cases, padding bits in the data may cause this to incorrectly return None
+        let mut mask = (1 << minimum_bits) - 1;
+        let mut divisions = 1..(bit_depth / minimum_bits);
        for &b in &png.data {
            if b == 0 || b == 255 {
                continue;
            }
            'try_depth: loop {
-                // Align the first pixel division with the mask
-                let mut byte = b.rotate_left(minimum_bits as u32);
-                // Each potential division of this pixel must be identical to successfully reduce
-                let compare = byte & mask;
-                for _ in divisions.clone() {
-                    // Align the next division with the mask
+                let mut byte = b;
+                // Loop over each pixel in the byte
+                for _ in 0..ppb {
+                    // Align the first pixel division with the mask
                    byte = byte.rotate_left(minimum_bits as u32);
-                    if byte & mask != compare {
-                        // This depth is not possible, try the next one up
-                        minimum_bits <<= 1;
-                        if minimum_bits == 8 {
-                            return None;
+                    // Each potential division of this pixel must be identical to successfully reduce
+                    let compare = byte & mask;
+                    for _ in divisions.clone() {
+                        // Align the next division with the mask
+                        byte = byte.rotate_left(minimum_bits as u32);
+                        if byte & mask != compare {
+                            // This depth is not possible, try the next one up
+                            minimum_bits <<= 1;
+                            if minimum_bits == bit_depth {
+                                return None;
+                            }
+                            mask = (1 << minimum_bits) - 1;
+                            divisions = 1..(bit_depth / minimum_bits);
+                            continue 'try_depth;
                        }
-                        mask = (1 << minimum_bits) - 1;
-                        divisions = 1..(8 / minimum_bits);
-                        continue 'try_depth;
                    }
                }
                break;
            }
        }
-
-        minimum_bits
-    };
+    }

    let mut reduced = Vec::with_capacity(png.data.len());
    let mask = (1 << minimum_bits) - 1;
    for line in png.scan_lines(false) {
        // Loop over the data in chunks that will produce 1 byte of output
-        for chunk in line.data.chunks(8 / minimum_bits) {
+        for chunk in line.data.chunks(bit_depth / minimum_bits) {
            let mut new_byte = 0;
            let mut shift = 8;
-            for byte in chunk {
-                shift -= minimum_bits;
-                // Take the low bits of the pixel and shift them into the output byte
-                new_byte |= (byte & mask) << shift;
+            for &(mut byte) in chunk {
+                // Loop over each pixel in the byte
+                for _ in 0..ppb {
+                    // Align the current pixel with the mask
+                    byte = byte.rotate_left(bit_depth as u32);
+                    shift -= minimum_bits;
+                    // Take the low bits of the pixel and shift them into the output byte
+                    new_byte |= (byte & mask) << shift;
+                }
            }
            reduced.push(new_byte);
        }
    }

    // If the image is grayscale we also need to reduce the transparency pixel
-    let color_type = if let ColorType::Grayscale {
-        transparent_shade: Some(trans),
-    } = png.ihdr.color_type
-    {
-        let reduced_trans = (trans & 0xFF) >> (8 - minimum_bits);
+    let mut transparency_pixel = png
+        .transparency_pixel
+        .clone()
+        .filter(|t| png.ihdr.color_type == ColorType::Grayscale && t.len() >= 2);
+    if let Some(trans) = transparency_pixel {
+        let reduced_trans = trans[1] >> (bit_depth - minimum_bits);
        // Verify the reduction is valid by restoring back to original bit depth
        let mut check = reduced_trans;
        let mut bits = minimum_bits;
-        while bits < 8 {
-            check = (check << bits) | check;
+        while bits < bit_depth {
+            check = check << bits | check;
            bits <<= 1;
        }
-        // If the transparency doesn't fit the new bit depth it is therefore unused - set it to None
-        ColorType::Grayscale {
-            transparent_shade: if trans == check {
-                Some(reduced_trans)
-            } else {
-                None
-            },
+        if trans[0] == 0 && trans[1] == check {
+            transparency_pixel = Some(vec![0, reduced_trans]);
+        } else {
+            // The transparency doesn't fit the new bit depth and is therefore unused - set it to None
+            transparency_pixel = None;
        }
-    } else {
-        png.ihdr.color_type.clone()
-    };
+    }

    Some(PngImage {
        data: reduced,
        ihdr: IhdrData {
-            color_type,
-            bit_depth: (minimum_bits as u8).try_into().unwrap(),
-            ..png.ihdr
-        },
-    })
-}
-
-/// Expand a 1/2/4-bit image to 8-bit, returning the expanded image if successful
-#[must_use]
-pub fn expanded_bit_depth_to_8(png: &PngImage) -> Option<PngImage> {
-    let bit_depth = png.ihdr.bit_depth as u32;
-    if bit_depth >= 8 {
-        return None;
-    }
-    // Calculate the current number of pixels per byte
-    let ppb = 8 / bit_depth;
-    let is_gray = matches!(png.ihdr.color_type, ColorType::Grayscale { .. });
-
-    let mut reduced = Vec::with_capacity((png.ihdr.width * png.ihdr.height) as usize);
-    let mut length = 0;
-    let mask = (1 << bit_depth) - 1;
-    for line in png.scan_lines(false) {
-        for &(mut byte) in line.data {
-            // Loop over each pixel in the byte
-            for _ in 0..ppb {
-                // Align the current pixel with the mask
-                byte = byte.rotate_left(bit_depth);
-                let mut val = byte & mask;
-                if is_gray {
-                    // Expand gray by repeating the bits
-                    let mut bits = bit_depth;
-                    while bits < 8 {
-                        val = (val << bits) | val;
-                        bits <<= 1;
-                    }
-                }
-                reduced.push(val);
-            }
-        }
-        // Trim any overflow
-        length += line.num_pixels;
-        reduced.truncate(length);
-    }
-
-    // If the image is grayscale we also need to expand the transparency pixel
-    let color_type = if let ColorType::Grayscale {
-        transparent_shade: Some(mut trans),
-    } = png.ihdr.color_type
-    {
-        let mut bits = bit_depth;
-        while bits < 8 {
-            trans = (trans << bits) | trans;
-            bits <<= 1;
-        }
-        ColorType::Grayscale {
-            transparent_shade: Some(trans),
-        }
-    } else {
-        png.ihdr.color_type.clone()
-    };
-
-    Some(PngImage {
-        data: reduced,
-        ihdr: IhdrData {
-            color_type,
-            bit_depth: BitDepth::Eight,
+            bit_depth: BitDepth::from_u8(minimum_bits as u8),
            ..png.ihdr
        },
+        aux_headers: png.aux_headers.clone(),
+        palette: png.palette.clone(),
+        transparency_pixel,
    })
 }
--- a/src/reduction/color.rs
+++ b/src/reduction/color.rs
@ -1,112 +1,153 @@
+use crate::colors::{BitDepth, ColorType};
+use crate::headers::IhdrData;
+use crate::png::PngImage;
+use indexmap::IndexMap;
+use rgb::{FromSlice, RGB8, RGBA, RGBA8};
+use rustc_hash::FxHasher;
 use std::hash::{BuildHasherDefault, Hash};

-use indexmap::IndexSet;
-use rgb::{ComponentMap, FromSlice, RGB, RGBA, alt::Gray};
-use rustc_hash::FxHasher;
+type FxIndexMap<K, V> = IndexMap<K, V, BuildHasherDefault<FxHasher>>;

-use crate::{
-    colors::{BitDepth, ColorType},
-    headers::IhdrData,
-    png::PngImage,
-};
-
-type FxIndexSet<V> = IndexSet<V, BuildHasherDefault<FxHasher>>;
-
-/// Maximum size difference between indexed and channels to consider a candidate for evaluation
-pub const INDEXED_MAX_DIFF: usize = 20000;
-
-fn build_palette<T>(
+fn reduce_scanline_to_palette<T>(
    iter: impl IntoIterator<Item = T>,
+    palette: &mut FxIndexMap<T, u8>,
    reduced: &mut Vec<u8>,
-) -> Option<FxIndexSet<T>>
+) -> bool
 where
    T: Eq + Hash,
 {
-    let mut palette = FxIndexSet::default();
-    palette.reserve(257);
    for pixel in iter {
-        let (idx, _) = palette.insert_full(pixel);
-        if idx == 256 {
-            return None;
-        }
-        reduced.push(idx as u8);
+        let idx = if let Some(&idx) = palette.get(&pixel) {
+            idx
+        } else {
+            let len = palette.len();
+            if len == 256 {
+                return false;
+            }
+            let idx = len as u8;
+            palette.insert(pixel, idx);
+            idx
+        };
+        reduced.push(idx);
    }
-    Some(palette)
+    true
 }

 #[must_use]
-pub fn reduced_to_indexed(png: &PngImage, allow_grayscale: bool) -> Option<PngImage> {
+pub fn reduce_to_palette(png: &PngImage) -> Option<PngImage> {
    if png.ihdr.bit_depth != BitDepth::Eight {
        return None;
    }
-    if matches!(png.ihdr.color_type, ColorType::Indexed { .. }) {
-        return None;
-    }
-    if !allow_grayscale && png.ihdr.color_type.is_gray() {
+    let mut raw_data = Vec::with_capacity(png.data.len());
+    let mut palette = FxIndexMap::default();
+    palette.reserve(257);
+    let transparency_pixel = png
+        .transparency_pixel
+        .as_ref()
+        .filter(|t| png.ihdr.color_type == ColorType::RGB && t.len() >= 6)
+        .map(|t| RGB8::new(t[1], t[3], t[5]));
+    let ok = if png.ihdr.color_type == ColorType::RGB {
+        reduce_scanline_to_palette(
+            png.data.as_rgb().iter().cloned().map(|px| {
+                px.alpha(if Some(px) != transparency_pixel {
+                    255
+                } else {
+                    0
+                })
+            }),
+            &mut palette,
+            &mut raw_data,
+        )
+    } else if png.ihdr.color_type == ColorType::GrayscaleAlpha {
+        reduce_scanline_to_palette(
+            png.data.as_gray_alpha().iter().cloned().map(|px| RGBA {
+                r: px.0,
+                g: px.0,
+                b: px.0,
+                a: px.1,
+            }),
+            &mut palette,
+            &mut raw_data,
+        )
+    } else {
+        debug_assert_eq!(png.ihdr.color_type, ColorType::RGBA);
+        reduce_scanline_to_palette(
+            png.data.as_rgba().iter().cloned(),
+            &mut palette,
+            &mut raw_data,
+        )
+    };
+    if !ok {
        return None;
    }

-    let mut raw_data = Vec::with_capacity(png.data.len() / png.channels_per_pixel());
-    let palette: Vec<_> = match png.ihdr.color_type {
-        ColorType::Grayscale { transparent_shade } => {
-            let pmap = build_palette(png.data.as_gray().iter().copied(), &mut raw_data)?;
-            // Convert the Gray16 transparency to Gray8
-            let transparency_pixel = transparent_shade.map(|t| Gray::from(t as u8));
-            pmap.into_iter()
-                .map(|px| {
-                    RGB::from(px).with_alpha(if Some(px) == transparency_pixel {
-                        0
-                    } else {
-                        255
-                    })
-                })
-                .collect()
+    let num_transparent = palette
+        .iter()
+        .filter_map(|(px, &idx)| {
+            if px.a != 255 {
+                Some(idx as usize + 1)
+            } else {
+                None
+            }
+        })
+        .max();
+    let trns_size = num_transparent.map_or(0, |n| n + 8);
+
+    let headers_size = palette.len() * 3 + 8 + trns_size;
+    if raw_data.len() + headers_size > png.data.len() {
+        // Reduction would result in a larger image
+        return None;
+    }
+
+    let mut aux_headers = png.aux_headers.clone();
+    if let Some(bkgd_header) = png.aux_headers.get(b"bKGD") {
+        if bkgd_header.len() != 6 {
+            // malformed chunk?
+            return None;
        }
-        ColorType::RGB { transparent_color } => {
-            let pmap = build_palette(png.data.as_rgb().iter().copied(), &mut raw_data)?;
-            // Convert the RGB16 transparency to RGB8
-            let transparency_pixel = transparent_color.map(|t| t.map(|c| c as u8));
-            pmap.into_iter()
-                .map(|px| {
-                    px.with_alpha(if Some(px) == transparency_pixel {
-                        0
-                    } else {
-                        255
-                    })
-                })
-                .collect()
-        }
-        ColorType::GrayscaleAlpha => {
-            let pmap = build_palette(png.data.as_gray_alpha().iter().copied(), &mut raw_data)?;
-            pmap.into_iter().map(RGBA::from).collect()
-        }
-        ColorType::RGBA => {
-            let pmap = build_palette(png.data.as_rgba().iter().copied(), &mut raw_data)?;
-            pmap.into_iter().collect()
-        }
-        _ => return None,
-    };
+        // In bKGD 16-bit values are used even for 8-bit images
+        let bg = RGBA8::new(bkgd_header[1], bkgd_header[3], bkgd_header[5], 255);
+        let entry = if let Some(&entry) = palette.get(&bg) {
+            entry
+        } else if palette.len() < 256 {
+            let entry = palette.len() as u8;
+            palette.insert(bg, entry);
+            entry
+        } else {
+            return None; // No space in palette to store the bg as an index
+        };
+        aux_headers.insert(*b"bKGD", vec![entry]);
+    }
+
+    if let Some(sbit_header) = png.aux_headers.get(b"sBIT") {
+        // Some programs save the sBIT header as RGB even if the image is RGBA.
+        aux_headers.insert(*b"sBIT", sbit_header.iter().cloned().take(3).collect());
+    }
+
+    let mut palette_vec = vec![RGBA8::new(0, 0, 0, 0); palette.len()];
+    for (color, idx) in palette {
+        palette_vec[idx as usize] = color;
+    }

    Some(PngImage {
        data: raw_data,
        ihdr: IhdrData {
-            color_type: ColorType::Indexed { palette },
+            color_type: ColorType::Indexed,
            ..png.ihdr
        },
+        aux_headers,
+        transparency_pixel: None,
+        palette: Some(palette_vec),
    })
 }

 #[must_use]
-pub fn reduced_rgb_to_grayscale(png: &PngImage) -> Option<PngImage> {
-    if !png.ihdr.color_type.is_rgb() {
-        return None;
-    }
-
+pub fn reduce_rgb_to_grayscale(png: &PngImage) -> Option<PngImage> {
    let mut reduced = Vec::with_capacity(png.data.len());
-    let byte_depth = png.bytes_per_channel();
-    let bpp = png.channels_per_pixel() * byte_depth;
+    let byte_depth = png.ihdr.bit_depth.as_u8() as usize >> 3;
+    let bpp = png.channels_per_pixel() as usize * byte_depth;
    let last_color = 2 * byte_depth;
-    for pixel in png.data.chunks_exact(bpp) {
+    for pixel in png.data.chunks(bpp) {
        if byte_depth == 1 {
            if pixel[0] != pixel[1] || pixel[1] != pixel[2] {
                return None;
@ -117,90 +158,39 @@ pub fn reduced_rgb_to_grayscale(png: &PngImage) -> Option<PngImage> {
        reduced.extend_from_slice(&pixel[last_color..]);
    }

-    let color_type = match png.ihdr.color_type {
-        ColorType::RGB { transparent_color } => ColorType::Grayscale {
-            // Copy the transparent component if it is also gray
-            transparent_shade: transparent_color
-                .filter(|t| t.r == t.g && t.g == t.b)
-                .map(|t| t.r),
-        },
-        _ => ColorType::GrayscaleAlpha,
+    let transparency_pixel = if let Some(ref trns) = png.transparency_pixel {
+        if trns.len() != 6 || trns[0..2] != trns[2..4] || trns[2..4] != trns[4..6] {
+            None
+        } else {
+            Some(trns[0..2].to_owned())
+        }
+    } else {
+        png.transparency_pixel.clone()
    };

+    let mut aux_headers = png.aux_headers.clone();
+    if let Some(sbit_header) = png.aux_headers.get(b"sBIT") {
+        if let Some(&byte) = sbit_header.first() {
+            aux_headers.insert(*b"sBIT", vec![byte]);
+        }
+    }
+    if let Some(bkgd_header) = png.aux_headers.get(b"bKGD") {
+        if let Some(b) = bkgd_header.get(0..2) {
+            aux_headers.insert(*b"bKGD", b.to_owned());
+        }
+    }
+
    Some(PngImage {
        data: reduced,
        ihdr: IhdrData {
-            color_type,
+            color_type: match png.ihdr.color_type {
+                ColorType::RGBA => ColorType::GrayscaleAlpha,
+                _ => ColorType::Grayscale,
+            },
            ..png.ihdr
        },
-    })
-}
-
-/// Attempt to convert indexed to a different color type, returning the resulting image if successful
-#[must_use]
-pub fn indexed_to_channels(
-    png: &PngImage,
-    allow_grayscale: bool,
-    optimize_alpha: bool,
-) -> Option<PngImage> {
-    if png.ihdr.bit_depth != BitDepth::Eight {
-        return None;
-    }
-    let mut palette = match &png.ihdr.color_type {
-        ColorType::Indexed { palette } => palette.clone(),
-        _ => return None,
-    };
-
-    // Ensure fully transparent colors are black, which can help with grayscale conversion
-    if optimize_alpha {
-        for color in &mut palette {
-            if color.a == 0 {
-                color.r = 0;
-                color.g = 0;
-                color.b = 0;
-            }
-        }
-    }
-
-    // Determine which channels are required
-    let is_gray = if allow_grayscale {
-        palette.iter().all(|c| c.r == c.g && c.g == c.b)
-    } else {
-        false
-    };
-    let has_alpha = palette.iter().any(|c| c.a != 255);
-    let color_type = match (is_gray, has_alpha) {
-        (false, true) => ColorType::RGBA,
-        (false, false) => ColorType::RGB {
-            transparent_color: None,
-        },
-        (true, true) => ColorType::GrayscaleAlpha,
-        (true, false) => ColorType::Grayscale {
-            transparent_shade: None,
-        },
-    };
-
-    // Don't proceed if output would be too much larger
-    let out_size = color_type.channels_per_pixel() as usize * png.data.len();
-    if out_size - png.data.len() > INDEXED_MAX_DIFF {
-        return None;
-    }
-
-    // Construct the new data
-    let black = RGBA::new(0, 0, 0, 255);
-    let ch_start = if is_gray { 2 } else { 0 };
-    let ch_end = if has_alpha { 3 } else { 2 };
-    let mut data = Vec::with_capacity(out_size);
-    for b in &png.data {
-        let color = palette.get(*b as usize).unwrap_or(&black);
-        data.extend_from_slice(&color.as_ref()[ch_start..=ch_end]);
-    }
-
-    Some(PngImage {
-        ihdr: IhdrData {
-            color_type,
-            ..png.ihdr
-        },
-        data,
+        aux_headers,
+        palette: None,
+        transparency_pixel,
    })
 }
--- a/src/reduction/mod.rs
+++ b/src/reduction/mod.rs
@ -1,203 +1,251 @@
-use std::sync::Arc;
-
-use crate::{ColorType, Deadline, Deflater, Options, evaluate::Evaluator, png::PngImage};
+use crate::colors::{BitDepth, ColorType};
+use crate::headers::IhdrData;
+use crate::png::PngImage;
+use indexmap::map::{Entry::*, IndexMap};
+use rgb::RGBA8;
+use std::borrow::Cow;

 pub mod alpha;
-use crate::alpha::*;
+use crate::alpha::reduced_alpha_channel;
 pub mod bit_depth;
-use crate::bit_depth::*;
+use crate::bit_depth::reduce_bit_depth_8_or_less;
 pub mod color;
 use crate::color::*;
-pub mod palette;
-use crate::palette::*;

-pub(crate) fn perform_reductions(
-    mut png: Arc<PngImage>,
-    opts: &Options,
-    deadline: &Deadline,
-    eval: &Evaluator,
-) -> Arc<PngImage> {
-    let mut evaluation_added = false;
+pub(crate) use crate::alpha::cleaned_alpha_channel;
+pub(crate) use crate::bit_depth::reduce_bit_depth;

-    // At low compression levels, skip some transformations which are less likely to be effective
-    // This currently affects optimization presets 0-2
-    let cheap = match opts.deflater {
-        Deflater::Libdeflater { compression } => compression < 12 && opts.fast_evaluation,
-        _ => false,
-    };
-
-    // Interlacing must be processed first in order to evaluate the rest correctly
-    if let Some(interlacing) = opts.interlace {
-        if let Some(reduced) = png.change_interlacing(interlacing) {
-            png = Arc::new(reduced);
-        }
+/// Attempt to reduce the number of colors in the palette
+/// Returns `None` if palette hasn't changed
+pub fn reduced_palette(png: &PngImage, optimize_alpha: bool) -> Option<PngImage> {
+    if png.ihdr.color_type != ColorType::Indexed {
+        // Can't reduce if there is no palette
+        return None;
+    }
+    if png.ihdr.bit_depth == BitDepth::One {
+        // Gains from 1-bit images will be at most 1 byte
+        // Not worth the CPU time
+        return None;
    }

-    // If alpha optimization is enabled, clean the alpha channel before continuing
-    // This can allow some color type reductions which may not have been possible otherwise
-    if opts.optimize_alpha && !deadline.passed() {
-        if let Some(reduced) = cleaned_alpha_channel(&png) {
-            png = Arc::new(reduced);
-        }
-    }
+    let mut palette_map = [None; 256];
+    let mut used = [false; 256];
+    {
+        let palette = png.palette.as_ref()?;

-    // Attempt to reduce 16-bit to 8-bit
-    // This is just removal of bytes and does not need to be evaluated
-    if opts.bit_depth_reduction && !deadline.passed() {
-        if let Some(reduced) = reduced_bit_depth_16_to_8(&png, opts.scale_16) {
-            png = Arc::new(reduced);
-        }
-    }
-
-    // Attempt to reduce RGB to grayscale
-    // This is just removal of bytes and does not need to be evaluated
-    if opts.color_type_reduction && opts.grayscale_reduction && !deadline.passed() {
-        if let Some(reduced) = reduced_rgb_to_grayscale(&png) {
-            png = Arc::new(reduced);
-        }
-    }
-
-    // Attempt to expand the bit depth to 8
-    // This does need to be evaluated but will be done so later when it gets reduced again
-    if opts.bit_depth_reduction && !deadline.passed() {
-        if let Some(reduced) = expanded_bit_depth_to_8(&png) {
-            png = Arc::new(reduced);
-        }
-    }
-
-    // Now retain the current png for the evaluator baseline
-    // It will only be entered into the evaluator if there are also others to evaluate
-    let mut baseline = png.clone();
-
-    // Attempt to reduce and sort the palette
-    if opts.palette_reduction && !deadline.passed() {
-        if let Some(reduced) = reduced_palette(&png, opts.optimize_alpha) {
-            png = Arc::new(reduced);
-            // If the palette was reduced but the data is unchanged then this should become the baseline
-            if png.data == baseline.data {
-                baseline = png.clone();
-            }
-        }
-        if let Some(reduced) = sorted_palette(&png) {
-            png = Arc::new(reduced);
-        }
-        // If either action changed the data then enter this into the evaluator
-        if !Arc::ptr_eq(&png, &baseline) {
-            eval.try_image_with_description(png.clone(), "Indexed (luma sort)");
-            evaluation_added = true;
-        }
-    }
-
-    // Attempt alpha removal
-    if opts.color_type_reduction && !deadline.passed() {
-        if let Some(reduced) = reduced_alpha_channel(&png, opts.optimize_alpha) {
-            png = Arc::new(reduced);
-            // For small differences, if a tRNS chunk is required then enter this into the evaluator
-            // Otherwise it is mostly just removal of bytes and should become the baseline
-            if png.ihdr.color_type.has_trns() && baseline.data.len() - png.data.len() <= 1000 {
-                eval.try_image(png.clone());
-                evaluation_added = true;
-            } else {
-                baseline = png.clone();
-            }
-        }
-    }
-
-    // Attempt to convert from indexed to channels
-    // This may give a better result due to dropping the PLTE chunk
-    if !cheap && opts.color_type_reduction && !deadline.passed() {
-        if let Some(reduced) =
-            indexed_to_channels(&png, opts.grayscale_reduction, opts.optimize_alpha)
-        {
-            // This result should not be passed on to subsequent reductions
-            eval.try_image(Arc::new(reduced));
-            evaluation_added = true;
-        }
-    }
-
-    // Attempt to reduce to indexed
-    // Keep the existing `png` var in case it is grayscale - we can test both for depth reduction later
-    let mut indexed = None;
-    if opts.color_type_reduction && opts.palette_reduction && !deadline.passed() {
-        if let Some(reduced) = reduced_to_indexed(&png, opts.grayscale_reduction) {
-            // Make sure the palette gets sorted (but don't bother evaluating both results)
-            let new = Arc::new(sorted_palette(&reduced).unwrap_or(reduced));
-            // For relatively small differences, enter this into the evaluator
-            // Otherwise we're confident enough for it to become the baseline
-            if png.data.len() - new.data.len() <= INDEXED_MAX_DIFF {
-                eval.try_image_with_description(new.clone(), "Indexed (luma sort)");
-                evaluation_added = true;
-            } else {
-                baseline = new.clone();
-            }
-            indexed = Some(new);
-        }
-    }
-
-    // Attempt additional palette sorting techniques
-    if !cheap && opts.palette_reduction {
-        // Collect a list of palettes so we can avoid evaluating the same one twice
-        let mut palettes = Vec::new();
-        if let ColorType::Indexed { palette } = &baseline.ihdr.color_type {
-            palettes.push(palette.clone());
-        }
-        // Make sure we use the `indexed` var as input if it exists
-        // This one doesn't need to be kept in the palette list as the sorters will fail if there's no change
-        let input = indexed.as_ref().unwrap_or(&png);
-
-        // Attempt to sort the palette using the battiato method
-        if !deadline.passed() {
-            if let Some(reduced) = sorted_palette_battiato(input) {
-                if let ColorType::Indexed { palette } = &reduced.ihdr.color_type {
-                    if !palettes.contains(palette) {
-                        palettes.push(palette.clone());
-                        eval.try_image_with_description(
-                            Arc::new(reduced),
-                            "Indexed (battiato sort)",
-                        );
-                        evaluation_added = true;
-                    }
+        // Find palette entries that are never used
+        match png.ihdr.bit_depth {
+            BitDepth::Eight => {
+                for &byte in &png.data {
+                    used[byte as usize] = true;
                }
            }
+            BitDepth::Four => {
+                for &byte in &png.data {
+                    used[(byte & 0x0F) as usize] = true;
+                    used[(byte >> 4) as usize] = true;
+                }
+            }
+            BitDepth::Two => {
+                for &byte in &png.data {
+                    used[(byte & 0x03) as usize] = true;
+                    used[((byte >> 2) & 0x03) as usize] = true;
+                    used[((byte >> 4) & 0x03) as usize] = true;
+                    used[(byte >> 6) as usize] = true;
+                }
+            }
+            _ => unreachable!(),
        }

-        // Attempt to sort the palette using the mzeng method
-        if !deadline.passed() {
-            if let Some(reduced) = sorted_palette_mzeng(input) {
-                if let ColorType::Indexed { palette } = &reduced.ihdr.color_type {
-                    if !palettes.contains(palette) {
-                        palettes.push(palette.clone());
-                        eval.try_image_with_description(Arc::new(reduced), "Indexed (mzeng sort)");
-                        evaluation_added = true;
-                    }
+        let mut used_enumerated: Vec<(usize, &bool)> = used.iter().enumerate().collect();
+        used_enumerated.sort_by(|a, b| {
+            //Sort by ascending alpha and descending luma.
+            let color_val = |i| {
+                let color = palette
+                    .get(i)
+                    .copied()
+                    .unwrap_or_else(|| RGBA8::new(0, 0, 0, 255));
+                ((color.a as i32) << 18)
+                // These are coefficients for standard sRGB to luma conversion
+                - i32::from(color.r) * 299
+                - i32::from(color.g) * 587
+                - i32::from(color.b) * 114
+            };
+            color_val(a.0).cmp(&color_val(b.0))
+        });
+
+        // Make sure the background is also included, but only after sorting since it may not be used in idat
+        if let Some(&idx) = png.aux_headers.get(b"bKGD").and_then(|b| b.first()) {
+            if !used[idx as usize] {
+                used_enumerated.push((idx as usize, &true));
+            }
+        }
+
+        let mut next_index = 0_u16;
+        let mut seen = IndexMap::with_capacity(palette.len());
+        for (i, used) in used_enumerated.iter().cloned() {
+            if !used {
+                continue;
+            }
+            // There are invalid files that use pixel indices beyond palette size
+            let mut color = palette
+                .get(i)
+                .cloned()
+                .unwrap_or_else(|| RGBA8::new(0, 0, 0, 255));
+            // If there are multiple fully transparent entries, reduce them into one
+            if optimize_alpha && color.a == 0 {
+                color.r = 0;
+                color.g = 0;
+                color.b = 0;
+            }
+            match seen.entry(color) {
+                Vacant(new) => {
+                    palette_map[i] = Some(next_index as u8);
+                    new.insert(next_index as u8);
+                    next_index += 1;
                }
+                Occupied(remap_to) => palette_map[i] = Some(*remap_to.get()),
            }
        }
    }

-    // Attempt to reduce to a lower bit depth
-    if opts.bit_depth_reduction && !deadline.passed() {
-        // First try the `png` var
-        let reduced = reduced_bit_depth_8_or_less(&png);
-        // Then try the `indexed` var, unless we're doing cheap evaluations and already have a reduction
-        if (!cheap || reduced.is_none()) && !deadline.passed() {
-            if let Some(indexed) = indexed.and_then(|png| reduced_bit_depth_8_or_less(&png)) {
-                // Only evaluate this if it's different from the first result (which must be grayscale if it exists)
-                if reduced.as_ref().is_none_or(|r| r.data != indexed.data) {
-                    eval.try_image(Arc::new(indexed));
-                    evaluation_added = true;
-                }
-            }
-        }
-        // Enter the first result into the evaluator
-        if let Some(reduced) = reduced {
-            eval.try_image(Arc::new(reduced));
-            evaluation_added = true;
-        }
-    }
-
-    if evaluation_added {
-        eval.try_image(baseline.clone());
-    }
-    baseline
+    do_palette_reduction(png, &palette_map)
+}
+
+#[must_use]
+fn do_palette_reduction(png: &PngImage, palette_map: &[Option<u8>; 256]) -> Option<PngImage> {
+    let byte_map = palette_map_to_byte_map(png, palette_map)?;
+
+    // Reassign data bytes to new indices
+    let raw_data = png.data.iter().map(|b| byte_map[*b as usize]).collect();
+
+    let mut aux_headers = png.aux_headers.clone();
+    if let Some(bkgd_header) = png.aux_headers.get(b"bKGD") {
+        if let Some(Some(map_to)) = bkgd_header
+            .first()
+            .and_then(|&idx| palette_map.get(idx as usize))
+        {
+            aux_headers.insert(*b"bKGD", vec![*map_to]);
+        }
+    }
+
+    Some(PngImage {
+        ihdr: IhdrData {
+            color_type: ColorType::Indexed,
+            ..png.ihdr
+        },
+        data: raw_data,
+        transparency_pixel: None,
+        palette: Some(reordered_palette(png.palette.as_ref()?, palette_map)),
+        aux_headers,
+    })
+}
+
+fn palette_map_to_byte_map(png: &PngImage, palette_map: &[Option<u8>; 256]) -> Option<[u8; 256]> {
+    if (0..256).all(|i| palette_map[i].map_or(true, |to| to == i as u8)) {
+        // No reduction necessary
+        return None;
+    }
+
+    let mut byte_map = [0_u8; 256];
+
+    // low bit-depths can be pre-computed for every byte value
+    match png.ihdr.bit_depth {
+        BitDepth::Eight => {
+            for byte in 0..=255usize {
+                byte_map[byte] = palette_map[byte].unwrap_or(0)
+            }
+        }
+        BitDepth::Four => {
+            for byte in 0..=255usize {
+                byte_map[byte] = palette_map[(byte & 0x0F)].unwrap_or(0)
+                    | (palette_map[(byte >> 4)].unwrap_or(0) << 4);
+            }
+        }
+        BitDepth::Two => {
+            for byte in 0..=255usize {
+                byte_map[byte] = palette_map[(byte & 0x03)].unwrap_or(0)
+                    | (palette_map[((byte >> 2) & 0x03)].unwrap_or(0) << 2)
+                    | (palette_map[((byte >> 4) & 0x03)].unwrap_or(0) << 4)
+                    | (palette_map[(byte >> 6)].unwrap_or(0) << 6);
+            }
+        }
+        _ => {}
+    }
+
+    Some(byte_map)
+}
+
+fn reordered_palette(palette: &[RGBA8], palette_map: &[Option<u8>; 256]) -> Vec<RGBA8> {
+    let max_index = palette_map.iter().cloned().flatten().max().unwrap_or(0) as usize;
+    let mut new_palette = vec![RGBA8::new(0, 0, 0, 255); max_index + 1];
+    for (&color, &map_to) in palette.iter().zip(palette_map.iter()) {
+        if let Some(map_to) = map_to {
+            new_palette[map_to as usize] = color;
+        }
+    }
+    new_palette
+}
+
+/// Attempt to reduce the color type of the image
+/// Returns true if the color type was reduced, false otherwise
+pub fn reduce_color_type(
+    png: &PngImage,
+    grayscale_reduction: bool,
+    optimize_alpha: bool,
+) -> Option<PngImage> {
+    let mut should_reduce_bit_depth = false;
+    let mut reduced = Cow::Borrowed(png);
+
+    // Go down one step at a time
+    // Maybe not the most efficient, but it's safe
+    if grayscale_reduction && matches!(reduced.ihdr.color_type, ColorType::RGBA | ColorType::RGB) {
+        if let Some(r) = reduce_rgb_to_grayscale(&reduced) {
+            reduced = Cow::Owned(r);
+            should_reduce_bit_depth = reduced.ihdr.color_type == ColorType::Grayscale;
+        }
+    }
+
+    // Attempt grayscale alpha reduction before palette, as grayscale will typically be smaller than indexed
+    if reduced.ihdr.color_type == ColorType::GrayscaleAlpha {
+        if let Some(r) = reduced_alpha_channel(&reduced, optimize_alpha) {
+            reduced = Cow::Owned(r);
+            should_reduce_bit_depth = true;
+        }
+    }
+
+    if matches!(
+        reduced.ihdr.color_type,
+        ColorType::RGBA | ColorType::RGB | ColorType::GrayscaleAlpha
+    ) {
+        if let Some(r) = reduce_to_palette(&reduced) {
+            reduced = Cow::Owned(r);
+            should_reduce_bit_depth = true;
+
+            // Make sure that palette gets sorted. Ideally, this should be done within reduce_to_palette.
+            if let Some(r) = reduced_palette(&reduced, optimize_alpha) {
+                reduced = Cow::Owned(r);
+            }
+        }
+    }
+
+    // Attempt RGBA alpha reduction after palette, so it can be skipped if palette was successful
+    if reduced.ihdr.color_type == ColorType::RGBA {
+        if let Some(r) = reduced_alpha_channel(&reduced, optimize_alpha) {
+            reduced = Cow::Owned(r);
+        }
+    }
+
+    if should_reduce_bit_depth {
+        // Some conversions will allow us to perform bit depth reduction that
+        // wasn't possible before
+        if let Some(r) = reduce_bit_depth_8_or_less(&reduced, 1) {
+            reduced = Cow::Owned(r);
+        }
+    }
+
+    match reduced {
+        Cow::Owned(r) => Some(r),
+        _ => None,
+    }
 }
--- a/src/reduction/palette.rs
+++ b/src/reduction/palette.rs
@ -1,439 +0,0 @@
-use indexmap::IndexSet;
-use rgb::RGBA8;
-
-use crate::{
-    colors::{BitDepth, ColorType},
-    headers::IhdrData,
-    png::{PngImage, scan_lines::ScanLine},
-};
-
-/// Attempt to reduce the number of colors in the palette, returning the reduced image if successful
-#[must_use]
-pub fn reduced_palette(png: &PngImage, optimize_alpha: bool) -> Option<PngImage> {
-    if png.ihdr.bit_depth != BitDepth::Eight {
-        return None;
-    }
-    let ColorType::Indexed { palette } = &png.ihdr.color_type else {
-        return None;
-    };
-
-    let mut used = [false; 256];
-    for &byte in &png.data {
-        used[byte as usize] = true;
-    }
-
-    let black = RGBA8::new(0, 0, 0, 255);
-    let mut condensed = IndexSet::with_capacity(palette.len());
-    let mut byte_map = [0; 256];
-    let mut did_change = false;
-    for (i, used) in used.iter().enumerate() {
-        if !used {
-            continue;
-        }
-        // There are invalid files that use pixel indices beyond palette size
-        let color = *palette.get(i).unwrap_or(&black);
-        byte_map[i] = add_color_to_set(color, &mut condensed, optimize_alpha);
-        if byte_map[i] as usize != i {
-            did_change = true;
-        }
-    }
-
-    let data = if did_change {
-        // Reassign data bytes to new indices
-        png.data.iter().map(|b| byte_map[*b as usize]).collect()
-    } else if condensed.len() != palette.len() {
-        // Data is unchanged but palette is different size
-        // Note the new palette could potentially be larger if the original had a missing entry
-        png.data.clone()
-    } else {
-        // Nothing has changed
-        return None;
-    };
-
-    let palette: Vec<_> = condensed.into_iter().collect();
-
-    Some(PngImage {
-        ihdr: IhdrData {
-            color_type: ColorType::Indexed { palette },
-            ..png.ihdr
-        },
-        data,
-    })
-}
-
-fn add_color_to_set(mut color: RGBA8, set: &mut IndexSet<RGBA8>, optimize_alpha: bool) -> u8 {
-    // If there are multiple fully transparent entries, reduce them into one
-    if optimize_alpha && color.a == 0 {
-        color.r = 0;
-        color.g = 0;
-        color.b = 0;
-    }
-    let (idx, _) = set.insert_full(color);
-    idx as u8
-}
-
-/// Attempt to sort the colors in the palette by luma, returning the sorted image if successful
-#[must_use]
-pub fn sorted_palette(png: &PngImage) -> Option<PngImage> {
-    if png.ihdr.bit_depth != BitDepth::Eight {
-        return None;
-    }
-    let palette = match &png.ihdr.color_type {
-        ColorType::Indexed { palette } if palette.len() > 1 => palette,
-        _ => return None,
-    };
-
-    let mut enumerated: Vec<_> = palette.iter().enumerate().collect();
-    // Put the most popular edge color first, which can help slightly if the filter bytes are 0
-    let keep_first = most_popular_edge_color(palette.len(), png);
-    let first = keep_first.map(|f| enumerated.remove(f));
-
-    // Sort the palette
-    enumerated.sort_by(|a, b| {
-        // Sort by ascending alpha and descending luma
-        let color_val = |color: &RGBA8| {
-            let a = i32::from(color.a);
-            // Put 7 high bits of alpha first, then luma, then low bit of alpha
-            // This provides notable improvement in images with a lot of alpha
-            ((a & 0xFE) << 18) + (a & 0x01)
-            // These are coefficients for standard sRGB to luma conversion
-            - i32::from(color.r) * 299
-            - i32::from(color.g) * 587
-            - i32::from(color.b) * 114
-        };
-        color_val(a.1).cmp(&color_val(b.1))
-    });
-    if let Some(first) = first {
-        enumerated.insert(0, first);
-    }
-
-    // Extract the new palette and determine if anything changed
-    let (remapping, palette): (Vec<_>, Vec<RGBA8>) = enumerated.into_iter().unzip();
-    if remapping.iter().enumerate().all(|(a, b)| a == *b) {
-        return None;
-    }
-
-    // Construct the new mapping and convert the data
-    let mut byte_map = [0; 256];
-    for (i, &v) in remapping.iter().enumerate() {
-        byte_map[v] = i as u8;
-    }
-    let data = png.data.iter().map(|&b| byte_map[b as usize]).collect();
-
-    Some(PngImage {
-        ihdr: IhdrData {
-            color_type: ColorType::Indexed { palette },
-            ..png.ihdr
-        },
-        data,
-    })
-}
-
-/// Sort the colors in the palette using the mzeng technique, returning the sorted image if successful
-#[must_use]
-pub fn sorted_palette_mzeng(png: &PngImage) -> Option<PngImage> {
-    // Interlacing not currently supported
-    if png.ihdr.bit_depth != BitDepth::Eight || png.ihdr.interlaced {
-        return None;
-    }
-    let palette = match &png.ihdr.color_type {
-        // Images with only two colors will remain unchanged from previous luma sort
-        ColorType::Indexed { palette } if palette.len() > 2 => palette,
-        _ => return None,
-    };
-
-    let matrix = co_occurrence_matrix(palette.len(), png);
-    let edges = weighted_edges(&matrix);
-    let mut remapping = mzeng_reindex(palette.len(), edges, &matrix);
-
-    apply_most_popular_color(png, &mut remapping);
-
-    apply_palette_reorder(png, &remapping)
-}
-
-/// Sort the colors in the palette using the battiato technique, returning the sorted image if successful
-#[must_use]
-pub fn sorted_palette_battiato(png: &PngImage) -> Option<PngImage> {
-    // Interlacing not currently supported
-    if png.ihdr.bit_depth != BitDepth::Eight || png.ihdr.interlaced {
-        return None;
-    }
-    let palette = match &png.ihdr.color_type {
-        // Images with only two colors will remain unchanged from previous luma sort
-        ColorType::Indexed { palette } if palette.len() > 2 => palette,
-        _ => return None,
-    };
-
-    let matrix = co_occurrence_matrix(palette.len(), png);
-    let edges = weighted_edges(&matrix);
-    let mut remapping = battiato_reindex(palette.len(), edges);
-
-    apply_most_popular_color(png, &mut remapping);
-
-    apply_palette_reorder(png, &remapping)
-}
-
-// Apply the palette reordering to the image data
-fn apply_palette_reorder(png: &PngImage, remapping: &[usize]) -> Option<PngImage> {
-    let ColorType::Indexed { palette } = &png.ihdr.color_type else {
-        return None;
-    };
-
-    // Check if anything changed
-    if remapping.iter().enumerate().all(|(a, b)| a == *b) {
-        return None;
-    }
-
-    // Construct the palette and byte maps and convert the data
-    let mut new_palette = Vec::new();
-    let mut byte_map = [0; 256];
-    for (i, &v) in remapping.iter().enumerate() {
-        new_palette.push(palette[v]);
-        byte_map[v] = i as u8;
-    }
-    let data = png.data.iter().map(|&b| byte_map[b as usize]).collect();
-
-    Some(PngImage {
-        ihdr: IhdrData {
-            color_type: ColorType::Indexed {
-                palette: new_palette,
-            },
-            ..png.ihdr
-        },
-        data,
-    })
-}
-
-// Find the most popular color on the image edges (the pixels neighboring the filter bytes)
-fn most_popular_edge_color(num_colors: usize, png: &PngImage) -> Option<usize> {
-    let mut counts = [0_u32; 256];
-    for line in png.scan_lines(false) {
-        if let &[first, .., last] = line.data {
-            counts[first as usize] += 1;
-            counts[last as usize] += 1;
-        }
-    }
-    let max = counts
-        .iter()
-        .take(num_colors)
-        .enumerate()
-        .max_by_key(|&(_, v)| v)
-        .unwrap();
-    // Ensure there's a clear winner - return None if multiple colors are tied
-    let max_equal = counts.iter().filter(|&v| v == max.1).count();
-    if max_equal > 1 {
-        return None;
-    }
-    Some(max.0)
-}
-
-// Find the most popular color in the image, along with its count
-fn most_popular_color(num_colors: usize, png: &PngImage) -> (usize, u32) {
-    let mut counts = [0_u32; 256];
-    for &val in &png.data {
-        counts[val as usize] += 1;
-    }
-    counts
-        .iter()
-        .copied()
-        .take(num_colors)
-        .enumerate()
-        .max_by_key(|&(_, v)| v)
-        .unwrap_or_default()
-}
-
-// Put the most popular color first
-fn apply_most_popular_color(png: &PngImage, remapping: &mut [usize]) {
-    let most_popular = most_popular_color(remapping.len(), png);
-    // If the most popular color is less than 15% of the image, don't use it
-    if most_popular.1 < png.data.len() as u32 * 3 / 20 {
-        return;
-    }
-    let first_idx = remapping.iter().position(|&i| i == most_popular.0).unwrap();
-    // If the index is past halfway, reverse the order so as to minimize the change
-    if first_idx >= remapping.len() / 2 {
-        remapping.reverse();
-        remapping.rotate_right(first_idx + 1);
-    } else {
-        remapping.rotate_left(first_idx);
-    }
-}
-
-// Calculate co-occurences matrix
-fn co_occurrence_matrix(num_colors: usize, png: &PngImage) -> Vec<Vec<u32>> {
-    let mut matrix = vec![vec![0_u32; num_colors]; num_colors];
-    let mut prev: Option<ScanLine> = None;
-    let mut prev_val = None;
-    for line in png.scan_lines(false) {
-        for i in 0..line.data.len() {
-            let val = line.data[i] as usize;
-            if val > num_colors {
-                continue;
-            }
-            if let Some(prev_val) = prev_val.replace(val) {
-                matrix[prev_val][val] += 1;
-                matrix[val][prev_val] += 1;
-            }
-            if let Some(prev) = &prev {
-                let prev_val = prev.data[i] as usize;
-                if prev_val > num_colors {
-                    continue;
-                }
-                matrix[prev_val][val] += 1;
-                matrix[val][prev_val] += 1;
-            }
-        }
-        prev = Some(line);
-    }
-    matrix
-}
-
-// Calculate edge list sorted by weight
-fn weighted_edges(matrix: &[Vec<u32>]) -> Vec<(usize, usize)> {
-    let mut edges = Vec::new();
-    for (i, m_row) in matrix.iter().enumerate() {
-        for (j, val) in m_row.iter().enumerate().take(i) {
-            edges.push(((j, i), val));
-        }
-    }
-    edges.sort_by(|(_, w1), (_, w2)| w2.cmp(w1));
-    edges.into_iter().map(|(e, _)| e).collect()
-}
-
-// Apply a greedy index assignment using the modified version of Zeng's techinque from
-// "A note on Zeng's technique for color reindexing of palette-based images" by Pinho et al
-// https://ieeexplore.ieee.org/document/1261987
-// Based on the C implementation in libwebp
-fn mzeng_reindex(num_colors: usize, edges: Vec<(usize, usize)>, matrix: &[Vec<u32>]) -> Vec<usize> {
-    // Initialize the mapping list with the two best indices.
-    let mut remapping = vec![edges[0].0, edges[0].1];
-
-    // Initialize the sums with the first two remappings and find the best one
-    let mut sums = Vec::new();
-    let mut best_sum_pos = 0;
-    let mut best_sum = (0, 0);
-    for (i, m_row) in matrix.iter().enumerate() {
-        if i == remapping[0] || i == remapping[1] {
-            continue;
-        }
-        let sum = (i, m_row[remapping[0]] + m_row[remapping[1]]);
-        if sum.1 > best_sum.1 {
-            best_sum_pos = sums.len();
-            best_sum = sum;
-        }
-        sums.push(sum);
-    }
-
-    while !sums.is_empty() {
-        let best_index = best_sum.0;
-        // Compute delta to know if we need to prepend or append the best index.
-        let mut delta: isize = 0;
-        let n = (num_colors - sums.len()) as isize;
-        for (i, &index) in remapping.iter().enumerate() {
-            delta += (n - 1 - 2 * i as isize) * matrix[best_index][index] as isize;
-        }
-        if delta > 0 {
-            remapping.insert(0, best_index);
-        } else {
-            remapping.push(best_index);
-        }
-        // Remove best_sum from sums.
-        sums.swap_remove(best_sum_pos);
-        if !sums.is_empty() {
-            // Update all the sums and find the best one.
-            best_sum_pos = 0;
-            best_sum = (0, 0);
-            for (i, sum) in sums.iter_mut().enumerate() {
-                sum.1 += matrix[best_index][sum.0];
-                if sum.1 > best_sum.1 {
-                    best_sum_pos = i;
-                    best_sum = *sum;
-                }
-            }
-        }
-    }
-
-    // Return the completed remapping
-    remapping
-}
-
-// Calculate an approximate solution of the Traveling Salesman Problem using the algorithm
-// from "An efficient Re-indexing algorithm for color-mapped images" by Battiato et al
-// https://ieeexplore.ieee.org/document/1344033
-fn battiato_reindex(num_colors: usize, edges: Vec<(usize, usize)>) -> Vec<usize> {
-    let mut chains = Vec::new();
-    // Keep track of the state of each vertex (.0) and it's chain number (.1)
-    // 0 = an unvisited vertex (White)
-    // 1 = an endpoint of a chain (Red)
-    // 2 = part of the middle of a chain (Black)
-    let mut vx = vec![(0, 0); num_colors];
-
-    // Iterate the edges and assemble them into a chain
-    for (i, j) in edges {
-        let vi = vx[i];
-        let vj = vx[j];
-        if vi.0 == 0 && vj.0 == 0 {
-            // Two unvisited vertices - create a new chain
-            vx[i].0 = 1;
-            vx[i].1 = chains.len();
-            vx[j].0 = 1;
-            vx[j].1 = chains.len();
-            chains.push(vec![i, j]);
-        } else if vi.0 == 0 && vj.0 == 1 {
-            // An unvisited vertex connects with an endpoint of an existing chain
-            vx[i].0 = 1;
-            vx[i].1 = vj.1;
-            vx[j].0 = 2;
-            let chain = &mut chains[vj.1];
-            if chain[0] == j {
-                chain.insert(0, i);
-            } else {
-                chain.push(i);
-            }
-        } else if vi.0 == 1 && vj.0 == 0 {
-            // An unvisited vertex connects with an endpoint of an existing chain
-            vx[j].0 = 1;
-            vx[j].1 = vi.1;
-            vx[i].0 = 2;
-            let chain = &mut chains[vi.1];
-            if chain[0] == i {
-                chain.insert(0, j);
-            } else {
-                chain.push(j);
-            }
-        } else if vi.0 == 1 && vj.0 == 1 && vi.1 != vj.1 {
-            // Two endpoints of different chains are connected together
-            vx[i].0 = 2;
-            vx[j].0 = 2;
-            let (a, b) = if vi.1 < vj.1 { (i, j) } else { (j, i) };
-            let ca = vx[a].1;
-            let cb = vx[b].1;
-            let chainb = std::mem::take(&mut chains[cb]);
-            for &v in &chainb {
-                vx[v].1 = ca;
-            }
-            let chaina = &mut chains[ca];
-            if chaina[0] == a && chainb[0] == b {
-                for v in chainb {
-                    chaina.insert(0, v);
-                }
-            } else if chaina[0] == a {
-                chaina.splice(0..0, chainb);
-            } else if chainb[0] == b {
-                chaina.extend(chainb);
-            } else {
-                let pos = chaina.len();
-                for v in chainb {
-                    chaina.insert(pos, v);
-                }
-            }
-        }
-
-        if chains[0].len() == num_colors {
-            break;
-        }
-    }
-
-    // Return the completed chain
-    chains.swap_remove(0)
-}
--- a/src/sanity_checks.rs
+++ b/src/sanity_checks.rs
@ -1,65 +0,0 @@
-use std::io::Cursor;
-
-use image::{codecs::png::PngDecoder, *};
-use log::{error, warn};
-
-#[cfg(not(feature = "parallel"))]
-use crate::rayon;
-
-/// Validate that the output png data still matches the original image
-pub fn validate_output(output: &[u8], original_data: &[u8]) -> bool {
-    let (old_frames, new_frames) = rayon::join(
-        || load_png_image_from_memory(original_data),
-        || load_png_image_from_memory(output),
-    );
-
-    match (new_frames, old_frames) {
-        (Err(new_err), _) => {
-            error!("Failed to read output image for validation: {}", new_err);
-            false
-        }
-        (_, Err(old_err)) => {
-            // The original image might be invalid if, for example, there is a CRC error,
-            // and we set fix_errors to true. In that case, all we can do is check that the
-            // new image is decodable.
-            warn!("Failed to read input image for validation: {}", old_err);
-            true
-        }
-        (Ok(new_frames), Ok(old_frames)) if new_frames.len() != old_frames.len() => false,
-        (Ok(new_frames), Ok(old_frames)) => {
-            for (a, b) in old_frames.iter().zip(new_frames) {
-                if !images_equal(a, &b) {
-                    return false;
-                }
-            }
-            true
-        }
-    }
-}
-
-/// Loads a PNG image from memory to frames of [RgbaImage]
-fn load_png_image_from_memory(png_data: &[u8]) -> Result<Vec<RgbaImage>, image::ImageError> {
-    let decoder = PngDecoder::new(Cursor::new(png_data))?;
-    if decoder.is_apng()? {
-        decoder
-            .apng()?
-            .into_frames()
-            .map(|f| f.map(image::Frame::into_buffer))
-            .collect()
-    } else {
-        DynamicImage::from_decoder(decoder).map(|i| vec![i.into_rgba8()])
-    }
-}
-
-/// Compares images pixel by pixel for equivalent content
-fn images_equal(old_png: &RgbaImage, new_png: &RgbaImage) -> bool {
-    let a = old_png.pixels().filter(|x| {
-        let p = x.channels();
-        !(p.len() == 4 && p[3] == 0)
-    });
-    let b = new_png.pixels().filter(|x| {
-        let p = x.channels();
-        !(p.len() == 4 && p[3] == 0)
-    });
-    a.eq(b)
-}
--- a/tests/alpha.rs
+++ b/tests/alpha.rs
@ -1,346 +0,0 @@
-use std::{
-    fs::remove_file,
-    path::{Path, PathBuf},
-};
-
-use oxipng::{internal_tests::*, *};
-
-const GRAYSCALE_ALPHA: u8 = 4;
-const RGBA: u8 = 6;
-
-fn get_opts(input: &Path) -> (OutFile, oxipng::Options) {
-    let options = oxipng::Options {
-        force: true,
-        optimize_alpha: true,
-        ..Default::default()
-    };
-    (OutFile::from_path(input.with_extension("out.png")), options)
-}
-
-fn test_it_converts(
-    input: &str,
-    filter: FilterStrategy,
-    color_type_in: u8,
-    bit_depth_in: BitDepth,
-    color_type_out: u8,
-    bit_depth_out: BitDepth,
-) {
-    let input = PathBuf::from(input);
-
-    let (output, mut opts) = get_opts(&input);
-    let png = PngData::new(&input, &opts).unwrap();
-    opts.filters = indexset! {filter};
-    assert_eq!(png.raw.ihdr.color_type.png_header_code(), color_type_in);
-    assert_eq!(png.raw.ihdr.bit_depth, bit_depth_in);
-
-    match oxipng::optimize(&InFile::Path(input), &output, &opts) {
-        Ok(_) => (),
-        Err(x) => panic!("{}", x),
-    }
-    let output = output.path().unwrap();
-    assert!(output.exists());
-
-    let png = match PngData::new(output, &opts) {
-        Ok(x) => x,
-        Err(x) => {
-            remove_file(output).ok();
-            panic!("{}", x)
-        }
-    };
-
-    assert_eq!(png.raw.ihdr.color_type.png_header_code(), color_type_out);
-    assert_eq!(png.raw.ihdr.bit_depth, bit_depth_out);
-    if let ColorType::Indexed { palette } = &png.raw.ihdr.color_type {
-        assert!(palette.len() <= 1 << (png.raw.ihdr.bit_depth as u8));
-    }
-
-    remove_file(output).ok();
-}
-
-#[test]
-fn alpha_filter_0_for_rgba_16() {
-    test_it_converts(
-        "tests/files/filter_0_for_rgba_16.png",
-        FilterStrategy::NONE,
-        RGBA,
-        BitDepth::Sixteen,
-        RGBA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_1_for_rgba_16() {
-    test_it_converts(
-        "tests/files/filter_1_for_rgba_16.png",
-        FilterStrategy::SUB,
-        RGBA,
-        BitDepth::Sixteen,
-        RGBA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_2_for_rgba_16() {
-    test_it_converts(
-        "tests/files/filter_2_for_rgba_16.png",
-        FilterStrategy::UP,
-        RGBA,
-        BitDepth::Sixteen,
-        RGBA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_3_for_rgba_16() {
-    test_it_converts(
-        "tests/files/filter_3_for_rgba_16.png",
-        FilterStrategy::AVERAGE,
-        RGBA,
-        BitDepth::Sixteen,
-        RGBA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_4_for_rgba_16() {
-    test_it_converts(
-        "tests/files/filter_4_for_rgba_16.png",
-        FilterStrategy::PAETH,
-        RGBA,
-        BitDepth::Sixteen,
-        RGBA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_5_for_rgba_16() {
-    test_it_converts(
-        "tests/files/filter_5_for_rgba_16.png",
-        FilterStrategy::MinSum,
-        RGBA,
-        BitDepth::Sixteen,
-        RGBA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_0_for_rgba_8() {
-    test_it_converts(
-        "tests/files/filter_0_for_rgba_8.png",
-        FilterStrategy::NONE,
-        RGBA,
-        BitDepth::Eight,
-        RGBA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_1_for_rgba_8() {
-    test_it_converts(
-        "tests/files/filter_1_for_rgba_8.png",
-        FilterStrategy::SUB,
-        RGBA,
-        BitDepth::Eight,
-        RGBA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_2_for_rgba_8() {
-    test_it_converts(
-        "tests/files/filter_2_for_rgba_8.png",
-        FilterStrategy::UP,
-        RGBA,
-        BitDepth::Eight,
-        RGBA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_3_for_rgba_8() {
-    test_it_converts(
-        "tests/files/filter_3_for_rgba_8.png",
-        FilterStrategy::AVERAGE,
-        RGBA,
-        BitDepth::Eight,
-        RGBA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_4_for_rgba_8() {
-    test_it_converts(
-        "tests/files/filter_4_for_rgba_8.png",
-        FilterStrategy::PAETH,
-        RGBA,
-        BitDepth::Eight,
-        RGBA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_5_for_rgba_8() {
-    test_it_converts(
-        "tests/files/filter_5_for_rgba_8.png",
-        FilterStrategy::MinSum,
-        RGBA,
-        BitDepth::Eight,
-        RGBA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_0_for_grayscale_alpha_16() {
-    test_it_converts(
-        "tests/files/filter_0_for_grayscale_alpha_16.png",
-        FilterStrategy::NONE,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_1_for_grayscale_alpha_16() {
-    test_it_converts(
-        "tests/files/filter_1_for_grayscale_alpha_16.png",
-        FilterStrategy::SUB,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_2_for_grayscale_alpha_16() {
-    test_it_converts(
-        "tests/files/filter_2_for_grayscale_alpha_16.png",
-        FilterStrategy::UP,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_3_for_grayscale_alpha_16() {
-    test_it_converts(
-        "tests/files/filter_3_for_grayscale_alpha_16.png",
-        FilterStrategy::AVERAGE,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_4_for_grayscale_alpha_16() {
-    test_it_converts(
-        "tests/files/filter_4_for_grayscale_alpha_16.png",
-        FilterStrategy::PAETH,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_5_for_grayscale_alpha_16() {
-    test_it_converts(
-        "tests/files/filter_5_for_grayscale_alpha_16.png",
-        FilterStrategy::MinSum,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-        GRAYSCALE_ALPHA,
-        BitDepth::Sixteen,
-    );
-}
-
-#[test]
-fn alpha_filter_0_for_grayscale_alpha_8() {
-    test_it_converts(
-        "tests/files/filter_0_for_grayscale_alpha_8.png",
-        FilterStrategy::NONE,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_1_for_grayscale_alpha_8() {
-    test_it_converts(
-        "tests/files/filter_1_for_grayscale_alpha_8.png",
-        FilterStrategy::SUB,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_2_for_grayscale_alpha_8() {
-    test_it_converts(
-        "tests/files/filter_2_for_grayscale_alpha_8.png",
-        FilterStrategy::UP,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_3_for_grayscale_alpha_8() {
-    test_it_converts(
-        "tests/files/filter_3_for_grayscale_alpha_8.png",
-        FilterStrategy::AVERAGE,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_4_for_grayscale_alpha_8() {
-    test_it_converts(
-        "tests/files/filter_4_for_grayscale_alpha_8.png",
-        FilterStrategy::PAETH,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-    );
-}
-
-#[test]
-fn alpha_filter_5_for_grayscale_alpha_8() {
-    test_it_converts(
-        "tests/files/filter_5_for_grayscale_alpha_8.png",
-        FilterStrategy::MinSum,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-        GRAYSCALE_ALPHA,
-        BitDepth::Eight,
-    );
-}
--- a/tests/files/c2pa-signed.png
+++ b/tests/files/c2pa-signed.png
--- a/tests/files/filter_0_for_grayscale_16.png
+++ b/tests/files/filter_0_for_grayscale_16.png
--- a/tests/files/filter_0_for_grayscale_8.png
+++ b/tests/files/filter_0_for_grayscale_8.png
--- a/tests/files/filter_0_for_grayscale_alpha_16.png
+++ b/tests/files/filter_0_for_grayscale_alpha_16.png
--- a/tests/files/filter_0_for_grayscale_alpha_8.png
+++ b/tests/files/filter_0_for_grayscale_alpha_8.png
--- a/tests/files/filter_0_for_palette_1.png
+++ b/tests/files/filter_0_for_palette_1.png
--- a/tests/files/filter_0_for_palette_2.png
+++ b/tests/files/filter_0_for_palette_2.png
--- a/tests/files/filter_0_for_palette_4.png
+++ b/tests/files/filter_0_for_palette_4.png
--- a/tests/files/filter_0_for_rgb_16.png
+++ b/tests/files/filter_0_for_rgb_16.png
--- a/tests/files/filter_0_for_rgb_8.png
+++ b/tests/files/filter_0_for_rgb_8.png
--- a/tests/files/filter_0_for_rgba_16.png
+++ b/tests/files/filter_0_for_rgba_16.png
--- a/tests/files/filter_0_for_rgba_8.png
+++ b/tests/files/filter_0_for_rgba_8.png
--- a/tests/files/filter_1_for_grayscale_16.png
+++ b/tests/files/filter_1_for_grayscale_16.png
--- a/tests/files/filter_1_for_grayscale_8.png
+++ b/tests/files/filter_1_for_grayscale_8.png
--- a/tests/files/filter_1_for_grayscale_alpha_16.png
+++ b/tests/files/filter_1_for_grayscale_alpha_16.png
--- a/tests/files/filter_1_for_grayscale_alpha_8.png
+++ b/tests/files/filter_1_for_grayscale_alpha_8.png
--- a/tests/files/filter_1_for_palette_1.png
+++ b/tests/files/filter_1_for_palette_1.png
--- a/tests/files/filter_1_for_palette_2.png
+++ b/tests/files/filter_1_for_palette_2.png
--- a/tests/files/filter_1_for_palette_4.png
+++ b/tests/files/filter_1_for_palette_4.png
--- a/tests/files/filter_1_for_rgb_16.png
+++ b/tests/files/filter_1_for_rgb_16.png
--- a/tests/files/filter_1_for_rgb_8.png
+++ b/tests/files/filter_1_for_rgb_8.png
--- a/tests/files/filter_1_for_rgba_16.png
+++ b/tests/files/filter_1_for_rgba_16.png
--- a/tests/files/filter_1_for_rgba_8.png
+++ b/tests/files/filter_1_for_rgba_8.png
--- a/tests/files/filter_2_for_grayscale_16.png
+++ b/tests/files/filter_2_for_grayscale_16.png
--- a/tests/files/filter_2_for_grayscale_8.png
+++ b/tests/files/filter_2_for_grayscale_8.png
--- a/tests/files/filter_2_for_grayscale_alpha_16.png
+++ b/tests/files/filter_2_for_grayscale_alpha_16.png
--- a/tests/files/filter_2_for_grayscale_alpha_8.png
+++ b/tests/files/filter_2_for_grayscale_alpha_8.png
--- a/tests/files/filter_2_for_palette_1.png
+++ b/tests/files/filter_2_for_palette_1.png
--- a/tests/files/filter_2_for_palette_2.png
+++ b/tests/files/filter_2_for_palette_2.png
--- a/tests/files/filter_2_for_palette_4.png
+++ b/tests/files/filter_2_for_palette_4.png
--- a/tests/files/filter_2_for_rgb_16.png
+++ b/tests/files/filter_2_for_rgb_16.png
--- a/tests/files/filter_2_for_rgb_8.png
+++ b/tests/files/filter_2_for_rgb_8.png
--- a/tests/files/filter_2_for_rgba_16.png
+++ b/tests/files/filter_2_for_rgba_16.png
--- a/tests/files/filter_2_for_rgba_8.png
+++ b/tests/files/filter_2_for_rgba_8.png
--- a/tests/files/filter_3_for_grayscale_16.png
+++ b/tests/files/filter_3_for_grayscale_16.png
--- a/tests/files/filter_3_for_grayscale_8.png
+++ b/tests/files/filter_3_for_grayscale_8.png
--- a/tests/files/filter_3_for_grayscale_alpha_16.png
+++ b/tests/files/filter_3_for_grayscale_alpha_16.png
--- a/tests/files/filter_3_for_grayscale_alpha_8.png
+++ b/tests/files/filter_3_for_grayscale_alpha_8.png
--- a/tests/files/filter_3_for_palette_1.png
+++ b/tests/files/filter_3_for_palette_1.png
--- a/tests/files/filter_3_for_palette_2.png
+++ b/tests/files/filter_3_for_palette_2.png
--- a/tests/files/filter_3_for_palette_4.png
+++ b/tests/files/filter_3_for_palette_4.png
--- a/tests/files/filter_3_for_rgb_16.png
+++ b/tests/files/filter_3_for_rgb_16.png
--- a/tests/files/filter_3_for_rgb_8.png
+++ b/tests/files/filter_3_for_rgb_8.png
--- a/tests/files/filter_3_for_rgba_16.png
+++ b/tests/files/filter_3_for_rgba_16.png
--- a/tests/files/filter_3_for_rgba_8.png
+++ b/tests/files/filter_3_for_rgba_8.png
--- a/tests/files/filter_4_for_grayscale_16.png
+++ b/tests/files/filter_4_for_grayscale_16.png
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				`<script>(function() {window.location.assign(window.location.href + "doc/oxipng/");})();</script>`