qcoreaaudiosink.mm

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd and/or its subsidiary(-ies).
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qcoreaaudiosink_p.h"
 
#include <QtCore/qloggingcategory.h>
#include <QtCore/qdebug.h>
#include <QtMultimedia/qmediadevices.h>
#include <QtMultimedia/private/qaudio_qiodevice_support_p.h>
#include <QtMultimedia/private/qaudiohelpers_p.h>
#include <QtMultimedia/private/qaudioringbuffer_p.h>
#include <QtMultimedia/private/qaudiosystem_platform_stream_support_p.h>
#include <QtMultimedia/private/qautoresetevent_p.h>
#include <QtMultimedia/private/qcoreaudioutils_p.h>
#include <QtMultimedia/private/qapple_utils_p.h>
#include <QtMultimedia/private/qcoreaudiodevice_p.h>
#include <QtMultimedia/private/qcoreaudiodevices_p.h>
 
#include <AudioUnit/AudioUnit.h>
#ifdef Q_OS_MACOS
#  include <AudioUnit/AudioComponent.h>
#  include <QtMultimedia/private/qmacosaudiodatautils_p.h>
#endif
 
#include <variant>
 
QT_BEGIN_NAMESPACE
 
////////////////////////////////////////////////////////////////////////////////////////////////////
 
QCoreAudioSinkStream::QCoreAudioSinkStream(QAudioDevice audioDevice, const QAudioFormat& format,
                                           std::optional<qsizetype> ringbufferSize,
                                           QCoreAudioSink *parent, float volume,
                                           std::optional<QtMultimediaPrivate::NativePeriodFrames> nativePeriodFrames,
                                           AudioEndpointRole)
    : QPlatformAudioSinkStream {
          std::move(audioDevice), format, ringbufferSize, nativePeriodFrames, volume,
      },
      m_parent(parent)
{
}
 
QCoreAudioSinkStream::~QCoreAudioSinkStream()
{
#ifdef Q_OS_MACOS
    m_stopOnDisconnected.cancelChain();
#endif
}
 
bool QCoreAudioSinkStream::open()
{
    using namespace QCoreAudioUtils;
 
#ifdef Q_OS_MACOS
    // Find the the most recent CoreAudio AudioDeviceID for the current device
    // to start the audio stream.
    std::optional<AudioDeviceID> audioDeviceId = findAudioDeviceId(m_audioDevice);
    if (!audioDeviceId) {
        qWarning() << "QAudioSource: Unable to use find most recent CoreAudio AudioDeviceID for "
                      "given device-id. The device might not be connected.";
        return false;
    }
    const AudioDeviceID nativeDeviceId = audioDeviceId.value();
#endif
 
    if (auto audioUnit = makeAudioUnitForIO())
        m_audioUnit = std::move(*audioUnit);
    else
        return false;
 
#ifdef Q_OS_MACOS
    // register listener
    if (!setDisconnectListener(*audioDeviceId))
        return false;
 
    // Set Audio Device
    audioUnitSetCurrentDevice(m_audioUnit, nativeDeviceId);
 
    if (m_nativePeriodFrames)
        audioObjectSetFramesPerBuffer(*audioDeviceId,
                                      qToUnderlying(*m_nativePeriodFrames));
#endif
 
    // Set stream format
    const AudioStreamBasicDescription streamFormat = toAudioStreamBasicDescription(m_format);
    if (!audioUnitSetInputStreamFormat(m_audioUnit, 0, streamFormat))
        return false;
 
    return m_audioUnit.initialize();
}
 
bool QCoreAudioSinkStream::start(QIODevice *device)
{
    AURenderCallbackStruct callback{
        .inputProc = [](void *self, [[maybe_unused]] AudioUnitRenderActionFlags *ioActionFlags,
                        [[maybe_unused]] const AudioTimeStamp *inTimeStamp,
                        [[maybe_unused]] UInt32 inBusNumber, UInt32 inNumberFrames,
                        AudioBufferList *ioData) noexcept Q_DECL_NONBLOCKING_FUNCTION -> OSStatus {
        return reinterpret_cast<QCoreAudioSinkStream *>(self)->processRingbuffer(inNumberFrames,
                                                                                 ioData);
    },
        .inputProcRefCon = this,
    };
    if (!audioUnitSetRenderCallback(m_audioUnit, callback))
        return false;
 
    setQIODevice(device);
    pullFromQIODevice();
 
#ifndef Q_OS_MACOS
    m_sessionActivation = QtMultimediaPrivate::QAVAudioSessionManager::instance()->activate(
            { /* needsRecord = */ false });
#endif
 
    if (!startAudioUnit())
        return false;
 
    createQIODeviceConnections(device);
 
    return true;
}
 
