### Install signinum-cli

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-cli/README.md

Install the signinum-cli using cargo.

```sh
cargo install signinum-cli
```

--------------------------------

### Install and Inspect JPEG/JP2 Tile Headers with `signinum-cli`

Source: https://context7.com/jcwal1516/signinum/llms.txt

Install the `signinum-cli` tool using cargo and use it to inspect header metadata of JPEG and JPEG 2000 files.

```sh
# Install
cargo install signinum-cli

# Inspect a JPEG tile
signinum inspect tile.jpg
# Output: 512×512 Baseline8 YCbCr bit=8 samp=[...] mcu=16x16 units=32x32 rst=None scans=1

# Inspect a JP2 tile
signinum inspect tile.jp2
# Output: 256×256 SRgb bit=8 comps=3 levels=6 tiles=Some(TileLayout { ... })

```

--------------------------------

### Install Apt Dependencies on Ubuntu/Debian

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Installs required benchmarking dependencies on Ubuntu or Debian systems using apt-get. This command updates package lists and installs the specified libraries.

```sh
sudo apt-get update
sudo apt-get install -y pkg-config libturbojpeg0-dev libjpeg-dev openjpeg-tools
```

--------------------------------

### Install Homebrew Dependencies on macOS

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Installs necessary benchmarking dependencies on macOS using Homebrew. Ensure Homebrew is installed before running.

```sh
brew install pkg-config jpeg-turbo openjpeg
```

--------------------------------

### Inspect Image from Command Line

Source: https://github.com/jcwal1516/signinum/blob/main/README.md

Inspect image files from the command line after installing the signinum-cli tool.

```sh
cargo install signinum-cli
signinum inspect tile.jp2
```

--------------------------------

### Decompress Tile Examples with Deflate, Zstd, LZW, and Uncompressed Codecs

Source: https://context7.com/jcwal1516/signinum/llms.txt

Demonstrates the usage of `decompress_into` for various tile codecs. Ensure the appropriate codec pools are initialized and output buffers are sized correctly.

```rust
use signinum::{
    tilecodec::{DeflateCodec, LzwCodec, ZstdCodec, UncompressedCodec},
    TileDecompress,
};

fn decompress_tile_examples(
    deflate_bytes: &[u8],
    zstd_bytes: &[u8],
    lzw_bytes: &[u8],
    raw_bytes: &[u8],
) -> Result<(), Box<dyn std::error::Error>> {
    let capacity = 1 << 20; // 1 MiB output buffer

    // Deflate (e.g., TIFF Deflate tiles)
    let mut deflate_pool = <DeflateCodec as TileDecompress>::Pool::default();
    let mut out = vec![0_u8; capacity];
    let n = DeflateCodec::decompress_into(&mut deflate_pool, deflate_bytes, &mut out)?;
    println!("Deflate: {} bytes", n);

    // Zstd (e.g., Zarr / DICOM Zstandard)
    let mut zstd_pool = <ZstdCodec as TileDecompress>::Pool::default();
    let mut out = vec![0_u8; capacity];
    let n = ZstdCodec::decompress_into(&mut zstd_pool, zstd_bytes, &mut out)?;
    println!("Zstd: {} bytes", n);

    // LZW (e.g., TIFF LZW tiles)
    let mut lzw_pool = <LzwCodec as TileDecompress>::Pool::default();
    let mut out = vec![0_u8; capacity];
    let n = LzwCodec::decompress_into(&mut lzw_pool, lzw_bytes, &mut out)?;
    println!("LZW: {} bytes", n);

    // Uncompressed (identity copy)
    let mut no_pool = <UncompressedCodec as TileDecompress>::Pool::default();
    let mut out = vec![0_u8; raw_bytes.len()];
    let n = UncompressedCodec::decompress_into(&mut no_pool, raw_bytes, &mut out)?;
    println!("Uncompressed: {} bytes", n);

    Ok(())
}

```

--------------------------------

### Install signinum-jpeg Crate

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-jpeg/README.md

Add the signinum-jpeg crate to your project dependencies using Cargo.

```sh
cargo add signinum-jpeg
```

--------------------------------

