qcoreaudiodevices.mm

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qcoreaudiodevices_p.h"
 
#include <QtMultimedia/qmediadevices.h>
#include <QtMultimedia/private/qaudiodevice_p.h>
#include <QtMultimedia/private/qcoreaudiodevice_p.h>
#include <QtMultimedia/private/qcoreaaudiosink_p.h>
#include <QtMultimedia/private/qcoreaaudiosource_p.h>
 
#include <QtCore/qcoreapplication.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qdebug.h>
 
#if defined(QT_PLATFORM_UIKIT)
#  import <AVFoundation/AVFoundation.h>
#else
#  include <QtMultimedia/private/qmacosaudiodatautils_p.h>
#endif
 
#ifdef Q_OS_MACOS
#  include <Block.h>
#endif
 
#if defined(Q_OS_MACOS)
Q_STATIC_LOGGING_CATEGORY(qLcDarwinMediaDevices, "qt.multimedia.darwin.mediaDevices");
#endif
 
QT_BEGIN_NAMESPACE
 
template <typename... Args>
static QAudioDevice createAudioDevice(bool isDefault, Args &&...args)
{
    auto dev = std::make_unique<QCoreAudioDeviceInfo>(std::forward<Args>(args)...);
    dev->isDefault = isDefault;
    return QAudioDevicePrivate::createQAudioDevice(std::move(dev));
}
 
#if defined(Q_OS_MACOS)
 
static AudioDeviceID defaultAudioDevice(QAudioDevice::Mode mode)
{
    const AudioObjectPropertySelector selector = (mode == QAudioDevice::Output)
            ? kAudioHardwarePropertyDefaultOutputDevice
            : kAudioHardwarePropertyDefaultInputDevice;
    const AudioObjectPropertyAddress propertyAddress = {
        selector,
        kAudioObjectPropertyScopeGlobal,
        kAudioObjectPropertyElementMain,
    };
 
    if (auto audioDevice = QCoreAudioUtils::getAudioProperty<AudioDeviceID>(kAudioObjectSystemObject, propertyAddress)) {
        return *audioDevice;
    }
 
    return 0;
}
 
static QList<QAudioDevice> availableAudioDevices(QAudioDevice::Mode mode)
{
    using namespace QCoreAudioUtils;
 
    QList<QAudioDevice> devices;
 
    AudioDeviceID defaultDevice = defaultAudioDevice(mode);
    if (defaultDevice != 0)
        devices << createAudioDevice(
            true,
            defaultDevice,
            QCoreAudioUtils::readPersistentDeviceId(defaultDevice, mode),
            mode);
 
    const AudioObjectPropertyAddress audioDevicesPropertyAddress = {
        kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
        kAudioObjectPropertyElementMain
    };
 
    if (auto audioDevices = getAudioPropertyList<AudioDeviceID>(
                kAudioObjectSystemObject, audioDevicesPropertyAddress)) {
        const AudioObjectPropertyAddress audioDeviceStreamFormatPropertyAddress =
                makePropertyAddress(kAudioDevicePropertyStreamFormat, mode);
 
        for (const auto &device : *audioDevices) {
            if (device == defaultDevice)
                continue;
 
            if (getAudioProperty<AudioStreamBasicDescription>(device,
                                                            audioDeviceStreamFormatPropertyAddress,
                                                            /*warnIfMissing=*/false)) {
                devices << createAudioDevice(false,
                                             device,
                                             QCoreAudioUtils::readPersistentDeviceId(device, mode),
                                             mode);
            }
        }
    }
 
    return devices;
}
 
#elif defined(QT_PLATFORM_UIKIT)
 