QIODevice *QCoreAudioSinkStream::start()
{
    QIODevice *reader = createRingbufferWriterDevice();
 
    bool success = start(reader);
    if (success)
        return reader;
    else
        return nullptr;
}
 
bool QCoreAudioSinkStream::start(AudioCallback cb)
{
    m_audioCallback = std::move(cb);
 
    AURenderCallbackStruct callback{
        .inputProc = [](void *self, [[maybe_unused]] AudioUnitRenderActionFlags *ioActionFlags,
                        [[maybe_unused]] const AudioTimeStamp *inTimeStamp,
                        [[maybe_unused]] UInt32 inBusNumber, UInt32 inNumberFrames,
                        AudioBufferList *ioData) noexcept Q_DECL_NONBLOCKING_FUNCTION -> OSStatus {
        return reinterpret_cast<QCoreAudioSinkStream *>(self)->processAudioCallback(inNumberFrames,
                                                                                    ioData);
    },
        .inputProcRefCon = this,
    };
    if (!audioUnitSetRenderCallback(m_audioUnit, callback))
        return false;
 
#ifndef Q_OS_MACOS
    m_sessionActivation = QtMultimediaPrivate::QAVAudioSessionManager::instance()->activate(
            { /* needsRecord = */ false });
#endif
 
    return startAudioUnit();
}
 
void QCoreAudioSinkStream::stop(ShutdownPolicy policy)
{
#ifndef Q_OS_MACOS
    if (m_parent)
        m_parent->notifyStreamStopped();
#endif
 
    m_parent = nullptr;
 
    if (m_audioCallback) {
        stopStream();
        return;
    }
 
    disconnectQIODeviceConnections();
    stopIdleDetection();
 
    switch (policy) {
    case ShutdownPolicy::DrainRingbuffer:
        stopStreamWhenBufferDrained();
        break;
    case ShutdownPolicy::DiscardRingbuffer:
        stopStream();
        break;
    default:
        Q_UNREACHABLE_RETURN();
    }
}
 
void QCoreAudioSinkStream::stopStreamWhenBufferDrained()
{
    if (this->isIdle())
        return stopStream();
 
    // we keep the stream alive until the idle handler is called by keeping a shared_ptr
    // reference alive. Once the stream finishes, the idle handler will stop the audio unit
    // and delete the stream.
    connectIdleHandler([this, ownedSelf = shared_from_this()]() mutable {
        if (!isIdle())
            return;
 
        // stop on application thread once ringbuffer is empty
        stopStream();
 
        ownedSelf = nullptr; // might delete the instance
    });
}
 
void QCoreAudioSinkStream::stopStream()
{
#ifdef Q_OS_MACOS
    m_stopOnDisconnected.cancelChain();
#endif
    requestStop();
    stopAudioUnit();
 
#ifndef Q_OS_MACOS
    m_sessionActivation.reset();
#endif
}
 
void QCoreAudioSinkStream::suspend()
{
    const auto status = AudioOutputUnitStop(m_audioUnit.get());
    if (status == noErr)
        return;
    else
        qDebug() << "AudioOutputUnitStop failed:" << QtMultimediaPrivate::QOSStatus(status);
}
 
bool QCoreAudioSinkStream::resume()
{
    return startAudioUnit();
}
 
bool QCoreAudioSinkStream::resumeIfNecessary()
{
    if (QCoreAudioUtils::audioUnitIsRunning(m_audioUnit))
        return true;
 
    return resume();
}
 
void QCoreAudioSinkStream::reportIOError()
{
    requestStop();
    handleIOError(m_parent);
}
 
