feat(apple): gamepad UI v2 — controller settings + add host, aurora, macOS

Sources reorganized (client: Home/Session/Settings/Stores/Support/Trust; kit: Audio/Connection/Gamepad/Input/Support/Video/Views) with the big files split along the same seams. The gamepad mode is couch-complete, and now on macOS too (the living-room Mac case), not just iOS/iPadOS: - GamepadSettingsView: a console-style, fully controller-navigable settings screen (X from the launcher) — up/down moves focus, left/right steps values (clamped, boundary thud), A cycles/toggles, B closes; the focused row shows a one-line description. Backed by GamepadMenuList, the vertical sibling of GamepadCarousel, and SettingsOptions — the option lists hoisted out of SettingsView statics and shared by the touch, tvOS and gamepad settings. - GamepadAddHostView + GamepadKeyboard: register a host end to end with a pad — field rows open an on-screen controller keyboard (dpad grid, A types, X backspaces, B done); the launcher carousel ends in an Add Host tile, so the dead-end "add one with touch first" empty state is gone. - Launcher polish: contextual hint bar with the pad's real button glyphs, controller name + battery chip, one shared console chrome. - GamepadScreenBackground: an animated aurora (TimelineView-driven drifting blobs in the brand's violet family, breathing radii, slow hue shift, legibility scrim; freezes under Reduce Motion). Pure SwiftUI on purpose — a .metal library only bundles reliably in one of the two build systems (SPM vs the xcodeproj's synced folders) these sources compile under. - macOS port: settings/add-host/library present as sized sheets (a macOS sheet takes its content's IDEAL size, and the GeometryReader-driven screens collapsed to nothing), NSScreen-based mode lists, scroll indicators .never (the "always show scroll bars" setting overrides .hidden), tray scrims so scrolled rows dim under the pinned title/hints, extra title clearance, and a PUNKTFUNK_FORCE_GAMEPAD_UI=1 dev hook — launcher/settings/add-host/keyboard/ library render-verified live on a real Mac + LAN hosts. - GamepadMenuInput: X button support, and (re)start now snapshots held buttons so a controller handoff press never fires twice (the B that closed the keyboard no longer also cancels the screen underneath). - Cleanups: one "Connection failed" alert in ContentView instead of one per home screen; HostDiscovery.advertises/unsaved shared by both home screens. - host: can_encode_444 stub for the non-Linux/Windows host build (the macOS synthetic-source loopback used by the Swift tests). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:05:10 +02:00
parent e925d00194
commit 133e25849d
84 changed files with 4231 additions and 2698 deletions
@@ -0,0 +1,140 @@
+// Opus ⇄ PCM through CoreAudio's built-in codec (kAudioFormatOpus, macOS 10.13+ / iOS
+// 11+) — no bundled libopus. The host's audio plane is raw Opus packets (48 kHz stereo,
+// one frame per packet); AVAudioConverter handles them as single-packet
+// AVAudioCompressedBuffers with explicit packet descriptions.
+//
+// Both classes are single-threaded by contract (one per direction, owned by their
+// drain/capture pipelines).
+
+import AVFoundation
+
+enum OpusCodecError: Error {
+    /// CoreAudio rejected the Opus stream format or had no converter for it.
+    case unavailable
+    case convertFailed(String)
+}
+
+/// 48 kHz stereo float32 interleaved — the PCM side of both converters and the layout
+/// of the playback ring buffer.
+func opusPCMFormat() -> AVAudioFormat? {
+    AVAudioFormat(
+        commonFormat: .pcmFormatFloat32, sampleRate: 48_000, channels: 2, interleaved: true)
+}
+
+/// The compressed side: raw Opus, `framesPerPacket` nominal samples per packet at 48 kHz
+/// (240 = the host's 5 ms audio plane; 960 = the 20 ms packets the encoder emits).
+private func opusFormat(framesPerPacket: UInt32) -> AVAudioFormat? {
+    var desc = AudioStreamBasicDescription(
+        mSampleRate: 48_000,
+        mFormatID: kAudioFormatOpus,
+        mFormatFlags: 0,
+        mBytesPerPacket: 0,
+        mFramesPerPacket: framesPerPacket,
+        mBytesPerFrame: 0,
+        mChannelsPerFrame: 2,
+        mBitsPerChannel: 0,
+        mReserved: 0)
+    return AVAudioFormat(streamDescription: &desc)
+}
+
+final class OpusDecoder {
+    private let converter: AVAudioConverter
+    private let inBuf: AVAudioCompressedBuffer
+    private let opus: AVAudioFormat
+    let pcmFormat: AVAudioFormat
+
+    /// `framesPerPacket`: the sender's packet duration in samples (host audio = 240).
+    init(framesPerPacket: UInt32) throws {
+        guard let pcm = opusPCMFormat(), let opus = opusFormat(framesPerPacket: framesPerPacket),
+              let converter = AVAudioConverter(from: opus, to: pcm)
+        else { throw OpusCodecError.unavailable }
+        self.converter = converter
+        self.opus = opus
+        self.pcmFormat = pcm
+        inBuf = AVAudioCompressedBuffer(
+            format: opus, packetCapacity: 1, maximumPacketSize: 1500)
+    }
+
+    /// Decode one Opus packet into `out` (whose format must be `pcmFormat`); returns the
+    /// number of frames written. Empty packets (DTX) decode to 0 frames.
+    func decode(_ packet: Data, into out: AVAudioPCMBuffer) throws -> AVAudioFrameCount {
+        guard !packet.isEmpty else { return 0 }
+        guard packet.count <= Int(inBuf.maximumPacketSize) else {
+            throw OpusCodecError.convertFailed("packet larger than maximumPacketSize")
+        }
+        packet.withUnsafeBytes { raw in
+            inBuf.data.copyMemory(from: raw.baseAddress!, byteCount: raw.count)
+        }
+        inBuf.byteLength = UInt32(packet.count)
+        inBuf.packetCount = 1
+        inBuf.packetDescriptions![0] = AudioStreamPacketDescription(
+            mStartOffset: 0, mVariableFramesInPacket: 0, mDataByteSize: UInt32(packet.count))
+
+        out.frameLength = 0
+        var fed = false
+        var convError: NSError?
+        let status = converter.convert(to: out, error: &convError) { [inBuf] _, outStatus in
+            if fed {
+                outStatus.pointee = .noDataNow
+                return nil
+            }
+            fed = true
+            outStatus.pointee = .haveData
+            return inBuf
+        }
+        if status == .error {
+            throw OpusCodecError.convertFailed(convError?.localizedDescription ?? "decode")
+        }
+        return out.frameLength
+    }
+}
+
+final class OpusEncoder {
+    /// The encoder's packet duration: 960 samples = 20 ms, CoreAudio's default Opus
+    /// framing. The host's mic service decodes any Opus frame size up to 120 ms.
+    static let framesPerPacket: AVAudioFrameCount = 960
+
+    private let converter: AVAudioConverter
+    private let outBuf: AVAudioCompressedBuffer
+    let pcmFormat: AVAudioFormat
+
+    init() throws {
+        guard let pcm = opusPCMFormat(),
+              let opus = opusFormat(framesPerPacket: UInt32(Self.framesPerPacket)),
+              let converter = AVAudioConverter(from: pcm, to: opus)
+        else { throw OpusCodecError.unavailable }
+        converter.bitRate = 96_000
+        self.converter = converter
+        self.pcmFormat = pcm
+        outBuf = AVAudioCompressedBuffer(
+            format: opus, packetCapacity: 4, maximumPacketSize: 1500)
+    }
+
+    /// Encode exactly `framesPerPacket` frames of `pcmFormat` audio; returns the encoded
+    /// packets (normally one).
+    func encode(_ pcm: AVAudioPCMBuffer) throws -> [Data] {
+        outBuf.byteLength = 0
+        outBuf.packetCount = 0
+        var fed = false
+        var convError: NSError?
+        let status = converter.convert(to: outBuf, error: &convError) { _, outStatus in
+            if fed {
+                outStatus.pointee = .noDataNow
+                return nil
+            }
+            fed = true
+            outStatus.pointee = .haveData
+            return pcm
+        }
+        if status == .error {
+            throw OpusCodecError.convertFailed(convError?.localizedDescription ?? "encode")
+        }
+        guard let descs = outBuf.packetDescriptions else { return [] }
+        return (0..<Int(outBuf.packetCount)).map { i in
+            let d = descs[i]
+            return Data(
+                bytes: outBuf.data.advanced(by: Int(d.mStartOffset)),
+                count: Int(d.mDataByteSize))
+        }
+    }
+}