### Profile Output Format

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Example of the compact key-value stderr lines emitted by the profiler for rows and summaries.

```text
signinum_profile codec=jpeg op=encode path=cpu width=... height=... entropy_us=... total_us=...
signinum_profile codec=jpeg op=decode path=cpu mode=region_scaled decode_us=... total_us=...
signinum_profile codec=j2k op=encode path=cpu dwt_us=... block_encode_us=... total_us=...
signinum_profile codec=j2k op=decode path=cpu codeblock_us=... idwt_us=... total_us=...
signinum_profile_summary codec=j2k op=encode path=cpu count=... dwt_us_sum=... dwt_us_avg=...
```

--------------------------------

### Add Signinum Facade Dependency

Source: https://github.com/jcwal1516/signinum/blob/main/README.md

To start a new application, add the signinum facade as a dependency. This provides a unified import surface for various codecs.

```toml
[dependencies]
signinum = "0.4.2"
```

--------------------------------

### Add signinum-j2k-metal Crate

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-j2k-metal/README.md

Install the signinum-j2k-metal crate using Cargo to enable Metal-backed JPEG 2000 / HTJ2K output.

```sh
cargo add signinum-j2k-metal
```

--------------------------------

### Backend Request Enum Example

Source: https://github.com/jcwal1516/signinum/blob/main/docs/architecture.md

Demonstrates the explicit routing for backend requests, specifying CPU, Auto (with measured grayscale batch validation), or strict Metal paths. Metal requests will fail for unsupported shapes, unlike Auto which may fall back to CPU.

```rust
BackendRequest::Cpu
BackendRequest::Auto
BackendRequest::Metal
```

--------------------------------

### Add signinum-j2k-cuda with CUDA runtime feature

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-j2k-cuda/README.md

Install this crate with the `cuda-runtime` feature when your pipeline needs JPEG 2000 / HTJ2K output copied into CUDA device memory.

```sh
cargo add signinum-j2k-cuda --features cuda-runtime
```

--------------------------------

### Add signinum-jpeg-cuda with CUDA support

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-jpeg-cuda/README.md

Install the signinum-jpeg-cuda crate with the `cuda-runtime` feature enabled to utilize CUDA capabilities. This is required when your pipeline needs JPEG output in CUDA device memory.

```sh
cargo add signinum-jpeg-cuda --features cuda-runtime
```

--------------------------------

### Run J2K compare bench with local OpenJPEG

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Runs the Signinum J2K Metal compare benchmark locally, specifically against an in-process OpenJPEG instance. Requires specifying the path to the OpenJPEG compress binary.

```bash
SIGNINUM_OPENJPEG_COMPRESS_BIN=/opt/homebrew/bin/opj_compress \
  cargo bench -p signinum-j2k-metal --bench compare
```

--------------------------------

### Run Facade Dispatch Benchmarks

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Execute the facade dispatch benchmarks for the signinum crate. This tests the main entry point or dispatch mechanism.

```sh
cargo bench -p signinum --bench facade
```

--------------------------------

### Run Tilecodec Compare Bench

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Runs the tilecodec compare benchmark for the signinum-tilecodec crate locally. This will execute the benchmarks and display the results.

```sh
cargo bench -p signinum-tilecodec --bench compare
```

--------------------------------

### Run J2K compare bench with OpenJPEG and Grok

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Executes the Signinum J2K Metal compare benchmark against both local OpenJPEG and Grok implementations. This requires setting environment variables for the OpenJPEG binary and Grok source/root directories.

```bash
SIGNINUM_OPENJPEG_COMPRESS_BIN=/opt/homebrew/bin/opj_compress \
SIGNINUM_GROK_SOURCE=/tmp/grok-signinum \
SIGNINUM_GROK_ROOT=/tmp/grok-signinum/build/bin \
  cargo bench -p signinum-j2k-metal --bench compare
```

--------------------------------

### Add signinum-jpeg-metal Dependency

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-jpeg-metal/README.md

Install the signinum-jpeg-metal crate using Cargo to add Metal device-output capabilities for JPEG tiles to your macOS pipeline.

```sh
cargo add signinum-jpeg-metal
```