static QList<QAudioDevice> availableAudioDevices(QAudioDevice::Mode mode)
{
    QList<QAudioDevice> devices;
 
    if (mode == QAudioDevice::Output) {
        devices.append(createAudioDevice(true, "default", QAudioDevice::Output));
    } else {
#if !defined(Q_OS_VISIONOS)
        AVCaptureDevice *defaultDevice =
                [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];
 
        // TODO: Support Bluetooth and USB devices
        AVCaptureDeviceDiscoverySession *captureDeviceDiscoverySession =
            [AVCaptureDeviceDiscoverySession
                discoverySessionWithDeviceTypes:@[ AVCaptureDeviceTypeMicrophone ]
                                      mediaType:AVMediaTypeAudio
                                       position:AVCaptureDevicePositionUnspecified];
 
        NSArray *captureDevices = [captureDeviceDiscoverySession devices];
        for (AVCaptureDevice *device in captureDevices) {
            const bool isDefault =
                    defaultDevice && [defaultDevice.uniqueID isEqualToString:device.uniqueID];
            devices.append(createAudioDevice(isDefault,
                                             QString::fromNSString(device.uniqueID).toUtf8(),
                                             QAudioDevice::Input));
        }
#endif
    }
 
    return devices;
}
 
#endif
 
#ifdef Q_OS_MACOS
 
static constexpr AudioObjectPropertyAddress listenerAddresses[] = {
    { kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal,
      kAudioObjectPropertyElementMain },
    { kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal,
      kAudioObjectPropertyElementMain },
    { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
      kAudioObjectPropertyElementMain }
};
 
#endif
 
namespace {
 
template <typename Block>
auto makeOwningBlock(Block block)
{
#if defined(__has_feature) && __has_feature(objc_arc)
    return std::make_shared<Block>(block);
#else
    struct BlockDeleter
    {
        void operator()(Block *b) const noexcept
        {
            if (b) {
                Block_release(*b);
                delete b;
            }
        }
    };
 
    return std::shared_ptr<Block>(new Block(Block_copy(block)), BlockDeleter{});
#endif
}
 
} // namespace
 
QCoreAudioDevices::QCoreAudioDevices()
{
    if (!QThread::isMainThread())
        moveToThread(qApp->thread());
 
#ifdef Q_OS_MACOS
    m_listenerQueue.reset(
            dispatch_queue_create("QtAudioDevicesListener", /*dispatch_queue_attr=*/nullptr));
    dispatch_set_target_queue(m_listenerQueue.get(), dispatch_get_main_queue());
 
    std::shared_ptr destroyedFlag = m_destroyed; // capture shared_ptr
    m_deviceListenerBlock = makeOwningBlock<AudioObjectPropertyListenerBlock>(
            [this, destroyedFlag](UInt32 numberOfProps, const AudioObjectPropertyAddress *props) {
        // the block is dispatched via a dispatch queue on the main thread and can be in-flight when
        // the QCoreAudioDevices instance is being destroyed. Check the destroyed flag to avoid
        // accessing deleted memory.
        if (*destroyedFlag)
            return;
 
        Q_ASSERT(QThread::isMainThread());
 
        auto properties = QSpan{ props, numberOfProps };
 
        bool updateInputs = false;
        bool updateOutputs = false;
 
        for (const AudioObjectPropertyAddress &address : properties) {
            qCDebug(qLcDarwinMediaDevices)
                    << "audioDeviceChangeListenerBlock: address: " << address.mSelector
                    << address.mScope << address.mElement;
 
            switch (address.mSelector) {
            case kAudioHardwarePropertyDefaultInputDevice:
                updateInputs = true;
                break;
            case kAudioHardwarePropertyDefaultOutputDevice:
                updateOutputs = true;
                break;
            default:
                updateInputs = true;
                updateOutputs = true;
                break;
            }
        }
 
        if (updateInputs)
            updateAudioInputsCache();
        if (updateOutputs)
            updateAudioOutputsCache();
    });
 
    for (const auto &address : listenerAddresses) {
        const auto err = AudioObjectAddPropertyListenerBlock(
                kAudioObjectSystemObject, &address, m_listenerQueue.get(), *m_deviceListenerBlock);
        if (err)
            qWarning() << "Fail to add listener. mSelector:" << address.mSelector
                       << "mScope:" << address.mScope << "mElement:" << address.mElement
                       << "err:" << err;
    }
 
    updateAudioInputsCache();
    updateAudioOutputsCache();
#endif
}
 
