Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

8.9 KB
Raw Blame
import CoreAudio

enum AudioCaptureIdlePolicy {
    struct CaptureAttemptIdentity: Equatable {
        let uid: String
        let name: String?
        let isBluetooth: Bool
        let isInternalMicrophone: Bool

        static func resolve(
            selectedInput: AudioDevice.Device?,
            forcingInputUID: String?,
            previous: Self?
        ) -> Self? {
            let uid = forcingInputUID ?? selectedInput?.uid
            guard let uid else { return nil }
            if let selectedInput, selectedInput.uid == uid {
                return Self(
                    uid: uid,
                    name: selectedInput.name,
                    isBluetooth: selectedInput.isBluetooth,
                    isInternalMicrophone: selectedInput.isUnavailableWhenClamshellClosed
                )
            }
            if previous?.uid == uid {
                return previous
            }
            return Self(
                uid: uid,
                name: nil,
                isBluetooth: false,
                isInternalMicrophone: false
            )
        }
    }

    enum BluetoothStartupRouteChangeDisposition: Equatable {
        case retryCurrentStart
        case preserveDeferredWork
        case ignore
    }

    struct DeferredBluetoothRouteRecovery {
        struct Request {
            let reason: String
            let requiresIdlePrewarm: Bool
            let reconcilesInputSelection: Bool
        }

        private var request: Request?

        mutating func preserve(
            reason: String,
            requiresIdlePrewarm: Bool,
            reconcilesInputSelection: Bool
        ) {
            guard requiresIdlePrewarm || reconcilesInputSelection else { return }
            self.request = Request(
                reason: self.request?.reason ?? reason,
                requiresIdlePrewarm: requiresIdlePrewarm || self.request?.requiresIdlePrewarm == true,
                reconcilesInputSelection: reconcilesInputSelection || self.request?.reconcilesInputSelection == true
            )
        }

        mutating func take() -> Request? {
            defer { self.request = nil }
            return self.request
        }
    }

    struct SilentPCMRecoveryWatchdog {
        static let requiredSilentWindows = 3
        static let maximumSilentRMS: Float = 0.00_001
        static let maximumSilentPeak: Float = 0.00_005

        private var hasSeenSignal = false
        private var consecutiveSilentWindows = 0
        private var hasRequestedRecovery = false

        mutating func shouldRecover(
            isInternalMicrophone: Bool,
            isDirectCapture: Bool,
            rms: Float,
            peak: Float
        ) -> Bool {
            guard isInternalMicrophone, isDirectCapture, self.hasRequestedRecovery == false else { return false }
            let isEffectivelySilent = rms <= Self.maximumSilentRMS && peak <= Self.maximumSilentPeak
            if isEffectivelySilent == false {
                self.hasSeenSignal = true
                self.consecutiveSilentWindows = 0
                return false
            }
            guard self.hasSeenSignal else { return false }
            self.consecutiveSilentWindows += 1
            guard self.consecutiveSilentWindows >= Self.requiredSilentWindows else { return false }
            self.hasRequestedRecovery = true
            return true
        }
    }

    struct BluetoothInputStabilization {
        /// New same-device retries may begin within this window. An admitted
        /// attempt still gets its normal readiness timeout so a nearly settled
        /// Bluetooth route is not cancelled at the deadline.
        static let retryAdmissionWindow: TimeInterval = 5

        private(set) var inputUID: String?
        private(set) var startedAt: TimeInterval?

        mutating func shouldRetry(
            inputUID: String,
            isBluetoothInput: Bool,
            now: TimeInterval
        ) -> Bool {
            guard isBluetoothInput || self.inputUID == inputUID else { return false }
            if self.inputUID != inputUID || self.startedAt == nil {
                self.inputUID = inputUID
                self.startedAt = now
            }
            return self.elapsed(at: now) < Self.retryAdmissionWindow
        }

        func elapsed(at now: TimeInterval) -> TimeInterval {
            guard let startedAt else { return 0 }
            return max(now - startedAt, 0)
        }
    }

