@swiftbrowser/native 0.19.0 → 0.23.0

package/swift/Packages/SwiftBrowserDSP/Sources/SwiftBrowserDSP/ProgramNode.swift

@@ -18,9 +18,11 @@ import SwiftBrowserProtocol
 /// ```
 @MainActor
 public enum SwiftBrowserDSP {
-    /// Registers the `program` kind with SwiftBrowserNative's audio engine; call at launch, before the bundle loads.
+    /// Registers the `program` kind with SwiftBrowserNative's audio engine, and `ScopeView`'s SwiftUI view; call at
+    /// launch, before the bundle loads.
     public static func install() {
         AudioEngineNodes.register("program") { context in ProgramNode(format: context.format) }
+        ViewRegistry.register("SwiftBrowserDSP.scope") { context in DSPScopeView(props: context.props) }
     }
 }
 
@@ -37,6 +39,8 @@ final class ProgramNode: AudioEngineCustomNode {
     private var program: DSPProgram?
     /// Every parameter the app set, by name: a program loaded later takes the values it has names for.
     private var values: [String: Float] = [:]
+    /// The transport's tempo as last set, for a program loaded later.
+    private var tempo: Double = 120
 
     init(format: AVAudioFormat) {
         sampleRate = format.sampleRate
@@ -50,13 +54,15 @@ final class ProgramNode: AudioEngineCustomNode {
             let buffers = UnsafeMutableAudioBufferListPointer(list)
             guard let first = buffers.first?.mData?.assumingMemoryBound(to: Float.self) else { return noErr }
             let count = Int(frames)
-            if !renderer.render(into: first, frames: count) {
+            // Two channels or more: the left side, then the right; one: their average.
+            let second = buffers.count > 1 ? buffers[1].mData?.assumingMemoryBound(to: Float.self) : nil
+            if !renderer.render(into: first, right: second, frames: count) {
                 silence.pointee = true
                 for buffer in buffers { buffer.mData?.initializeMemory(as: Float.self, repeating: 0, count: count) }
                 return noErr
             }
-            for buffer in buffers.dropFirst() {
-                buffer.mData?.assumingMemoryBound(to: Float.self).update(from: first, count: count)
+            for buffer in buffers.dropFirst(2) {
+                buffer.mData?.initializeMemory(as: Float.self, repeating: 0, count: count)
             }
             return noErr
         }
@@ -64,6 +70,12 @@ final class ProgramNode: AudioEngineCustomNode {
 
     func set(_ key: String, _ value: JSONValue) throws -> Bool {
         defer { renderer.collect() }
+        if key == "view" {
+            // What a view finds the node's frames by.
+            guard let token = value.string else { throw ProgramNodeError("unsupported: view takes a string") }
+            ScopeTaps.register(token, renderer.tap)
+            return true
+        }
         if key == "program" {
             guard let json = value.string else { throw DSPProgramError("a program crosses as JSON") }
             let program = try DSPProgram(json: json)
@@ -72,10 +84,51 @@ final class ProgramNode: AudioEngineCustomNode {
             for (name, value) in values {
                 if let index = machine.parameterIndex(name) { machine.setParameter(at: index, value) }
             }
+            machine.setTempo(tempo)
             self.program = program
             renderer.replace(machine)
             return true
         }
+        if key == "tempo" || key == "beat" {
+            guard let number = value.double else { throw ProgramNodeError("unsupported: \(key) takes a number") }
+            if key == "tempo" {
+                tempo = number
+                renderer.send(.tempo(number))
+            } else {
+                renderer.send(.seek(number))
+            }
+            return true
+        }
+        if key.hasPrefix("table.") || key.hasPrefix("shape.") || key.hasPrefix("sample.") {
+            // Data replaced by name (DSPNode `setTable` …): made ready here, off the audio thread, then swapped in.
+            guard let json = value.string, let data = json.data(using: .utf8), let object = try? JSONSerialization.jsonObject(with: data) else {
+                throw ProgramNodeError("unsupported: \(key) crosses as JSON")
+            }
+            let name = String(key[key.index(after: key.firstIndex(of: ".")!)...])
+            func floats(_ value: Any?) -> [Float] { (value as? [NSNumber] ?? []).map(\.floatValue) }
+            if key.hasPrefix("table."), let index = program?.tables.firstIndex(where: { $0.name == name }) {
+                let table = object as? [String: Any] ?? [:]
+                let frames = (table["frames"] as? [Any] ?? []).map { floats($0) }
+                let cosines = (table["cosines"] as? [Any])?.map { floats($0) }
+                renderer.send(.table(Int32(index), DSPMachine.tableLevels(frames: frames, cosines: cosines), Int32(frames.count)))
+            } else if key.hasPrefix("shape."), let index = program?.shapes.firstIndex(where: { $0.name == name }) {
+                renderer.send(.shape(Int32(index), DSPBuffer(floats(object))))
+            } else if key.hasPrefix("sample."), let index = program?.samples.firstIndex(where: { $0.name == name }) {
+                let sample = object as? [String: Any] ?? [:]
+                let bytes = Data(base64Encoded: sample["data"] as? String ?? "") ?? Data()
+                var audio = [Float](repeating: 0, count: bytes.count / 4)
+                _ = audio.withUnsafeMutableBytes { bytes.copyBytes(to: $0) }
+                renderer.send(.sample(Int32(index), DSPBuffer(audio), (sample["rate"] as? NSNumber)?.doubleValue ?? 44100))
+            }
+            return true
+        }
+        if key.hasPrefix("routes.") {
+            // A route list replaced (DSPNode `setRoutes`): its registers, copied in by the machine.
+            guard let json = value.string, let data = json.data(using: .utf8), let list = (try? JSONSerialization.jsonObject(with: data)) as? [NSNumber],
+                  let index = Int32(key.dropFirst(7)) else { throw ProgramNodeError("unsupported: \(key) crosses as JSON") }
+            renderer.send(.routes(index, DSPBuffer(list.map(\.floatValue))))
+            return true
+        }
         if key.hasPrefix("param.") {
             guard let number = value.double else { throw ProgramNodeError("unsupported: \(key) takes a number") }
             let name = String(key.dropFirst(6))
@@ -91,11 +144,13 @@ final class ProgramNode: AudioEngineCustomNode {
     func note(_ action: String, _ params: JSONObject) throws -> Bool {
         defer { renderer.collect() }
         let int = { (key: String) in Int32(truncatingIfNeeded: params.int(key) ?? 0) }
+        // When on the program's transport, for a command that says.
+        let beat = params.double("beat")
         switch action {
-        case "startNote": renderer.send(.noteOn(int("note"), int("velocity")))
-        case "stopNote": renderer.send(.noteOff(int("note")))
-        case "controller": renderer.send(.controller(int("controller"), int("value")))
-        case "pitchBend": renderer.send(.pitchBend(Int32(truncatingIfNeeded: params.int("value") ?? 8192)))
+        case "startNote": renderer.send(.noteOn(int("note"), int("velocity"), beat))
+        case "stopNote": renderer.send(.noteOff(int("note"), beat))
+        case "controller": renderer.send(.controller(int("controller"), int("value"), beat))
+        case "pitchBend": renderer.send(.pitchBend(Int32(truncatingIfNeeded: params.int("value") ?? 8192), beat))
         default: return false
         }
         return true
@@ -115,11 +170,19 @@ struct ProgramNodeError: Error, CustomStringConvertible {
 
 /// What the main actor sends the audio thread.
 enum ProgramEvent: Sendable {
-    case noteOn(Int32, Int32)
-    case noteOff(Int32)
-    case controller(Int32, Int32)
-    case pitchBend(Int32)
+    case noteOn(Int32, Int32, Double?)
+    case noteOff(Int32, Double?)
+    case controller(Int32, Int32, Double?)
+    case pitchBend(Int32, Double?)
     case parameter(Int32, Float)
+    /// Data replaced (a table's samples and frames, a shape's points, a sample's audio and rate), made off the audio
+    /// thread; once swapped in, the buffer holds what the machine let go of, freed back off the audio thread.
+    case table(Int32, DSPBuffer, Int32)
+    case shape(Int32, DSPBuffer)
+    case sample(Int32, DSPBuffer, Double)
+    case routes(Int32, DSPBuffer)
+    case tempo(Double)
+    case seek(Double)
     case reset
 }
 
@@ -134,16 +197,26 @@ final class Renderer: @unchecked Sendable {
         var events: [ProgramEvent] = []
         var machine: DSPMachine?
         var retired: DSPMachine?
+        /// Buffers the audio thread swapped out, for the main actor to free.
+        var spent: [DSPBuffer] = []
     }
 
     private let lock = OSAllocatedUnfairLock(initialState: Shared())
+    /// The frames rendered last, for views.
+    let tap = ScopeTap()
     // The audio thread's own.
     private var machine: DSPMachine?
     private var inbox: [ProgramEvent] = []
+    /// Buffers swapped out since the lock was last free, waiting to go to `Shared.spent`.
+    private var spent: [DSPBuffer] = []
 
     init() {
         inbox.reserveCapacity(256)
-        lock.withLockUnchecked { $0.events.reserveCapacity(256) }
+        spent.reserveCapacity(64)
+        lock.withLockUnchecked {
+            $0.events.reserveCapacity(256)
+            $0.spent.reserveCapacity(64)
+        }
     }
 
     func send(_ event: ProgramEvent) {
@@ -164,22 +237,29 @@ final class Renderer: @unchecked Sendable {
 
     /// Releases, on the caller's thread, a machine the audio thread let go of.
     func collect() {
-        let retired = lock.withLockUnchecked { shared -> DSPMachine? in
-            defer { shared.retired = nil }
-            return shared.retired
+        let (retired, spent) = lock.withLockUnchecked { shared -> (DSPMachine?, [DSPBuffer]) in
+            defer {
+                shared.retired = nil
+                shared.spent.removeAll(keepingCapacity: true)
+            }
+            return (shared.retired, shared.spent)
         }
-        _ = retired
+        _ = (retired, spent)
     }
 
-    /// The audio thread: false when there is no program yet (silence).
-    func render(into out: UnsafeMutablePointer<Float>, frames: Int) -> Bool {
+    /// The audio thread: false when there is no program yet (silence). With `right`, the left side into `out`.
+    func render(into out: UnsafeMutablePointer<Float>, right: UnsafeMutablePointer<Float>? = nil, frames: Int) -> Bool {
         _ = lock.withLockIfAvailableUnchecked { shared in
             if let next = shared.machine, shared.retired == nil {
+                // The transport carries on through a new program.
+                if let machine { next.seek(toBeat: machine.position) }
                 shared.retired = machine
                 machine = next
                 shared.machine = nil
             }
             swap(&shared.events, &inbox)
+            // What was swapped out, for the main actor to free (when it has taken the last).
+            if shared.spent.isEmpty && !spent.isEmpty { swap(&shared.spent, &spent) }
         }
         guard let machine else {
             inbox.removeAll(keepingCapacity: true)
@@ -187,17 +267,98 @@ final class Renderer: @unchecked Sendable {
         }
         for event in inbox {
             switch event {
-            case let .noteOn(note, velocity): machine.noteOn(note, velocity: velocity)
-            case let .noteOff(note): machine.noteOff(note)
-            case let .controller(number, value): machine.controller(number, value: value)
-            case let .pitchBend(value): machine.pitchBend(value)
+            case let .noteOn(note, velocity, beat): machine.noteOn(note, velocity: velocity, atBeat: beat)
+            case let .noteOff(note, beat): machine.noteOff(note, atBeat: beat)
+            case let .controller(number, value, beat): machine.controller(number, value: value, atBeat: beat)
+            case let .pitchBend(value, beat): machine.pitchBend(value, atBeat: beat)
             case let .parameter(index, value): machine.setParameter(at: Int(index), value)
+            case let .table(index, levels, frames):
+                if machine.replaceTable(Int(index), levels: levels, frames: Int(frames)) { spent.append(levels) }
+            case let .shape(index, points):
+                if machine.replaceShape(Int(index), points: points) { spent.append(points) }
+            case let .sample(index, audio, rate):
+                if machine.replaceSample(Int(index), audio: audio, rate: rate) { spent.append(audio) }
+            case let .routes(index, list):
+                _ = machine.replaceRoutes(Int(index), registers: list)
+                spent.append(list)
+            case let .tempo(bpm): machine.setTempo(bpm)
+            case let .seek(beat): machine.seek(toBeat: beat)
             case .reset: machine.reset()
             }
         }
         inbox.removeAll(keepingCapacity: true)
-        machine.render(into: out, frames: frames)
+        if let right {
+            machine.render(left: out, right: right, frames: frames)
+        } else {
+            machine.render(into: out, frames: frames)
+        }
+        tap.write(out, right, frames: frames)
         return true
     }
 }
+
+/// A node's last 2048 frames, its two sides mixed, for views (`DSPScopeView`): the audio thread writes them when the
+/// lock is free (never waiting, and a frame a view misses is only a frame), a view copies the newest out.
+final class ScopeTap: @unchecked Sendable {
+    static let capacity = 2048
+    /// Frames written so far; the samples are only touched under it.
+    private let lock = OSAllocatedUnfairLock(initialState: 0)
+    private let samples: UnsafeMutablePointer<Float>
+
+    init() {
+        samples = .allocate(capacity: Self.capacity)
+        samples.initialize(repeating: 0, count: Self.capacity)
+    }
+
+    deinit {
+        samples.deallocate()
+    }
+
+    /// The audio thread.
+    func write(_ left: UnsafePointer<Float>, _ right: UnsafePointer<Float>?, frames: Int) {
+        let samples = samples
+        _ = lock.withLockIfAvailableUnchecked { written in
+            let mask = Self.capacity - 1
+            if let right {
+                for i in 0..<frames { samples[(written + i) & mask] = (left[i] + right[i]) * 0.5 }
+            } else {
+                for i in 0..<frames { samples[(written + i) & mask] = left[i] }
+            }
+            written += frames
+        }
+    }
+
+    /// The newest `buffer.count` frames (at most 2048), oldest first.
+    func read(into buffer: inout [Float]) {
+        let count = Swift.min(buffer.count, Self.capacity)
+        let samples = samples
+        buffer.withUnsafeMutableBufferPointer { out in
+            lock.withLockUnchecked { written in
+                let mask = Self.capacity - 1
+                for i in 0..<count { out[i] = samples[(written - count + i) & mask] }
+            }
+        }
+    }
+}
+
+/// The program nodes' taps by view token, for views made before or after the node.
+enum ScopeTaps {
+    private struct Weak {
+        weak var tap: ScopeTap?
+    }
+
+    private static let lock = OSAllocatedUnfairLock(initialState: [String: Weak]())
+
+    static func register(_ token: String, _ tap: ScopeTap) {
+        lock.withLockUnchecked { taps in
+            taps = taps.filter { $0.value.tap != nil }
+            taps[token] = Weak(tap: tap)
+        }
+    }
+
+    static func tap(_ token: String) -> ScopeTap? {
+        lock.withLockUnchecked { $0[token]?.tap }
+    }
+}
 #endif
+

package/swift/Packages/SwiftBrowserDSP/Sources/SwiftBrowserDSP/ScopeView.swift

@@ -0,0 +1,79 @@
+#if canImport(AVFoundation) && canImport(SwiftUI)
+import SwiftBrowserProtocol
+import SwiftUI
+
+/// `ScopeView` (@swiftbrowser/dsp): a program node's output as a waveform,
+/// drawn every display frame from what the audio thread keeps for it
+/// (`ScopeTap`), its frames never crossing to the app's JavaScript. The
+/// trace starts at a rising zero crossing, so a steady tone stands still;
+/// it is the page's canvas (packages/dsp/src/scope.ts), step for step.
+struct DSPScopeView: View {
+    let token: String
+    let color: Color
+    let gain: Float
+    @State private var reader = ScopeReader()
+
+    init(props: JSONValue) {
+        token = props["view"].string ?? ""
+        gain = Float(props["gain"].double ?? 1)
+        color = props["color"].string.flatMap(Self.color(hex:)) ?? .accentColor
+    }
+
+    var body: some View {
+        TimelineView(.animation) { timeline in
+            // The tick's date is the trace's own input: SwiftUI draws a view again only when its inputs change, and
+            // a canvas that read nothing from the timeline was drawn once and left.
+            ScopeTrace(date: timeline.date, token: token, color: color, gain: gain, reader: reader)
+        }
+    }
+
+    /// The first rising zero crossing in the first half (scope.ts `traceStart`).
+    static func traceStart(_ samples: [Float], _ length: Int) -> Int {
+        let last = Swift.max(1, samples.count - length)
+        for i in 1..<last where samples[i - 1] < 0 && samples[i] >= 0 { return i }
+        return 0
+    }
+
+    /// `#rrggbb`.
+    static func color(hex: String) -> Color? {
+        let digits = hex.hasPrefix("#") ? String(hex.dropFirst()) : hex
+        guard digits.count == 6, let value = UInt32(digits, radix: 16) else { return nil }
+        return Color(red: Double((value >> 16) & 0xFF) / 255, green: Double((value >> 8) & 0xFF) / 255, blue: Double(value & 0xFF) / 255)
+    }
+}
+
+/// One display frame's trace: what the tap holds at `date`.
+private struct ScopeTrace: View {
+    let date: Date
+    let token: String
+    let color: Color
+    let gain: Float
+    let reader: ScopeReader
+
+    var body: some View {
+        Canvas { context, size in
+            let samples = reader.read(ScopeTaps.tap(token))
+            let length = samples.count / 2
+            let start = DSPScopeView.traceStart(samples, length)
+            var path = Path()
+            for i in 0..<length {
+                let x = CGFloat(i) / CGFloat(length - 1) * size.width
+                let value = Swift.max(-1, Swift.min(1, samples[start + i] * gain))
+                let y = size.height / 2 - CGFloat(value) * size.height / 2
+                if i == 0 { path.move(to: CGPoint(x: x, y: y)) } else { path.addLine(to: CGPoint(x: x, y: y)) }
+            }
+            context.stroke(path, with: .color(color), style: StrokeStyle(lineWidth: 1.5, lineJoin: .round))
+        }
+    }
+}
+
+/// The view's copy of the newest frames, made again each display frame.
+final class ScopeReader {
+    private var samples = [Float](repeating: 0, count: 1024)
+
+    func read(_ tap: ScopeTap?) -> [Float] {
+        tap?.read(into: &samples)
+        return samples
+    }
+}
+#endif