QCoreAudioDevices::~QCoreAudioDevices()
{
#ifdef Q_OS_MACOS
    *m_destroyed = true;
    for (const auto &address : listenerAddresses) {
        Q_ASSERT(m_deviceListenerBlock);
        AudioObjectRemovePropertyListenerBlock(kAudioObjectSystemObject, &address,
                                               m_listenerQueue.get(), *m_deviceListenerBlock);
    }
    m_listenerQueue = {};
#endif
}
 
QList<QAudioDevice> QCoreAudioDevices::findAudioInputs() const
{
    return availableAudioDevices(QAudioDevice::Input);
}
 
QList<QAudioDevice> QCoreAudioDevices::findAudioOutputs() const
{
    return availableAudioDevices(QAudioDevice::Output);
}
 
QPlatformAudioSource *QCoreAudioDevices::createAudioSource(const QAudioDevice &info,
                                                             const QAudioFormat &fmt,
                                                             QObject *parent)
{
    return new QCoreAudioSource(info, fmt, parent);
}
 
QPlatformAudioSink *QCoreAudioDevices::createAudioSink(const QAudioDevice &info,
                                                         const QAudioFormat &fmt, QObject *parent)
{
    return new QCoreAudioSink(info, fmt, parent);
}
 
namespace QCoreAudioUtils {
 
#ifdef Q_OS_MACOS
 
static constexpr AudioObjectPropertyAddress propertyAddressDeviceIsAlive = {
    kAudioDevicePropertyDeviceIsAlive,
    kAudioObjectPropertyScopeGlobal,
    kAudioObjectPropertyElementMain,
};
 
static void removeListenerBlock(AudioObjectID id, AudioObjectPropertyListenerBlock listenerBlock)
{
    UInt32 isAlive = 0;
    UInt32 size = sizeof(isAlive);
    OSStatus status = AudioObjectGetPropertyData(id, &propertyAddressDeviceIsAlive, 0, nullptr,
                                                 &size, &isAlive);
    if (status == noErr && isAlive)
        AudioObjectRemovePropertyListenerBlock(id, &propertyAddressDeviceIsAlive,
                                               /*inDispatchQueue=*/nullptr, listenerBlock);
}
 
// force dtor in a translation unit with ARC enabled
DeviceDisconnectMonitor::~DeviceDisconnectMonitor()
{
    if (m_state)
        removeListenerBlock(m_state->id, *m_state->block);
}
 
std::optional<QFuture<void>> DeviceDisconnectMonitor::setDisconnectListener(AudioObjectID id)
{
    if (m_state) {
        removeListenerBlock(m_state->id, *m_state->block);
        m_state = std::nullopt;
    }
 
    auto disconnectedPromise = std::make_shared<QPromise<void>>();
 
    auto removeListenerPromise = std::make_shared<QPromise<void>>();
    auto listenerBlock = makeOwningBlock<AudioObjectPropertyListenerBlock>(
            [disconnectedPromise, removeListenerPromise](UInt32 numberOfProps,
                                                         const AudioObjectPropertyAddress *props) {
        // Called on HAL thread
        auto properties = QSpan{ props, numberOfProps };
 
        for (const AudioObjectPropertyAddress &address : properties) {
            if (address.mSelector == kAudioDevicePropertyDeviceIsAlive) {
                disconnectedPromise->start();
                disconnectedPromise->finish();
                removeListenerPromise->start();
                removeListenerPromise->finish();
                return;
            }
        }
    });
 
    OSStatus status =
            AudioObjectAddPropertyListenerBlock(id, &propertyAddressDeviceIsAlive,
                                                /*inDispatchQueue=*/nullptr, *listenerBlock);
 
    if (status != noErr) {
        qWarning() << "QAudioOutput: Failed to add property listener";
        return std::nullopt;
    }
 
    removeListenerPromise->future().then(this, [this, id, listenerBlock] {
        if (m_state && m_state->block == listenerBlock) {
            removeListenerBlock(id, *listenerBlock);
            m_state = std::nullopt;
        }
    });
 
    m_state = State{
        id,
        std::move(listenerBlock),
    };
 
    return disconnectedPromise->future();
}
 
#endif
 
} // namespace QCoreAudioUtils
 
QT_END_NAMESPACE