qaaudiostream.cpp

Go to the documentation of this file.

// Copyright (C) 2025 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 "qaaudiostream_p.h"
 
#include <chrono>
#include <dlfcn.h>
 
QT_BEGIN_NAMESPACE
 
namespace {
 
using namespace std::chrono_literals;
constexpr std::chrono::nanoseconds stateChangeTimeout = 1s;
constexpr int bufferSizeInBursts = 3; // Triple buffering
 
static aaudio_format_t aaudioFormat(const QAudioFormat::SampleFormat sampleFormat)
{
    switch (sampleFormat) {
    case QAudioFormat::Int16:
    case QAudioFormat::UInt8: // NOTE: Requires conversion
        return AAUDIO_FORMAT_PCM_I16;
    case QAudioFormat::Int32:
        return AAUDIO_FORMAT_PCM_I32;
    case QAudioFormat::Float:
        return AAUDIO_FORMAT_PCM_FLOAT;
    case QAudioFormat::Unknown:
    case QAudioFormat::NSampleFormats:
        qWarning() << "Sample format not supported by AAudio, needs converting";
        return AAUDIO_FORMAT_INVALID;
    }
}
 
void setMMapPolicy(int policy)
{
    if (QNativeInterface::QAndroidApplication::sdkVersion() < 36)
        return;
 
    auto handle = dlopen("libaaudio.so", RTLD_NOW);
    Q_ASSERT(handle);
    auto guard = qScopeGuard([handle] {
        dlclose(handle);
    });
 
    auto getPolicy = (int (*)(void))dlsym(handle, "AAudio_getMMapPolicy");
    Q_ASSERT(getPolicy);
    auto currentPolicy = getPolicy();
    if (currentPolicy == policy)
        return; // No need to set
 
    auto setPolicy = (aaudio_result_t (*)(int))dlsym(handle, "AAudio_setMMapPolicy");
    Q_ASSERT(setPolicy);
    setPolicy(policy);
};
 
} // namespace
 
