patchaudio.swift

import Foundation
import CoreAudio
import AVFoundation

let appVersion = "dev"

// MARK: - Model

struct AudioDevice {
    let id: AudioDeviceID
    let name: String
    let inputChannels: Int
    let outputChannels: Int
    var hasInput: Bool { inputChannels > 0 }
    var hasOutput: Bool { outputChannels > 0 }
}

// MARK: - CoreAudio Helpers

func channelCount(_ deviceID: AudioDeviceID, scope: AudioObjectPropertyScope) -> Int {
    var addr = AudioObjectPropertyAddress(
        mSelector: kAudioDevicePropertyStreamConfiguration,
        mScope: scope,
        mElement: kAudioObjectPropertyElementMain
    )
    var size: UInt32 = 0
    guard AudioObjectGetPropertyDataSize(deviceID, &addr, 0, nil, &size) == noErr, size > 0 else { return 0 }
    let ptr = UnsafeMutableRawPointer.allocate(byteCount: Int(size), alignment: MemoryLayout<AudioBufferList>.alignment)
    defer { ptr.deallocate() }
    guard AudioObjectGetPropertyData(deviceID, &addr, 0, nil, &size, ptr) == noErr else { return 0 }
    return UnsafeMutableAudioBufferListPointer(ptr.assumingMemoryBound(to: AudioBufferList.self))
        .reduce(0) { $0 + Int($1.mNumberChannels) }
}

func deviceName(_ deviceID: AudioDeviceID) -> String {
    var addr = AudioObjectPropertyAddress(
        mSelector: kAudioObjectPropertyName,
        mScope: kAudioObjectPropertyScopeGlobal,
        mElement: kAudioObjectPropertyElementMain
    )
    var cfName: CFString? = nil
    var size = UInt32(MemoryLayout<CFString?>.size)
    _ = withUnsafeMutablePointer(to: &cfName) {
        AudioObjectGetPropertyData(deviceID, &addr, 0, nil, &size, $0)
    }
    return cfName.map { $0 as String } ?? "Unknown"
}

func fetchDevices() -> [AudioDevice] {
    var addr = AudioObjectPropertyAddress(
        mSelector: kAudioHardwarePropertyDevices,
        mScope: kAudioObjectPropertyScopeGlobal,
        mElement: kAudioObjectPropertyElementMain
    )
    var size: UInt32 = 0
    guard AudioObjectGetPropertyDataSize(AudioObjectID(kAudioObjectSystemObject), &addr, 0, nil, &size) == noErr else { return [] }
    let count = Int(size) / MemoryLayout<AudioDeviceID>.size
    var ids = [AudioDeviceID](repeating: 0, count: count)
    guard AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &addr, 0, nil, &size, &ids) == noErr else { return [] }
    return ids.map {
        AudioDevice(id: $0, name: deviceName($0),
                    inputChannels: channelCount($0, scope: kAudioObjectPropertyScopeInput),
                    outputChannels: channelCount($0, scope: kAudioObjectPropertyScopeOutput))
    }
}

// MARK: - Display

let B = "\u{1B}[1m"; let G = "\u{1B}[32m"; let D = "\u{1B}[2m"; let R = "\u{1B}[0m"

func printDevices(_ devices: [AudioDevice], isInput: Bool) {
    let list = isInput ? devices.filter(\.hasInput) : devices.filter(\.hasOutput)
    let label = isInput ? "INPUT DEVICES" : "OUTPUT DEVICES"
    print("\(B)── \(label) ──────────────────────\(R)")
    for (i, d) in list.enumerated() {
        let ch = isInput ? d.inputChannels : d.outputChannels
        print("  [\(i)]  \(d.name)  \(D)(\(ch)ch)\(R)")
    }
}

// MARK: - Interactive Selection

func selectDevice(isInput: Bool) -> AudioDevice {
    let devices = fetchDevices()
    let list = isInput ? devices.filter(\.hasInput) : devices.filter(\.hasOutput)

    printDevices(devices, isInput: isInput)
    print("\n→ Enter number: ", terminator: "")
    fflush(stdout)

    while true {
        let line = readLine()?.trimmingCharacters(in: .whitespaces) ?? ""
        if let i = Int(line), i >= 0, i < list.count {
            return list[i]
        }
        print("Invalid selection. Try again: ", terminator: "")
        fflush(stdout)
    }
}

// MARK: - Engine

func getSystemDefault(isInput: Bool) -> AudioDeviceID {
    var addr = AudioObjectPropertyAddress(
        mSelector: isInput ? kAudioHardwarePropertyDefaultInputDevice : kAudioHardwarePropertyDefaultOutputDevice,
        mScope: kAudioObjectPropertyScopeGlobal,
        mElement: kAudioObjectPropertyElementMain
    )
    var id: AudioDeviceID = 0
    var size = UInt32(MemoryLayout<AudioDeviceID>.size)
    AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &addr, 0, nil, &size, &id)
    return id
}

