// prism-audio: read-only audio analyser for Prism. // Captures system audio (or one app) via ScreenCaptureKit, runs a 2048-point FFT // every 800 samples (60 Hz at 48 kHz) and prints one JSON line per hop: // {"rms","peak","bands":[64 × 0–255],"bass","mid","high","flux","kick"} // Bands are log-spaced 30 Hz–16 kHz on a FIXED dB scale (no auto-gain), with a // +3 dB/octave tilt so pink noise reads flat. Nothing is played or recorded. // // prism-audio all system audio (except this process) // prism-audio --app one application, e.g. com.ableton.live // prism-audio --stdin [rate] raw float32 mono PCM on stdin (tests) // // Build: swiftc AudioCapture.swift -o prism-audio -O \ // -framework ScreenCaptureKit -framework AVFoundation -framework CoreMedia -framework Accelerate import Foundation import ScreenCaptureKit import AVFoundation import CoreMedia import Accelerate func emit(_ value: [String: Any]) { if let data = try? JSONSerialization.data(withJSONObject: value), let s = String(data: data, encoding: .utf8) { print(s); fflush(stdout) } } func round4(_ v: Float) -> Double { (Double(v) * 10000).rounded() / 10000 } final class Analyzer { static let size = 2048, bandCount = 64, minHz: Float = 30, maxHz: Float = 16000 let sampleRate: Float, hop: Int private var ring = [Float](repeating: 0, count: Analyzer.size) private var write = 0, filled = 0, sinceHop = 0 private var hopSquares: Float = 0, hopPeak: Float = 0 private let window: [Float] private let setup: vDSP_DFT_Setup private var reference: Float = 1 private var previousBands = [Float](repeating: 0, count: Analyzer.bandCount) private let edges: [Float] var output: ([String: Any]) -> Void = emit init(sampleRate: Float) { self.sampleRate = sampleRate hop = max(256, Int((sampleRate / 60).rounded())) window = vDSP.window(ofType: Float.self, usingSequence: .hanningDenormalized, count: Analyzer.size, isHalfWindow: false) setup = vDSP_DFT_zrop_CreateSetup(nil, vDSP_Length(Analyzer.size), .FORWARD)! edges = (0...Analyzer.bandCount).map { Analyzer.minHz * pow(Analyzer.maxHz / Analyzer.minHz, Float($0) / Float(Analyzer.bandCount)) } // Self-calibrate: a full-scale 1 kHz sine defines 0 dBFS for one bin. let tone = (0.. [Float] { let half = Analyzer.size / 2 var windowed = [Float](repeating: 0, count: Analyzer.size) vDSP.multiply(frame, window, result: &windowed) var inR = [Float](repeating: 0, count: half), inI = inR, outR = inR, outI = inR for i in 0.., count: Int, stride: Int = 1) { for i in 0..= hop { sinceHop = 0; if filled == Analyzer.size { analyse() }; hopSquares = 0; hopPeak = 0 } } } private func analyse() { let frame = Array(ring[write...] + ring[..= first { power = 0 for k in first...min(last, mags.count - 1) { power += mags[k] * mags[k] } power /= Float(min(last, mags.count - 1) - first + 1) } else { // Band narrower than one bin (deep bass): interpolate at its centre. let x = sqrt(lo * hi) / binHz, k = min(Int(x), mags.count - 2), t = x - Float(k) let m = mags[k] * (1 - t) + mags[k + 1] * t power = m * m } let centre = sqrt(lo * hi) let db = 10 * log10(max(power, 1e-14)) - 20 * log10(reference) + 3 * log2(centre / 1000) bands[b] = pow(min(1, max(0, (db + 72) / 62)), 1.15) } func average(_ from: Float, _ to: Float) -> Float { var sum: Float = 0, n: Float = 0 for b in 0..= from && sqrt(edges[b] * edges[b + 1]) < to { sum += bands[b]; n += 1 } return n > 0 ? sum / n : 0 } var flux: Float = 0, kick: Float = 0, kickBands: Float = 0 for b in 0.. 0 else { return } do { try sample.withAudioBufferList { list, _ in guard let pcm = AVAudioPCMBuffer(pcmFormat: format, bufferListNoCopy: list.unsafePointer), let channels = pcm.floatChannelData else { return } pcm.frameLength = AVAudioFrameCount(frames) let count = Int(pcm.frameLength), stride = Int(pcm.stride), n = Int(format.channelCount) if mono.count < count { mono = [Float](repeating: 0, count: count) } for i in 0..