mozjpeg-oxide

Pure Rust JPEG encoder based on Mozilla's mozjpeg, featuring trellis quantization for optimal compression.

Why mozjpeg-oxide?

Choose mozjpeg-oxide when you want:

• Memory-safe JPEG encoding without C dependencies
• Smaller files than libjpeg-turbo (trellis quantization)
• Simple integration via Cargo

Choose C mozjpeg when you need:

• Maximum baseline encoding speed (SIMD-optimized)
• Established C ABI for FFI

Benchmark Results

Tested on Kodak corpus (24 images). Settings: progressive mode, trellis quantization, optimized Huffman, 4:2:0 subsampling.

Summary: At Q15-Q50, Rust produces smaller files. At Q55+, files are 0.2-5% larger. Quality (SSIM2, Butteraugli) is virtually identical across all levels.

Reproduce Benchmarks

# Fetch test corpus (Kodak images, ~15MB)
./scripts/fetch-corpus.sh

# Run benchmark
cargo bench-corpus

# Or just Kodak images
cargo bench-kodak

Results written to benchmark_results.csv. See also cargo bench-micro for criterion microbenchmarks.

Usage

use mozjpeg_oxide::{Encoder, Subsampling};

// Default: trellis quantization + Huffman optimization
let jpeg = Encoder::new()
    .quality(85)
    .encode_rgb(&pixels, width, height)?;

// Maximum compression: progressive + trellis + scan optimization
let jpeg = Encoder::max_compression()
    .quality(85)
    .encode_rgb(&pixels, width, height)?;

// Fastest: no optimizations (libjpeg-turbo compatible output)
let jpeg = Encoder::fastest()
    .quality(85)
    .encode_rgb(&pixels, width, height)?;

// Custom configuration
let jpeg = Encoder::new()
    .quality(75)
    .progressive(true)
    .subsampling(Subsampling::S420)
    .optimize_huffman(true)
    .encode_rgb(&pixels, width, height)?;

Features

• Trellis quantization - Rate-distortion optimized coefficient selection
• Progressive JPEG - Multi-scan encoding with spectral selection
• Huffman optimization - 2-pass encoding for optimal entropy coding
• Overshoot deringing - Reduces ringing artifacts at sharp edges
• Chroma subsampling - 4:4:4, 4:2:2, 4:2:0 modes
• Safe Rust - #![deny(unsafe_code)] with exceptions only for SIMD intrinsics

Performance

With trellis quantization enabled (the default), mozjpeg-oxide matches or exceeds C mozjpeg performance.

Development

Running CI Locally

To reproduce the CI checks locally:

# Format check
cargo fmt --all -- --check

# Clippy lints
cargo clippy --workspace --all-targets -- -D warnings

# Build
cargo build --workspace

# Unit tests
cargo test --lib

# Codec comparison tests
cargo test --test codec_comparison

# FFI validation tests (requires mozjpeg-sys from crates.io)
cargo test --test ffi_validation

For full CI reproduction including container isolation, install act:

# Install act (macOS)
brew install act

# Run CI locally
act push

Test Coverage

# Install cargo-llvm-cov
cargo install cargo-llvm-cov

# Generate coverage report
cargo llvm-cov --lib --html

# Open report
open target/llvm-cov/html/index.html

License

BSD-3-Clause - Same license as the original mozjpeg.

Acknowledgments

Based on Mozilla's mozjpeg, which builds on libjpeg-turbo and the Independent JPEG Group's libjpeg.

AI-Generated Code Notice

This crate was developed with significant assistance from Claude (Anthropic). While the code has been tested against the C mozjpeg reference implementation and passes 191 tests including FFI validation, not all code has been manually reviewed or human-audited.

Before using in production:

• Review critical code paths for your use case
• Run your own validation against expected outputs
• Consider the encoder's test suite coverage for your specific requirements

The FFI comparison tests in tests/ffi_comparison.rs and tests/ffi_validation.rs provide confidence in correctness by comparing outputs against C mozjpeg.