Revision control
++ // Copyright (C) 2016 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 "qandroidaudiosink_p.h"
++
++ #include "qandroidaudioutil_p.h"
++
++ #include <QtMultimedia/private/qaudiohelpers_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QtAAudio {
++
++ Q_STATIC_LOGGING_CATEGORY(qLcAndroidAudioSink, "qt.multimedia.android.audiosink")
++
++ QAndroidAudioSinkStream::QAndroidAudioSinkStream(QAudioDevice device, const QAudioFormat &format,
++ std::optional<qsizetype> ringbufferSize,
++ QAndroidAudioSink *parent, float volume,
++ std::optional<NativePeriodFrames> nativePeriodFrames,
++ AudioEndpointRole role)
++ : QtMultimediaPrivate::QPlatformAudioSinkStream(std::move(device), format, ringbufferSize,
++ nativePeriodFrames, volume),
++ m_parent(parent),
++ m_role(role)
++ {
++ QtAAudio::StreamBuilder builder(format);
++
++ qCDebug(qLcAndroidAudioSink) << "Creating sink for device id:" << m_audioDevice.id()
++ << ", description:" << m_audioDevice.description();
++
++ builder.deviceId = m_audioDevice.id().toInt();
++
++ // Set buffer parameters
++ builder.bufferCapacity = m_nativePeriodFrames
++ ? qToUnderlying(*m_nativePeriodFrames)
++ : 1024;
++
++ // NOTE: AAudio doesn't support UINT8, so convert to INT16 if that's requested
++ if (format.sampleFormat() == QAudioFormat::UInt8) {
++ m_hostFormat = format;
++ m_hostFormat->setSampleFormat(QAudioFormat::Int16);
++ }
++
++ // Set builder parameters for audio sink
++ builder.params.sharingMode = AAUDIO_SHARING_MODE_SHARED;
++ builder.params.direction = AAUDIO_DIRECTION_OUTPUT;
++ switch (m_role) {
++ case QtMultimediaPrivate::AudioEndpointRole::SoundEffect:
++ builder.params.outputUsage = AAUDIO_USAGE_GAME;
++ builder.params.outputContentType = AAUDIO_CONTENT_TYPE_SONIFICATION;
++ break;
++ case QtMultimediaPrivate::AudioEndpointRole::Accessibility:
++ builder.params.outputUsage = AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
++ builder.params.outputContentType = AAUDIO_CONTENT_TYPE_SPEECH;
++ break;
++ case QtMultimediaPrivate::AudioEndpointRole::MediaPlayback:
++ case QtMultimediaPrivate::AudioEndpointRole::Other:
++ builder.params.outputUsage = AAUDIO_USAGE_MEDIA;
++ builder.params.outputContentType = AAUDIO_CONTENT_TYPE_MUSIC;
++ break;
++ }
++
++ if (QAndroidAudioUtil::supportsLowLatency() && !QAndroidAudioUtil::isBluetoothDevice(m_audioDevice))
++ builder.params.performanceMode = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
++
++ builder.userData = this;
++ builder.callback = [](AAudioStream *, void *userData, void *audioData,
++ int32_t numFrames) -> int {
++ auto *stream = reinterpret_cast<QAndroidAudioSinkStream *>(userData);
++ Q_ASSERT(stream);
++ QSpan<std::byte> audioSpan = stream->getHostSpan(audioData, numFrames);
++ return stream->m_audioCallback ? stream->processCallback(audioSpan)
++ : stream->processRingbuffer(audioSpan, numFrames);
++ };
++ builder.errorCallback = [](AAudioStream *, void *userData, aaudio_result_t error) -> void {
++ auto *stream = reinterpret_cast<QAndroidAudioSinkStream *>(userData);
++ Q_ASSERT(stream);
++ stream->handleError(error);
++ };
++
++ builder.setupBuilder();
++ m_stream = std::make_unique<QtAAudio::Stream>(builder);
++ if (builder.format.sampleFormat() != format.sampleFormat()) {
++ // Original sample format unsupported, so doing sample format conversion
++ Q_ASSERT(builder.format.sampleFormat() == QAudioFormat::Float);
++ m_hostFormat = builder.format;
++ }
++ }
++
++ bool QAndroidAudioSinkStream::open()
++ {
++ if (!m_stream->isOpen()) {
++ qCWarning(qLcAndroidAudioSink) << "Stream null";
++ requestStop();
++ return false;
++ }
++
++ if (!m_stream->areStreamParametersRespected())
++ qCWarning(qLcAndroidAudioSink) << "Stream parameters not correct";
++
++ return true;
++ }
++
++ bool QAndroidAudioSinkStream::start(QIODevice *device)
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++ setQIODevice(device);
++ pullFromQIODevice();
++ createQIODeviceConnections(device);
++
++ // TODO: Fill host ringbuffer before starting
++ if (!m_stream->start()) {
++ requestStop();
++ return false;
++ }
++
++ return true;
++ }
++
++ QIODevice *QAndroidAudioSinkStream::start()
++ {
++ auto *writer = createRingbufferWriterDevice();
++ return start(writer) ? writer : nullptr;
++ }
++
++ bool QAndroidAudioSinkStream::start(AudioCallback cb)
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++ m_audioCallback = std::move(cb);
++
++ if (!m_stream->start()) {
++ requestStop();
++ return false;
++ }
++
++ return true;
++ }
++
++ void QAndroidAudioSinkStream::suspend()
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++ m_stream->stop();
++ }
++
++ void QAndroidAudioSinkStream::resume()
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++ m_stream->start();
++ }
++
++ void QAndroidAudioSinkStream::stop(ShutdownPolicy policy)
++ {
++ requestStop();
++ disconnectQIODeviceConnections();
++
++ switch (policy) {
++ case ShutdownPolicy::DrainRingbuffer:
++ stop();
++ break;
++ case ShutdownPolicy::DiscardRingbuffer:
++ reset();
++ break;
++ default:
++ Q_UNREACHABLE_RETURN();
++ }
++ }
++
++ void QAndroidAudioSinkStream::stop()
++ {
++ if (isIdle() || m_audioCallback)
++ return reset();
++
++ stopIdleDetection();
++ connectIdleHandler([this] {
++ Q_ASSERT(thread()->isCurrentThread());
++ if (!isIdle()) // Only handle <not idle> -> <idle> transitions
++ return;
++
++ // We have written everything we want to write, synchronous stop on application thread
++ m_stream->stop();
++ m_self = nullptr; // might delete the instance
++ });
++
++ m_parent = nullptr;
++
++ // Take ownership of self to avoid deletion until AAudio stream is stopped
++ m_self = shared_from_this();
++ }
++
++ void QAndroidAudioSinkStream::reset()
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++ m_stream->stop();
++ }
++
++ void QAndroidAudioSinkStream::updateStreamIdle(bool arg)
++ {
++ if (m_parent)
++ m_parent->updateStreamIdle(arg);
++ }
++
++ QSpan<std::byte>
++ QAndroidAudioSinkStream::getHostSpan(void *audioData,
++ int numFrames) const noexcept Q_DECL_NONBLOCKING_FUNCTION
++ {
++ qsizetype byteAmount = m_hostFormat ? m_hostFormat->bytesForFrames(numFrames)
++ : m_format.bytesForFrames(numFrames);
++ return QSpan{ reinterpret_cast<std::byte *>(audioData), byteAmount };
++ }
++
++ aaudio_data_callback_result_t
++ QAndroidAudioSinkStream::processRingbuffer(QSpan<std::byte> audioSpan,
++ int numFrames) noexcept Q_DECL_NONBLOCKING_FUNCTION
++ {
++ auto consumedFrames = m_hostFormat
++ ? QPlatformAudioSinkStream::process(
++ audioSpan, numFrames,
++ QAudioHelperInternal::toNativeSampleFormat(m_hostFormat->sampleFormat()))
++ : QPlatformAudioSinkStream::process(audioSpan, numFrames);
++ if (consumedFrames != static_cast<uint64_t>(numFrames) && isStopRequested())
++ return AAUDIO_CALLBACK_RESULT_STOP;
++
++ return AAUDIO_CALLBACK_RESULT_CONTINUE;
++ }
++
++ aaudio_data_callback_result_t
++ QAndroidAudioSinkStream::processCallback(QSpan<std::byte> audioSpan) noexcept Q_DECL_NONBLOCKING_FUNCTION
++ {
++ if (isStopRequested())
++ return AAUDIO_CALLBACK_RESULT_STOP;
++
++ if (m_hostFormat)
++ QtMultimediaPrivate::runAudioCallback(*m_audioCallback, audioSpan, m_format, volume(),
++ *m_hostFormat);
++ else
++ QtMultimediaPrivate::runAudioCallback(*m_audioCallback, audioSpan, m_format, volume());
++
++ return AAUDIO_CALLBACK_RESULT_CONTINUE;
++ }
++
++ void QAndroidAudioSinkStream::handleError(aaudio_result_t)
++ {
++ // Handle as IO error which closes the stream
++ // TODO: Check for underruns
++ requestStop();
++ invokeOnAppThread([this] {
++ // clang-format off
++ handleIOError(m_parent);
++ // clang-format on
++ });
++ }
++
++ QAndroidAudioSink::QAndroidAudioSink(QAudioDevice device, const QAudioFormat &fmt, QObject *parent)
++ : BaseClass(std::move(device), fmt, parent)
++ {
++ }
++
++ QAndroidAudioSink::~QAndroidAudioSink()
++ = default;
++
++ } // namespace QtAAudio
++
++ QT_END_NAMESPACE