    static func bluetoothInputAwaitingAvailability(
        priorityInputUIDs: [String],
        preferredInputUID: String?,
        resolvedInputUID: String?,
        allDevices: [AudioDevice.Device],
        excluding excludedUIDs: Set<String>
    ) -> AudioDevice.Device? {
        func settlingBluetoothDevice(uid: String) -> AudioDevice.Device? {
            guard let candidate = allDevices.first(where: { $0.uid == uid }),
                  candidate.isBluetooth,
                  candidate.hasInput == false,
                  candidate.isAlive
            else { return nil }
            return candidate
        }

        for uid in priorityInputUIDs where excludedUIDs.contains(uid) == false {
            if uid == resolvedInputUID { return nil }
            if let candidate = settlingBluetoothDevice(uid: uid) { return candidate }
        }
        guard let preferredInputUID,
              excludedUIDs.contains(preferredInputUID) == false,
              preferredInputUID != resolvedInputUID
        else { return nil }
        return settlingBluetoothDevice(uid: preferredInputUID)
    }

    static func shouldPrewarmCapture(experimentalDirectAudioCaptureEnabled: Bool) -> Bool {
        experimentalDirectAudioCaptureEnabled
    }

    static func didResolvedPriorityInputChange(
        priorityInputUIDs: [String],
        previousInputUIDs: Set<String>,
        currentInputUIDs: Set<String>
    ) -> Bool {
        let previousChoice = priorityInputUIDs.first(where: previousInputUIDs.contains)
        let currentChoice = priorityInputUIDs.first(where: currentInputUIDs.contains)
        return previousChoice != currentChoice
    }

    static func didResolvedPriorityInputIdentityChange(
        priorityInputUIDs: [String],
        previousInputDeviceIDsByUID: [String: AudioObjectID],
        currentInputDeviceIDsByUID: [String: AudioObjectID]
    ) -> Bool {
        let previousChoice = priorityInputUIDs.first { previousInputDeviceIDsByUID[$0] != nil }
        let currentChoice = priorityInputUIDs.first { currentInputDeviceIDsByUID[$0] != nil }
        guard previousChoice == currentChoice else { return true }
        guard let currentChoice else { return false }
        return previousInputDeviceIDsByUID[currentChoice] != currentInputDeviceIDsByUID[currentChoice]
    }

    static func shouldReconcileInputSelection(
        priorityInputUIDs: [String],
        migrationPending: Bool,
        previousInputUIDs: Set<String>,
        currentInputUIDs: Set<String>
    ) -> Bool {
        if currentInputUIDs.isEmpty {
            return previousInputUIDs.isEmpty == false && self.didResolvedPriorityInputChange(
                priorityInputUIDs: priorityInputUIDs,
                previousInputUIDs: previousInputUIDs,
                currentInputUIDs: currentInputUIDs
            )
        }
        return migrationPending || priorityInputUIDs.isEmpty || self.didResolvedPriorityInputChange(
            priorityInputUIDs: priorityInputUIDs,
            previousInputUIDs: previousInputUIDs,
            currentInputUIDs: currentInputUIDs
        )
    }

    static func shouldRecoverEngineConfigurationChange(
        isRunning: Bool,
        isStarting: Bool
    ) -> Bool {
        isRunning || isStarting
    }

    static func shouldDeferRouteRecoveryToBluetoothStart(
        directCaptureEnabled: Bool,
        isStarting: Bool,
        isRunning: Bool,
        attemptedInputIsBluetooth: Bool
    ) -> Bool {
        directCaptureEnabled && isStarting && isRunning == false && attemptedInputIsBluetooth
    }

    static func bluetoothStartupRouteChangeDisposition(
        invalidatesCurrentStart: Bool,
        requiresIdlePrewarm: Bool,
        reconcilesInputSelection: Bool
    ) -> BluetoothStartupRouteChangeDisposition {
        if invalidatesCurrentStart {
            return .retryCurrentStart
        }
        if requiresIdlePrewarm || reconcilesInputSelection {
            return .preserveDeferredWork
        }
        return .ignore
    }

    static func shouldRecoverAfterDeferredBluetoothReconciliation(
        isRunning: Bool,
        confirmedInputUID: String?,
        activeDeviceID: AudioObjectID?,
        resolvedInputUID: String?,
        resolvedDeviceID: AudioObjectID?,
        hasPreparedCapture: Bool,
        requiresIdlePrewarm: Bool
    ) -> Bool {
        if isRunning {
            return resolvedInputUID != confirmedInputUID || resolvedDeviceID != activeDeviceID
        }
        if hasPreparedCapture {
            return resolvedDeviceID != activeDeviceID
        }
        return requiresIdlePrewarm
    }
}