--------------------------------

### Run Benchmarks with Local Extracted WSI JPEG Tiles

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Run the comparator benchmarks for signinum-jpeg using local extracted WSI JPEG tiles. Ensure the SIGNINUM_WSI_ROOT environment variable is set to the directory containing the tiles.

```sh
SIGNINUM_BENCH_INPUTS="${SIGNINUM_WSI_ROOT:?set SIGNINUM_WSI_ROOT to extracted JPEG tiles}" \
  cargo bench -p signinum-jpeg --bench compare
```

--------------------------------

### Lossless JPEG 2000 / HTJ2K Encoding (Rust)

Source: https://context7.com/jcwal1516/signinum/llms.txt

Encodes interleaved samples into a raw JPEG 2000 lossless codestream using a pure-Rust engine. Supports various bit depths, block coding modes, and progression orders. The output codestream starts with the J2K SOC marker.

```rust
use signinum::j2k::{
    encode_j2k_lossless,
    J2kBlockCodingMode,
    J2kLosslessEncodeOptions,
    J2kLosslessSamples,
    J2kProgressionOrder,
};

fn encode_lossless_rgb(
    pixels: &[u8],
    width: u32,
    height: u32,
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    let samples = J2kLosslessSamples::new(pixels, width, height, 3, 8, false)?;
    let options = J2kLosslessEncodeOptions {
        block_coding_mode: J2kBlockCodingMode::HighThroughput,  // HTJ2K
        progression: J2kProgressionOrder::Rpcl,
        max_decomposition_levels: Some(5),
        ..J2kLosslessEncodeOptions::default()
    };
    let encoded = encode_j2k_lossless(samples, &options)?;
    // codestream starts with J2K SOC marker 0xFF 0x4F
    assert!(encoded.codestream.starts_with(&[0xFF, 0x4F]));
    println!(
        "encoded {}×{} {} comp, {} bits → {} bytes via ?",
        encoded.width, encoded.height, encoded.components,
        encoded.bit_depth, encoded.codestream.len(), encoded.backend,
    );
    Ok(encoded.codestream)
}
```

--------------------------------

### Capture Release Bench Baseline

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Commands to capture release-bench baselines for various signinum components. These are essential for comparing performance before and after changes.

```sh
cargo bench --profile release-bench -p signinum-j2k --bench public_api
```

```sh
cargo bench --profile release-bench -p signinum --bench facade
```

```sh
cargo bench --profile release-bench -p signinum-jpeg
```

```sh
cargo bench --profile release-bench -p signinum-j2k-native
```

```sh
cargo bench --profile release-bench -p signinum-jpeg-metal --bench compare --no-run
```

```sh
cargo bench --profile release-bench -p signinum-j2k-metal --bench compare --no-run
```

--------------------------------

### Compile J2K compare bench

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Compiles the Signinum J2K Metal compare benchmark without running it. This is useful for checking compilation or preparing for a run.

```bash
cargo bench -p signinum-j2k-metal --bench compare --no-run
```

--------------------------------

### Run Signinum-Only Microbenchmarks

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Execute the microbenchmarks specifically for the signinum-jpeg crate. These benchmarks focus on small, isolated pieces of functionality.

```sh
cargo bench -p signinum-jpeg --bench micro
```

--------------------------------

### Run J2K Public API Benchmarks

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Execute the public API benchmarks for the signinum-j2k crate. This tests the external interface of the JPEG2000 implementation.

```sh
cargo bench -p signinum-j2k --bench public_api
```

--------------------------------

### Generate Workspace Documentation

Source: https://github.com/jcwal1516/signinum/blob/main/CONTRIBUTING.md

Generate documentation for all crates in the workspace, excluding dependencies. This command is useful for reviewing the project's API and internal documentation.

```sh
cargo doc --workspace --no-deps
```

--------------------------------

### Run JPEG Comparator Benchmarks

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Execute the comparator benchmarks for the signinum-jpeg crate. This command runs tests that compare different JPEG decoding implementations.

```sh
cargo bench -p signinum-jpeg --bench compare
```

--------------------------------

### Run JPEG Metal device upload bench

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