namespace QtAAudio {
 
Q_LOGGING_CATEGORY(qLcAAudioStream, "qt.multimedia.android.aaudiostream") // FIXME: Deprecated
 
StreamBuilder::StreamBuilder(QAudioFormat format)
    : format{ format }
{
    AAudio_createStreamBuilder(&m_builder);
    Q_ASSERT(m_builder);
}
 
StreamBuilder::~StreamBuilder()
{
    AAudioStreamBuilder_delete(m_builder);
}
 
void StreamBuilder::setupBuilder()
{
    // Set device
    AAudioStreamBuilder_setDeviceId(m_builder, deviceId);
 
    // Set buffer capacity
    AAudioStreamBuilder_setBufferCapacityInFrames(m_builder, bufferCapacity);
    // TODO: Tuning buffer size at run-time?
 
    // Set parameters from audio format
    AAudioStreamBuilder_setSampleRate(m_builder, format.sampleRate());
    AAudioStreamBuilder_setChannelCount(m_builder, format.channelCount());
    AAudioStreamBuilder_setFormat(m_builder, aaudioFormat(format.sampleFormat()));
 
    // Set callbacks
    AAudioStreamBuilder_setDataCallback(m_builder, callback, userData);
    AAudioStreamBuilder_setErrorCallback(m_builder, errorCallback, userData);
 
    // Set other parameters if not default
    StreamParameterSet defaultParams;
    if (params.sharingMode != defaultParams.sharingMode)
        AAudioStreamBuilder_setSharingMode(m_builder, params.sharingMode);
    // Set performance mode to low latency if mmap policy cannot be set
    if (params.direction == AAUDIO_DIRECTION_OUTPUT) {
        AAudioStreamBuilder_setPerformanceMode(m_builder, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
        setMMapPolicy(2); // Also set MMap policy to AUTO
        if (params.outputUsage != defaultParams.outputUsage)
            AAudioStreamBuilder_setUsage(m_builder, params.outputUsage);
        if (params.outputContentType != defaultParams.outputContentType)
            AAudioStreamBuilder_setContentType(m_builder, params.outputContentType);
    } else {
        AAudioStreamBuilder_setDirection(m_builder, params.direction);
        if (params.inputPreset != defaultParams.inputPreset)
            AAudioStreamBuilder_setInputPreset(m_builder, params.inputPreset);
    }
}
 
Stream::Stream(const StreamBuilder &builder)
{
    // Request stream open
    auto result = AAudioStreamBuilder_openStream(builder.m_builder, &m_stream);
    if (result != AAUDIO_OK) {
        qCWarning(qLcAAudioStream)
                << "Opening stream failed:" << AAudio_convertResultToText(result);
        if (isOpen())
            close();
        return;
    }
 
    qCDebug(qLcAAudioStream) << "Stream opened:" << m_stream << "for device"
                             << AAudioStream_getDeviceId(m_stream);
 
    // Verify parameters
    if (builder.deviceId != AAUDIO_UNSPECIFIED
        && AAudioStream_getDeviceId(m_stream) != builder.deviceId) {
        qCWarning(qLcAAudioStream) << "Stream device not correct";
        if (isOpen())
            close();
        return;
    }
 
    Q_ASSERT(AAudioStream_getSampleRate(m_stream) == builder.format.sampleRate()
             && AAudioStream_getChannelCount(m_stream) == builder.format.channelCount()
             && AAudioStream_getFormat(m_stream) == aaudioFormat(builder.format.sampleFormat()));
 
    StreamParameterSet defaultParams;
    if ((builder.params.sharingMode == defaultParams.sharingMode
         || AAudioStream_getSharingMode(m_stream) == builder.params.sharingMode)
        && (builder.params.direction == defaultParams.direction
            || AAudioStream_getDirection(m_stream) == builder.params.direction)
        && (builder.params.outputUsage == defaultParams.outputUsage
            || AAudioStream_getUsage(m_stream) == builder.params.outputUsage)
        && (builder.params.outputContentType == defaultParams.outputContentType
            || AAudioStream_getContentType(m_stream) == builder.params.outputContentType))
        m_areStreamParametersRespected = true;
 
    if (builder.params.direction == AAUDIO_DIRECTION_OUTPUT
        && AAudioStream_getPerformanceMode(m_stream) != AAUDIO_PERFORMANCE_MODE_LOW_LATENCY)
        qCWarning(qLcAAudioStream) << "Low latency performance mode not set";
 
    // Set buffer size
    auto burstSize = AAudioStream_getFramesPerBurst(m_stream);
    AAudioStream_setBufferSizeInFrames(m_stream, burstSize * bufferSizeInBursts);
}
 
Stream::~Stream()
{
    if (isOpen())
        close();
}
 
bool Stream::start()
{
    auto result = requestWithExpectedState(AAudioStream_requestStart, AAUDIO_STREAM_STATE_STARTED);
    return result == AAUDIO_OK;
}
 
void Stream::stop()
{
    // Plays pending data and stops
    requestWithExpectedState(AAudioStream_requestStop, AAUDIO_STREAM_STATE_STOPPED);
}
 
void Stream::pause()
{
    // Will freeze data flow
    requestWithExpectedState(AAudioStream_requestPause, AAUDIO_STREAM_STATE_PAUSED);
}
 
void Stream::flush()
{
    // Discards pending data
    requestWithExpectedState(AAudioStream_requestFlush, AAUDIO_STREAM_STATE_FLUSHED);
}
 
bool Stream::isOpen() const
{
    return static_cast<bool>(m_stream);
}
 
bool Stream::areStreamParametersRespected() const
{
    return m_areStreamParametersRespected;
}
 
void Stream::close()
{
    Q_ASSERT(isOpen());
 
    AAudioStream_close(m_stream);
    m_stream = nullptr;
}
 
aaudio_result_t Stream::waitForTargetState(aaudio_stream_state_t targetState)
{
    Q_ASSERT(isOpen());
 
    aaudio_result_t result = AAUDIO_OK;
    aaudio_stream_state_t currentState = AAudioStream_getState(m_stream);
    aaudio_stream_state_t inputState = currentState;
 
    while (result == AAUDIO_OK && currentState != targetState) {
        qCDebug(qLcAAudioStream) << "Waiting for state change:"
                                 << AAudio_convertStreamStateToText(currentState) << " -> "
                                 << AAudio_convertStreamStateToText(targetState);
        result = AAudioStream_waitForStateChange(m_stream, inputState, &currentState,
                                                 stateChangeTimeout.count());
        inputState = currentState;
    }
 
    return result;
}
 
template <typename Functor>
aaudio_result_t Stream::requestWithExpectedState(Functor &&request, aaudio_stream_state_t expected)
{
    auto result = request(m_stream);
    if (result != AAUDIO_OK) {
        qCWarning(qLcAAudioStream) << "Request failed:" << AAudio_convertResultToText(result);
        return result;
    }
 
    return waitForTargetState(expected);
}
 
} // namespace QtAAudio
 
QT_END_NAMESPACE