func setSystemDefault(_ id: AudioDeviceID, isInput: Bool) {
    var addr = AudioObjectPropertyAddress(
        mSelector: isInput ? kAudioHardwarePropertyDefaultInputDevice : kAudioHardwarePropertyDefaultOutputDevice,
        mScope: kAudioObjectPropertyScopeGlobal,
        mElement: kAudioObjectPropertyElementMain
    )
    var d = id
    AudioObjectSetPropertyData(AudioObjectID(kAudioObjectSystemObject), &addr, 0, nil, UInt32(MemoryLayout<AudioDeviceID>.size), &d)
}

func transportType(_ id: AudioDeviceID) -> UInt32 {
    var addr = AudioObjectPropertyAddress(
        mSelector: kAudioDevicePropertyTransportType,
        mScope: kAudioObjectPropertyScopeGlobal,
        mElement: kAudioObjectPropertyElementMain
    )
    var t: UInt32 = 0
    var size = UInt32(MemoryLayout<UInt32>.size)
    guard AudioObjectGetPropertyData(id, &addr, 0, nil, &size, &t) == noErr else { return 0 }
    return t
}

func isBuiltIn(_ id: AudioDeviceID) -> Bool {
    transportType(id) == kAudioDeviceTransportTypeBuiltIn
}

func confirm(_ prompt: String) -> Bool {
    print("\(prompt) [y/N]: ", terminator: "")
    fflush(stdout)
    let line = readLine()?.trimmingCharacters(in: .whitespaces).lowercased() ?? ""
    return line == "y" || line == "yes"
}

func bufferSize(_ id: AudioDeviceID) -> UInt32? {
    var addr = AudioObjectPropertyAddress(
        mSelector: kAudioDevicePropertyBufferFrameSize,
        mScope: kAudioObjectPropertyScopeGlobal,
        mElement: kAudioObjectPropertyElementMain
    )
    var frames: UInt32 = 0
    var size = UInt32(MemoryLayout<UInt32>.size)
    guard AudioObjectGetPropertyData(id, &addr, 0, nil, &size, &frames) == noErr else { return nil }
    return frames
}

@discardableResult
func setBufferSize(_ id: AudioDeviceID, frames: UInt32) -> Bool {
    var addr = AudioObjectPropertyAddress(
        mSelector: kAudioDevicePropertyBufferFrameSize,
        mScope: kAudioObjectPropertyScopeGlobal,
        mElement: kAudioObjectPropertyElementMain
    )
    var f = frames
    return AudioObjectSetPropertyData(id, &addr, 0, nil, UInt32(MemoryLayout<UInt32>.size), &f) == noErr
}

// MARK: - Meter

final class Meter: @unchecked Sendable {
    private var pL: Float = 0, pR: Float = 0
    private let lock = NSLock()
    func push(l: Float, r: Float) {
        lock.lock(); if l > pL { pL = l }; if r > pR { pR = r }; lock.unlock()
    }
    func sample() -> (Float, Float) {
        lock.lock(); let l = pL, r = pR; pL = 0; pR = 0; lock.unlock()
        return (l, r)
    }
}

func bar(_ v: Float, width: Int = 40) -> String {
    let c = min(max(v, 0), 1)
    let filled = Int(c * Float(width))
    let bars = String(repeating: "█", count: filled) + String(repeating: "·", count: width - filled)
    let db = c > 0 ? 20 * log10f(c) : -.infinity
    let dbStr = db.isFinite ? String(format: "%5.1f dB", db) : "  -inf"
    return "\(bars) \(dbStr)"
}

