I Built a macOS App to Detect Fake Lossless Audio

Ale — Tue, 28 Apr 2026 09:58:08 +0000

A WAV file is not always what it claims to be.
If you download a track labeled .wav from a music store, you assume it's lossless — uncompressed PCM audio, bit-for-bit identical to the original master. Sometimes it is. Sometimes it's an MP3 that someone converted to WAV, either by accident or to make it look higher quality than it is. The file size looks right. The bit depth looks right. Your media player reads it fine. But the audio has already been degraded, and no amount of re-encoding recovers what lossy compression discarded.

This is called fake lossless audio. It's common enough in DJ libraries and audiophile collections that I built a macOS app — Spectro — to detect it automatically. This post is about how the detection works.

Why lossy compression is detectable
MP3, AAC, and OGG compress audio by permanently discarding frequency information that psychoacoustic models consider inaudible — mostly high-frequency content above a certain threshold. A 128kbps MP3 typically cuts off around 16 kHz. A 320kbps MP3 cuts off at approximately 19–20 kHz. Genuine lossless audio from a 44.1 kHz source has content up to 22 kHz (the Nyquist limit).

When someone converts a 128kbps MP3 to WAV, the container changes but the frequency content doesn't. The high frequencies that were removed during MP3 encoding are gone permanently. The resulting WAV file carries a characteristic signature: a hard cutoff in the frequency spectrum — a flat, dark region above the cutoff frequency where audio energy simply doesn't exist.
That cutoff is the fingerprint of a fake.

Detecting it with FFT
The detection approach is Fast Fourier Transform spectral analysis. FFT decomposes an audio signal from the time domain into its constituent frequencies. The output is a frequency spectrum showing how much energy exists at each frequency across the audio. By analyzing this spectrum, you can see exactly where the audio content ends.

In Swift, Apple's vDSP framework makes FFT efficient and straightforward. Here's a simplified version of the core analysis:
swiftimport Accelerate

func computeSpectrum(samples: [Float], fftSize: Int = 4096) -> [Float] {
    let log2n = vDSP_Length(log2(Float(fftSize)))
    guard let fftSetup = vDSP_create_fftsetup(log2n, FFTRadix(kFFTRadix2)) else {
        return []
    }
    defer { vDSP_destroy_fftsetup(fftSetup) }

    var real = [Float](samples.prefix(fftSize))
    var imag = [Float](repeating: 0, count: fftSize)

    real.withUnsafeMutableBufferPointer { realPtr in
        imag.withUnsafeMutableBufferPointer { imagPtr in
            var splitComplex = DSPSplitComplex(
                realp: realPtr.baseAddress!,
                imagp: imagPtr.baseAddress!
            )
            vDSP_fft_zip(fftSetup, &splitComplex, 1, log2n, FFTDirection(FFT_FORWARD))

            // Compute magnitude spectrum
            var magnitudes = [Float](repeating: 0, count: fftSize / 2)
            vDSP_zvmags(&splitComplex, 1, &magnitudes, 1, vDSP_Length(fftSize / 2))
            real = magnitudes
        }
    }

    return real
}

Running this across multiple frames of the audio (not just one window) and averaging gives a stable picture of the frequency content across the whole track. From this averaged spectrum, finding the cutoff frequency is a matter of locating where the high-frequency energy drops below a threshold.

The verdict engine
Once you have the cutoff frequency in kHz, the classification logic is straightforward. Here's the actual VerdictEngine from Spectro:

`swiftstruct VerdictEngine {
    func evaluate(
        cutoffKHz: Float,
        fileExtension: String,
        declaredKbps: Int? = nil,
        sampleRate: Float? = nil
    ) -> Verdict {
        let ext = fileExtension.lowercased()
        let isLossyContainer = (ext == "mp3" || ext == "m4a")
        let isLosslessContainer = (ext == "wav" || ext == "aiff" || ext == "flac")

        // Low declared bitrate is a strong fake signal
        if let declaredKbps, declaredKbps <= 160 {
            return .fake
        }

        // Nyquist-aware guard: a FLAC at 32 kHz has Nyquist at 16 kHz —
        // without this check it would be incorrectly classified as FAKE
        if isLosslessContainer, let sampleRate {
            let expectedNyquistKHz = (sampleRate / 2.0) / 1000.0
            if abs(cutoffKHz - expectedNyquistKHz) <= 0.5 {
                return .highQuality
            }
        }

        // Classify from cutoff frequency
        let verdictFromCutoff: Verdict
        if cutoffKHz < 16 {
            verdictFromCutoff = .fake
        } else if cutoffKHz < 19 {
            verdictFromCutoff = .medium
        } else if cutoffKHz >= 20 {
            verdictFromCutoff = .highQuality
        } else {
            verdictFromCutoff = .medium
        }

        // Lossy containers (MP3, M4A) can never be lossless regardless of cutoff
        if isLossyContainer && verdictFromCutoff == .highQuality {
            return .medium
        }

        return verdictFromCutoff
    }
}`

The three verdicts:

LOSSLESS (highQuality) — frequency content extends naturally to the Nyquist limit. The file is what it claims to be.
FAKE — hard cutoff detected below 16 kHz, or declared bitrate ≤ 160kbps. The file is almost certainly a transcoded lossy source.
MEDIUM — cutoff between 16–20 kHz, or a lossy container with high-frequency content. Could be 320kbps MP3, a heavily mastered track with intentional high-cut, or a vinyl rip. Borderline cases that need judgment.

The edge cases that matter
The classification logic looks simple, but getting it right required handling several non-obvious cases.

Non-standard sample rates. A FLAC file recorded at 32 kHz has a Nyquist frequency of 16 kHz — not 22 kHz. Without the sample rate guard in the verdict engine, every 32 kHz lossless file would be classified as FAKE because the cutoff appears to be at 16 kHz. The fix is to compare the measured cutoff against the expected Nyquist for the file's actual sample rate, not a hardcoded 22 kHz assumption.

320kbps MP3 as WAV. A 320kbps MP3 converted to WAV cuts off at approximately 20 kHz — barely below the 22 kHz Nyquist. On a spectrogram this is genuinely hard to distinguish from a real lossless file by eye. The verdict engine flags these as MEDIUM rather than LOSSLESS, which is conservative but accurate: the file is not technically lossless.

Intentional mastering cutoffs. Some mastering engineers apply a brick-wall EQ high-cut at 20 kHz intentionally. A genuine lossless file can show a hard cutoff at 20 kHz and still be truly lossless. This is why the MEDIUM verdict exists — to avoid false positives on edge cases where the spectral evidence is ambiguous.

Audio optimizers. Tools like Platinum Notes process audio and modify its frequency content, which can cause a legitimately lossless file to be misclassified. This is a known limitation and worth documenting for users.

The app
Spectro processes files in batch — drag in a folder of 200 tracks and it returns a verdict for each in a few minutes. It runs entirely offline (audio never leaves the machine), which matters for DJs working with unreleased tracks or promos. It integrates with macOS Finder tags so flagged files are visible in the library at a glance.
It's a $39 one-time purchase for Mac, with a 100-file free trial that requires no account.
https://getspectro.app

The fake lossless problem is more common than most people realize — any DJ who has audited their library has found them. The detection is technically straightforward once you know what to look for. The hard part, as usual, was the edge cases.

If you have questions about the FFT implementation or the verdict logic, happy to discuss in the comments.

DEV Community: Ale

I Built a macOS App to Detect Fake Lossless Audio