OSStatus QCoreAudioSinkStream::processRingbuffer(uint32_t numberOfFrames,
                                                 AudioBufferList *ioData) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
    Q_ASSERT(int64_t(ioData->mBuffers[0].mDataByteSize) == m_format.bytesForFrames(numberOfFrames));
 
    QSpan audioBufferSpan{
        reinterpret_cast<std::byte *>(ioData->mBuffers[0].mData),
        ioData->mBuffers[0].mDataByteSize,
    };
 
    QPlatformAudioSinkStream::process(audioBufferSpan, numberOfFrames);
 
    return noErr;
}
 
OSStatus QCoreAudioSinkStream::processAudioCallback(uint32_t numberOfFrames,
                                                    AudioBufferList *ioData) noexcept Q_DECL_NONBLOCKING_FUNCTION
{
    using namespace QtMultimediaPrivate;
 
    Q_ASSERT(int64_t(ioData->mBuffers[0].mDataByteSize) == m_format.bytesForFrames(numberOfFrames));
 
    QSpan<std::byte> inputSpan{
        reinterpret_cast<std::byte *>(ioData->mBuffers[0].mData),
        ioData->mBuffers[0].mDataByteSize,
    };
 
    runAudioCallback(*m_audioCallback, inputSpan, m_format, volume());
 
    return noErr;
}
 
 
void QCoreAudioSinkStream::updateStreamIdle(bool arg)
{
    if (m_parent)
        m_parent->updateStreamIdle(arg);
}
 
bool QCoreAudioSinkStream::startAudioUnit()
{
    if (!m_audioUnit) {
        // the audio unit has been disposed, e.g. after the operating system invalidated it
        return false;
    }
 
    const OSStatus status = AudioOutputUnitStart(m_audioUnit.get());
    if (status != noErr) {
        qDebug() << "AudioOutputUnitStart failed:" << QtMultimediaPrivate::QOSStatus(status);
        return false;
    }
 
    return true;
}
 
void QCoreAudioSinkStream::stopAudioUnit()
{
    invalidateAudioUnit();
 
#ifdef Q_OS_MACOS
    m_stopOnDisconnected.cancelChain();
#endif
}
 
void QCoreAudioSinkStream::invalidateAudioUnit()
{
    if (!m_audioUnit)
        return;
 
    const auto status = AudioOutputUnitStop(m_audioUnit.get());
    if (status != noErr)
        qDebug() << "AudioOutputUnitStop failed:" << QtMultimediaPrivate::QOSStatus(status);
 
    m_audioUnit = {};
}
 
#ifdef Q_OS_MACOS
bool QCoreAudioSinkStream::setDisconnectListener(AudioObjectID id)
{
    m_stopOnDisconnected.cancelChain();
 
    auto disconnectionFuture = m_disconnectMonitor.setDisconnectListener(id);
    if (!disconnectionFuture)
        return false;
 
    m_stopOnDisconnected = disconnectionFuture->then(m_parent, [this] {
        // Coreaudio will pause for a bit and restart the audio unit with a different device.
        // This is problematic, as it switches kAudioOutputUnitProperty_CurrentDevice and
        // invalidates the native device ID (and the disconnect handler). furthermore, we don't have
        // a way to re-synchronize the audio stream. so we explicitly stop the audio unit
 
        stopAudioUnit();
        reportIOError();
    });
 
    return true;
}
#endif
 
////////////////////////////////////////////////////////////////////////////////////////////////////
 
QCoreAudioSink::QCoreAudioSink(QAudioDevice device, const QAudioFormat &format, QObject *parent)
    : BaseClass(std::move(device), format, parent)
{
}
 
QCoreAudioSink::~QCoreAudioSink()
    = default;
 
void QCoreAudioSink::resumeStreamIfNecessary()
{
    // An application-requested suspend must survive backgrounding: only an OS-initiated stop
    // of the audio unit may be undone here.
    if (!m_stream || state() == QAudio::SuspendedState)
        return;
    if (!m_stream->resumeIfNecessary())
        qWarning() << "QCoreAudioSink: failed to resume audio unit";
}
 
#ifndef Q_OS_MACOS
void QCoreAudioSink::resume()
{
    // An explicit application resume() takes precedence over a pending automatic one.
    m_recovery.userResumeRequested();
    BaseClass::resume();
}
#endif
 
QT_END_NAMESPACE