@swiftbrowser/native 0.18.3 → 0.19.0

package/swift/Packages/SwiftBrowserDSP/Sources/SwiftBrowserDSPCore/Machine.swift

@@ -0,0 +1,523 @@
+import Foundation
+
+/// The DSP machine: runs a `DSPProgram` for up to 16 voices, a lane each, in
+/// blocks of up to 128 frames. It is the JavaScript machine
+/// (packages/dsp/src/machine.ts) instruction for instruction, so a program
+/// sounds the same in a native app and on a page; ParityTests hold the two
+/// to the samples the JavaScript one renders.
+///
+/// Real-time safe once made: `render` and the note and parameter calls
+/// allocate nothing, take no lock and call nothing that might; every buffer
+/// is sized from the program in `init`, and the program was checked there,
+/// so no instruction can reach outside them. One thread at a time: the audio
+/// thread renders and applies events, which another thread hands it
+/// (ProgramNode.swift in SwiftBrowserDSP).
+///
+/// Events apply at the next block. A note takes the lane already playing it,
+/// else a free one, else the oldest released, else the oldest; a lane's gate
+/// is up from its note on to its note off, or under the sustain pedal until
+/// the pedal lifts, and it sounds while the gate is up and then while any
+/// `adsr` in the program has not finished its release.
+public final class DSPMachine: @unchecked Sendable {
+    public let program: DSPProgram
+    public let sampleRate: Float
+
+    private static let lanes = 16
+    private let registers: UnsafeMutablePointer<Float>
+    private let state: UnsafeMutablePointer<Float>
+    private let stateCount: Int
+    private let noise: UnsafeMutablePointer<UInt32>
+    private let noiseCount: Int
+    private let blockCode: UnsafeMutablePointer<Int32>
+    private let blockCount: Int
+    private let sampleCode: UnsafeMutablePointer<Int32>
+    private let sampleCount: Int
+    /// Each instance's builtin and where its state starts (in floats, lanes included; a noise instance's in `noise`).
+    private let instanceKinds: [DSPBuiltin]
+    private let instanceOffsets: [Int]
+    private let envelopeOffsets: [Int]
+    private let filterOffsets: [Int]
+    private let parameterRegisters: [Int]
+    private let parameterRanges: [(min: Float, max: Float)]
+    private let parameterIndices: [String: Int]
+    private let targets: UnsafeMutablePointer<Float>
+    private var snapped = true
+
+    private let laneNote: UnsafeMutablePointer<Int32>
+    private let laneGate: UnsafeMutablePointer<Float>
+    private let laneVelocity: UnsafeMutablePointer<Float>
+    private let laneHeld: UnsafeMutablePointer<Bool>
+    private let laneActive: UnsafeMutablePointer<Float>
+    private let laneAge: UnsafeMutablePointer<Double>
+    private let trigger: UnsafeMutablePointer<Float>
+    private var age: Double = 0
+    private var pedal = false
+    private var bend: Double = 0
+
+    public init(program: DSPProgram, sampleRate: Double) {
+        let L = Self.lanes
+        self.program = program
+        self.sampleRate = Float(sampleRate)
+        registers = .allocate(capacity: program.registers * L)
+        registers.initialize(repeating: 0, count: program.registers * L)
+        var kinds: [DSPBuiltin] = []
+        var offsets: [Int] = []
+        var envelopes: [Int] = []
+        var filters: [Int] = []
+        var words = 0
+        var noises = 0
+        for builtin in program.instances {
+            kinds.append(builtin)
+            if builtin == .noise {
+                offsets.append(noises * L)
+                noises += 1
+            } else {
+                offsets.append(words * L)
+                if builtin == .adsr { envelopes.append(words * L) }
+                if builtin == .lowpass || builtin == .highpass || builtin == .bandpass { filters.append(words * L) }
+                words += builtin.words
+            }
+        }
+        instanceKinds = kinds
+        instanceOffsets = offsets
+        envelopeOffsets = envelopes
+        filterOffsets = filters
+        stateCount = max(1, words) * L
+        state = .allocate(capacity: stateCount)
+        state.initialize(repeating: 0, count: stateCount)
+        noiseCount = max(1, noises) * L
+        noise = .allocate(capacity: noiseCount)
+        noise.initialize(repeating: 1, count: noiseCount)
+        (blockCode, blockCount) = Self.decode(program.block, offsets: offsets)
+        (sampleCode, sampleCount) = Self.decode(program.sample, offsets: offsets)
+        for constant in program.constants {
+            (registers + constant.register * L).update(repeating: constant.value, count: L)
+        }
+        registers.update(repeating: Float(sampleRate), count: L)
+        parameterRegisters = program.parameters.map(\.register)
+        parameterRanges = program.parameters.map { ($0.min, $0.max) }
+        parameterIndices = Dictionary(program.parameters.enumerated().map { ($1.name, $0) }, uniquingKeysWith: { first, _ in first })
+        targets = .allocate(capacity: max(1, program.parameters.count))
+        for (i, parameter) in program.parameters.enumerated() {
+            targets[i] = parameter.defaultValue
+            (registers + parameter.register * L).update(repeating: parameter.defaultValue, count: L)
+        }
+        laneNote = .allocate(capacity: L)
+        laneNote.initialize(repeating: -1, count: L)
+        laneGate = .allocate(capacity: L)
+        laneGate.initialize(repeating: 0, count: L)
+        laneVelocity = .allocate(capacity: L)
+        laneVelocity.initialize(repeating: 0, count: L)
+        laneHeld = .allocate(capacity: L)
+        laneHeld.initialize(repeating: false, count: L)
+        laneActive = .allocate(capacity: L)
+        laneActive.initialize(repeating: 0, count: L)
+        laneAge = .allocate(capacity: L)
+        laneAge.initialize(repeating: 0, count: L)
+        trigger = .allocate(capacity: L)
+        trigger.initialize(repeating: 0, count: L)
+        for lane in 0..<L { resetLane(lane) }
+    }
+
+    deinit {
+        for pointer in [registers, state, targets, laneGate, laneVelocity, laneActive, trigger] { pointer.deallocate() }
+        noise.deallocate()
+        blockCode.deallocate()
+        sampleCode.deallocate()
+        laneNote.deallocate()
+        laneHeld.deallocate()
+        laneAge.deallocate()
+    }
+
+    /// Instructions at a stride of 8 (op, destination, five operands, state offset), registers as offsets into the file.
+    private static func decode(_ code: [Int32], offsets: [Int]) -> (UnsafeMutablePointer<Int32>, Int) {
+        var out: [Int32] = []
+        var pc = 0
+        while pc < code.count {
+            let op = DSPOpcode(rawValue: code[pc])!
+            var slot = [Int32](repeating: 0, count: 8)
+            slot[0] = op.rawValue
+            slot[1] = code[pc + 1] * Int32(lanes)
+            for k in 0..<op.arity { slot[2 + k] = code[pc + 2 + k] * Int32(lanes) }
+            if op.builtin != nil { slot[7] = Int32(offsets[Int(code[pc + 2 + op.arity])]) }
+            out += slot
+            pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
+        }
+        let pointer = UnsafeMutablePointer<Int32>.allocate(capacity: max(8, out.count))
+        pointer.initialize(repeating: 0, count: max(8, out.count))
+        out.withUnsafeBufferPointer { pointer.update(from: $0.baseAddress!, count: out.count) }
+        return (pointer, out.count / 8)
+    }
+
+    // MARK: Events
+
+    /// The index `setParameter(at:_:)` takes for a parameter's name: look it up off the audio thread.
+    public func parameterIndex(_ name: String) -> Int? {
+        parameterIndices[name]
+    }
+
+    /// A parameter, clamped to its range; it glides there over about 20 ms.
+    public func setParameter(at index: Int, _ value: Float) {
+        guard index >= 0, index < parameterRegisters.count, value.isFinite else { return }
+        targets[index] = Swift.min(Swift.max(value, parameterRanges[index].min), parameterRanges[index].max)
+    }
+
+    /// MIDI note on: `velocity` 1 … 127 (0 is a note off).
+    public func noteOn(_ note: Int32, velocity: Int32) {
+        if velocity <= 0 {
+            noteOff(note)
+            return
+        }
+        let voices = program.voices
+        var lane = -1
+        for l in 0..<voices where lane < 0 && laneNote[l] == note && laneGate[l] > 0.5 { lane = l }
+        var fresh = false
+        if lane < 0 {
+            for l in 0..<voices where lane < 0 && laneActive[l] == 0 { lane = l }
+            fresh = lane >= 0
+        }
+        if lane < 0 {
+            // Steal: the oldest released voice, else the oldest.
+            var best = -1
+            for l in 0..<voices where laneGate[l] <= 0.5 && !laneHeld[l] && (best < 0 || laneAge[l] < laneAge[best]) { best = l }
+            if best < 0 { for l in 0..<voices where best < 0 || laneAge[l] < laneAge[best] { best = l } }
+            lane = best
+            fresh = true
+        }
+        if fresh { resetLane(lane) }
+        laneNote[lane] = note
+        laneGate[lane] = 1
+        laneHeld[lane] = false
+        laneVelocity[lane] = Float(Double(Swift.min(127, velocity)) / 127)
+        laneActive[lane] = 1
+        trigger[lane] += 1
+        age += 1
+        laneAge[lane] = age
+    }
+
+    public func noteOff(_ note: Int32) {
+        for l in 0..<program.voices where laneNote[l] == note && laneGate[l] > 0.5 {
+            // Under the pedal the gate stays up until it lifts.
+            if pedal { laneHeld[l] = true } else { laneGate[l] = 0 }
+        }
+    }
+
+    /// 64 the sustain pedal, 120 all sound off, 123 all notes off.
+    public func controller(_ number: Int32, value: Int32) {
+        let L = Self.lanes
+        switch number {
+        case 64:
+            pedal = value >= 64
+            if !pedal {
+                for l in 0..<L where laneHeld[l] { laneGate[l] = 0 }
+                laneHeld.update(repeating: false, count: L)
+            }
+        case 123:
+            laneGate.update(repeating: 0, count: L)
+            laneHeld.update(repeating: false, count: L)
+        case 120:
+            for l in 0..<L {
+                laneGate[l] = 0
+                laneHeld[l] = false
+                laneActive[l] = 0
+                resetLane(l)
+            }
+        default:
+            break
+        }
+    }
+
+    /// The pitch wheel, 0 … 16383, 8192 centered: ±2 semitones.
+    public func pitchBend(_ value: Int32) {
+        bend = Double(Swift.min(16383, Swift.max(0, value)) - 8192) / 8192 * 2
+    }
+
+    /// Silences every voice at once.
+    public func reset() {
+        controller(120, value: 0)
+    }
+
+    /// How many voices sound now.
+    public var sounding: Int {
+        (0..<Self.lanes).reduce(0) { $0 + (laneActive[$1] != 0 ? 1 : 0) }
+    }
+
+    // MARK: Rendering
+
+    /// Writes `frames` mono frames to `out`, in blocks of up to 128.
+    public func render(into out: UnsafeMutablePointer<Float>, frames: Int) {
+        var done = 0
+        while done < frames {
+            let n = Swift.min(DSPProgram.blockFrames, frames - done)
+            block(out + done, n)
+            done += n
+        }
+    }
+
+    private func resetLane(_ l: Int) {
+        let L = Self.lanes
+        for entry in program.state { registers[entry.register * L + l] = entry.initial }
+        for (i, kind) in instanceKinds.enumerated() {
+            let base = instanceOffsets[i] + l
+            if kind == .noise {
+                let seed = UInt32(truncatingIfNeeded: i + 1) &* 2_654_435_761 &+ UInt32(truncatingIfNeeded: l + 1) &* 2_246_822_519
+                noise[base] = seed == 0 ? 1 : seed
+                continue
+            }
+            for w in 0..<kind.words { state[base + w * L] = 0 }
+            if kind == .adsr {
+                state[base + 4 * L] = .nan
+                state[base + 6 * L] = .nan
+            } else if kind.words == 8 {
+                state[base + 2 * L] = .nan
+            }
+        }
+    }
+
+    private func block(_ out: UnsafeMutablePointer<Float>, _ n: Int) {
+        let L = Self.lanes
+        let R = registers
+        let sr = sampleRate
+        // Parameters glide toward their targets, about 20 ms.
+        let alpha = snapped ? Float(1) : 1 - exp(-Float(n) / (0.02 * sr))
+        snapped = false
+        for (i, register) in parameterRegisters.enumerated() {
+            let at = R + register * L
+            at.update(repeating: at[0] + (targets[i] - at[0]) * alpha, count: L)
+        }
+        var any = false
+        for l in 0..<L where laneActive[l] != 0 { any = true }
+        guard any else {
+            out.update(repeating: 0, count: n)
+            return
+        }
+        for l in 0..<L {
+            let note = laneNote[l]
+            R[1 * L + l] = note >= 0 ? Float(440 * Foundation.pow(2, (Double(note) - 69 + bend) / 12)) : 0
+            R[2 * L + l] = laneGate[l]
+            R[3 * L + l] = laneVelocity[l]
+            R[4 * L + l] = note >= 0 ? Float(note) : 0
+        }
+        run(blockCode, blockCount)
+        let o = R + program.output * L
+        var check: Float = 0
+        for i in 0..<n {
+            run(sampleCode, sampleCount)
+            var sum: Float = 0
+            for l in 0..<L { sum += o[l] * laneActive[l] }
+            out[i] = sum
+            check += sum
+        }
+        guard check.isFinite else {
+            // A voice went to infinity or NaN: silence the block and start every voice over.
+            out.update(repeating: 0, count: n)
+            for l in 0..<L {
+                laneActive[l] = 0
+                laneGate[l] = 0
+                laneHeld[l] = false
+                resetLane(l)
+            }
+            return
+        }
+        // Denormals in the filters' integrators would slow every frame after.
+        for offset in filterOffsets {
+            for k in offset..<(offset + 2 * L) where Swift.abs(state[k]) < 1e-20 { state[k] = 0 }
+        }
+        // A released voice sounds until its envelopes finish.
+        for l in 0..<L where laneActive[l] != 0 && laneGate[l] <= 0.5 && !laneHeld[l] {
+            var sounding = false
+            for offset in envelopeOffsets where state[offset + l] != 0 { sounding = true }
+            if !sounding { laneActive[l] = 0 }
+        }
+    }
+
+    @inline(__always)
+    private static func blep(_ t: Float, _ dt: Float) -> Float {
+        if t < dt {
+            let x = t / dt
+            return x + x - x * x - 1
+        }
+        if t > 1 - dt {
+            let x = (t - 1) / dt
+            return x * x + x + x + 1
+        }
+        return 0
+    }
+
+    // The interpreter: one instruction at a time, every lane per instruction.
+    private func run(_ code: UnsafeMutablePointer<Int32>, _ count: Int) {
+        let L = Self.lanes
+        let R = registers
+        let S = state
+        let N = noise
+        let sr = sampleRate
+        var at = 0
+        let end = count * 8
+        while at < end {
+            let op = code[at]
+            let d = R + Int(code[at + 1])
+            let a = R + Int(code[at + 2])
+            let b = R + Int(code[at + 3])
+            let c = R + Int(code[at + 4])
+            switch op {
+            case 0: for l in 0..<L { d[l] = a[l] }
+            case 1: for l in 0..<L { d[l] = a[l] + b[l] }
+            case 2: for l in 0..<L { d[l] = a[l] - b[l] }
+            case 3: for l in 0..<L { d[l] = a[l] * b[l] }
+            case 4: for l in 0..<L { d[l] = a[l] / b[l] }
+            case 5: for l in 0..<L { d[l] = a[l].truncatingRemainder(dividingBy: b[l]) }
+            case 6: for l in 0..<L { d[l] = -a[l] }
+            case 7: for l in 0..<L { d[l] = Swift.min(a[l], b[l]) }
+            case 8: for l in 0..<L { d[l] = Swift.max(a[l], b[l]) }
+            case 9: for l in 0..<L { d[l] = Swift.abs(a[l]) }
+            case 10: for l in 0..<L { d[l] = a[l].rounded(.down) }
+            case 11: for l in 0..<L { d[l] = a[l].rounded(.up) }
+            case 12: for l in 0..<L { d[l] = (a[l] + 0.5).rounded(.down) }
+            case 13: for l in 0..<L { d[l] = a[l].squareRoot() }
+            case 14: for l in 0..<L { d[l] = Foundation.sin(a[l]) }
+            case 15: for l in 0..<L { d[l] = Foundation.cos(a[l]) }
+            case 16: for l in 0..<L { d[l] = Foundation.tan(a[l]) }
+            case 17: for l in 0..<L { d[l] = Foundation.exp(a[l]) }
+            case 18: for l in 0..<L { d[l] = Foundation.log(a[l]) }
+            case 19: for l in 0..<L { d[l] = Foundation.pow(a[l], b[l]) }
+            case 20: for l in 0..<L { d[l] = Foundation.tanh(a[l]) }
+            case 21: for l in 0..<L { d[l] = a[l] < b[l] ? 1 : 0 }
+            case 22: for l in 0..<L { d[l] = a[l] <= b[l] ? 1 : 0 }
+            case 23: for l in 0..<L { d[l] = a[l] > b[l] ? 1 : 0 }
+            case 24: for l in 0..<L { d[l] = a[l] >= b[l] ? 1 : 0 }
+            case 25: for l in 0..<L { d[l] = a[l] == b[l] ? 1 : 0 }
+            case 26: for l in 0..<L { d[l] = a[l] != b[l] ? 1 : 0 }
+            case 27: for l in 0..<L { d[l] = a[l] != 0 && b[l] != 0 ? 1 : 0 }
+            case 28: for l in 0..<L { d[l] = a[l] != 0 || b[l] != 0 ? 1 : 0 }
+            case 29: for l in 0..<L { d[l] = a[l] == 0 ? 1 : 0 }
+            case 30: for l in 0..<L { d[l] = a[l] != 0 ? b[l] : c[l] }
+            case 31: for l in 0..<L { d[l] = Swift.min(Swift.max(a[l], b[l]), c[l]) }
+            case 32: for l in 0..<L { d[l] = a[l] + (b[l] - a[l]) * c[l] }
+            case 33: for l in 0..<L { d[l] = a[l] - a[l].rounded(.down) }
+            case 34: for l in 0..<L { d[l] = a[l] > 0 ? 1 : a[l] < 0 ? -1 : 0 }
+            case 35: for l in 0..<L { d[l] = Foundation.atan(a[l]) }
+            case 40, 41, 42, 43, 44:
+                // Oscillators: the output from the phase now, then the phase steps by freq / sampleRate.
+                let s = S + Int(code[at + 7])
+                for l in 0..<L {
+                    let p = s[l]
+                    let dt = a[l] / sr
+                    var v: Float
+                    switch op {
+                    case 40: v = p
+                    case 41: v = Foundation.sin(2 * Float.pi * p)
+                    case 42:
+                        v = 2 * p - 1
+                        if dt > 0 { v -= Self.blep(p, dt) }
+                    case 43:
+                        let w = Swift.min(Swift.max(b[l], 0), 1)
+                        v = p < w ? 1 : -1
+                        if dt > 0 {
+                            let q = p + 1 - w
+                            v += Self.blep(p, dt) - Self.blep(q - q.rounded(.down), dt)
+                        }
+                    default: v = 1 - 4 * Swift.abs(p - 0.5)
+                    }
+                    d[l] = v
+                    let next = p + dt
+                    s[l] = next - next.rounded(.down)
+                }
+            case 45:
+                let s = N + Int(code[at + 7])
+                for l in 0..<L {
+                    var x = s[l]
+                    x ^= x << 13
+                    x ^= x >> 17
+                    x ^= x << 5
+                    s[l] = x
+                    d[l] = Float(Double(x) / 4_294_967_296 * 2 - 1)
+                }
+            case 46:
+                // adsr(gate, attack, decay, sustain, release): stage, level, trigger, gate before, decay time and coefficient, release time and coefficient.
+                let s = S + Int(code[at + 7])
+                let sustainIn = R + Int(code[at + 5])
+                let releaseIn = R + Int(code[at + 6])
+                for l in 0..<L {
+                    let gate = a[l]
+                    var stage = s[l]
+                    var level = s[L + l]
+                    if s[2 * L + l] != trigger[l] {
+                        s[2 * L + l] = trigger[l]
+                        if gate > 0.5 { stage = 1 }
+                    } else if gate > 0.5 && s[3 * L + l] <= 0.5 {
+                        stage = 1
+                    }
+                    if gate <= 0.5 && stage >= 1 && stage <= 3 { stage = 4 }
+                    s[3 * L + l] = gate
+                    let sustain = Swift.min(Swift.max(sustainIn[l], 0), 1)
+                    if stage == 1 {
+                        level += 1 / Swift.max(1, b[l] * sr)
+                        if level >= 1 {
+                            level = 1
+                            stage = 2
+                        }
+                    } else if stage == 2 {
+                        let time = c[l]
+                        if !(s[4 * L + l] == time) {
+                            s[4 * L + l] = time
+                            s[5 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                        }
+                        level = sustain + (level - sustain) * s[5 * L + l]
+                        if level - sustain < 0.0001 { stage = 3 }
+                    } else if stage == 3 {
+                        level = sustain
+                    } else if stage == 4 {
+                        let time = releaseIn[l]
+                        if !(s[6 * L + l] == time) {
+                            s[6 * L + l] = time
+                            s[7 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                        }
+                        level *= s[7 * L + l]
+                        if level < 0.0001 {
+                            level = 0
+                            stage = 0
+                        }
+                    } else {
+                        level = 0
+                    }
+                    s[l] = stage
+                    s[L + l] = level
+                    d[l] = level
+                }
+            case 47, 48, 49:
+                // A state-variable filter (Simper's form): resonance 0 … 1.
+                let s = S + Int(code[at + 7])
+                for l in 0..<L {
+                    let cutoff = Swift.min(Swift.max(b[l], 10), 0.49 * sr)
+                    let resonance = Swift.min(Swift.max(c[l], 0), 0.98)
+                    if !(s[2 * L + l] == cutoff && s[3 * L + l] == resonance) {
+                        s[2 * L + l] = cutoff
+                        s[3 * L + l] = resonance
+                        let g = Foundation.tan(Float.pi * cutoff / sr)
+                        let k = 2 - 2 * resonance
+                        let a1 = 1 / (1 + g * (g + k))
+                        s[4 * L + l] = a1
+                        s[5 * L + l] = g * a1
+                        s[6 * L + l] = g * g * a1
+                        s[7 * L + l] = k
+                    }
+                    let a1 = s[4 * L + l]
+                    let a2 = s[5 * L + l]
+                    let a3 = s[6 * L + l]
+                    let ic1 = s[l]
+                    let ic2 = s[L + l]
+                    let x = a[l]
+                    let v3 = x - ic2
+                    let v1 = a1 * ic1 + a2 * v3
+                    let v2 = ic2 + a2 * ic1 + a3 * v3
+                    s[l] = 2 * v1 - ic1
+                    s[L + l] = 2 * v2 - ic2
+                    d[l] = op == 47 ? v2 : op == 49 ? v1 : x - s[7 * L + l] * v1 - v2
+                }
+            default:
+                break
+            }
+            at += 8
+        }
+    }
+}