import Foundation import AppKit import AVFoundation import CoreMedia public final class AudioRecorder: NSObject, AVCaptureAudioDataOutputSampleBufferDelegate { private var captureSession: AVCaptureSession? private var audioOutput: AVCaptureAudioDataOutput? private var audioConverter: AVAudioConverter? private let targetFormat: AVAudioFormat private var pcmBuffer = Data() private var preRollBuffer = Data() private let preRollByteLimit = 9600 // 300ms rolling pre-roll at 16kHz 16-bit mono (32,000 bytes/sec) private let lock = NSLock() private let captureQueue = DispatchQueue(label: "com.soniox.audiocapture", qos: .userInteractive) private let sessionQueue = DispatchQueue(label: "com.soniox.audiosession", qos: .userInteractive) // Pre-allocated reusable buffers to eliminate 50Hz per-frame heap allocations private var reusableSrcBuffer: AVAudioPCMBuffer? private var reusableOutBuffer: AVAudioPCMBuffer? public private(set) var isRecording = false public var onAudioLevelUpdate: ((Float) -> Void)? public var onAudioChunkAvailable: ((Data) -> Void)? public override init() { self.targetFormat = AVAudioFormat(commonFormat: .pcmFormatInt16, sampleRate: 16000, channels: 1, interleaved: false)! super.init() setupLifecycleObservers() } private func setupLifecycleObservers() { NSWorkspace.shared.notificationCenter.addObserver(forName: NSWorkspace.willSleepNotification, object: nil, queue: .main) { [weak self] _ in print("AudioRecorder: Mac going to sleep. Resetting audio hardware session.") self?.resetSession() } NSWorkspace.shared.notificationCenter.addObserver(forName: NSWorkspace.didWakeNotification, object: nil, queue: .main) { [weak self] _ in print("AudioRecorder: Mac woke from sleep. Resetting and priming audio session in 1.0s...") self?.resetSession() DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { try? self?.ensureSessionRunning() } } NotificationCenter.default.addObserver(forName: .AVCaptureSessionRuntimeError, object: nil, queue: .main) { [weak self] notif in print("AudioRecorder: AVCaptureSessionRuntimeError received. Resetting capture graph:", notif) self?.resetSession() } NotificationCenter.default.addObserver(forName: .AVCaptureSessionWasInterrupted, object: nil, queue: .main) { [weak self] _ in print("AudioRecorder: AVCaptureSessionWasInterrupted received. Resetting session.") self?.resetSession() } } public func resetSession() { lock.lock() isRecording = false let session = captureSession captureSession = nil audioOutput = nil audioConverter = nil reusableSrcBuffer = nil reusableOutBuffer = nil pcmBuffer.removeAll(keepingCapacity: true) preRollBuffer.removeAll(keepingCapacity: true) lock.unlock() if let session = session { sessionQueue.async { if session.isRunning { session.stopRunning() } } } print("AudioRecorder: Hardware capture session reset.") } public func requestMicrophonePermission(completion: @escaping (Bool) -> Void) { switch AVCaptureDevice.authorizationStatus(for: .audio) { case .authorized: completion(true) case .notDetermined: AVCaptureDevice.requestAccess(for: .audio) { granted in DispatchQueue.main.async { completion(granted) } } case .denied, .restricted: completion(false) @unknown default: completion(false) } } public static func availableAudioDevices() -> [AVCaptureDevice] { var types: [AVCaptureDevice.DeviceType] = [] if #available(macOS 14.0, *) { types = [.microphone, .external] } else { types = [.builtInMicrophone, .externalUnknown] } let session = AVCaptureDevice.DiscoverySession(deviceTypes: types, mediaType: .audio, position: .unspecified) return session.devices } private func resolveCaptureDevice() -> AVCaptureDevice? { let all = AudioRecorder.availableAudioDevices() if let prefID = SonioxSettings.shared.preferredAudioDeviceID, let matched = all.first(where: { $0.uniqueID == prefID }) { return matched } return AVCaptureDevice.default(for: .audio) ?? all.first } public func ensureSessionConfigured() throws { try ensureSessionRunning() } public func ensureSessionRunning() throws { lock.lock() if let session = captureSession, session.isRunning { lock.unlock() return } lock.unlock() guard let device = resolveCaptureDevice() else { throw NSError(domain: "AudioRecorder", code: 1, userInfo: [NSLocalizedDescriptionKey: "No microphone device found"]) } lock.lock() if captureSession == nil { let session = AVCaptureSession() let input = try AVCaptureDeviceInput(device: device) if session.canAddInput(input) { session.addInput(input) } let output = AVCaptureAudioDataOutput() output.setSampleBufferDelegate(self, queue: captureQueue) if session.canAddOutput(output) { session.addOutput(output) } self.captureSession = session self.audioOutput = output print("AudioRecorder: Capture session graph configured for device:", device.localizedName) } let session = captureSession lock.unlock() if let session = session, !session.isRunning { session.startRunning() print("AudioRecorder: Pre-warmed hot audio session running for device:", device.localizedName) } } public func startRecording() throws { lock.lock() if isRecording { lock.unlock() return } isRecording = true let preRoll = preRollBuffer preRollBuffer.removeAll(keepingCapacity: true) pcmBuffer.removeAll(keepingCapacity: true) pcmBuffer.append(preRoll) let session = captureSession lock.unlock() if let session = session, !session.isRunning { sessionQueue.async { if !session.isRunning { session.startRunning() } } } else if session == nil { sessionQueue.async { [weak self] in try? self?.ensureSessionRunning() } } if !preRoll.isEmpty { onAudioChunkAvailable?(preRoll) } let preRollMs = Int(Double(preRoll.count) / 32.0) print("AudioRecorder: Instant 0ms recording started (hot mic, pre-roll: \(preRoll.count) bytes / \(preRollMs)ms).") } public func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) { // Audio converter runs continuously to maintain 300ms rolling pre-roll ring buffer! guard let formatDesc = CMSampleBufferGetFormatDescription(sampleBuffer) else { return } let srcFormat = AVAudioFormat(cmAudioFormatDescription: formatDesc) if audioConverter == nil || audioConverter?.inputFormat != srcFormat { audioConverter = AVAudioConverter(from: srcFormat, to: targetFormat) reusableSrcBuffer = nil reusableOutBuffer = nil } guard let converter = self.audioConverter else { return } guard let blockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer) else { return } let numSamples = CMSampleBufferGetNumSamples(sampleBuffer) guard numSamples > 0 else { return } let requiredSrcCap = AVAudioFrameCount(numSamples) if reusableSrcBuffer == nil || reusableSrcBuffer!.frameCapacity < requiredSrcCap || reusableSrcBuffer!.format != srcFormat { reusableSrcBuffer = AVAudioPCMBuffer(pcmFormat: srcFormat, frameCapacity: max(requiredSrcCap, 4096)) } guard let srcBuffer = reusableSrcBuffer else { return } srcBuffer.frameLength = requiredSrcCap let bytesPerFrame = Int(srcFormat.streamDescription.pointee.mBytesPerFrame) let totalBlockLen = CMBlockBufferGetDataLength(blockBuffer) guard bytesPerFrame > 0, totalBlockLen > 0 else { return } if srcFormat.isInterleaved { let abl = srcBuffer.mutableAudioBufferList if let dst = abl.pointee.mBuffers.mData { let bytesToCopy = min(totalBlockLen, Int(requiredSrcCap) * bytesPerFrame) guard CMBlockBufferCopyDataBytes(blockBuffer, atOffset: 0, dataLength: bytesToCopy, destination: dst) == kCMBlockBufferNoErr else { return } abl.pointee.mBuffers.mDataByteSize = UInt32(bytesToCopy) } } else { let chCount = Int(srcFormat.channelCount) let planeBytes = Int(requiredSrcCap) * bytesPerFrame for ch in 0..= totalBlockLen { break } let copyLen = min(planeBytes, totalBlockLen - offset) if let floatChannel = srcBuffer.floatChannelData?[ch] { _ = CMBlockBufferCopyDataBytes(blockBuffer, atOffset: offset, dataLength: copyLen, destination: floatChannel) } else if let int16Channel = srcBuffer.int16ChannelData?[ch] { _ = CMBlockBufferCopyDataBytes(blockBuffer, atOffset: offset, dataLength: copyLen, destination: int16Channel) } else if let int32Channel = srcBuffer.int32ChannelData?[ch] { _ = CMBlockBufferCopyDataBytes(blockBuffer, atOffset: offset, dataLength: copyLen, destination: int32Channel) } } } let outCapacity = AVAudioFrameCount(Double(numSamples) * (16000.0 / srcFormat.sampleRate)) + 128 if reusableOutBuffer == nil || reusableOutBuffer!.frameCapacity < outCapacity { reusableOutBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: max(outCapacity, 2048)) } guard let outBuffer = reusableOutBuffer else { return } outBuffer.frameLength = 0 var error: NSError? var haveData = true let status = converter.convert(to: outBuffer, error: &error) { inNumPackets, outStatus in if haveData { haveData = false outStatus.pointee = .haveData return srcBuffer } else { outStatus.pointee = .noDataNow return nil } } if status == .haveData || status == .inputRanDry { let frameLen = Int(outBuffer.frameLength) if frameLen > 0, let int16Ptr = outBuffer.int16ChannelData?[0] { let bytesCount = frameLen * MemoryLayout.size let data = Data(bytes: int16Ptr, count: bytesCount) lock.lock() if isRecording { pcmBuffer.append(data) lock.unlock() // Stream live audio chunk to WebSocket immediately onAudioChunkAvailable?(data) // Calculate decibel loudness for perceptual, high-responsiveness audio meter var sumSquare: Float = 0 for i in 0.. preRollByteLimit { preRollBuffer.removeFirst(preRollBuffer.count - preRollByteLimit) } lock.unlock() } } } } /// Non-blocking drain of the serial capture queue (keeps audio engine hot for 0ms next capture) public func stopRecording() -> Data { lock.lock() if !isRecording { let data = pcmBuffer lock.unlock() return data } lock.unlock() // Synchronize with serial captureQueue (<1ms) so any in-flight sampleBuffer finishes cleanly captureQueue.sync { self.lock.lock() self.isRecording = false self.preRollBuffer.removeAll(keepingCapacity: true) self.lock.unlock() } lock.lock() let data = pcmBuffer lock.unlock() print("AudioRecorder: Stopped. Audio engine kept hot for 0ms delay. Total PCM captured: \(data.count) bytes.") return data } /// Immediate abort (e.g. Escape key pressed) — discards buffered audio immediately public func abortRecording() { lock.lock() isRecording = false pcmBuffer.removeAll(keepingCapacity: true) preRollBuffer.removeAll(keepingCapacity: true) lock.unlock() print("AudioRecorder: Aborted immediately.") } }