qcoreaudioaggregatedevice.cpp

Enable keyboard shortcuts

// Copyright (C) 2026 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "qcoreaudioaggregatedevice_p.h"

#include <QtMultimedia/qmediadevices.h>

#include <QtMultimedia/private/qmultimedia_ranges_p.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdeadlinetimer.h>

#include <QtCore/qthread.h>

#include <QtCore/quuid.h>

#include <QtCore/private/qcore_mac_p.h>

#include <CoreAudio/CoreAudio.h>

#include <CoreFoundation/CoreFoundation.h>

#include <atomic>

#include <optional>

QT_BEGIN_NAMESPACE

using namespace Qt::StringLiterals;

using namespace std::chrono_literals;

namespace {

constexpr AudioObjectPropertyAddress isAliveAddress{

    kAudioDevicePropertyDeviceIsAlive,

    kAudioObjectPropertyScopeGlobal,

    kAudioObjectPropertyElementMain,

};

std::optional<QString> defaultDeviceUid(QCoreAudioAggregateDevice::Direction direction)

    const AudioObjectPropertyAddress defaultDeviceAddress{

        direction == QCoreAudioAggregateDevice::Direction::Output

                ? kAudioHardwarePropertyDefaultOutputDevice

                : kAudioHardwarePropertyDefaultInputDevice,

        kAudioObjectPropertyScopeGlobal,

        kAudioObjectPropertyElementMain,

};

    AudioObjectID deviceId = kAudioObjectUnknown;

    UInt32 size = sizeof(deviceId);

    if (AudioObjectGetPropertyData(kAudioObjectSystemObject, &defaultDeviceAddress, 0, nullptr,

                                   &size, &deviceId)

                != noErr

        || deviceId == kAudioObjectUnknown)

        return std::nullopt;

    const AudioObjectPropertyAddress uidAddress{

        kAudioDevicePropertyDeviceUID,

        kAudioObjectPropertyScopeGlobal,

        kAudioObjectPropertyElementMain,

};

    CFStringRef uid = nullptr;

    size = sizeof(uid);

    if (AudioObjectGetPropertyData(deviceId, &uidAddress, 0, nullptr, &size, &uid) != noErr || !uid)

        return std::nullopt;

    QCFType<CFStringRef> ownedUid{ uid };

    return QString::fromCFString(ownedUid);

OSStatus onPropertyChanged(AudioObjectID, UInt32 numberOfAddresses,

                           const AudioObjectPropertyAddress *addresses, void *clientData)

    auto *notifications = static_cast<std::atomic<int> *>(clientData);

    for (UInt32 index = 0; index != numberOfAddresses; ++index) {

        if (addresses[index].mSelector == kAudioDevicePropertyDeviceIsAlive)

            notifications->fetch_add(1);

    return noErr;

} // namespace

struct QCoreAudioAggregateDevice::Private

    ~Private()

        if (id == kAudioObjectUnknown)

            return;

        if (listenerInstalled)

            AudioObjectRemovePropertyListener(id, &isAliveAddress, onPropertyChanged,

                                              &isAliveNotifications);

        AudioHardwareDestroyAggregateDevice(id);

    AudioObjectID id = kAudioObjectUnknown;

    QString name;

    std::atomic<int> isAliveNotifications = 0;

    bool listenerInstalled = false;

};

QCoreAudioAggregateDevice::QCoreAudioAggregateDevice(std::unique_ptr<Private> priv)

    : d{ std::move(priv) }

QCoreAudioAggregateDevice::~QCoreAudioAggregateDevice() = default;

