.cargo/config.toml

@@ -1,2 +1,9 @@
-[alias]
-xtask = "run --manifest-path xtask/Cargo.toml --"
+# Remove this if targeting AArch64 from an AArch64 Linux box
+[target.'cfg(all(target_os = "linux", target_arch = "aarch64"))']
+runner = 'qemu-aarch64'
+
+[target.aarch64-unknown-linux-gnu]
+linker = 'aarch64-linux-gnu-gcc'
+
+[target.aarch64-unknown-linux-musl]
+linker = 'aarch64-linux-musl-gcc'

.dockerignore

@@ -1,7 +0,0 @@
-.editorconfig
-.gitignore
-/.git/
-/.github/
-/.pre-commit-hooks.yaml
-/scripts/
-/target/

.github/dependabot.yml

@@ -1,24 +1,6 @@
 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"
+      interval: monthly

.github/workflows/deploy.yml

@@ -3,12 +3,7 @@ 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
+      - 'v*.*.*'
 
 permissions:
   actions: read
@@ -25,10 +20,6 @@ jobs:
     if: ${{ !github.event.repository.fork }}
 
     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
@@ -42,32 +33,18 @@ jobs:
 
     steps:
       - name: Checkout source
-        uses: actions/checkout@v6
-
-      - name: Install Rust toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          toolchain: nightly
-          cache-bin: false
-          cache-shared-key: cache
-
-      - name: Install cargo-deb
-        if: endsWith(matrix.target, '-linux-gnu')
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-deb
+        uses: actions/checkout@v4
 
       - 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"
+        run: echo "version=$(cargo metadata --format-version 1 --no-deps | jq -r '.packages[] | select(.name == "oxipng").version')"
+          >> "$GITHUB_OUTPUT"
 
       - name: Retrieve ${{ matrix.target }} binary
-        uses: dawidd6/action-download-artifact@v21
+        uses: dawidd6/action-download-artifact@v2
         with:
           workflow: oxipng.yml
-          commit: ${{ github.sha }}
+          commit: ${{ env.GITHUB_SHA }}
           name: Oxipng binary (${{ matrix.target }})
           path: target
 
@@ -90,49 +67,17 @@ jobs:
             *)
               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
+        run: tail -n +2 CHANGELOG.md | sed -e '/^$/,$d' > RELEASE_NOTES.txt
 
       - name: Create release