This command runs the Signinum JPEG Metal device upload benchmark in release mode. It uses the 'summary' profile for route decisions.

```bash
SIGNINUM_GPU_ROUTE_PROFILE=summary \
  cargo bench --profile release-bench -p signinum-jpeg-metal --bench device_upload
```

--------------------------------

### Compile Tilecodec Compare Bench

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Compiles the tilecodec compare benchmark for the signinum-tilecodec crate. Use --no-run to only compile without executing.

```sh
cargo bench -p signinum-tilecodec --bench compare --no-run
```

--------------------------------

### Decode Pipeline Overview

Source: https://github.com/jcwal1516/signinum/blob/main/docs/architecture.md

Illustrates the general flow for decoding compressed bytes into viewable data, with separate paths for CPU and device execution. The CPU path involves entropy decoding, IDCT/DWT, color conversion, and output buffering, leveraging SIMD instructions. The device path (Metal) handles upload, kernel dispatch, and returns resident Metal surfaces.

```text
compressed bytes
    │
    ▼
inspect(bytes)              → Info (no decode)
    │
    ▼
view = View::parse(bytes)   → borrowed parse (no copy)
    │
    ▼
decoder = Decoder::from_view(view)
    │
    ├─ CPU path ───────────────────────────────────────────────┐
    │   decode_into / decode_into_with_scratch                 │
    │   decode_region_into / decode_scaled_into /
    │   decode_region_scaled_into / decode_rows                │
    │     entropy → IDCT or DWT → color conv → output buffer   │
    │     SIMD: AVX2 / SSE4.1 / NEON (jpeg)                    │
    │           fearless_simd (j2k-native)                     │
    │   returns DecodeOutcome<Warning>                         │
    │                                                           │
    └─ Device path (Metal today, CUDA API-only) ───────────────┘
        submit_to_device(session, fmt, BackendRequest::Metal)
            │
            ▼
        capability check
            │
            ├─ supported shape: prepare packet, upload to MTLBuffer,
            │   dispatch compute kernel (color conv, interleave/pack)
            │   → DeviceSubmission → wait() → Surface (with MTLBuffer)
            │
            └─ unsupported explicit backend: fail before decode;
                Auto/Cpu may wrap CPU output in a host-backed DeviceSurface
```

--------------------------------

### Fetch Parity Corpus Entries

Source: https://github.com/jcwal1516/signinum/blob/main/corpus/README.md

Use this script to fetch entries from a public manifest with URLs and SHA-256s. Specify the path to the manifest file and the destination directory for the corpus samples.

```sh
scripts/parity-corpus-fetch.sh path/to/manifest.json corpus/wsi-samples
```

--------------------------------

### Compile Metal Benches

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Compile the Metal benches for JPEG and J2K on Apple Silicon macOS. Use `--no-run` to only compile.

```sh
cargo bench -p signinum-jpeg-metal --bench compare --no-run

```

```sh
cargo bench -p signinum-jpeg-metal --bench device_upload --no-run

```

```sh
cargo bench -p signinum-j2k-metal --bench device_upload --no-run

```

--------------------------------

### Set Local Inputs for JPEG Benchmarking

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Configure the SIGNINUM_BENCH_INPUTS environment variable to include local JPEG files or directories for benchmarking. The path separator is platform-dependent.

```sh
SIGNINUM_BENCH_INPUTS=/path/to/jpeg_dir:/path/to/extracted_wsi_tiles cargo bench -p signinum-jpeg --bench compare
```

--------------------------------

### Add signinum-core Dependency

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-core/README.md

Use this command to add the signinum-core crate to your project's dependencies.

```sh
cargo add signinum-core
```

--------------------------------

### Inspect a file with signinum-cli

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-cli/README.md

Use the inspect command to parse JPEG and JPEG 2000 headers and print decoded metadata.

```sh
signinum inspect <file>
```

--------------------------------

### Profile GPU Route Diagnostics

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Commands to run GPU route diagnostics. Use `SIGNINUM_GPU_ROUTE_PROFILE=1` to enable profiling for helper smoke tests and adapter tests on local hardware or fallback paths.