std::unique_ptr<QCoreAudioAggregateDevice> QCoreAudioAggregateDevice::create(Direction direction)

    const std::optional<QString> subDeviceUid = defaultDeviceUid(direction);

    if (!subDeviceUid)

        return nullptr;

    // Fresh name/UID per attempt: parallel ctest processes create aggregates concurrently,

    // so a reused UID could collide with a device owned by another test process.

    constexpr int maxAttempts = 3;

    for (int attempt = 0; attempt != maxAttempts; ++attempt) {

        const QString uniqueSuffix = QUuid::createUuid().toString(QUuid::Id128);

        const QString name = u"QtTestAggregate"_s + uniqueSuffix;

        const QString uid = u"io.qt.test.aggregate."_s + uniqueSuffix;

        QCFType<CFMutableDictionaryRef> description{ CFDictionaryCreateMutable(

                kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,

                &kCFTypeDictionaryValueCallBacks) };

        QCFType<CFStringRef> cfName = name.toCFString();

        QCFType<CFStringRef> cfUid = uid.toCFString();

        QCFType<CFStringRef> cfSubDeviceUid = subDeviceUid->toCFString();

        const int isPrivate = 1;

        QCFType<CFNumberRef> cfIsPrivate =

                CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &isPrivate);

        QCFType<CFMutableDictionaryRef> subDevice{

            CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,

                                      &kCFTypeDictionaryValueCallBacks),

};

        CFDictionaryAddValue(subDevice, CFSTR(kAudioSubDeviceUIDKey), cfSubDeviceUid);

        QCFType<CFMutableArrayRef> subDevices{

            CFArrayCreateMutable(kCFAllocatorDefault, 1, &kCFTypeArrayCallBacks),

};

        CFArrayAppendValue(subDevices, subDevice);

        CFDictionaryAddValue(description, CFSTR(kAudioAggregateDeviceNameKey), cfName);

        CFDictionaryAddValue(description, CFSTR(kAudioAggregateDeviceUIDKey), cfUid);

        CFDictionaryAddValue(description, CFSTR(kAudioAggregateDeviceIsPrivateKey), cfIsPrivate);

        CFDictionaryAddValue(description, CFSTR(kAudioAggregateDeviceSubDeviceListKey), subDevices);

        AudioObjectID id = kAudioObjectUnknown;

        if (AudioHardwareCreateAggregateDevice(description, &id) == noErr

            && id != kAudioObjectUnknown) {

            auto priv = std::make_unique<Private>();

            priv->id = id;

            priv->name = name;

            return std::unique_ptr<QCoreAudioAggregateDevice>{

                new QCoreAudioAggregateDevice{ std::move(priv) },

};

    return nullptr;

std::optional<QAudioDevice>

QCoreAudioAggregateDevice::waitForQtDevice(std::chrono::milliseconds timeout) const

    namespace ranges = QtMultimediaPrivate::ranges;

    QDeadlineTimer deadline{ timeout };

    do {

        QCoreApplication::processEvents(QEventLoop::AllEvents, 5);

        for (auto devices : { QMediaDevices::audioOutputs(), QMediaDevices::audioInputs() }) {

            const auto it = ranges::find_if(devices, [&](const QAudioDevice &device) {

                return device.description() == d->name;

});

            if (it != devices.end())

                return *it;

        std::this_thread::sleep_for(2ms);

    } while (!deadline.hasExpired());

    return std::nullopt;

bool QCoreAudioAggregateDevice::destroyAndWaitForDisconnectNotification(

        std::chrono::milliseconds timeout)

    const AudioObjectID id = d->id;

    if (id == kAudioObjectUnknown)

        return false;

    d->isAliveNotifications = 0;

    if (AudioObjectAddPropertyListener(id, &isAliveAddress, onPropertyChanged,

                                       &d->isAliveNotifications)

        != noErr)

        return false;

    d->listenerInstalled = true;

    if (AudioHardwareDestroyAggregateDevice(id) != noErr) {

        AudioObjectRemovePropertyListener(id, &isAliveAddress, onPropertyChanged,

                                          &d->isAliveNotifications);

        d->listenerInstalled = false;

        return false;

    // The HAL drops listeners with the destroyed device

    d->id = kAudioObjectUnknown;

    d->listenerInstalled = false;

    // Block without running the Qt event loop, so QtMultimedia's disconnect handling stays queued

    QDeadlineTimer deadline{ timeout };

    while (d->isAliveNotifications.load() == 0) {

        if (deadline.hasExpired())

            return false;

        std::this_thread::sleep_for(1ms);

    // The HAL notifies listeners in registration order on one thread. QtMultimedia's listener

    // fulfills the promise that posts the continuation, so wait until it has run.

    std::this_thread::sleep_for(20ms);

    return true;

QT_END_NAMESPACE