Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

5.9 KB
Raw Blame
import Accelerate
import Foundation

/// Splits the most recent microphone audio into log-spaced frequency bands for the
/// overlay visualizer. Read-only tap: it never alters or delays the captured samples.
final class AudioSpectrumMeter: @unchecked Sendable {
    static let shared = AudioSpectrumMeter()
    static let bandCount = 11

    private static let log2n: vDSP_Length = 9
    private static let frameSize = 1 << 9
    private static let sampleRate: Float = 16_000
    private static let lowestFrequency: Float = 120
    private static let highestFrequency: Float = 6000
    private static let floorDecibels: Float = -62
    private static let rangeDecibels: Float = 50
    /// Speech energy falls off with pitch; lift higher bands so consonants register.
    private static let tiltDecibelsPerOctave: Float = 3

    private let lock = NSLock()
    private let setup: FFTSetup?
    private let window: [Float]
    private let bandEdges: [Int]
    private var ring = [Float](repeating: 0, count: AudioSpectrumMeter.frameSize)
    private var ringIndex = 0
    private var frame = [Float](repeating: 0, count: AudioSpectrumMeter.frameSize)
    private var real = [Float](repeating: 0, count: AudioSpectrumMeter.frameSize / 2)
    private var imaginary = [Float](repeating: 0, count: AudioSpectrumMeter.frameSize / 2)
    private var magnitudes = [Float](repeating: 0, count: AudioSpectrumMeter.frameSize / 2)
    private var latest = [Float](repeating: 0, count: AudioSpectrumMeter.bandCount)

    private init() {
        self.setup = vDSP_create_fftsetup(Self.log2n, FFTRadix(kFFTRadix2))
        var window = [Float](repeating: 0, count: Self.frameSize)
        vDSP_hann_window(&window, vDSP_Length(Self.frameSize), Int32(vDSP_HANN_NORM))
        self.window = window

        let binWidth = Self.sampleRate / Float(Self.frameSize)
        let ratio = Self.highestFrequency / Self.lowestFrequency
        var edges: [Int] = []
        for band in 0...Self.bandCount {
            let frequency = Self.lowestFrequency * pow(ratio, Float(band) / Float(Self.bandCount))
            let bin = Int((frequency / binWidth).rounded())
            // Low bands are narrower than one bin; keep every band at least one bin wide.
            edges.append(max(bin, (edges.last ?? 0) + 1))
        }
        self.bandEdges = edges
    }

    deinit {
        if let setup { vDSP_destroy_fftsetup(setup) }
    }

    /// Feed 16 kHz mono samples. Called from the capture pipeline.
    func ingest(_ samples: [Float]) {
        guard let setup, samples.isEmpty == false else { return }
        self.lock.lock()
        defer { self.lock.unlock() }

        for sample in samples.suffix(Self.frameSize) {
            self.ring[self.ringIndex] = sample
            self.ringIndex = (self.ringIndex + 1) % Self.frameSize
        }
        for index in 0..<Self.frameSize {
            self.frame[index] = self.ring[(self.ringIndex + index) % Self.frameSize] * self.window[index]
        }

        let halfSize = Self.frameSize / 2
        self.real.withUnsafeMutableBufferPointer { realPointer in
            self.imaginary.withUnsafeMutableBufferPointer { imaginaryPointer in
                guard let realBase = realPointer.baseAddress, let imaginaryBase = imaginaryPointer.baseAddress else { return }
                var split = DSPSplitComplex(realp: realBase, imagp: imaginaryBase)
                self.frame.withUnsafeBufferPointer { framePointer in
                    guard let frameBase = framePointer.baseAddress else { return }
                    frameBase.withMemoryRebound(to: DSPComplex.self, capacity: halfSize) { complex in
                        vDSP_ctoz(complex, 2, &split, 1, vDSP_Length(halfSize))
                    }
                }
                vDSP_fft_zrip(setup, &split, 1, Self.log2n, FFTDirection(FFT_FORWARD))
                vDSP_zvabs(&split, 1, &self.magnitudes, 1, vDSP_Length(halfSize))
            }
        }

        // zrip output is scaled by 2; the normalized Hann window halves amplitude again.
        let amplitudeScale = 2 / Float(Self.frameSize)
        for band in 0..<Self.bandCount {
            let lower = min(self.bandEdges[band], halfSize - 1)
            let upper = min(max(self.bandEdges[band + 1], lower + 1), halfSize)
            var peak: Float = 0
            self.magnitudes.withUnsafeBufferPointer { pointer in
                guard let base = pointer.baseAddress else { return }
                vDSP_maxv(base + lower, 1, &peak, vDSP_Length(upper - lower))
            }
            let octave = Float(band) / Float(Self.bandCount) * log2(Self.highestFrequency / Self.lowestFrequency)
            let decibels = 20 * log10(max(peak * amplitudeScale, 1e-9)) + octave * Self.tiltDecibelsPerOctave
            let value = min(max((decibels - Self.floorDecibels) / Self.rangeDecibels, 0), 1)
            // Single FFT frames flicker; ease toward each new reading.
            self.latest[band] += (value - self.latest[band]) * 0.45
        }
    }

    func reset() {
        self.lock.lock()
        defer { self.lock.unlock() }
        for index in self.ring.indices {
            self.ring[index] = 0
        }
        for index in self.latest.indices {
            self.latest[index] = 0
        }
    }

    /// Band levels in 0...1, low frequencies first, resampled to `count` bars.
    func bands(count: Int) -> [CGFloat] {
        guard count > 0 else { return [] }
        self.lock.lock()
        let snapshot = self.latest
        self.lock.unlock()
        guard count != snapshot.count else { return snapshot.map { CGFloat($0) } }
        return (0..<count).map { index in
            let position = Float(index) / Float(max(count - 1, 1)) * Float(snapshot.count - 1)
            let lower = Int(position)
            let upper = min(lower + 1, snapshot.count - 1)
            let fraction = position - Float(lower)
            return CGFloat(snapshot[lower] * (1 - fraction) + snapshot[upper] * fraction)
        }
    }
}