```sh
# Helper smoke tests for the env parser and row formatter.
SIGNINUM_GPU_ROUTE_PROFILE=1 cargo test -p signinum-jpeg-metal profile::tests --lib -- --nocapture
SIGNINUM_GPU_ROUTE_PROFILE=1 cargo test -p signinum-j2k-metal profile::tests --lib -- --nocapture
SIGNINUM_GPU_ROUTE_PROFILE=1 cargo test -p signinum-jpeg-cuda profile::tests --lib -- --nocapture
SIGNINUM_GPU_ROUTE_PROFILE=1 cargo test -p signinum-j2k-cuda profile::tests --lib -- --nocapture
```

```sh
# Route-producing adapter tests on local hardware or fallback paths.
SIGNINUM_GPU_ROUTE_PROFILE=1 \
  cargo test -p signinum-jpeg-metal explicit_metal_unsupported_grayscale_shape_is_rejected \
  --test core_traits -- --nocapture
SIGNINUM_GPU_ROUTE_PROFILE=1 \
  cargo test -p signinum-j2k-metal explicit_metal_unsupported_rgba16_full_decode_is_rejected \
  --test device -- --nocapture
SIGNINUM_GPU_ROUTE_PROFILE=1 \
  cargo test -p signinum-jpeg-cuda explicit_cuda_request_returns_cuda_surface_or_clear_unavailable_error \
  --test host_surface -- --nocapture
SIGNINUM_GPU_ROUTE_PROFILE=1 \
  cargo test -p signinum-j2k-cuda explicit_cuda_request_returns_cuda_surface_or_clear_unavailable_error \
  --test host_surface -- --nocapture
```

--------------------------------

### Run Local NDPI Regression Test

Source: https://github.com/jcwal1516/signinum/blob/main/docs/wsi-dicom-passthrough.md

Execute the local NDPI passthrough test using cargo. Set SIGNINUM_NDPI_PATH to the location of your NDPI file.

```sh
SIGNINUM_NDPI_PATH=/path/to/slide.ndpi \
  cargo test -p signinum-jpeg --test ndpi_passthrough --profile release-bench -- --nocapture
```

--------------------------------

### Run Full-Container NDPI Passthrough Test

Source: https://github.com/jcwal1516/signinum/blob/main/docs/wsi-dicom-passthrough.md

Perform a full-container pass of the NDPI passthrough test by setting SIGNINUM_NDPI_TILE_LIMIT to 0. This ensures all payloads are processed.

```sh
SIGNINUM_NDPI_PATH=/path/to/slide.ndpi \
SIGNINUM_NDPI_TILE_LIMIT=0 \
  cargo test -p signinum-jpeg --test ndpi_passthrough --profile release-bench -- --nocapture
```

--------------------------------

### Profile CPU Codec Stage Rows

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Commands to profile CPU codec stage rows. Use the `SIGNINUM_JPEG_PROFILE_STAGES` or `SIGNINUM_J2K_PROFILE_STAGES` environment variables to enable detailed or aggregated stage profiling.

```sh
# One row per operation; useful for focused tests.
SIGNINUM_JPEG_PROFILE_STAGES=1 \
  cargo test -p signinum-jpeg cpu_encoder_round_trips_gray_and_writes_required_markers \
  --test encode_baseline -- --nocapture
```

```sh
SIGNINUM_J2K_PROFILE_STAGES=1 \
  cargo test -p signinum-j2k-native j2c::encode::tests::test_encode_decode_roundtrip_gray_8bit \
  --features std -- --nocapture
```

```sh
# Aggregated rows; suitable for release-bench investigation.
SIGNINUM_JPEG_PROFILE_STAGES=summary \
  cargo bench --profile release-bench -p signinum-jpeg --bench compare
```

```sh
SIGNINUM_J2K_PROFILE_STAGES=summary \
  cargo bench --profile release-bench -p signinum-j2k-metal --bench encode_stages
```

--------------------------------

### Add Signinum Crate to Project

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum/README.md

Use this command to add the signinum crate as a dependency to your Cargo project.

```sh
cargo add signinum
```

--------------------------------

### Add signinum-tilecodec Dependency

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-tilecodec/README.md