-        uses: softprops/action-gh-release@v3
+        uses: softprops/action-gh-release@v1
         with:
           name: v${{ steps.oxipngMeta.outputs.version }}
           body_path: RELEASE_NOTES.txt
           files: |
             target/*.zip
             target/*.tar.gz
-            target/${{ matrix.target }}/debian/*.deb

.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 }}

.github/workflows/oxipng.yml

@@ -8,11 +8,6 @@ on:
       - 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
-
 jobs:
   ci:
     name: CI
@@ -38,89 +33,107 @@ jobs:
 
         include:
           - target: x86_64-unknown-linux-gnu
-            os: ubuntu-24.04
+            os: ubuntu-22.04
             target-apt-arch: amd64
           - target: x86_64-unknown-linux-musl
-            os: ubuntu-24.04
+            os: ubuntu-22.04
             target-apt-arch: amd64
           - target: aarch64-unknown-linux-gnu
-            os: ubuntu-24.04-arm
+            os: ubuntu-22.04
             target-apt-arch: arm64
           - target: aarch64-unknown-linux-musl
-            os: ubuntu-24.04-arm
+            os: ubuntu-22.04
             target-apt-arch: arm64
           - 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
+            os: macos-latest
           - target: aarch64-apple-darwin
-            os: macos-15
+            os: macos-latest
 
     env:
       CARGO_BUILD_TARGET: ${{ matrix.target }}
 
     steps:
       - name: Checkout source
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           persist-credentials: false
 
+      - name: Set up Ubuntu multiarch
+        if: startsWith(matrix.os, 'ubuntu') && matrix.target-apt-arch != 'amd64'
+        run: |
+          readonly DISTRO_CODENAME=jammy
+          sudo dpkg --add-architecture "${{ matrix.target-apt-arch }}"
+          sudo sed -i "s/^deb http/deb [arch=$(dpkg-architecture -q DEB_HOST_ARCH)] http/" /etc/apt/sources.list
+          sudo sed -i "s/^deb mirror/deb [arch=$(dpkg-architecture -q DEB_HOST_ARCH)] mirror/" /etc/apt/sources.list
+          for suite in '' '-updates' '-backports' '-security'; do
+            echo "deb [arch=${{ matrix.target-apt-arch }}] http://ports.ubuntu.com/ $DISTRO_CODENAME$suite main universe multiverse" | \
+            sudo tee -a /etc/apt/sources.list >/dev/null
+          done
+
       - 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 QEMU and AArch64 cross compiler
+        if: startsWith(matrix.target, 'aarch64-unknown-linux')
+        run: |
+          sudo apt-get -yq update
+          # libc6 must be present to run executables dynamically linked
+          # against glibc for the target architecture
+          sudo apt-get -yq install qemu-user gcc-aarch64-linux-gnu libc6:arm64
+
+      - name: Cache Cargo artifacts
+        uses: Swatinem/rust-cache@v2
+
       - name: Install Rust toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
+        uses: dtolnay/rust-toolchain@v1
         with:
           toolchain: nightly
-          target: ${{ env.CARGO_BUILD_TARGET }}
-          components: clippy, rustfmt, rust-src
-          cache-bin: false
-          cache-shared-key: cache
+          targets: ${{ env.CARGO_BUILD_TARGET }}
+          components: clippy, rustfmt
 
       - 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
-
       - name: Run rustfmt
         if: matrix.target == 'x86_64-unknown-linux-gnu'
         run: cargo fmt --check
 
-      - name: Run Clippy for all feature combinations
+      - name: Run Clippy (no default features)
         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
+        uses: giraffate/clippy-action@v1
+        with:
+          clippy_flags: --no-deps --all-targets --no-default-features -- -D warnings
+          reporter: github-check
+          fail_on_error: true
 
+      - name: Run Clippy (all features)
+        if: matrix.target == 'x86_64-unknown-linux-gnu'
+        uses: giraffate/clippy-action@v1
+        with:
+          clippy_flags: --no-deps --all-targets --all-features -- -D warnings
+          reporter: github-check
+          fail_on_error: true
+
+      # There aren't good user-mode ARM64 emulators we can use on x64 macOS hosts.
+      # QEMU doesn't have any plans to add such support due to a lack of kernel
+      # syscall stability guarantees: https://gitlab.com/qemu-project/qemu/-/issues/1682
       - name: Run tests
+        if: matrix.target != 'aarch64-apple-darwin'
         run: |
           cargo nextest run --release --features sanity-checks
           cargo test --doc --release --features sanity-checks
 
+      - name: Build tests (ARM64 macOS only)
+        if: matrix.target == 'aarch64-apple-darwin'
+        run: cargo test --release --features sanity-checks --no-run
+
       - name: Build benchmarks
         run: cargo bench --no-run
 
@@ -129,26 +142,16 @@ jobs:
         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"
+        run: cargo build --release
 
       - name: Upload CLI binary as artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v3
         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
 
@@ -160,16 +163,15 @@ jobs:
 
     steps:
       - name: Checkout source
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           persist-credentials: false
 
+      - name: Cache Cargo artifacts
+        uses: Swatinem/rust-cache@v2
+
       - 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
+        uses: dtolnay/rust-toolchain@1.66.0
 
       - name: Install nextest
         uses: taiki-e/install-action@nextest

.gitignore

@@ -1,6 +1,6 @@
-.DS_Store
+target
 *.bk
+.DS_Store
 *.out.png
-/.idea/
-/node_modules/
-/target/
+/.idea
+/node_modules

CHANGELOG.md

@@ -1,82 +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.
@@ -199,51 +120,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 +173,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 +203,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 +255,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 +287,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 +326,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 +351,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 +396,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 +428,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 +444,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 +455,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
 

Cargo.lock

@@ -1,74 +1,73 @@
 # 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"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+checksum = "0ca84f3628370c59db74ee214b3263d58f9aadd9b4fe7e711fd87dc452b7f163"
 dependencies = [
  "anstyle",
  "anstyle-parse",
  "anstyle-query",
  "anstyle-wincon",
  "colorchoice",
- "is_terminal_polyfill",
+ "is-terminal",
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle"
-version = "1.0.14"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+checksum = "3a30da5c5f2d5e72842e00bcb57657162cdabef0931f40e2deb9b4140440cecd"
 
 [[package]]
 name = "anstyle-parse"
-version = "1.0.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+checksum = "938874ff5980b03a87c5524b3ae5b59cf99b1d6bc836848df7bc5ada9643c333"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.5"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
 dependencies = [
  "windows-sys",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.11"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+checksum = "180abfa45703aebe0093f79badacc01b8fd4ea2e35118747e5811127f926e188"
 dependencies = [
  "anstyle",
- "once_cell_polyfill",
  "windows-sys",
 ]
 
 [[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,57 +81,48 @@ 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.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+checksum = "17febce684fd15d89027105661fec94afb475cb995fbc59d2865198446ba2eea"
 
 [[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.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
-dependencies = [
- "find-msvc-tools",
- "shlex",
-]
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
 
 [[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 = "4.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
+checksum = "d9394150f5b4273a1763355bd1c2ec54cc5a2593f790587bcd6b2c947cfa9211"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.6.0"
+version = "4.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
+checksum = "9a78fbdd3cc2914ddf37ba444114bc7765bbdcb55ec9cbe6fa054f0137400717"
 dependencies = [
  "anstream",
  "anstyle",
+ "bitflags",
  "clap_lex",
  "strsim",
  "terminal_size",
@@ -140,113 +130,144 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2da6da31387c7e4ef160ffab6d5e7f00c42626fe39aea70a7b0f1773f7dd6c1b"
+
+[[package]]
+name = "color_quant"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
 [[package]]
 name = "colorchoice"
-version = "1.0.5"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
 
 [[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.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
 dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
+dependencies = [
+ "cfg-if",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.18"
+version = "0.9.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7"
 dependencies = [
+ "autocfg",
+ "cfg-if",
  "crossbeam-utils",
+ "memoffset",
+ "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
-
-[[package]]
-name = "either"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
-
-[[package]]
-name = "env_filter"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32e90c2accc4b07a8456ea0debdc2e7587bdd890680d71173a15d4ae604f6eef"
+checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294"
 dependencies = [
- "log",
+ "cfg-if",
 ]
 
 [[package]]
-name = "env_logger"
-version = "0.11.10"
+name = "either"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a"
+checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
+
+[[package]]
+name = "env_logger"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0"
 dependencies = [
- "anstream",
- "anstyle",
- "env_filter",
+ "is-terminal",
  "log",
+ "termcolor",
 ]
 
 [[package]]
 name = "equivalent"
-version = "1.0.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+checksum = "88bffebc5d80432c9b140ee17875ff173a8ab62faad5b257da912bd2f6c1c0a1"
 
 [[package]]
 name = "errno"
-version = "0.3.14"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
 dependencies = [
+ "errno-dragonfly",
  "libc",
  "windows-sys",
 ]
 
 [[package]]
-name = "fdeflate"
-version = "0.3.7"
+name = "errno-dragonfly"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "fdeflate"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d329bdeac514ee06249dabc27877490f17f5d371ec693360768b838e19f3ae10"
 dependencies = [
  "simd-adler32",
 ]
 
 [[package]]
-name = "find-msvc-tools"
-version = "0.1.9"
+name = "filetime"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+checksum = "5cbc844cecaee9d4443931972e1289c8ff485cb4cc2767cb03ca139ed6885153"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "windows-sys",
+]
 
 [[package]]
 name = "flate2"
-version = "1.1.9"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+checksum = "3b9429470923de8e8cbd4d2dc513535400b4b3fef0319fb5c4e1f520a7bef743"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -260,34 +281,50 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "glob"
-version = "0.3.3"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
 [[package]]
 name = "hashbrown"
-version = "0.17.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+
+[[package]]
+name = "hermit-abi"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
 
 [[package]]
 name = "image"
-version = "0.25.9"
+version = "0.24.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a"
+checksum = "527909aa81e20ac3a44803521443a765550f09b5130c2c2fa1ea59c2f8f50a3a"
 dependencies = [
  "bytemuck",
- "byteorder-lite",
- "moxcms",
+ "byteorder",
+ "color_quant",
+ "num-rational",
  "num-traits",
  "png",
 ]
 
 [[package]]
 name = "indexmap"
-version = "2.14.0"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -295,132 +332,149 @@ dependencies = [
 ]
 
 [[package]]
-name = "is_terminal_polyfill"
-version = "1.70.2"
+name = "io-lifetimes"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
+dependencies = [
+ "hermit-abi 0.3.1",
+ "libc",
+ "windows-sys",
+]
 
 [[package]]
-name = "itoa"
-version = "1.0.18"
+name = "is-terminal"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+checksum = "adcf93614601c8129ddf72e2d5633df827ba6551541c6d8c59520a371475be1f"
+dependencies = [
+ "hermit-abi 0.3.1",
+ "io-lifetimes",
+ "rustix",
+ "windows-sys",
+]
 
 [[package]]
 name = "libc"
-version = "0.2.185"
+version = "0.2.146"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
+checksum = "f92be4933c13fd498862a9e02a3055f8a8d9c039ce33db97306fd5a6caa7f29b"
 
 [[package]]
 name = "libdeflate-sys"
-version = "1.25.2"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72753e0008ea87963d2f0770042d0df7abe51fafbb8dcaf618ac440f2f1fec0a"
+checksum = "67921a7f85100c1559efc3d1c7c472091b7da05f304b4bbd5356f075e97f1cc2"
 dependencies = [
  "cc",
- "pkg-config",
 ]
 
 [[package]]
 name = "libdeflater"
-version = "1.25.2"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1ee41cf6fb1bb6030dfb59ffb7bc01ab26aade44142084c87f0fc7a1658fe71"
+checksum = "3a31b22f662350ec294b13859f935aea772ba7b2bc8776269f4a5627308eab7d"
 dependencies = [
  "libdeflate-sys",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.12.1"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
 
 [[package]]
 name = "log"
-version = "0.4.30"
+version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 
 [[package]]
-name = "memchr"
-version = "2.8.0"
+name = "memoffset"
+version = "0.9.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"
-dependencies = [
- "adler2",
- "simd-adler32",
-]
-
-[[package]]
-name = "moxcms"
-version = "0.7.11"
-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 = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
-name = "once_cell_polyfill"
-version = "1.70.2"
+name = "miniz_oxide"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+dependencies = [
+ "adler",
+ "simd-adler32",
+]
+
+[[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 = "oxipng"
-version = "10.1.1"
+version = "9.0.0"
 dependencies = [
  "bitvec",
  "clap",
+ "crossbeam-channel",
  "env_logger",
+ "filetime",
  "glob",
  "image",
  "indexmap",
  "libdeflater",
  "log",
- "parse-size",
  "rayon",
  "rgb",
  "rustc-hash",
- "serde_json",
+ "rustc_version",
  "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.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+checksum = "59871cc5b6cce7eaccca5a802b4173377a1c2ba90654246789a8fa2334426d11"
 dependencies = [
  "bitflags",
  "crc32fast",
@@ -429,30 +483,6 @@ dependencies = [
  "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 +491,9 @@ checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
 name = "rayon"
-version = "1.12.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
 dependencies = [
  "either",
  "rayon-core",
@@ -471,112 +501,86 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.13.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
 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.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4"
+checksum = "20ec2d3e3fc7a92ced357df9cebd5a10b6fb2aa1ee797bf7e9ce2f17dffc8f59"
 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 = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
 
 [[package]]
 name = "rustix"
-version = "1.1.4"
+version = "0.37.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+checksum = "b96e891d04aa506a6d1f318d2771bcb1c7dfda84e126660ace067c9b474bb2c0"
 dependencies = [
  "bitflags",
  "errno",
+ "io-lifetimes",
  "libc",
  "linux-raw-sys",
  "windows-sys",
 ]
 
 [[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"
-dependencies = [
- "serde_core",
-]
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
-name = "serde_core"
-version = "1.0.228"
+name = "semver"
+version = "1.0.17"
 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"
+checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.9"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
 
 [[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 +589,133 @@ 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 = [
+ "winapi-util",
+]
+
+[[package]]
+name = "terminal_size"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e6bf6f19e9f8ed8d4048dc22981458ebcf406d67e94cd422e5ecd73d63b3237"
 dependencies = [
  "rustix",
  "windows-sys",
 ]
 
 [[package]]
-name = "unicode-ident"
-version = "1.0.24"
+name = "typed-arena"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
 
 [[package]]
 name = "utf8parse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
-
-[[package]]
-name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+
+[[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.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
- "windows-link",
+ "windows-targets",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
+dependencies = [
+ "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.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -630,20 +725,14 @@ 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.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
+checksum = "5c1f48f3508a3a3f2faee01629564400bc12260f6214a056d06a3aaaa6ef0736"
 dependencies = [
- "bumpalo",
  "crc32fast",
  "log",
  "simd-adler32",
+ "typed-arena",
 ]

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 = "9.0.0"
+rust-version = "1.66.0"
 
 [badges]
-travis-ci = { repository = "oxipng/oxipng", branch = "master" }
+travis-ci = { repository = "shssoichiro/oxipng", branch = "master" }
 maintenance = { status = "actively-developed" }
 
 [[bin]]
@@ -38,33 +27,56 @@ name = "zopfli"
 required-features = ["zopfli"]
 
 [dependencies]
+zopfli = { version = "0.8.0", optional = true, default-features = false, features = ["std", "zlib"] }
+rgb = "0.8.36"
+indexmap = "2.0.0"
+libdeflater = "1.19.0"
+log = "0.4.19"
 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.env_logger]
+optional = true
+default-features = false
+features = ["auto-color"]
+version = "0.10.0"
 
-[dev-dependencies]
-serde_json = "1.0.150"
+[dependencies.crossbeam-channel]
+optional = true
+version = "0.5.8"
+
+[dependencies.filetime]
+optional = true
+version = "0.2.21"
+
+[dependencies.rayon]
+optional = true
+version = "1.7.0"
+
+[dependencies.clap]
+optional = true
+version = "4.3.8"
+features = ["wrap_help"]
+
+[target.'cfg(windows)'.dependencies.glob]
+optional = true
+version = "0.3.1"
+
+[dependencies.image]
+optional = true
+default-features = false
+features = ["png"]
+version = "0.24.6"
+
+[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", "glob", "env_logger"]
+default = ["binary", "filetime", "parallel", "zopfli"]
+parallel = ["rayon", "indexmap/rayon", "crossbeam-channel"]
 freestanding = ["libdeflater/freestanding"]
-sanity-checks = ["dep:image"]
-zopfli = ["dep:zopfli"]
-system-libdeflate = ["libdeflater/dynamic"]
+sanity-checks = ["image"]
 
 [lib]
 name = "oxipng"
@@ -74,48 +86,8 @@ path = "src/lib.rs"
 opt-level = 2
 
 [profile.release]
-lto = "fat"
+lto = "thin"
 strip = "symbols"
-panic = "abort"
 
-[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

Dockerfile

@@ -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" ]

MANUAL.txt

@@ -1,4 +1,4 @@
-oxipng 10.1.0
+oxipng 9.0.0
 Losslessly improve compression of PNG files
 
 Usage: oxipng [OPTIONS] <files>...
@@ -13,14 +13,14 @@ Options:
           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)
+          0   => --zc 5 --fast               (1 trial, determined heuristically)
+          1   => --zc 10 --fast              (1 trial, determined heuristically)
+          2   => --zc 11 -f 0,1,6,7 --fast   (4 fast trials, 1 main trial)
+          3   => --zc 11 -f 0,7,8,9          (4 trials)
+          4   => --zc 12 -f 0,7,8,9          (4 trials)
+          5   => --zc 12 -f 0,1,2,5,6,7,8,9  (8 trials)
+          6   => --zc 12 -f 0-9              (10 trials)
+          max =>                             (stable alias for the max level)
           
           Manually specifying a compression option (zc, f, etc.) will override the optimization
           preset, regardless of the order you write the arguments.
@@ -45,7 +45,7 @@ Options:
   -p, --preserve
           Preserve file permissions and timestamps if possible
 
-  -d, --dry-run
+  -P, --pretend
           Do not write any files, only show compression results
 
   -s
@@ -54,28 +54,18 @@ Options:
       --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'
+          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.
+          Note that 'bKGD', 'sBIT' and 'hIST' will be forcibly stripped if the color type or bit
+          depth is changed, regardless of any options set.
 
       --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.
+          Strip all metadata except in the comma-separated list
 
   -a, --alpha
           Perform additional optimization on images with an alpha channel, by altering the color
@@ -83,17 +73,17 @@ Options:
           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:
+  -i, --interlace <type>
+          Set the PNG interlacing type, where <type> 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
+          0     =>  Remove interlacing from all images that are processed
+          1     =>  Apply Adam7 interlacing on all images that are processed
+          keep  =>  Keep the existing interlacing type 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]
+          [default: 0]
 
       --scale16
           Forcibly reduce images with 16 bits per channel to 8 bits per channel. This is a lossy
@@ -105,13 +95,10 @@ Options:
           losslessly.
 
   -v, --verbose...
-          Show per-file info (use multiple times for more detail)
+          Run in verbose mode (use twice to increase verbosity)
 
   -q, --quiet
-          Suppress all output messages
-
-  -j, --json
-          Print results as JSON
+          Run in quiet mode
 
   -f, --filters <list>
           Perform compression trials with each of the given filter types. You can specify a
@@ -123,12 +110,11 @@ Options:
               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
+              6  =>  Entropy   Highest Shannon entropy
               7  =>  Bigrams   Lowest count of distinct bigrams
-              8  =>  BigEnt    Smallest Shannon entropy of bigrams
+              8  =>  BigEnt    Highest Shannon entropy of bigrams
               9  =>  Brute     Smallest compressed size (slow)
           
           The default value depends on the optimization level preset.
@@ -139,7 +125,7 @@ Options:
           CPU cores.
 
       --zc <level>
-          Deflate compression level (0-12) for main compression trials. The levels here are defined
+          Deflate compression level (1-12) for main compression trials. The levels here are defined
           by the libdeflate compression library.
           
           The default value depends on the optimization level preset.
@@ -166,33 +152,15 @@ Options:
 
       --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.
+          be processed successfully.
 
       --force
           Write the output even if it is larger than the input
 
-  -z, --zopfli
+  -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
@@ -200,25 +168,8 @@ Options:
           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'.
+          Set number of threads to use [default: num CPU cores]
 
   -h, --help
           Print help (see a summary with '-h')

README.md

@@ -1,46 +1,38 @@
 # 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.
+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.66.0**.
 
 Oxipng follows Semantic Versioning.
 
@@ -56,7 +48,7 @@ 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.
+  better but generally have increasingly diminishing returns.
 - 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
@@ -71,80 +63,77 @@ More advanced options can be found by running `oxipng --help`, or viewed [here](
 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 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.
+## Git integration via [Trunk]
 
-## APNG support
+[Trunk] is an extendable superlinter which can be used to run `oxipng` to automatically optimize `png`s when committing them into a git repo, or to gate any `png`s being added to a git repo on whether they are optimized. The [trunk] oxipng integration is [here](https://github.com/trunk-io/plugins/tree/main/linters/oxipng).
 
-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:
+To enable oxipng via [trunk]:
 
 ```bash
-docker run --rm -v $(pwd):/work ghcr.io/oxipng/oxipng -o 4 /work/file.png
+# to get the latest version:
+trunk check enable oxipng
+
+# to get a specific version:
+trunk check enable oxipng@9.0.0
 ```
 
-Some older images are also available at [`ghcr.io/shssoichiro/oxipng`](https://github.com/users/shssoichiro/packages/container/package/oxipng).
+or modify `.trunk/trunk.yaml` in your repo to contain:
+
+```
+lint:
+  enabled:
+    - oxipng@9.0.0
+```
+
+Then just run:
+
+```bash
+# to optimize a png:
+trunk fmt <file>
+
+# to check if a png is already optimized:
+trunk check <file>
+```
+
+You can setup [trunk] to [manage your git hooks](https://docs.trunk.io/docs/actions-git-hooks) and automatically optimize any `png`s you commit to git, _when_ you `git commit`. To enable this, run:
+
+```bash
+trunk actions enable trunk-fmt-pre-commit
+```
+
+[trunk]: https://docs.trunk.io
 
 ## 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).
+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/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
+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
+`oxipng = { version = "9.0", features = ["parallel", "zopfli", "filetime"], default-features = false }`
 
 ## 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.
+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).
 
-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.
+Note that, while similar, Oxipng is not a drop-in replacement for OptiPNG.
+If you are migrating from OptiPNG, please check the [help](MANUAL.txt) before using.
 
 ## Contributing
 
@@ -154,11 +143,78 @@ 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 9.0.0 (commit `c16519b38b0519988db625913be919d4f0e42f5d`, compiled
+on `rustc 1.74.0-nightly (7b4d9e155 2023-09-28)`) against OptiPNG version 0.7.7,
+as packaged by Debian unstable, on a Linux 6.5.0-2-amd64 kernel, Intel Core
+i7-12700 CPU (8 performance cores, 4 efficiency cores, 20 threads), DDR5-5200
+RAM in dual channel configuration.
+
+```
+
+Benchmark 1: ./target/release/oxipng -P ./tests/files/rgb_16_should_be_grayscale_8.png
+  Time (mean ± σ):      59.6 ms ±   7.7 ms    [User: 77.4 ms, System: 3.6 ms]
+  Range (min … max):    53.3 ms …  89.9 ms    32 runs
+
+Benchmark 2: optipng -simulate ./tests/files/rgb_16_should_be_grayscale_8.png
+  Time (mean ± σ):     132.4 ms ±   0.8 ms    [User: 132.5 ms, System: 0.6 ms]
+  Range (min … max):   131.8 ms … 134.4 ms    22 runs
+
+Summary
+  ./target/release/oxipng -P ./tests/files/rgb_16_should_be_grayscale_8.png ran
+    2.22 ± 0.29 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 ± σ):      88.7 ms ±   4.3 ms    [User: 270.3 ms, System: 11.0 ms]
+  Range (min … max):    86.8 ms … 109.4 ms    26 runs
+
+Benchmark 2: optipng -o 4 -simulate ./tests/files/rgb_16_should_be_grayscale_8.png
+  Time (mean ± σ):     444.9 ms ±   0.3 ms    [User: 444.8 ms, System: 0.7 ms]
+  Range (min … max):   444.4 ms … 445.6 ms    10 runs
+
+Summary
+  ./target/release/oxipng -o4 -P ./tests/files/rgb_16_should_be_grayscale_8.png ran
+    5.01 ± 0.25 times faster than optipng -o 4 -simulate ./tests/files/rgb_16_should_be_grayscale_8.png
+
+```
+
+<details>
+<summary>Older benchmark</summary>
+
+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'
+
+```
+</details>

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.

benches/deflate.rs

@@ -3,9 +3,9 @@
 extern crate oxipng;
 extern crate test;
 
+use oxipng::internal_tests::*;
+use oxipng::*;
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;
 
 #[bench]
@@ -13,7 +13,10 @@ 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();
 
-    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]
@@ -21,7 +24,10 @@ 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();
 
-    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]
@@ -31,7 +37,10 @@ fn deflate_4_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).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]
@@ -41,7 +50,10 @@ fn deflate_2_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).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]
@@ -51,7 +63,10 @@ fn deflate_1_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).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]

benches/filters.rs

@@ -3,9 +3,9 @@
 extern crate oxipng;
 extern crate test;
 
+use oxipng::internal_tests::*;
+use oxipng::*;
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;
 
 #[bench]
@@ -13,7 +13,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }
 
 #[bench]
@@ -21,7 +23,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }
 
 #[bench]
@@ -31,7 +35,9 @@ fn filters_4_bits_filter_0(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }
 
 #[bench]
@@ -41,7 +47,9 @@ fn filters_2_bits_filter_0(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }
 
 #[bench]
@@ -51,7 +59,9 @@ fn filters_1_bits_filter_0(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::NONE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::None, false);
+    });
 }
 
 #[bench]
@@ -59,7 +69,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }
 
 #[bench]
@@ -67,7 +79,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }
 
 #[bench]
@@ -77,7 +91,9 @@ fn filters_4_bits_filter_1(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }
 
 #[bench]
@@ -87,7 +103,9 @@ fn filters_2_bits_filter_1(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }
 
 #[bench]
@@ -97,7 +115,9 @@ fn filters_1_bits_filter_1(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::SUB, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Sub, false);
+    });
 }
 
 #[bench]
@@ -105,7 +125,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }
 
 #[bench]
@@ -113,7 +135,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }
 
 #[bench]
@@ -123,7 +147,9 @@ fn filters_4_bits_filter_2(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }
 
 #[bench]
@@ -133,7 +159,9 @@ fn filters_2_bits_filter_2(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }
 
 #[bench]
@@ -143,7 +171,9 @@ fn filters_1_bits_filter_2(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::UP, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Up, false);
+    });
 }
 
 #[bench]
@@ -151,7 +181,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }
 
 #[bench]
@@ -159,7 +191,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }
 
 #[bench]
@@ -169,7 +203,9 @@ fn filters_4_bits_filter_3(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }
 
 #[bench]
@@ -179,7 +215,9 @@ fn filters_2_bits_filter_3(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }
 
 #[bench]
@@ -189,7 +227,9 @@ fn filters_1_bits_filter_3(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::AVERAGE, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Average, false);
+    });
 }
 
 #[bench]
@@ -197,7 +237,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }
 
 #[bench]
@@ -205,7 +247,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }
 
 #[bench]
@@ -215,7 +259,9 @@ fn filters_4_bits_filter_4(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }
 
 #[bench]
@@ -225,7 +271,9 @@ fn filters_2_bits_filter_4(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }
 
 #[bench]
@@ -235,7 +283,9 @@ fn filters_1_bits_filter_4(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::PAETH, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Paeth, false);
+    });
 }
 
 #[bench]
@@ -243,7 +293,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }
 
 #[bench]
@@ -251,7 +303,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }
 
 #[bench]
@@ -261,7 +315,9 @@ fn filters_4_bits_filter_5(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }
 
 #[bench]
@@ -271,7 +327,9 @@ fn filters_2_bits_filter_5(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }
 
 #[bench]
@@ -281,5 +339,7 @@ fn filters_1_bits_filter_5(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }

benches/interlacing.rs

@@ -3,9 +3,9 @@
 extern crate oxipng;
 extern crate test;
 
+use oxipng::internal_tests::*;
+use oxipng::*;
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;
 
 #[bench]
@@ -13,7 +13,7 @@ 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();
 
-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }
 
 #[bench]
@@ -21,7 +21,7 @@ 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();
 
-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }
 
 #[bench]
@@ -31,7 +31,7 @@ fn interlacing_4_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }
 
 #[bench]
@@ -41,7 +41,7 @@ fn interlacing_2_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }
 
 #[bench]
@@ -51,7 +51,7 @@ fn interlacing_1_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.change_interlacing(true));
+    b.iter(|| png.raw.change_interlacing(Interlacing::Adam7));
 }
 
 #[bench]
@@ -61,7 +61,7 @@ fn deinterlacing_16_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }
 
 #[bench]
@@ -71,7 +71,7 @@ fn deinterlacing_8_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }
 
 #[bench]
@@ -81,7 +81,7 @@ fn deinterlacing_4_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }
 
 #[bench]
@@ -91,7 +91,7 @@ fn deinterlacing_2_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }
 
 #[bench]
@@ -101,5 +101,5 @@ fn deinterlacing_1_bits(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| png.raw.change_interlacing(false));
+    b.iter(|| png.raw.change_interlacing(Interlacing::None));
 }

benches/reductions.rs

@@ -3,9 +3,9 @@
 extern crate oxipng;
 extern crate test;
 
+use oxipng::internal_tests::*;
+use oxipng::*;
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;
 
 #[bench]
@@ -54,6 +54,36 @@ fn reductions_8_to_1_bits(b: &mut Bencher) {
     b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
 }
 
+#[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, &Options::default()).unwrap();
+
+    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+}
+
+#[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, &Options::default()).unwrap();
+
+    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+}
+
+#[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, &Options::default()).unwrap();
+
+    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+}
+
 #[bench]
 fn reductions_grayscale_8_to_4_bits(b: &mut Bencher) {
     let input = test::black_box(PathBuf::from(
@@ -84,12 +114,42 @@ fn reductions_grayscale_8_to_1_bits(b: &mut Bencher) {
     b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
 }
 
+#[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, &Options::default()).unwrap();
+
+    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+}
+
+#[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, &Options::default()).unwrap();
+
+    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+}
+
+#[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, &Options::default()).unwrap();
+
+    b.iter(|| bit_depth::reduced_bit_depth_8_or_less(&png.raw));
+}
+
 #[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();
 
-    b.iter(|| alpha::reduced_alpha_channel(&png.raw, true));
+    b.iter(|| alpha::reduced_alpha_channel(&png.raw, false));
 }
 
 #[bench]
@@ -97,15 +157,7 @@ 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();
 
-    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(|| alpha::reduced_alpha_channel(&png.raw, false));
 }
 
 #[bench]
@@ -128,6 +180,32 @@ fn reductions_rgba_to_grayscale_alpha_8(b: &mut Bencher) {
     b.iter(|| color::reduced_rgb_to_grayscale(&png.raw));
 }
 
+#[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, &Options::default()).unwrap();
+
+    b.iter(|| {
+        color::reduced_rgb_to_grayscale(&png.raw)
+            .and_then(|r| alpha::reduced_alpha_channel(&r, 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, &Options::default()).unwrap();
+
+    b.iter(|| {
+        color::reduced_rgb_to_grayscale(&png.raw)
+            .and_then(|r| alpha::reduced_alpha_channel(&r, false))
+    });
+}
+
 #[bench]
 fn reductions_rgb_to_grayscale_16(b: &mut Bencher) {
     let input = test::black_box(PathBuf::from(
@@ -162,36 +240,6 @@ fn reductions_rgb_to_palette_8(b: &mut Bencher) {
     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(
@@ -209,7 +257,7 @@ fn reductions_palette_8_to_grayscale_8(b: &mut Bencher) {
     ));
     let png = PngData::new(&input, &Options::default()).unwrap();
 
-    b.iter(|| color::indexed_to_channels(&png.raw, true, false));
+    b.iter(|| color::indexed_to_channels(&png.raw, true));
 }
 
 #[bench]
@@ -252,16 +300,6 @@ fn reductions_palette_sort(b: &mut Bencher) {
     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(

benches/strategies.rs

@@ -3,9 +3,9 @@
 extern crate oxipng;
 extern crate test;
 
+use oxipng::internal_tests::*;
+use oxipng::*;
 use std::path::PathBuf;
-
-use oxipng::{internal_tests::*, *};
 use test::Bencher;
 
 #[bench]
@@ -13,7 +13,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::MinSum, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::MinSum, false);
+    });
 }
 
 #[bench]
@@ -21,7 +23,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::Entropy, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Entropy, false);
+    });
 }
 
 #[bench]
@@ -29,7 +33,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::Bigrams, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::Bigrams, false);
+    });
 }
 
 #[bench]
@@ -37,7 +43,9 @@ 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();
 
-    b.iter(|| png.raw.filter_image(FilterStrategy::BigEnt, false));
+    b.iter(|| {
+        png.raw.filter_image(RowFilter::BigEnt, false);
+    });
 }
 
 #[bench]
@@ -46,12 +54,6 @@ fn filters_brute(b: &mut Bencher) {
     let png = PngData::new(&input, &Options::default()).unwrap();
 
     b.iter(|| {
-        png.raw.filter_image(
-            FilterStrategy::Brute {
-                num_lines: 4,
-                level: 1,
-            },
-            false,
-        )
+        png.raw.filter_image(RowFilter::Brute, false);
     });
 }

benches/zopfli.rs

@@ -3,18 +3,22 @@
 extern crate oxipng;
 extern crate test;
 
+use oxipng::internal_tests::*;
+use oxipng::*;
+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();
 
     b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
     });
 }
 
@@ -24,7 +28,7 @@ fn zopfli_8_bits_strategy_0(b: &mut Bencher) {
     let png = PngData::new(&input, &Options::default()).unwrap();
 
     b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
     });
 }
 
@@ -36,7 +40,7 @@ fn zopfli_4_bits_strategy_0(b: &mut Bencher) {
     let png = PngData::new(&input, &Options::default()).unwrap();
 
     b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
     });
 }
 
@@ -48,7 +52,7 @@ fn zopfli_2_bits_strategy_0(b: &mut Bencher) {
     let png = PngData::new(&input, &Options::default()).unwrap();
 
     b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
     });
 }
 
@@ -60,6 +64,6 @@ fn zopfli_1_bits_strategy_0(b: &mut Bencher) {
     let png = PngData::new(&input, &Options::default()).unwrap();
 
     b.iter(|| {
-        zopfli_deflate(png.raw.data.as_ref(), ZopfliOptions::default()).ok();
+        zopfli_deflate(png.raw.data.as_ref(), DEFAULT_ZOPFLI_ITERATIONS).ok();
     });
 }

index.html

@@ -0,0 +1 @@
+<script>(function() {window.location.assign(window.location.href + "doc/oxipng/");})();</script>

scripts/manual.sh

@@ -1,7 +1,5 @@
-#!/bin/sh -eu
+#!/bin/bash
 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
+./target/debug/oxipng --help >> MANUAL.txt

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

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

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),
-        )
-}

src/colors.rs

@@ -1,6 +1,5 @@
-use std::{fmt, fmt::Display};
-
 use rgb::{RGB16, RGBA8};
+use std::{fmt, fmt::Display};
 
 use crate::PngError;
 
@@ -32,11 +31,13 @@ impl 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"),
+            ColorType::Grayscale { .. } => Display::fmt("Grayscale", f),
+            ColorType::RGB { .. } => Display::fmt("RGB", f),
+            ColorType::Indexed { palette } => {
+                Display::fmt(&format!("Indexed ({} colors)", palette.len()), f)
+            }
+            ColorType::GrayscaleAlpha => Display::fmt("Grayscale + Alpha", f),
+            ColorType::RGBA => Display::fmt("RGB + Alpha", f),
         }
     }
 }
@@ -44,47 +45,49 @@ impl Display for ColorType {
 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(crate) fn channels_per_pixel(&self) -> u8 {
         match self {
-            Self::Grayscale { .. } | Self::Indexed { .. } => 1,
-            Self::GrayscaleAlpha => 2,
-            Self::RGB { .. } => 3,
-            Self::RGBA => 4,
+            ColorType::Grayscale { .. } | ColorType::Indexed { .. } => 1,
+            ColorType::GrayscaleAlpha => 2,
+            ColorType::RGB { .. } => 3,
+            ColorType::RGBA => 4,
         }
     }
 
     #[inline]
-    pub(crate) const fn is_rgb(&self) -> bool {
-        matches!(self, Self::RGB { .. } | Self::RGBA)
+    pub(crate) fn is_rgb(&self) -> bool {
+        matches!(self, ColorType::RGB { .. } | ColorType::RGBA)
     }
 
     #[inline]
-    pub(crate) const fn is_gray(&self) -> bool {
-        matches!(self, Self::Grayscale { .. } | Self::GrayscaleAlpha)
+    pub(crate) fn is_gray(&self) -> bool {
+        matches!(
+            self,
+            ColorType::Grayscale { .. } | ColorType::GrayscaleAlpha
+        )
     }
 
     #[inline]
-    pub(crate) const fn has_alpha(&self) -> bool {
-        matches!(self, Self::GrayscaleAlpha | Self::RGBA)
+    pub(crate) fn has_alpha(&self) -> bool {
+        matches!(self, ColorType::GrayscaleAlpha | ColorType::RGBA)
     }
 
     #[inline]
-    pub(crate) const fn has_trns(&self) -> bool {
+    pub(crate) fn has_trns(&self) -> bool {
         match self {
-            Self::Grayscale { transparent_shade } => transparent_shade.is_some(),
-            Self::RGB { transparent_color } => transparent_color.is_some(),
+            ColorType::Grayscale { transparent_shade } => transparent_shade.is_some(),
+            ColorType::RGB { transparent_color } => transparent_color.is_some(),
             _ => false,
         }
     }
@@ -116,7 +119,7 @@ impl TryFrom<u8> for BitDepth {
             4 => Ok(Self::Four),
             8 => Ok(Self::Eight),
             16 => Ok(Self::Sixteen),
-            _ => Err(PngError::InvalidData),
+            _ => Err(PngError::new("Unexpected bit depth")),
         }
     }
 }

src/deflate/deflater.rs

@@ -1,10 +1,12 @@
+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()));
+    let capacity = max_size
+        .get()
+        .unwrap_or_else(|| compressor.zlib_compress_bound(data.len()));
     let mut dest = vec![0; capacity];
     let len = compressor
         .zlib_compress(data, &mut dest)
@@ -22,13 +24,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);

src/deflate/mod.rs

@@ -1,38 +1,44 @@
 mod deflater;
+use crate::AtomicMin;
+use crate::{PngError, PngResult};
+pub use deflater::crc32;
+pub use deflater::deflate;
+pub use deflater::inflate;
 use std::{fmt, fmt::Display};
 
-pub use deflater::{crc32, deflate, inflate};
-
-use crate::{PngError, PngResult};
-
+#[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),
+    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,
+    },
 }
 
-impl Deflater {
-    pub(crate) fn deflate(self, data: &[u8], max_size: Option<usize>) -> PngResult<Vec<u8>> {
+impl Deflaters {
+    pub(crate) fn deflate(self, data: &[u8], max_size: &AtomicMin) -> 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)?,
+            Self::Zopfli { iterations } => zopfli_deflate(data, iterations)?,
         };
-        if let Some(max) = max_size {
+        if let Some(max) = max_size.get() {
             if compressed.len() > max {
                 return Err(PngError::DeflatedDataTooLong(max));
             }
@@ -41,13 +47,13 @@ impl Deflater {
     }
 }
 
-impl Display for Deflater {
+impl Display for Deflaters {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Libdeflater { compression } => write!(f, "zc = {compression}"),
+            Self::Libdeflater { compression } => Display::fmt(compression, f),
             #[cfg(feature = "zopfli")]
-            Self::Zopfli(options) => write!(f, "zopfli, zi = {}", options.iteration_count),
+            Self::Zopfli { .. } => Display::fmt("zopfli", f),
         }
     }
 }

src/deflate/zopfli_oxipng.rs

@@ -1,13 +1,16 @@
 use crate::{PngError, PngResult};
+use std::num::NonZeroU8;
 
-pub fn deflate(data: &[u8], options: zopfli::Options) -> PngResult<Vec<u8>> {
+pub fn deflate(data: &[u8], iterations: NonZeroU8) -> 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(()) => (),
+    let options = zopfli::Options {
+        iteration_count: iterations.into(),
+        ..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)
 }

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",
-];

src/error.rs

@@ -1,23 +1,19 @@
-use std::{error::Error, fmt};
-
 use crate::colors::{BitDepth, ColorType};
+use std::error::Error;
+use std::fmt;
 
-#[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),
+    InvalidDepthForType(BitDepth, ColorType),
+    IncorrectDataLength(usize, usize),
     Other(Box<str>),
 }
 
@@ -28,42 +24,31 @@ 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::InvalidDepthForType(d, ref c) => {
+                write!(f, "Invalid bit depth {} for color type {}", d, c)
+            }
+            PngError::IncorrectDataLength(l1, l2) => write!(
+                f,
+                "Data length {} does not match the expected length {}",
+                l1, l2
+            ),
+            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())
     }
 }

src/evaluate.rs

@@ -1,47 +1,42 @@
 //! Check if a reduction makes file smaller, and keep best reductions.
 //! Works asynchronously when possible
 
+use crate::atomicmin::AtomicMin;
+use crate::deflate;
+use crate::filters::RowFilter;
+use crate::png::PngImage;
 #[cfg(not(feature = "parallel"))]
-use std::cell::RefCell;
-use std::sync::{
-    Arc,
-    atomic::{AtomicUsize, Ordering::*},
-};
-
-use deflate::Deflater;
+use crate::rayon;
+use crate::Deadline;
+use crate::PngError;
+#[cfg(feature = "parallel")]
+use crossbeam_channel::{unbounded, Receiver, Sender};
 use indexmap::IndexSet;
 use log::trace;
 use rayon::prelude::*;
-#[cfg(feature = "parallel")]
-use std::sync::mpsc::{Receiver, Sender, channel};
-
 #[cfg(not(feature = "parallel"))]
-use crate::rayon;
-use crate::{
-    Deadline, PngError, atomicmin::AtomicMin, deflate, filters::FilterStrategy, png::PngImage,
-};
+use std::cell::RefCell;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::*;
+use std::sync::Arc;
 
-pub(crate) struct Candidate {
+pub 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 idat_data: Vec<u8>,
+    pub filtered: Vec<u8>,
+    pub filter: RowFilter,
+    // 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.idat_data.len() + self.image.key_chunks_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.ihdr.bit_depth,
+            self.filter,
+            self.nth,
         )
     }
 }
@@ -49,10 +44,9 @@ 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>,
@@ -67,19 +61,17 @@ 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)),
@@ -118,22 +110,14 @@ 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);
-    }
-
-    /// 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) {
         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")]
@@ -146,37 +130,29 @@ impl Evaluator {
             // 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());
+                let filtered = image.filter_image(filter, optimize_alpha);
+                let idat_data = deflate::deflate(&filtered, compression, &best_candidate_size);
                 if let Ok(idat_data) = idat_data {
-                    let estimated_output_size = image.estimated_output_size(&idat_data);
+                    let size = idat_data.len() + image.key_chunks_size();
+                    best_candidate_size.set_min(size);
                     trace!(
-                        "Eval: {}-bit {:23} {:8}   {} bytes",
-                        image.ihdr.bit_depth, description, filter, estimated_output_size
+                        "Eval: {}-bit {:20}  {:8}   {} bytes",
+                        image.ihdr.bit_depth,
+                        image.ihdr.color_type,
+                        filter,
+                        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 new = Candidate {
                         image: image.clone(),
-                        idat_data: if final_round { Some(idat_data) } else { None },
-                        estimated_output_size,
-                        filter: filter.clone(),
-                        filter_used,
+                        idat_data,
+                        filtered,
+                        filter,
                         nth,
                     };
-                    best_candidate_size.set_min(estimated_output_size);
 
                     #[cfg(feature = "parallel")]
                     {
@@ -192,8 +168,11 @@ impl Evaluator {
                     }
                 } else if let Err(PngError::DeflatedDataTooLong(size)) = idat_data {
                     trace!(
-                        "Eval: {}-bit {:23} {:8}  >{} bytes",
-                        image.ihdr.bit_depth, description, filter, size
+                        "Eval: {}-bit {:20}  {:8}  >{} bytes",
+                        image.ihdr.bit_depth,
+                        image.ihdr.color_type,
+                        filter,
+                        size
                     );
                 }
             });

src/filters.rs

@@ -1,67 +1,30 @@
-use std::{fmt, fmt::Display, mem::transmute};
+use std::mem::transmute;
+use std::{fmt, fmt::Display};
 
-/// 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) }
@@ -77,6 +40,11 @@ impl Display for RowFilter {
                 Self::Up => "Up",
                 Self::Average => "Average",
                 Self::Paeth => "Paeth",
+                Self::MinSum => "MinSum",
+                Self::Entropy => "Entropy",
+                Self::Bigrams => "Bigrams",
+                Self::BigEnt => "BigEnt",
+                Self::Brute => "Brute",
             },
             f,
         )
@@ -84,7 +52,9 @@ impl Display for RowFilter {
 }
 
 impl RowFilter {
-    pub(crate) const ALL: [Self; 5] = [Self::None, Self::Sub, Self::Up, Self::Average, Self::Paeth];
+    pub const LAST: u8 = Self::Brute as u8;
+    pub(crate) const STANDARD: [Self; 5] =
+        [Self::None, Self::Sub, Self::Up, Self::Average, Self::Paeth];
     pub(crate) const SINGLE_LINE: [Self; 2] = [Self::None, Self::Sub];
 
     pub(crate) fn filter_line(
@@ -127,20 +97,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 +126,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 +139,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,6 +171,7 @@ impl RowFilter {
                             };
                         }
                     }
+                    _ => unreachable!(),
                 }
             }
         }
@@ -225,7 +183,7 @@ impl RowFilter {
         data: &[u8],
         prev_line: &[u8],
         buf: &mut Vec<u8>,
-    ) {
+    ) -> Result<(), PngError> {
         buf.clear();
         buf.reserve(data.len());
         assert!(data.len() >= bpp);
@@ -237,7 +195,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 +211,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 +232,9 @@ impl RowFilter {
                     );
                 }
             }
+            _ => return Err(PngError::InvalidData),
         }
+        Ok(())
     }
 }
 

src/headers.rs

@@ -1,15 +1,14 @@
+use crate::colors::{BitDepth, ColorType};
+use crate::deflate::{crc32, inflate};
+use crate::error::PngError;
+use crate::interlace::Interlacing;
+use crate::AtomicMin;
+use crate::Deflaters;
+use crate::PngResult;
 use indexmap::IndexSet;
-use log::{debug, trace, warn};
+use log::warn;
 use rgb::{RGB16, RGBA8};
 
-use crate::{
-    Deflater, Options, PngResult,
-    colors::{BitDepth, ColorType},
-    deflate::{crc32, inflate},
-    display_chunks::DISPLAY_CHUNKS,
-    error::PngError,
-};
-
 #[derive(Debug, Clone)]
 /// Headers from the IHDR chunk of the image
 pub struct IhdrData {
@@ -21,30 +20,32 @@ 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 interlacing mode of the image
+    pub interlaced: Interlacing,
 }
 
 impl IhdrData {
     /// Bits per pixel
     #[must_use]
     #[inline]
-    pub const fn bpp(&self) -> usize {
+    pub fn bpp(&self) -> usize {
         self.bit_depth as usize * self.color_type.channels_per_pixel() as usize
     }
 
     /// 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: usize, w: usize, h: usize) -> usize {
+            ((w * bpp + 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,8 +59,6 @@ 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
         }
     }
 }
@@ -70,16 +69,14 @@ pub struct Chunk {
     pub data: Vec<u8>,
 }
 
-/// [`Options`][crate::Options] to use when stripping chunks (metadata)
 #[derive(Debug, PartialEq, Eq, Clone)]
+/// Options to use when stripping chunks
 pub enum StripChunks {
     /// 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
+    /// Remove all chunks that won't affect rendering
     Safe,
     /// Remove all non-critical chunks except these
     Keep(IndexSet<[u8; 4]>),
@@ -88,13 +85,18 @@ pub enum StripChunks {
 }
 
 impl StripChunks {
+    /// List of chunks that will be kept when using the `Safe` option
+    pub const KEEP_SAFE: [[u8; 4]; 7] = [
+        *b"cICP", *b"iCCP", *b"sRGB", *b"pHYs", *b"acTL", *b"fcTL", *b"fdAT",
+    ];
+
     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,
+            StripChunks::None => true,
+            StripChunks::Keep(names) => names.contains(name),
+            StripChunks::Strip(names) => !names.contains(name),
+            StripChunks::Safe => Self::KEEP_SAFE.contains(name),
+            StripChunks::All => false,
         }
     }
 }
@@ -112,36 +114,6 @@ pub struct RawChunk<'a> {
     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>(
     byte_data: &'a [u8],
     byte_offset: &mut usize,
@@ -152,27 +124,37 @@ pub fn parse_next_chunk<'a>(
             .get(*byte_offset..*byte_offset + 4)
             .ok_or(PngError::TruncatedData)?,
     );
-    if byte_data.len() < *byte_offset + 12 + length as usize {
-        return Err(PngError::TruncatedData);
-    }
     *byte_offset += 4;
 
     let chunk_start = *byte_offset;
-    let chunk_name = &byte_data[chunk_start..chunk_start + 4];
+    let chunk_name = byte_data
+        .get(chunk_start..chunk_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 crc = read_be_u32(
+        byte_data
+            .get(*byte_offset..*byte_offset + 4)
+            .ok_or(PngError::TruncatedData)?,
+    );
     *byte_offset += 4;
 
-    let chunk_bytes = &byte_data[chunk_start..chunk_start + 4 + length as usize];
+    let chunk_bytes = byte_data
+        .get(chunk_start..chunk_start + 4 + length as usize)
+        .ok_or(PngError::TruncatedData)?;
     if !fix_errors && crc32(chunk_bytes) != crc {
-        return Err(PngError::CRCMismatch(chunk_name.try_into().unwrap()));
+        return Err(PngError::new(&format!(
+            "CRC Mismatch in {} chunk; May be recoverable by using --fix",
+            String::from_utf8_lossy(chunk_name)
+        )));
     }
 
     let name: [u8; 4] = chunk_name.try_into().unwrap();
@@ -191,13 +173,13 @@ pub fn parse_ihdr_chunk(
             0 => ColorType::Grayscale {
                 transparent_shade: trns_data
                     .filter(|t| t.len() >= 2)
-                    .map(|t| read_be_u16(&t[0..2])),
+                    .map(|t| u16::from_be_bytes([t[0], t[1]])),
             },
             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]),
+                    r: u16::from_be_bytes([t[0], t[1]]),
+                    g: u16::from_be_bytes([t[2], t[3]]),
+                    b: u16::from_be_bytes([t[4], t[5]]),
                 }),
             },
             3 => ColorType::Indexed {
@@ -205,16 +187,12 @@ pub fn parse_ihdr_chunk(
             },
             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),
-        },
+        interlaced: interlaced.try_into()?,
     })
 }
 
@@ -223,9 +201,9 @@ 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 palette_data = palette_data.ok_or_else(|| PngError::new("no palette in indexed image"))?;
     let mut palette: Vec<_> = palette_data
-        .chunks_exact(3)
+        .chunks(3)
         .map(|color| RGBA8::new(color[0], color[1], color[2], 255))
         .collect();
 
@@ -238,17 +216,12 @@ fn palette_to_rgba(
 }
 
 #[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 {
+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>> {
+pub fn extract_icc(iccp: &Chunk) -> Option<Vec<u8>> {
     // Skip (useless) profile name
     let mut data = iccp.data.as_slice();
     loop {
@@ -263,24 +236,21 @@ pub fn extract_icc(iccp: &Chunk, max_size: Option<usize>) -> Option<Vec<u8>> {
     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) {
+    // The decompressed size is unknown so we have to guess the required buffer size
+    let max_size = compressed_data.len() * 2 + 1000;
+    match inflate(compressed_data, max_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}");
+            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)?;
+/// Construct an iCCP chunk by compressing the ICC profile
+pub fn construct_iccp(icc: &[u8], deflater: Deflaters) -> PngResult<Chunk> {
+    let mut compressed = deflater.deflate(icc, &AtomicMin::new(None))?;
     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
@@ -317,109 +287,3 @@ pub fn srgb_rendering_intent(icc_data: &[u8]) -> Option<u8> {
         _ => 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
-    });
-}

src/interlace.rs

@@ -1,6 +1,40 @@
+use std::{fmt, 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 fmt::Formatter<'_>) -> fmt::Result {
+        Display::fmt(
+            match self {
+                Self::None => "non-interlaced",
+                Self::Adam7 => "interlaced",
+            },
+            f,
+        )
+    }
+}
 
 #[must_use]
 pub fn interlace_image(png: &PngImage) -> PngImage {
@@ -53,7 +87,7 @@ pub fn interlace_image(png: &PngImage) -> PngImage {
         data: output,
         ihdr: IhdrData {
             color_type: png.ihdr.color_type.clone(),
-            interlaced: true,
+            interlaced: Interlacing::Adam7,
             ..png.ihdr
         },
     }
@@ -67,7 +101,7 @@ pub fn deinterlace_image(png: &PngImage) -> PngImage {
         },
         ihdr: IhdrData {
             color_type: png.ihdr.color_type.clone(),
-            interlaced: false,
+            interlaced: Interlacing::None,
             ..png.ihdr
         },
     }
@@ -85,8 +119,10 @@ 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
+        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;
         for (i, bit) in bit_vec.iter().by_vals().enumerate() {
             // Avoid moving padded 0's into new image
@@ -149,7 +185,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;
     }

src/main.rs

@@ -1,172 +1,442 @@
+#![warn(trivial_casts, trivial_numeric_casts, unused_import_braces)]
+#![deny(missing_debug_implementations, missing_copy_implementations)]
+#![warn(clippy::expl_impl_clone_on_copy)]
+#![warn(clippy::float_cmp_const)]
+#![warn(clippy::linkedlist)]
+#![warn(clippy::map_flatten)]
+#![warn(clippy::match_same_arms)]
+#![warn(clippy::mem_forget)]
+#![warn(clippy::mut_mut)]
+#![warn(clippy::mutex_integer)]
+#![warn(clippy::needless_continue)]
+#![warn(clippy::path_buf_push_overwrite)]
+#![warn(clippy::range_plus_one)]
+#![allow(clippy::cognitive_complexity)]
+
 #[cfg(not(feature = "parallel"))]
 mod rayon;
 
-#[cfg(feature = "zopfli")]
-use std::num::NonZeroU64;
-use std::{
-    ffi::{OsStr, OsString},
-    fs::DirBuilder,
-    io::{IsTerminal, Write, stdout},
-    path::PathBuf,
-    process::ExitCode,
-    sync::atomic::{AtomicUsize, Ordering::AcqRel},
-    time::Duration,
-};
-
-use clap::ArgMatches;
-mod cli;
+use clap::{value_parser, Arg, ArgAction, ArgMatches, Command};
 use indexmap::IndexSet;
-use log::{Level, LevelFilter, error, warn};
-#[cfg(feature = "zopfli")]
-use oxipng::ZopfliOptions;
-use oxipng::{
-    Deflater, FilterStrategy, InFile, OptimizationResult, Options, OutFile, PngError, StripChunks,
-};
+use log::{error, warn, Level, LevelFilter};
+use oxipng::Deflaters;
+use oxipng::Options;
+use oxipng::RowFilter;
+use oxipng::StripChunks;
+use oxipng::{InFile, OutFile};
 use rayon::prelude::*;
+use std::ffi::OsString;
+use std::fs::DirBuilder;
+use std::io::Write;
+#[cfg(feature = "zopfli")]
+use std::num::NonZeroU8;
+use std::path::PathBuf;
+use std::process::exit;
+use std::time::Duration;
 
-use crate::cli::DISPLAY_CHUNKS;
+fn main() {
+    // 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.
+    let matches = Command::new("oxipng")
+        .version(env!("CARGO_PKG_VERSION"))
+        .author("Joshua Holmer <jholmer.in@gmail.com>")
+        .about("Losslessly improve compression of PNG files")
+        .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.
 
-fn main() -> ExitCode {
-    let matches = cli::build_command()
-        // Set the value parser for filters which isn't appropriate to do in the build_command function
-        .mut_arg("filters", |arg| {
-            arg.value_parser(|x: &str| {
-                parse_numeric_range_opts(x, 0, 9).map_err(|_| "Invalid option for filters")
-            })
-        })
+0   => --zc 5 --fast               (1 trial, determined heuristically)
+1   => --zc 10 --fast              (1 trial, determined heuristically)
+2   => --zc 11 -f 0,1,6,7 --fast   (4 fast trials, 1 main trial)
+3   => --zc 11 -f 0,7,8,9          (4 trials)
+4   => --zc 12 -f 0,7,8,9          (4 trials)
+5   => --zc 12 -f 0,1,2,5,6,7,8,9  (8 trials)
+6   => --zc 12 -f 0-9              (10 trials)
+max =>                             (stable alias for the max 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("backup")
+                .help("Back up modified files")
+                .short('b')
+                .long("backup")
+                .hide(true)
+                .action(ArgAction::SetTrue),
+        )
+        .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("pretend")
+                .help("Do not write any files, only show compression results")
+                .short('P')
+                .long("pretend")
+                .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.
+
+Note that 'bKGD', 'sBIT' and 'hIST' will be forcibly stripped if the color type or bit \
+depth is changed, regardless of any options set.",
+                    StripChunks::KEEP_SAFE
+                        .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("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 type (0, 1, keep)")
+                .long_help("\
+Set the PNG interlacing type, where <type> is one of:
+
+0     =>  Remove interlacing from all images that are processed
+1     =>  Apply Adam7 interlacing on all images that are processed
+keep  =>  Keep the existing interlacing type 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("type")
+                .default_value("0")
+                .value_parser(["0", "1", "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("Run in verbose mode (use twice to increase verbosity)")
+                .short('v')
+                .long("verbose")
+                .action(ArgAction::Count)
+                .conflicts_with("quiet"),
+        )
+        .arg(
+            Arg::new("quiet")
+                .help("Run in quiet mode")
+                .short('q')
+                .long("quiet")
+                .action(ArgAction::SetTrue)
+                .conflicts_with("verbose"),
+        )
+        .arg(
+            Arg::new("filters")
+                .help(format!("Filters to try (0-{}; see '--help' for details)", RowFilter::LAST))
+                .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   Highest Shannon entropy
+    7  =>  Bigrams   Lowest count of distinct bigrams
+    8  =>  BigEnt    Highest 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")
+                .value_parser(|x: &str| {
+                    parse_numeric_range_opts(x, 0, RowFilter::LAST)
+                        .map_err(|_| "Invalid option for filters")
+                }),
+        )
+        .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 (1-12)")
+                .long_help("\
+Deflate compression level (1-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(1..=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("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.")
+                .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')
+                .long("zopfli")
+                .action(ArgAction::SetTrue),
+        )
+        .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.")
+                .value_name("secs")
+                .long("timeout")
+                .value_parser(value_parser!(u64)),
+        )
+        .arg(
+            Arg::new("threads")
+                .help("Set number of threads to use [default: num CPU cores]")
+                .long("threads")
+                .short('t')
+                .value_name("num")
+                .value_parser(value_parser!(usize)),
+        )
         .after_help("Run `oxipng --help` to see full details of all options")
         .after_long_help("")
         .get_matches_from(std::env::args());
 
-    let (mut out_file, out_dir, opts) = match parse_opts_into_struct(&matches) {
+    if matches.get_flag("backup") {
+        eprintln!("The --backup flag is no longer supported. Please use --out or --dir to preserve your existing files.");
+        exit(1)
+    }
+
+    let (out_file, out_dir, opts) = match parse_opts_into_struct(&matches) {
         Ok(x) => x,
         Err(x) => {
-            error!("{x}");
-            return ExitCode::FAILURE;
+            error!("{}", x);
+            exit(1)
         }
     };
 
-    // Determine input and output
-    let file_args = matches.get_many::<PathBuf>("files").unwrap().cloned();
-    #[cfg(windows)]
-    let inputs: Vec<_> = file_args.flat_map(apply_glob_pattern).collect();
-    #[cfg(not(windows))]
-    let inputs: Vec<_> = file_args.collect();
-    let using_stdin = inputs.len() == 1 && inputs[0].to_str() == Some("-");
-    if using_stdin && out_dir.is_some() {
-        error!("Cannot use --dir when reading from stdin.");
-        return ExitCode::FAILURE;
-    }
-    if using_stdin && matches!(out_file, OutFile::Path { path: None, .. }) {
-        out_file = OutFile::StdOut;
-    }
-    let using_stdout = matches!(out_file, OutFile::StdOut);
-    let json = matches.get_flag("json");
-    if using_stdout && json {
-        error!("Cannot use --json when writing to stdout.");
-        return ExitCode::FAILURE;
-    }
+    let files = collect_files(
+        #[cfg(windows)]
+        matches
+            .get_many::<PathBuf>("files")
+            .unwrap()
+            .cloned()
+            .flat_map(apply_glob_pattern)
+            .collect(),
+        #[cfg(not(windows))]
+        matches
+            .get_many::<PathBuf>("files")
+            .unwrap()
+            .cloned()
+            .collect(),
+        &out_dir,
+        &out_file,
+        matches.get_flag("recursive"),
+        true,
+    );
 
-    let files = if using_stdin {
-        vec![(InFile::StdIn, out_file)]
-    } else {
-        collect_files(
-            inputs,
-            &out_dir,
-            &out_file,
-            matches.get_flag("recursive"),
-            true,
-        )
-    };
-
-    let is_verbose = matches.get_count("verbose") > 0;
-    let print_summary = !matches.get_flag("quiet") && !using_stdout;
-    let print_progress = print_summary && !is_verbose && stdout().is_terminal();
-    let total_files = files.len();
-    let num_processed = AtomicUsize::new(0);
-    if print_progress {
-        print!("Files processed: 0/{}...", total_files);
-        stdout().flush().ok();
-    }
-    let process = |(input, output): &(InFile, OutFile)| {
-        let result = process_file(input, output, &opts);
-        if print_progress && matches!(result, OptimizationResult::Ok(_)) {
-            let value = num_processed.fetch_add(1, AcqRel) + 1;
-            print!("\rFiles processed: {}/{}...", value, total_files);
-            stdout().flush().ok();
-        }
-        result
-    };
-    let results: Vec<OptimizationResult> = if matches.get_flag("parallel-files") {
-        files.par_iter().map(process).collect()
-    } else {
-        files.iter().map(process).collect()
-    };
-
-    // Collect stats
-    let mut num_succeeded = 0;
-    let mut num_not_optimized = 0;
-    let mut num_failed = 0;
-    let mut total_in: i64 = 0;
-    let mut total_out: i64 = 0;
-    for result in &results {
-        match result {
-            Ok((insize, outsize)) => {
-                num_succeeded += 1;
-                total_in += *insize as i64;
-                total_out += *outsize as i64;
-                if !opts.force && insize == outsize {
-                    num_not_optimized += 1;
-                }
+    let success = files.into_par_iter().filter(|(input, output)| {
+        match oxipng::optimize(input, output, &opts) {
+            // For optimizing single files, this will return the correct exit code always.
+            // For recursive optimization, the correct choice is a bit subjective.
+            // We're choosing to return a 0 exit code if ANY file in the set
+            // runs correctly.
+            // The reason for this is that recursion may pick up files that are not
+            // PNG files, and return an error for them.
+            // We don't really want to return an error code for those files.
+            Ok(_) => true,
+            Err(e) => {
+                error!("{}: {}", input, e);
+                false
             }
-            Err(PngError::C2PAMetadataPreventsChanges | PngError::InflatedDataTooLong(_)) => {}
-            Err(_) => num_failed += 1,
         }
-    }
+    });
 
-    // Print results
-    if json {
-        json_output(&files, &results);
-    } else if print_summary {
-        let in_bytes = format_bytes(total_in, true);
-        let out_bytes = format_bytes(total_out, true);
-        let saved = total_in - total_out;
-        let saved_bytes = format_bytes(saved, false);
-        let percent = if total_in > 0 {
-            saved as f64 / total_in as f64 * 100_f64
-        } else {
-            0_f64
-        };
-        if is_verbose {
-            println!("--------------------");
-        }
-        println!("\rFiles processed: {num_succeeded}/{total_files}   ");
-        println!("Input size: {}", in_bytes);
-        println!("Output size: {}", out_bytes);
-        println!("Total saved: {} ({:.2}%)", saved_bytes, percent);
-        if num_not_optimized == 1 {
-            println!("({num_not_optimized} file could not be optimized further)");
-        } else if num_not_optimized > 0 {
-            println!("({num_not_optimized} files could not be optimized further)");
-        }
-        if matches.get_flag("dry-run") {
-            println!("Dry run, no changes saved");
-        }
-    }
-
-    // For optimizing single files, this will return the correct exit code always.
-    // For recursive optimization, the correct choice is a bit subjective.
-    // We're choosing to return a 0 exit code if ANY file in the set
-    // runs correctly.
-    // The reason for this is that recursion may pick up files that are not
-    // PNG files, and return an error for them.
-    // We don't really want to return an error code for those files.
-    if num_succeeded > 0 {
-        ExitCode::SUCCESS
-    } else if num_failed > 0 {
-        ExitCode::FAILURE
-    } else {
-        ExitCode::from(3)
+    if success.count() == 0 {
+        exit(1);
     }
 }
 
@@ -178,8 +448,10 @@ fn collect_files(
     top_level: bool, //explicitly specify files
 ) -> Vec<(InFile, OutFile)> {
     let mut in_out_pairs = Vec::new();
+    let allow_stdin = top_level && files.len() == 1;
     for input in files {
-        if input.is_dir() {
+        let using_stdin = allow_stdin && input.to_str().map_or(false, |p| p == "-");
+        if !using_stdin && input.is_dir() {
             if recursive {
                 match input.read_dir() {
                     Ok(dir) => {
@@ -195,16 +467,7 @@ fn collect_files(
                 warn!("{} is a directory, skipping", input.display());
             }
             continue;
-        }
-
-        // Skip non png files if not given on top level
-        if !top_level && {
-            let extension = input.extension().map(OsStr::to_ascii_lowercase);
-            extension != Some(OsString::from("png")) && extension != Some(OsString::from("apng"))
-        } {
-            continue;
-        }
-
+        };
         let out_file =
             if let (Some(out_dir), &OutFile::Path { preserve_attrs, .. }) = (out_dir, out_file) {
                 let path = Some(out_dir.join(input.file_name().unwrap()));
@@ -215,7 +478,19 @@ fn collect_files(
             } else {
                 (*out_file).clone()
             };
-        let in_file = InFile::Path(input);
+        let in_file = if using_stdin {
+            InFile::StdIn
+        } else {
+            // Skip non png files if not given on top level
+            if !top_level && {
+                let extension = input.extension().map(|f| f.to_ascii_lowercase());
+                extension != Some(OsString::from("png"))
+                    && extension != Some(OsString::from("apng"))
+            } {
+                continue;
+            }
+            InFile::Path(input)
+        };
         in_out_pairs.push((in_file, out_file));
     }
     in_out_pairs
@@ -225,8 +500,7 @@ fn collect_files(
 fn apply_glob_pattern(path: PathBuf) -> Vec<PathBuf> {
     let matches = path
         .to_str()
-        // Use MatchOptions::default() to disable case-sensitivity
-        .and_then(|pattern| glob::glob_with(pattern, glob::MatchOptions::default()).ok())
+        .and_then(|pattern| glob::glob(pattern).ok())
         .map(|paths| paths.flatten().collect::<Vec<_>>());
 
     match matches {
@@ -240,23 +514,18 @@ fn parse_opts_into_struct(
 ) -> Result<(OutFile, Option<PathBuf>, Options), String> {
     let log_level = match matches.get_count("verbose") {
         _ if matches.get_flag("quiet") => LevelFilter::Off,
-        0 => LevelFilter::Warn,
-        1 => LevelFilter::Info,
-        2 => LevelFilter::Debug,
+        0 => LevelFilter::Info,
+        1 => LevelFilter::Debug,
         _ => LevelFilter::Trace,
     };
     env_logger::builder()
         .filter_module(module_path!(), log_level)
         .format(|buf, record| {
-            match record.level() {
-                Level::Error | Level::Warn => {
-                    let style = buf.default_level_style(record.level());
-                    // Prepend carriage return to clear progress line
-                    writeln!(buf, "\r{style}{}{style:#}", record.args())
-                }
-                // Leave info, debug and trace unstyled
-                _ => writeln!(buf, "{}", record.args()),
-            }
+            let style = match record.level() {
+                Level::Error | Level::Warn => buf.default_level_style(record.level()),
+                _ => buf.style(), // Leave info, debug and trace unstyled
+            };
+            writeln!(buf, "{}", style.value(record.args()))
         })
         .init();
 
@@ -266,39 +535,11 @@ fn parse_opts_into_struct(
         Some(level) => Options::from_preset(level.parse::<u8>().unwrap()),
     };
 
-    // Get custom brute settings and rebuild the filter set to apply them
-    let mut brute_lines = matches.get_one::<usize>("brute-lines").copied();
-    let mut brute_level = matches.get_one::<i64>("brute-level").map(|x| *x as u8);
-    let mut new_filters = IndexSet::new();
-    for mut f in opts.filters.drain(..) {
-        if let FilterStrategy::Brute { num_lines, level } = &mut f {
-            *num_lines = brute_lines.unwrap_or(*num_lines);
-            *level = brute_level.unwrap_or(*level);
-            // If custom settings were not given, we still need to retain the default values
-            // from the preset so we can re-apply them if the filters are overridden below
-            brute_lines = Some(*num_lines);
-            brute_level = Some(*level);
-        }
-        new_filters.insert(f);
-    }
-    opts.filters = new_filters;
-
     if let Some(x) = matches.get_one::<IndexSet<u8>>("filters") {
-        opts.filters = x
-            .iter()
-            .map(|&f| match f {
-                0..=4 => FilterStrategy::Basic(f.try_into().unwrap()),
-                5 => FilterStrategy::MinSum,
-                6 => FilterStrategy::Entropy,
-                7 => FilterStrategy::Bigrams,
-                8 => FilterStrategy::BigEnt,
-                9 => FilterStrategy::Brute {
-                    num_lines: brute_lines.unwrap_or(3),
-                    level: brute_level.unwrap_or(1),
-                },
-                _ => unreachable!(),
-            })
-            .collect();
+        opts.filter.clear();
+        for &f in x {
+            opts.filter.insert(f.try_into().unwrap());
+        }
     }
 
     if let Some(&num) = matches.get_one::<u64>("timeout") {
@@ -308,9 +549,9 @@ fn parse_opts_into_struct(
     let out_dir = if let Some(path) = matches.get_one::<PathBuf>("output_dir") {
         if !path.exists() {
             match DirBuilder::new().recursive(true).create(path) {
-                Ok(()) => (),
-                Err(x) => return Err(format!("Could not create output directory {x}")),
-            }
+                Ok(_) => (),
+                Err(x) => return Err(format!("Could not create output directory {}", x)),
+            };
         } else if !path.is_dir() {
             return Err(format!(
                 "{} is an existing file (not a directory), cannot create directory",
@@ -322,7 +563,7 @@ fn parse_opts_into_struct(
         None
     };
 
-    let out_file = if matches.get_flag("dry-run") {
+    let out_file = if matches.get_flag("pretend") {
         OutFile::None
     } else if matches.get_flag("stdout") {
         OutFile::StdOut
@@ -346,8 +587,6 @@ fn parse_opts_into_struct(
 
     opts.fix_errors = matches.get_flag("fix");
 
-    opts.max_decompressed_size = matches.get_one::<u64>("max-size").map(|&x| x as usize);
-
     opts.bit_depth_reduction = !matches.get_flag("no-bit-reduction");
 
     opts.color_type_reduction = !matches.get_flag("no-color-reduction");
@@ -367,29 +606,19 @@ fn parse_opts_into_struct(
     opts.idat_recoding = !matches.get_flag("no-recoding");
 
     if let Some(x) = matches.get_one::<String>("interlace") {
-        opts.interlace = match x.as_str() {
-            "off" | "0" => Some(false),
-            "on" | "1" => Some(true),
-            _ => None, // keep
+        opts.interlace = if x == "keep" {
+            None
+        } else {
+            x.parse::<u8>().unwrap().try_into().ok()
         };
     }
 
     if let Some(keep) = matches.get_one::<String>("keep") {
-        let mut keep_display = false;
-        let mut names = keep
+        let names = keep
             .split(',')
-            .filter_map(|name| {
-                if name == "display" {
-                    keep_display = true;
-                    return None;
-                }
-                Some(parse_chunk_name(name))
-            })
-            .collect::<Result<IndexSet<_>, _>>()?;
-        if keep_display {
-            names.extend(DISPLAY_CHUNKS.iter().copied());
-        }
-        opts.strip = StripChunks::Keep(names);
+            .map(parse_chunk_name)
+            .collect::<Result<_, _>>()?;
+        opts.strip = StripChunks::Keep(names)
     }
 
     if let Some(strip) = matches.get_one::<String>("strip") {
@@ -411,7 +640,7 @@ fn parse_opts_into_struct(
                     }
                     let name = parse_chunk_name(x)?;
                     if FORBIDDEN_CHUNKS.contains(&name) {
-                        return Err(format!("{x} chunk is not allowed to be stripped"));
+                        return Err(format!("{} chunk is not allowed to be stripped", x));
                     }
                     Ok(name)
                 })
@@ -424,32 +653,15 @@ fn parse_opts_into_struct(
         opts.strip = StripChunks::Safe;
     }
 
-    #[cfg(feature = "zopfli")]
     if matches.get_flag("zopfli") {
-        let iteration_count = *matches.get_one::<NonZeroU64>("iterations").unwrap();
-        let iterations_without_improvement = *matches
-            .get_one::<NonZeroU64>("iterations-without-improvement")
-            .unwrap_or(&NonZeroU64::MAX);
-
-        if iterations_without_improvement > iteration_count
-            && iterations_without_improvement != NonZeroU64::MAX
-        {
-            warn!(
-                "--ziwi ({}) is higher than --zi ({}) and will never be reached.",
-                iterations_without_improvement, iteration_count
-            );
+        #[cfg(feature = "zopfli")]
+        if let Some(iterations) = NonZeroU8::new(15) {
+            opts.deflate = Deflaters::Zopfli { iterations };
+        }
+    } else if let Deflaters::Libdeflater { compression } = &mut opts.deflate {
+        if let Some(x) = matches.get_one::<i64>("compression") {
+            *compression = *x as u8;
         }
-
-        opts.deflater = Deflater::Zopfli(ZopfliOptions {
-            iteration_count,
-            iterations_without_improvement,
-            ..Default::default()
-        });
-    }
-    if let (Deflater::Libdeflater { compression }, Some(x)) =
-        (&mut opts.deflater, matches.get_one::<i64>("compression"))
-    {
-        *compression = *x as u8;
     }
 
     #[cfg(feature = "parallel")]
@@ -467,7 +679,7 @@ fn parse_chunk_name(name: &str) -> Result<[u8; 4], String> {
     name.trim()
         .as_bytes()
         .try_into()
-        .map_err(|_| format!("Invalid chunk name {name}"))
+        .map_err(|_| format!("Invalid chunk name {}", name))
 }
 
 fn parse_numeric_range_opts(
@@ -522,133 +734,3 @@ fn parse_numeric_range_opts(
 
     Err(ERROR_MESSAGE.to_owned())
 }
-
-fn process_file(input: &InFile, output: &OutFile, opts: &Options) -> OptimizationResult {
-    if let (Some(max_size), InFile::Path(path)) = (opts.max_decompressed_size, input) {
-        if path.metadata().is_ok_and(|m| m.len() > max_size as u64) {
-            warn!("{input}: Skipped: File exceeds the maximum size ({max_size} bytes)");
-            return Err(PngError::InflatedDataTooLong(max_size));
-        }
-    }
-
-    let result = oxipng::optimize(input, output, opts);
-    match &result {
-        Ok(_) => {}
-        Err(e @ PngError::C2PAMetadataPreventsChanges | e @ PngError::InflatedDataTooLong(_)) => {
-            warn!("{input}: Skipped: {e}");
-        }
-        Err(e) => {
-            error!("{input}: {e}");
-        }
-    }
-    result
-}
-
-/// Write optimization results as json.
-/// ```
-/// {
-///   "results": [
-///     {
-///       "input": string,
-///       "status": "success",
-///       "output": string|null,
-///       "insize": number,
-///       "outsize": number
-///     },
-///     {
-///       "input": string,
-///       "status": "error",
-///       "error": string
-///     }
-///   ]
-/// }
-/// ```
-fn json_output(files: &[(InFile, OutFile)], results: &[OptimizationResult]) {
-    print!(r#"{{"results":["#);
-    let mut first = true;
-    results
-        .iter()
-        .zip(files)
-        .for_each(|(result, (input, output))| {
-            if !first {
-                print!(",");
-            }
-            print!(r#"{{"input":"{}","#, json_escape(&input.to_string()));
-            match result {
-                Ok((insize, outsize)) => {
-                    let outpath = match output {
-                        OutFile::None => "null".to_owned(),
-                        OutFile::Path { path: None, .. } => {
-                            format!(r#""{}""#, json_escape(&input.to_string()))
-                        }
-                        OutFile::Path { path: Some(p), .. } => {
-                            format!(r#""{}""#, json_escape(&p.display().to_string()))
-                        }
-                        OutFile::StdOut => unreachable!(),
-                    };
-                    print!(
-                        r#""status":"success","output":{},"insize":{},"outsize":{}}}"#,
-                        outpath, insize, outsize
-                    );
-                }
-                Err(e) => {
-                    print!(
-                        r#""status":"error","error":"{}"}}"#,
-                        json_escape(&e.to_string())
-                    );
-                }
-            }
-            first = false;
-        });
-    print!("]}}");
-}
-
-fn json_escape(string: &str) -> String {
-    string
-        .replace("\\", "\\\\")
-        .replace("\"", "\\\"")
-        .replace("\n", "\\n")
-        .replace("\t", "\\t")
-        .replace("\r", "\\r")
-        .replace("\x08", "\\b")
-        .replace("\x0c", "\\f")
-}
-
-/// Format byte counts as IEC units to 3 significant figures.
-fn format_bytes(count: i64, include_raw: bool) -> String {
-    const K: i64 = 1 << 10;
-    const M: i64 = 1 << 20;
-    const G: i64 = 1 << 30;
-    fn format_3sf(value: f64) -> String {
-        match value.abs() {
-            ..9.995 => format!("{:.2}", value),
-            9.995..99.95 => format!("{:.1}", value),
-            _ => format!("{:.0}", value),
-        }
-    }
-    let formatted = match count.abs() {
-        ..K => format!("{} bytes", count),
-        K..M => format!("{} KiB", format_3sf(count as f64 / K as f64)),
-        M..G => format!("{} MiB", format_3sf(count as f64 / M as f64)),
-        _ => format!("{} GiB", format_3sf(count as f64 / G as f64)),
-    };
-    if include_raw && count.abs() >= K {
-        format!("{} ({} bytes)", formatted, count)
-    } else {
-        formatted
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::format_bytes;
-
-    #[test]
-    fn test_format_bytes() {
-        assert_eq!(format_bytes(1023, false), "1023 bytes");
-        assert_eq!(format_bytes(800_000, false), "781 KiB");
-        assert_eq!(format_bytes(12_500_000, false), "11.9 MiB");
-        assert_eq!(format_bytes(2_000_000_000, false), "1.86 GiB");
-        assert_eq!(format_bytes(-1024, false), "-1.00 KiB");
-    }
-}

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,
-        }
-    }
-}

src/png/mod.rs

@@ -1,24 +1,30 @@
-use std::{fs, path::Path, sync::Arc};
-
+use crate::colors::{BitDepth, ColorType};
+use crate::deflate;
+use crate::error::PngError;
+use crate::filters::*;
+use crate::headers::*;
+use crate::interlace::{deinterlace_image, interlace_image, Interlacing};
+use crate::Options;
+use bitvec::bitarr;
 use libdeflater::{CompressionLvl, Compressor};
 use log::warn;
+use rgb::ComponentSlice;
 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
@@ -36,25 +42,44 @@ pub struct PngData {
     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>,
 }
 
 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, opts: &Options) -> Result<Self, PngError> {
         let byte_data = Self::read_file(filepath)?;
 
         Self::from_slice(&byte_data, opts)
     }
 
-    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], opts: &Options) -> 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)?;
@@ -67,8 +92,6 @@ impl PngData {
         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" => {
@@ -77,53 +100,25 @@ impl PngData {
                         aux_chunks.push(Chunk {
                             name: chunk.name,
                             data: Vec::new(),
-                        });
+                        })
                     }
                     idat_data.extend_from_slice(chunk.data);
                 }
                 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 opts.strip.keep(&chunk.name) {
+                        aux_chunks.push(Chunk {
+                            name: chunk.name,
+                            data: chunk.data.to_owned(),
+                        })
+                    } else if chunk.name == *b"acTL" {
+                        warn!(
+                            "Stripping animation data from APNG - image will become standard PNG"
+                        );
                     }
-                    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");
-                }
-                _ => (),
             }
         }
 
@@ -131,57 +126,64 @@ impl PngData {
         if idat_data.is_empty() {
             return Err(PngError::ChunkMissing("IDAT"));
         }
-        let Some(ihdr_chunk) = key_chunks.remove(b"IHDR") else {
-            return Err(PngError::ChunkMissing("IHDR"));
+        let ihdr_chunk = match key_chunks.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 raw_data = deflate::inflate(idat_data.as_ref(), 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 raw = PngImage::new(ihdr, &idat_data)?;
-
+        let mut raw = PngImage {
+            ihdr,
+            data: raw_data,
+        };
+        raw.data = raw.unfilter_image()?;
         // Return the PngData
         Ok(Self {
             idat_data,
             raw: Arc::new(raw),
             aux_chunks,
-            frames,
         })
     }
 
+    /// Return an estimate of the output size which can help with evaluation of very small data
+    pub fn estimated_output_size(&self) -> usize {
+        self.idat_data.len() + self.raw.key_chunks_size()
+    }
+
     /// 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
             .iter()
-            .filter(|c| !matches!(&c.name, b"bKGD" | b"hIST" | b"tRNS" | b"fcTL"))
+            .filter(|c| !(&c.name == b"bKGD" || &c.name == b"hIST" || &c.name == b"tRNS"))
         {
             write_png_block(&chunk.name, &chunk.data, &mut output);
         }
@@ -190,7 +192,7 @@ impl PngData {
             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());
+                    palette_data.extend_from_slice(px.rgb().as_slice());
                 }
                 write_png_block(b"PLTE", &palette_data, &mut output);
                 if let Some(last_trns) = palette.iter().rposition(|px| px.a != 255) {
@@ -208,30 +210,20 @@ impl PngData {
                 transparent_color: Some(trns),
             } => {
                 // Transparency pixel - 6 byte RGB16
-                let trns_data: Vec<_> = trns.iter().flat_map(u16::to_be_bytes).collect();
+                let trns_data: Vec<_> = trns.iter().flat_map(|c| c.to_be_bytes()).collect();
                 write_png_block(b"tRNS", &trns_data, &mut output);
             }
             _ => {}
         }
         // Special ancillary chunks that need to come after PLTE but before IDAT
-        let mut sequence_number = 0;
         for chunk in aux_pre
             .iter()
-            .filter(|c| matches!(&c.name, b"bKGD" | b"hIST" | b"tRNS" | b"fcTL"))
+            .filter(|c| &c.name == b"bKGD" || &c.name == b"hIST" || &c.name == b"tRNS")
         {
             write_png_block(&chunk.name, &chunk.data, &mut output);
-            if &chunk.name == b"fcTL" {
-                sequence_number += 1;
-            }
         }
         // 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 {
@@ -246,33 +238,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,15 +260,13 @@ 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 {
+    pub 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 {
+    pub fn bytes_per_channel(&self) -> usize {
         match self.ihdr.bit_depth {
             BitDepth::Sixteen => 2,
             // Depths lower than 8 will round up to 1 byte
@@ -300,15 +275,15 @@ impl PngImage {
     }
 
     /// 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)
+                if let Some(trns) = palette.iter().rposition(|p| p.a != 255) {
+                    plte + 12 + trns + 1
+                } else {
+                    plte
+                }
             }
             ColorType::Grayscale { transparent_shade } if transparent_shade.is_some() => 12 + 2,
             ColorType::RGB { transparent_color } if transparent_color.is_some() => 12 + 6,
@@ -316,21 +291,14 @@ impl PngImage {
         }
     }
 
-    /// 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()
-    }
-
     /// 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 mut last_line: Vec<u8> = Vec::new();
@@ -342,8 +310,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,12 +320,7 @@ 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();
         // If alpha optimization is enabled, determine how many bytes of alpha there are per pixel
@@ -370,58 +333,35 @@ impl PngImage {
         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 +374,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 +397,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 +429,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,17 +470,11 @@ 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
     }
 }
 
@@ -572,7 +490,7 @@ fn write_png_block(key: &[u8], chunk: &[u8], output: &mut Vec<u8>) {
 }
 
 // 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)
 }

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,22 @@ 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, num_pixels)| {
+            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,
+                num_pixels,
+            }
         })
     }
 }
@@ -69,7 +62,7 @@ impl ScanLineRanges {
             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
@@ -81,7 +74,6 @@ impl ScanLineRanges {
 
 impl Iterator for ScanLineRanges {
     type Item = (usize, Option<u8>, usize);
-
     fn next(&mut self) -> Option<Self::Item> {
         if self.left == 0 {
             return None;
@@ -138,7 +130,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;
@@ -157,7 +149,7 @@ impl Iterator for ScanLineRanges {
             (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 mut len = (bits_per_line + 7) / 8;
         if self.has_filter {
             len += 1;
         }

src/rayon.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 pub mod prelude {
     pub use super::*;
 }
@@ -72,10 +70,12 @@ where
 
 impl<I: Iterator> ParallelIterator for I {}
 
+#[allow(dead_code)]
 pub fn join<A, B>(a: impl FnOnce() -> A, b: impl FnOnce() -> B) -> (A, B) {
     (a(), b())
 }
 
+#[allow(dead_code)]
 pub fn spawn<A>(a: impl FnOnce() -> A) -> A {
     a()
 }

src/reduction/alpha.rs

@@ -1,13 +1,10 @@
 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;
@@ -17,7 +14,7 @@ pub fn cleaned_alpha_channel(png: &PngImage) -> Option<PngImage> {
     let colored_bytes = bpp - byte_depth;
 
     let mut reduced = Vec::with_capacity(png.data.len());
-    for pixel in png.data.chunks_exact(bpp) {
+    for pixel in png.data.chunks(bpp) {
         if pixel.iter().skip(colored_bytes).all(|b| *b == 0) {
             reduced.resize(reduced.len() + bpp, 0);
         } else {
@@ -46,7 +43,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;
@@ -75,19 +72,19 @@ pub fn reduced_alpha_channel(png: &PngImage, optimize_alpha: bool) -> Option<Png
     };
 
     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);
             }
             _ => 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),
+        BitDepth::Sixteen => (trns as u16) << 8 | trns as u16,
+        _ => trns as u16,
     });
     let target_color_type = match png.ihdr.color_type {
         ColorType::GrayscaleAlpha => ColorType::Grayscale {

src/reduction/bit_depth.rs

@@ -1,8 +1,6 @@
-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
 #[must_use]
@@ -16,13 +14,13 @@ pub fn reduced_bit_depth_16_to_8(png: &PngImage, force_scale: bool) -> Option<Pn
     }
 
     // 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,
@@ -41,15 +39,15 @@ pub fn scaled_bit_depth_16_to_8(png: &PngImage) -> Option<PngImage> {
     // Reduce from 16 to 8 bits per channel per pixel by scaling when necessary
     let data = png
         .data
-        .chunks_exact(2)
+        .chunks(2)
         .map(|pair| {
             if pair[0] == pair[1] {
                 return pair[0];
             }
             // 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
+            let val = u16::from_be_bytes([pair[0], pair[1]]) as f64;
+            (val * 255.0 / 65535.0).round() as u8
         })
         .collect();
 
@@ -70,17 +68,17 @@ pub fn reduced_bit_depth_8_or_less(png: &PngImage) -> Option<PngImage> {
         return None;
     }
 
-    let minimum_bits = if let ColorType::Indexed { palette } = &png.ihdr.color_type {
+    let mut minimum_bits = 1;
+
+    if let ColorType::Indexed { palette } = &png.ihdr.color_type {
         // We can easily determine minimum depth by the palette size
-        match palette.len() {
+        minimum_bits = 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;
@@ -110,9 +108,7 @@ pub fn reduced_bit_depth_8_or_less(png: &PngImage) -> Option<PngImage> {
                 break;
             }
         }
-
-        minimum_bits
-    };
+    }
 
     let mut reduced = Vec::with_capacity(png.data.len());
     let mask = (1 << minimum_bits) - 1;
@@ -140,7 +136,7 @@ pub fn reduced_bit_depth_8_or_less(png: &PngImage) -> Option<PngImage> {
         let mut check = reduced_trans;
         let mut bits = minimum_bits;
         while bits < 8 {
-            check = (check << bits) | check;
+            check = check << bits | check;
             bits <<= 1;
         }
         // If the transparency doesn't fit the new bit depth it is therefore unused - set it to None
@@ -190,7 +186,7 @@ pub fn expanded_bit_depth_to_8(png: &PngImage) -> Option<PngImage> {
                     // Expand gray by repeating the bits
                     let mut bits = bit_depth;
                     while bits < 8 {
-                        val = (val << bits) | val;
+                        val = val << bits | val;
                         bits <<= 1;
                     }
                 }
@@ -209,7 +205,7 @@ pub fn expanded_bit_depth_to_8(png: &PngImage) -> Option<PngImage> {
     {
         let mut bits = bit_depth;
         while bits < 8 {
-            trans = (trans << bits) | trans;
+            trans = trans << bits | trans;
             bits <<= 1;
         }
         ColorType::Grayscale {

src/reduction/color.rs

@@ -1,14 +1,11 @@
-use std::hash::{BuildHasherDefault, Hash};
-
+use crate::colors::{BitDepth, ColorType};
+use crate::headers::IhdrData;
+use crate::png::PngImage;
 use indexmap::IndexSet;
-use rgb::{ComponentMap, FromSlice, RGB, RGBA, alt::Gray};
+use rgb::alt::Gray;
+use rgb::{ComponentMap, ComponentSlice, FromSlice, RGB, RGBA};
 use rustc_hash::FxHasher;
-
-use crate::{
-    colors::{BitDepth, ColorType},
-    headers::IhdrData,
-    png::PngImage,
-};
+use std::hash::{BuildHasherDefault, Hash};
 
 type FxIndexSet<V> = IndexSet<V, BuildHasherDefault<FxHasher>>;
 
@@ -49,39 +46,39 @@ pub fn reduced_to_indexed(png: &PngImage, allow_grayscale: bool) -> Option<PngIm
     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)?;
+            let pmap = build_palette(png.data.as_gray().iter().cloned(), &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 {
+                    RGB::from(px).alpha(if Some(px) != transparency_pixel {
                         255
+                    } else {
+                        0
                     })
                 })
                 .collect()
         }
         ColorType::RGB { transparent_color } => {
-            let pmap = build_palette(png.data.as_rgb().iter().copied(), &mut raw_data)?;
+            let pmap = build_palette(png.data.as_rgb().iter().cloned(), &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 {
+                    px.alpha(if Some(px) != transparency_pixel {
                         255
+                    } else {
+                        0
                     })
                 })
                 .collect()
         }
         ColorType::GrayscaleAlpha => {
-            let pmap = build_palette(png.data.as_gray_alpha().iter().copied(), &mut raw_data)?;
+            let pmap = build_palette(png.data.as_gray_alpha().iter().cloned(), &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)?;
+            let pmap = build_palette(png.data.as_rgba().iter().cloned(), &mut raw_data)?;
             pmap.into_iter().collect()
         }
         _ => return None,
@@ -106,7 +103,7 @@ pub fn reduced_rgb_to_grayscale(png: &PngImage) -> Option<PngImage> {
     let byte_depth = png.bytes_per_channel();
     let bpp = png.channels_per_pixel() * 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;
@@ -138,30 +135,15 @@ pub fn reduced_rgb_to_grayscale(png: &PngImage) -> Option<PngImage> {
 
 /// 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> {
+pub fn indexed_to_channels(png: &PngImage, allow_grayscale: 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(),
+    let palette = match &png.ihdr.color_type {
+        ColorType::Indexed { palette } => palette,
         _ => 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)
@@ -193,7 +175,7 @@ pub fn indexed_to_channels(
     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]);
+        data.extend_from_slice(&color.as_slice()[ch_start..=ch_end]);
     }
 
     Some(PngImage {

src/reduction/mod.rs

@@ -1,7 +1,10 @@
+use crate::evaluate::Evaluator;
+use crate::png::PngImage;
+use crate::Deadline;
+use crate::Deflaters;
+use crate::Options;
 use std::sync::Arc;
 
-use crate::{ColorType, Deadline, Deflater, Options, evaluate::Evaluator, png::PngImage};
-
 pub mod alpha;
 use crate::alpha::*;
 pub mod bit_depth;
@@ -21,8 +24,8 @@ pub(crate) fn perform_reductions(
 
     // 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,
+    let cheap = match opts.deflate {
+        Deflaters::Libdeflater { compression } => compression < 12 && opts.fast_evaluation,
         _ => false,
     };
 
@@ -83,7 +86,7 @@ pub(crate) fn perform_reductions(
         }
         // 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)");
+            eval.try_image(png.clone());
             evaluation_added = true;
         }
     }
@@ -106,9 +109,7 @@ pub(crate) fn perform_reductions(
     // 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)
-        {
+        if let Some(reduced) = indexed_to_channels(&png, opts.grayscale_reduction) {
             // This result should not be passed on to subsequent reductions
             eval.try_image(Arc::new(reduced));
             evaluation_added = true;
@@ -116,16 +117,15 @@ pub(crate) fn perform_reductions(
     }
 
     // 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 opts.color_type_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)");
+                eval.try_image(new.clone());
                 evaluation_added = true;
             } else {
                 baseline = new.clone();
@@ -134,62 +134,20 @@ pub(crate) fn perform_reductions(
         }
     }
 
-    // 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;
-                    }
-                }
-            }
-        }
-
-        // 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;
-                    }
-                }
-            }
+    // Attempt to sort the palette using an alternative method
+    if !cheap && opts.palette_reduction && !deadline.passed() {
+        if let Some(reduced) = sorted_palette_battiato(&png) {
+            eval.try_image(Arc::new(reduced));
+            evaluation_added = true;
         }
     }
 
     // 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
+        // Try reducing the previous png, falling back to the indexed one if it exists
+        // This allows a grayscale depth reduction to be preferred over an indexed depth reduction
+        let reduced = reduced_bit_depth_8_or_less(&png)
+            .or_else(|| indexed.and_then(|png| reduced_bit_depth_8_or_less(&png)));
         if let Some(reduced) = reduced {
             eval.try_image(Arc::new(reduced));
             evaluation_added = true;

src/reduction/palette.rs

@@ -1,20 +1,20 @@
+use crate::colors::{BitDepth, ColorType};
+use crate::headers::IhdrData;
+use crate::png::scan_lines::ScanLine;
+use crate::png::PngImage;
+use crate::Interlacing;
 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 palette = match &png.ihdr.color_type {
+        ColorType::Indexed { palette } if palette.len() > 1 => palette,
+        _ => return None,
     };
 
     let mut used = [false; 256];
@@ -41,9 +41,8 @@ pub fn reduced_palette(png: &PngImage, optimize_alpha: bool) -> Option<PngImage>
     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
+    } else if condensed.len() < palette.len() {
+        // Data is unchanged but palette will be truncated
         png.data.clone()
     } else {
         // Nothing has changed
@@ -86,7 +85,7 @@ pub fn sorted_palette(png: &PngImage) -> Option<PngImage> {
     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));
+    let first = enumerated.remove(keep_first);
 
     // Sort the palette
     enumerated.sort_by(|a, b| {
@@ -103,19 +102,17 @@ pub fn sorted_palette(png: &PngImage) -> Option<PngImage> {
         };
         color_val(a.1).cmp(&color_val(b.1))
     });
-    if let Some(first) = first {
-        enumerated.insert(0, 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) {
+    let (old_map, palette): (Vec<_>, Vec<RGBA8>) = enumerated.into_iter().unzip();
+    if old_map.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() {
+    for (i, &v) in old_map.iter().enumerate() {
         byte_map[v] = i as u8;
     }
     let data = png.data.iter().map(|&b| byte_map[b as usize]).collect();
@@ -129,33 +126,11 @@ pub fn sorted_palette(png: &PngImage) -> Option<PngImage> {
     })
 }
 
-/// 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
+/// Sort the colors in the palette by minimizing entropy, 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 {
+    if png.ihdr.bit_depth != BitDepth::Eight || png.ihdr.interlaced != Interlacing::None {
         return None;
     }
     let palette = match &png.ihdr.color_type {
@@ -166,28 +141,28 @@ pub fn sorted_palette_battiato(png: &PngImage) -> Option<PngImage> {
 
     let matrix = co_occurrence_matrix(palette.len(), png);
     let edges = weighted_edges(&matrix);
-    let mut remapping = battiato_reindex(palette.len(), edges);
+    let mut old_map = battiato_tsp(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;
-    };
+    // 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_idx = old_map.iter().position(|&i| i == keep_first).unwrap();
+    // If the index is past halfway, reverse the order so as to minimize the change
+    if first_idx >= old_map.len() / 2 {
+        old_map.reverse();
+        old_map.rotate_right(first_idx + 1);
+    } else {
+        old_map.rotate_left(first_idx);
+    }
 
     // Check if anything changed
-    if remapping.iter().enumerate().all(|(a, b)| a == *b) {
+    if old_map.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() {
+    for (i, &v) in old_map.iter().enumerate() {
         new_palette.push(palette[v]);
         byte_map[v] = i as u8;
     }
@@ -205,162 +180,50 @@ fn apply_palette_reorder(png: &PngImage, remapping: &[usize]) -> Option<PngImage
 }
 
 // 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];
+fn most_popular_edge_color(num_colors: usize, png: &PngImage) -> usize {
+    let mut counts = vec![0; num_colors];
     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);
+        counts[line.data[0] as usize] += 1;
+        counts[line.data[line.data.len() - 1] as usize] += 1;
     }
+    counts.iter().enumerate().max_by_key(|(_, &v)| v).unwrap().0
 }
 
 // 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];
+fn co_occurrence_matrix(num_colors: usize, png: &PngImage) -> Vec<Vec<usize>> {
+    let mut matrix = vec![vec![0; 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 i > 0 {
+                matrix[line.data[i - 1] as usize][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;
+                matrix[prev.data[i] as usize][val] += 1;
             }
         }
-        prev = Some(line);
+        prev = Some(line)
     }
     matrix
 }
 
 // Calculate edge list sorted by weight
-fn weighted_edges(matrix: &[Vec<u32>]) -> Vec<(usize, usize)> {
+fn weighted_edges(matrix: &[Vec<usize>]) -> 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));
+    for i in 0..matrix.len() {
+        for j in 0..i {
+            edges.push(((j, i), matrix[i][j] + matrix[j][i]));
         }
     }
     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> {
+fn battiato_tsp(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)

src/sanity_checks.rs

@@ -1,11 +1,6 @@
-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(
@@ -39,12 +34,12 @@ pub fn validate_output(output: &[u8], original_data: &[u8]) -> bool {
 
 /// 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()? {
+    let decoder = PngDecoder::new(png_data)?;
+    if decoder.is_apng() {
         decoder
-            .apng()?
+            .apng()
             .into_frames()
-            .map(|f| f.map(image::Frame::into_buffer))
+            .map(|f| f.map(|f| f.into_buffer()))
             .collect()
     } else {
         DynamicImage::from_decoder(decoder).map(|i| vec![i.into_rgba8()])

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,
-    );
-}