flaccheck

flaccheck is an open-source Rust CLI (plus local web UI) that answers one question: is this “lossless” file actually lossless, or a lossy transcode in disguise?

It scans FLAC, ALAC, WAV, AIFF, and other decodable formats locally — no cloud upload — and returns a structured verdict with optional per-detector evidence.

Public repo: github.com/dasunNimantha/flaccheck

What it is

Why we built it

Fake lossless is common in downloaded music libraries:

• A 128 kbps MP3 re-wrapped as FLAC does not recover quality — it only grows file size.
• “Hi-res” 24-bit releases are sometimes upsampled 16-bit PCM with no new information.
• Marketplaces and forum rips are not always honest about source format.

Manual tools like Spek show spectrograms but do not scale to whole libraries. Existing automated tools either false-positive on genuine masters (flagging narrow-band archival transfers) or miss transcodes on some codecs.

We wanted a tool that:

1. Runs fully offline on Linux/macOS/Windows
2. Abstains (INCONCLUSIVE) on ambiguous band-limited content instead of guessing
3. Ships with reproducible benchmarks against alternatives (FLAC Detective, isflac, soundaudit, audiocheckr)

How detection works

Detector tiers

Evidence from all tiers is fused into one transcode verdict and a confidence score. Use --explain to see per-detector notes in the report.

Technical pipeline

1. Decode to PCM

Every file is decoded to interleaved f32 PCM — tags and container format are ignored after decode.

The decoder picks the first audio track, preserves sample rate and channel count, and hands a PcmBuffer to the detector pipeline.

2. Windowed analysis

Long tracks are not analyzed as one giant FFT. The PCM is split into time windows (configurable duration and count). Windows with RMS below 15% of the peak are dropped so silent gaps do not dilute the spectrum.

3. Tier 1 — Spectral (rustfft, 4096-point)

On each window:

1. Convert to mono (left channel)
2. Compute average power spectral density across windows
3. Smooth the PSD in dB (5-bin moving average)
4. Measure:
   • Brick-wall cutoff — sharp drop to a digital noise floor below Nyquist
   • Rolloff steepness — dB/octave at the cliff (MP3 tends to be steeper than AAC)
   • Spectral edge — highest frequency with meaningful energy
   • AAC shelf — gradual high-frequency shelf before cutoff
   • SBR mirroring — HF band that mirrors energy from a lower band (HE-AAC hint)

Codec signature matching compares measured cutoff/edge against known MP3, AAC, and Opus bitrate tables (e.g. MP3 128k ≈ 16 kHz, AAC 256k ≈ 20 kHz). A match raises codec_guess and codec_certainty.

full_band is set when content reaches ~97% of Nyquist and there is no strong brick wall — a key input to abstention logic.

4. Tier 2 — MDCT / PQMF quantization

Searches for lossy codec block structure in the decoded samples:

• MP3 PQMF / granule hybrid filterbank patterns
• MDCT quantization residual from transform-codec frame boundaries

This tier is gated by scan mode and spectral suspicion — it is skipped on clean full-band files in balanced mode because PQMF heuristics false-positive on live/acoustic material. Quant evidence can corroborate a spectral cutoff but never alone flag full-bandwidth audio as transcoded.

5. Tier 3 — Time-domain artifacts

Looks for encoder-specific signatures in the waveform:

fast mode runs a light artifact pass; balanced / max run the full set when spectral suspicion is elevated.

6. Tier 4 — Fake hi-res

Separate from transcode detection:

• Upsampled — 16 kHz / 44.1 kHz content in a 48 kHz / 96 kHz container
• Padded depth — 16-bit samples zero-padded into 24-bit words

A genuine transcode verdict can be downgraded to SUSPICIOUS if hi-res fraud is detected.

7. Evidence fusion & abstention

Each detector emits weighted evidence records (signal, value, weight, note). fuse_evidence() in flaccheck-core combines them:

weighted_score = Σ (value × weight) / Σ weight

Key rules:

• Strong cliff (brick_wall ≥ threshold) → transcode fingerprint even on bass-heavy tracks with little HF energy
• Strong AAC shelf + cutoff below Nyquist → transcode even without MP3-style brick wall
• Band-limited content (edge below ~18 kHz, not full-band) → INCONCLUSIVE unless a strong cliff overrides
• Full-band + low artifact suspicion → quant tier cannot promote to TRANSCODED on its own

Optional ML tier (--ml, ONNX): refines borderline cases only; does not replace the rule-based fusion.

Scan modes

Verdicts

ALAC and .m4a files

flaccheck can scan .m4a and .alac files (decoded via symphonia). Two questions often get conflated:

Example: a streaming AAC .m4a is legitimately lossy — not “fake ALAC.” flaccheck analyzes the audio content, not the shopping label.

Quick usage

git clone https://github.com/dasunNimantha/flaccheck.git
cd flaccheck
cargo build --release -p flaccheck

./target/release/flaccheck scan ~/Music --format json --explain
./target/release/flaccheck serve   # local web UI

Requirements: Rust stable. Optional ffmpeg for APE, WavPack, and Opus decode.

Native decode: FLAC, WAV, AIFF, ALAC, AAC, MP3, Vorbis, .m4a · With ffmpeg: APE, WavPack, Opus

What we optimized for

Benchmarks & validation

We validate flaccheck against labeled real-music corpora — not synthetic sine waves — by transcoding genuine sources with ffmpeg and comparing tool outputs to ground truth.

Charts and raw JSON: docs/benchmarks/comparison.json

Why benchmark this way

Our approach:

1. Start from genuine lossless sources (archival, classical, live, netlabel)
2. Transcode with ffmpeg to MP3/AAC/Opus/Vorbis, wrap back to FLAC
3. Label each file genuine or transcoded in manifest.json
4. Run flaccheck and competitors on identical paths
5. Score precision, recall, and false positives on genuine references

Corpora

Tools compared

Combined results (253 files)

flaccheck leads on precision (one false positive across 23 genuine references). audiocheckr catches more borderline transcodes but flags most genuine files as fake.

Recall by codec (flaccheck)

AAC at 128–256 kbps is the hard case — gentle shelf instead of a hard brick wall.

Reproduce benchmarks

./datasets/generate_realistic.sh /path/to/sources datasets/output/realistic
./datasets/download_benchmark_v2.sh
./datasets/generate_realistic.sh datasets/benchmark_v2_sources datasets/output/benchmark_v2

cargo build --release -p flaccheck
./target/release/flaccheck scan datasets/output/realistic \
  --format json --quiet -o benchmarks/flaccheck_per_file.json --workers 8
flac-detective --format json --output benchmarks/flac_detective.json datasets/output/realistic

python3 scripts/benchmark_compare.py --collect   # per corpus
python3 scripts/benchmark_compare.py --combine   # → docs/benchmarks/

Research references

Detection draws on published work on lossy fingerprinting: D'Alessandro & Shi (ACM MM&Sec 2009), Derrien (JAES 2019), Lacroix et al. (AES 2015).