Add the signinum-tilecodec crate to your project's dependencies using Cargo.

```sh
cargo add signinum-tilecodec
```

--------------------------------

### Signinum Crate Dependency Graph

Source: https://github.com/jcwal1516/signinum/blob/main/docs/architecture.md

Detailed dependency graph of Signinum workspace crates, excluding external crates and dev-dependencies. Shows direct dependencies between internal crates.

```text
signinum-core         (leaf)
signinum-profile      (instrumentation helper)
signinum-cuda-runtime (CUDA runtime helper)

signinum-tilecodec    -> signinum-core

signinum-jpeg         -> signinum-profile, signinum-core
signinum-jpeg-metal   -> signinum-jpeg, signinum-profile, signinum-core
signinum-jpeg-cuda    -> signinum-jpeg, signinum-cuda-runtime, signinum-profile, signinum-core

signinum-j2k-native   -> signinum-profile
signinum-j2k          -> signinum-j2k-native, signinum-core
signinum-j2k-metal    -> signinum-j2k, signinum-j2k-native, signinum-profile, signinum-core
signinum-j2k-cuda     -> signinum-j2k, signinum-j2k-native, signinum-cuda-runtime, signinum-profile, signinum-core

signinum              -> signinum-core, signinum-jpeg, signinum-j2k, signinum-tilecodec, signinum-jpeg-metal, signinum-j2k-metal, signinum-jpeg-cuda, signinum-j2k-cuda
signinum-cli          -> signinum-jpeg, signinum-j2k

signinum-j2k-compare  -> signinum-core, signinum-j2k (test/bench reference only)
```

--------------------------------

### Run Metal Benches on Apple Silicon

Source: https://github.com/jcwal1516/signinum/blob/main/docs/bench.md

Run the Metal benches for JPEG and J2K on Apple Silicon macOS. The `--noplot` flag disables plotting.

```sh
cargo bench -p signinum-jpeg-metal --bench compare -- --noplot

```

```sh
cargo bench -p signinum-jpeg-metal --bench device_upload -- --noplot

```

```sh
cargo bench -p signinum-j2k-metal --bench device_upload -- --noplot

```

--------------------------------

### Batch Decode JPEG Tiles with Options

Source: https://github.com/jcwal1516/signinum/blob/main/crates/signinum-jpeg/README.md

Efficiently decode multiple JPEG tiles in parallel using production batch APIs. This method is optimized for WSI viewers and allows specifying color transforms and other decoding options.

```rust
use signinum_jpeg::{
    decode_tiles_into_with_options,
    ColorTransform,
    DecodeOptions,
    PixelFormat,
    TileBatchOptions,
    TileDecodeJob,
};

let decode_options = DecodeOptions::default().with_color_transform(ColorTransform::ForceYCbCr);
let stride = tile_width as usize * 3;
let mut outputs = compressed_tiles
    .iter()
    .map(|_| vec![0_u8; stride * tile_height as usize])
    .collect::<Vec<_>>();
let mut jobs = compressed_tiles
    .iter()
    .zip(outputs.iter_mut())
    .map(|(input, out)| TileDecodeJob {
        input: input.as_ref(),
        out: out.as_mut_slice(),
        stride,
    })
    .collect::<Vec<_>>();

decode_tiles_into_with_options(
    &mut jobs,
    PixelFormat::Rgb8,
    decode_options,
    TileBatchOptions::default(),
)?;
```

--------------------------------

### Run Workspace Tests

Source: https://github.com/jcwal1516/signinum/blob/main/CONTRIBUTING.md

Execute all tests across the entire workspace to ensure code integrity. This is a standard command for verifying the project's health.

```sh
cargo test --workspace
```

--------------------------------

### Opt-in Local WSI JPEG Coverage

Source: https://github.com/jcwal1516/signinum/blob/main/corpus/README.md

Enable local WSI JPEG coverage by setting the SIGNINUM_WSI_ROOT environment variable before running cargo tests. This command targets the signinum-jpeg crate and the external_wsi test.

```sh
SIGNINUM_WSI_ROOT=corpus/wsi-samples cargo test -p signinum-jpeg --test external_wsi
```