@swiftbrowser/native 0.19.0 → 0.21.0

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