func startPatching(input: AudioDevice, output: AudioDevice, buffer: UInt32?) {
    let origInput  = getSystemDefault(isInput: true)
    let origOutput = getSystemDefault(isInput: false)

    setSystemDefault(input.id,  isInput: true)
    setSystemDefault(output.id, isInput: false)

    let restoreDefaults = {
        setSystemDefault(origInput,  isInput: true)
        setSystemDefault(origOutput, isInput: false)
    }

    if let b = buffer {
        if !setBufferSize(input.id, frames: b) { print("\(D)warn: input device rejected buffer \(b)\(R)") }
        if !setBufferSize(output.id, frames: b) { print("\(D)warn: output device rejected buffer \(b)\(R)") }
    }

    let engine = AVAudioEngine()
    let format = engine.inputNode.outputFormat(forBus: 0)
    // Route through mainMixerNode so AVAudioEngine handles sample-rate / channel
    // conversion when input and output devices disagree.
    engine.connect(engine.inputNode, to: engine.mainMixerNode, format: format)

    let meter = Meter()
    engine.inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { buf, _ in
        guard let data = buf.floatChannelData else { return }
        let n = Int(buf.frameLength), chs = Int(buf.format.channelCount)
        var pL: Float = 0, pR: Float = 0
        for i in 0..<n {
            let l = abs(data[0][i]); if l > pL { pL = l }
            if chs > 1 { let r = abs(data[1][i]); if r > pR { pR = r } }
        }
        if chs == 1 { pR = pL }
        meter.push(l: pL, r: pR)
    }

    do {
        try engine.start()
    } catch {
        restoreDefaults()
        print("Engine failed to start: \(error)"); exit(1)
    }

    let sr = format.sampleRate
    func describe(_ frames: UInt32?) -> String {
        guard let f = frames else { return "?" }
        return "\(f)f (\(String(format: "%.1f", Double(f) / sr * 1000))ms)"
    }
    print("\n\(G)✓ Patching: \(input.name)  →  \(output.name)\(R)")
    print("\(D)buffer: in \(describe(bufferSize(input.id))) · out \(describe(bufferSize(output.id))) @ \(Int(sr))Hz\(R)")
    print("\(D)Ctrl+C to stop.\(R)\n")
    print("")  // reserve one line above; cursor sits on the R line

    let render = DispatchSource.makeTimerSource(queue: .main)
    render.schedule(deadline: .now() + 0.05, repeating: 0.05)
    render.setEventHandler {
        let (l, r) = meter.sample()
        print("\u{1B}[1A\rL \(bar(l))\u{1B}[K")
        print("\rR \(bar(r))\u{1B}[K", terminator: "")
        fflush(stdout)
    }
    render.resume()

    let cleanup = {
        render.cancel()
        engine.stop()
        restoreDefaults()
        print("\nStopped. Devices restored.")
        exit(0)
    }

    signal(SIGINT,  SIG_IGN)
    signal(SIGTERM, SIG_IGN)
    let sigInt  = DispatchSource.makeSignalSource(signal: SIGINT,  queue: .main)
    let sigTerm = DispatchSource.makeSignalSource(signal: SIGTERM, queue: .main)
    sigInt.setEventHandler(handler: cleanup)
    sigTerm.setEventHandler(handler: cleanup)
    sigInt.resume()
    sigTerm.resume()

    RunLoop.main.run()
}

// MARK: - Permissions

func ensureMicPermission() {
    switch AVCaptureDevice.authorizationStatus(for: .audio) {
    case .authorized:
        return
    case .notDetermined:
        let sem = DispatchSemaphore(value: 0)
        var granted = false
        AVCaptureDevice.requestAccess(for: .audio) { granted = $0; sem.signal() }
        sem.wait()
        if granted { return }
        fallthrough
    case .denied, .restricted:
        print("Microphone access denied. Grant access in System Settings → Privacy & Security → Microphone, then rerun.")
        exit(1)
    @unknown default:
        print("Unknown microphone authorization status; aborting."); exit(1)
    }
}

// MARK: - Args

func parseArg(_ flag: String) -> String? {
    let args = CommandLine.arguments
    guard let i = args.firstIndex(of: flag), i + 1 < args.count else { return nil }
    return args[i + 1]
}

func resolve(query: String, isInput: Bool) -> AudioDevice {
    let list = (isInput ? fetchDevices().filter(\.hasInput) : fetchDevices().filter(\.hasOutput))
    let q = query.lowercased()
    let matches = list.filter { $0.name.lowercased().contains(q) }
    if matches.count == 1 { return matches[0] }
    let label = isInput ? "input" : "output"
    if matches.isEmpty {
        print("No \(label) device matches '\(query)'. Available:")
    } else {
        print("Ambiguous \(label) '\(query)' — matched \(matches.count):")
    }
    for d in (matches.isEmpty ? list : matches) { print("  - \(d.name)") }
    exit(1)
}

// MARK: - Entry Point

if CommandLine.arguments.contains("--version") {
    print(appVersion)
    exit(0)
}

print("\(B)patchaudio \(appVersion)\(R)\n")

ensureMicPermission()

let input: AudioDevice
if let q = parseArg("-i") {
    input = resolve(query: q, isInput: true)
} else {
    print("Select input:\n")
    input = selectDevice(isInput: true)
}
print("\n\(G)✓ Input: \(input.name)\(R)\n")

let output: AudioDevice
if let q = parseArg("-o") {
    output = resolve(query: q, isInput: false)
} else {
    print("Select output:\n")
    output = selectDevice(isInput: false)
}
print("\n\(G)✓ Output: \(output.name)\(R)")

let buffer = parseArg("--buffer").flatMap(UInt32.init)

if isBuiltIn(input.id) && isBuiltIn(output.id) {
    print("\n\u{1B}[33m⚠  Built-in mic → built-in speakers will produce audio feedback.\(R)")
    if !confirm("You're routing the built-in mic into the built-in speakers. Continue?") {
        print("Aborted. Rerun and pick a different output (e.g. headphones)."); exit(0)
    }
    if !confirm("Are you sure? This will likely cause a loud feedback howl") {
        print("Aborted. Rerun and pick a different output (e.g. headphones)."); exit(0)
    }
}

startPatching(input: input, output: output, buffer: buffer)