如何将音频路由到 Swift for macOS 中的默认扬声器？

Question

我有一个 function 为 macOS swiftUI 应用程序播放音频，但我希望它每次都通过默认的内置扬声器播放声音。 有谁知道任何可靠的方法吗？

我已经研究了很多，但还没有找到适用于 macos 的可靠方法。 这是我试过的：

1. AVRoutePickerView

这仅适用于 ios 和 Mac 催化剂，但不适用于 macOS

2. 在 AVAudioEngine 中获取设备 ID

我找到了这个代码片段，但它假定内置扬声器设备 ID 保持不变，但事实并非如此，所以这无济于事。

    engine = AVAudioEngine()
    let output = engine.outputNode

    // get the low level input audio unit from the engine:
    let outputUnit = output.audioUnit!
    // use core audio low level call to set the input device:
    var outputDeviceID: AudioDeviceID = 51  // replace with actual, dynamic value
    AudioUnitSetProperty(outputUnit,
                         kAudioOutputUnitProperty_CurrentDevice,
                         kAudioUnitScope_Global,
                         0,
                         &outputDeviceID,
                         UInt32(MemoryLayout<AudioDeviceID>.size))

3. 禁用蓝牙，以便音频仅通过主扬声器而不通过蓝牙扬声器。 这似乎不是最好的方法，所以我还没有测试过。

以下是我播放声音的代码：

func playTheSound() {
    let url = Bundle.main.url(forResource: "Blow", withExtension: "mp3")
    player = try! AVAudioPlayer(contentsOf: url!)
    player?.play()
    print("Sound was played")
    //

那么，关于如何将音频路由到 macOS 的主扬声器有什么建议吗？

Answer 1

对于“默认内置”，我假设您实际上只是指“内置”。 默认扬声器是音频将路由到的扬声器。

可能始终有效的最简单解决方案是路由到 UID“BuiltInSpeakerDevice”。 例如，这会执行您想要的操作：

let player = AVPlayer()

func playTheSound() {
    let url = URL(filePath: "/System/Library/Sounds/Blow.aiff")
    let item = AVPlayerItem(url: url)
    player.replaceCurrentItem(with: item)
    player.audioOutputDeviceUniqueID = "BuiltInSpeakerDevice"
    player.play()
}

注意这里使用了 AVPlayer 和audioOutputDeviceUniqueID 。 我打赌这将在大约 100% 的情况下起作用。 如果没有内置扬声器，它甚至应该“工作”，因为如果 UID 不存在，它会默默地失败（不会崩溃）。

但是......叹气......我找不到任何关于这个记录的地方或这个字符串的任何系统常量。 而且我真的很讨厌魔法，未记录的字符串。 所以，让我们做对吧。 此外，如果我们做对了，它也可以与 AVAudioEngine 一起工作。 让我们开始吧。

首先，您应该始终查看Swift 4 中宝贵的 CoreAudio output 设备有用方法。 我不知道是否有人将其变成了真正的框架，但这是示例的宝库。 以下代码是其现代化版本。

struct AudioDevice {
    let id: AudioDeviceID
    
    static func getAll() -> [AudioDevice] {
        var propertyAddress = AudioObjectPropertyAddress(
            mSelector: kAudioHardwarePropertyDevices,
            mScope: kAudioObjectPropertyScopeGlobal,
            mElement: kAudioObjectPropertyElementMain)

        // Get size of buffer for list
        var devicesBufferSize: UInt32 = 0
        AudioObjectGetPropertyDataSize(AudioObjectID(kAudioObjectSystemObject), &propertyAddress,
                                       0, nil,
                                       &devicesBufferSize)
        let devicesCount = Int(devicesBufferSize) / MemoryLayout<AudioDeviceID>.stride

        // Get list
        let devices = Array<AudioDeviceID>(unsafeUninitializedCapacity: devicesCount) { buffer, initializedCount in
            AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &propertyAddress,
                                       0, nil,
                                       &devicesBufferSize, buffer.baseAddress!)
            initializedCount = devicesCount
        }

        return devices.map(Self.init)
    }

    var hasOutputStreams: Bool {
        var propertySize: UInt32 = 256

        var propertyAddress = AudioObjectPropertyAddress(
            mSelector: kAudioDevicePropertyStreams,
            mScope: kAudioDevicePropertyScopeOutput,
            mElement: kAudioObjectPropertyElementMain)

        AudioObjectGetPropertyDataSize(id, &propertyAddress, 0, nil, &propertySize)

        return propertySize > 0
    }

    var isBuiltIn: Bool {
        transportType == kAudioDeviceTransportTypeBuiltIn
    }

    var transportType: AudioDevicePropertyID {
        var deviceTransportType = AudioDevicePropertyID()
        var propertySize = UInt32(MemoryLayout<AudioDevicePropertyID>.size)

        var propertyAddress = AudioObjectPropertyAddress(
            mSelector: kAudioDevicePropertyTransportType,
            mScope: kAudioObjectPropertyScopeGlobal,
            mElement: kAudioObjectPropertyElementMain)

        AudioObjectGetPropertyData(id, &propertyAddress,
                                   0, nil, &propertySize,
                                   &deviceTransportType)
        return deviceTransportType
    }

    var uid: String {
        var propertySize = UInt32(MemoryLayout<CFString>.size)

        var propertyAddress = AudioObjectPropertyAddress(
            mSelector: kAudioDevicePropertyDeviceUID,
            mScope: kAudioObjectPropertyScopeGlobal,
            mElement: kAudioObjectPropertyElementMain)

        var result: CFString = "" as CFString
        AudioObjectGetPropertyData(id, &propertyAddress, 0, nil, &propertySize, &result)
        return result as String
    }
}

有了它，您就可以获取第一个内置的 output 设备：

player.audioOutputDeviceUniqueID = AudioDevice.getAll()
        .first(where: {$0.hasOutputStreams && $0.isBuiltIn })?
        .uid

或者，如果您想要更多控制，可以使用 AVAudioEngine 方法（请注意此处uid和id之间的区别）：

let player = AVAudioPlayerNode()
let engine = AVAudioEngine()

func playTheSound() {
    let output = engine.outputNode

    let outputUnit = output.audioUnit!
    var outputDeviceID = AudioDevice.getAll()
        .first(where: {$0.hasOutputStreams && $0.isBuiltIn })!
        .id

    AudioUnitSetProperty(outputUnit,
                         kAudioOutputUnitProperty_CurrentDevice,
                         kAudioUnitScope_Global,
                         0,
                         &outputDeviceID,
                         UInt32(MemoryLayout<AudioDeviceID>.size))

    engine.attach(player)
    engine.connect(player, to: engine.outputNode, format: nil)
    try! engine.start()

    let url = URL(filePath: "/System/Library/Sounds/Blow.aiff")
    let file = try! AVAudioFile(forReading: url)
    player.scheduleFile(file, at: nil)
    player.play()
}