Revision control
Copy as Markdown
// Copyright (C) 2016 Research In Motion
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qqnxaudiosink_p.h"
#include <private/qaudiohelpers_p.h>
#include <sys/asoundlib.h>
#include <sys/asound_common.h>
#include <algorithm>
#include <limits>
#pragma GCC diagnostic ignored "-Wvla"
QT_BEGIN_NAMESPACE
QQnxAudioSink::QQnxAudioSink(QAudioDevice device, const QAudioFormat &format, QObject *parent)
: QPlatformAudioSink(std::move(device), format, parent),
m_source(0),
m_pushSource(false),
m_timer(new QTimer(this)),
m_state(QAudio::StoppedState),
m_suspendedInState(QAudio::SuspendedState),
m_periodSize(0),
m_bytesWritten(0),
m_requestedBufferSize(0),
m_pcmNotifier(0)
{
m_timer->setSingleShot(false);
m_timer->setInterval(20);
connect(m_timer, &QTimer::timeout, this, &QQnxAudioSink::pullData);
const std::optional<snd_pcm_channel_info_t> info =
QnxAudioUtils::pcmChannelInfo(m_audioDevice.id(), QAudioDevice::Output);
if (info)
m_requestedBufferSize = info->max_fragment_size;
}
QQnxAudioSink::~QQnxAudioSink()
{
stop();
}
void QQnxAudioSink::start(QIODevice *source)
{
if (m_state != QAudio::StoppedState)
stop();
m_source = source;
m_pushSource = false;
if (open()) {
changeState(QAudio::ActiveState, QAudio::NoError);
m_timer->start();
} else {
changeState(QAudio::StoppedState, QAudio::OpenError);
}
}
QIODevice *QQnxAudioSink::start()
{
if (m_state != QAudio::StoppedState)
stop();
m_source = new QnxPushIODevice(this);
m_source->open(QIODevice::WriteOnly|QIODevice::Unbuffered);
m_pushSource = true;
if (open()) {
changeState(QAudio::IdleState, QAudio::NoError);
} else {
changeState(QAudio::StoppedState, QAudio::OpenError);
}
return m_source;
}
void QQnxAudioSink::stop()
{
if (m_state == QAudio::StoppedState)
return;
changeState(QAudio::StoppedState, QAudio::NoError);
close();
}
void QQnxAudioSink::reset()
{
if (m_pcmHandle)
#if SND_PCM_VERSION < SND_PROTOCOL_VERSION('P',3,0,2)
snd_pcm_playback_drain(m_pcmHandle.get());
#else
snd_pcm_channel_drain(m_pcmHandle.get(), SND_PCM_CHANNEL_PLAYBACK);
#endif
stop();
}
void QQnxAudioSink::suspend()
{
if (!m_pcmHandle)
return;
snd_pcm_playback_pause(m_pcmHandle.get());
suspendInternal(QAudio::SuspendedState);
}
void QQnxAudioSink::resume()
{
if (!m_pcmHandle)
return;
snd_pcm_playback_resume(m_pcmHandle.get());
resumeInternal();
}
void QQnxAudioSink::setBufferSize(qsizetype bufferSize)
{
m_requestedBufferSize = std::clamp<qsizetype>(bufferSize, 0, std::numeric_limits<int>::max());
}
qsizetype QQnxAudioSink::bufferSize() const
{
const std::optional<snd_pcm_channel_setup_t> setup = m_pcmHandle
? QnxAudioUtils::pcmChannelSetup(m_pcmHandle.get(), QAudioDevice::Output)
: std::nullopt;
return setup ? setup->buf.block.frag_size : m_requestedBufferSize;
}
qsizetype QQnxAudioSink::bytesFree() const
{
if (m_state != QAudio::ActiveState && m_state != QAudio::IdleState)
return 0;
const std::optional<snd_pcm_channel_status_t> status = QnxAudioUtils::pcmChannelStatus(
m_pcmHandle.get(), QAudioDevice::Output);
return status ? status->free : 0;
}
qint64 QQnxAudioSink::processedUSecs() const
{
return qint64(1000000) * m_format.framesForBytes(m_bytesWritten) / m_format.sampleRate();
}
QAudio::State QQnxAudioSink::state() const
{
return m_state;
}
void QQnxAudioSink::updateState()
{
const std::optional<snd_pcm_channel_status_t> status = QnxAudioUtils::pcmChannelStatus(
m_pcmHandle.get(), QAudioDevice::Output);
if (!status)
return;
if (state() == QAudio::ActiveState && status->underrun > 0)
changeState(QAudio::IdleState, QAudio::NoError);
else if (state() == QAudio::IdleState && status->underrun == 0)
changeState(QAudio::ActiveState, QAudio::NoError);
}
void QQnxAudioSink::pullData()
{
if (m_state == QAudio::StoppedState
|| m_state == QAudio::SuspendedState)
return;
const int bytesAvailable = bytesFree();
// skip if we have less than 4ms of data
if (m_format.durationForBytes(bytesAvailable) < 4000)
return;
const int frames = m_format.framesForBytes(bytesAvailable);
// The buffer is placed on the stack so no more than 64K or 1 frame
// whichever is larger.
const int maxFrames = qMax(m_format.framesForBytes(64 * 1024), 1);
const int bytesRequested = m_format.bytesForFrames(qMin(frames, maxFrames));
char buffer[bytesRequested];
const int bytesRead = m_source->read(buffer, bytesRequested);
// reading can take a while and stream may have been stopped
if (!m_pcmHandle)
return;
if (bytesRead > 0) {
const qint64 bytesWritten = write(buffer, bytesRead);
if (bytesWritten <= 0) {
close();
changeState(QAudio::StoppedState, QAudio::FatalError);
} else if (bytesWritten != bytesRead) {
m_source->seek(m_source->pos()-(bytesRead-bytesWritten));
}
} else {
// We're done
if (bytesRead == 0)
changeState(QAudio::IdleState, QAudio::NoError);
else
changeState(QAudio::IdleState, QAudio::IOError);
}
}
bool QQnxAudioSink::open()
{
m_pcmHandle = QnxAudioUtils::openPcmDevice(m_audioDevice.id(), QAudioDevice::Output);
if (!m_pcmHandle)
return false;
int errorCode = 0;
if ((errorCode = snd_pcm_nonblock_mode(m_pcmHandle.get(), 0)) < 0) {
qWarning("QQnxAudioSink: open error, couldn't set non block mode (0x%x)", -errorCode);
close();
return false;
}
addPcmEventFilter();
// Necessary so that bytesFree() which uses the "free" member of the status struct works
snd_pcm_plugin_set_disable(m_pcmHandle.get(), PLUGIN_MMAP);
const std::optional<snd_pcm_channel_info_t> info = QnxAudioUtils::pcmChannelInfo(
m_pcmHandle.get(), QAudioDevice::Output);
if (!info) {
close();
return false;
}
const int fragmentSize = std::clamp(m_requestedBufferSize,
info->min_fragment_size, info->max_fragment_size);
snd_pcm_channel_params_t params = QnxAudioUtils::formatToChannelParams(m_format,
QAudioDevice::Output, fragmentSize);
if ((errorCode = snd_pcm_plugin_params(m_pcmHandle.get(), ¶ms)) < 0) {
qWarning("QQnxAudioSink: open error, couldn't set channel params (0x%x)", -errorCode);
close();
return false;
}
if ((errorCode = snd_pcm_plugin_prepare(m_pcmHandle.get(), SND_PCM_CHANNEL_PLAYBACK)) < 0) {
qWarning("QQnxAudioSink: open error, couldn't prepare channel (0x%x)", -errorCode);
close();
return false;
}
const std::optional<snd_pcm_channel_setup_t> setup = QnxAudioUtils::pcmChannelSetup(
m_pcmHandle.get(), QAudioDevice::Output);
if (!setup) {
close();
return false;
}
m_periodSize = qMin(2048, setup->buf.block.frag_size);
m_bytesWritten = 0;
createPcmNotifiers();
return true;
}
void QQnxAudioSink::close()
{
if (!m_pushSource)
m_timer->stop();
destroyPcmNotifiers();
if (m_pcmHandle) {
#if SND_PCM_VERSION < SND_PROTOCOL_VERSION('P',3,0,2)
snd_pcm_plugin_flush(m_pcmHandle.get(), SND_PCM_CHANNEL_PLAYBACK);
#else
snd_pcm_plugin_drop(m_pcmHandle.get(), SND_PCM_CHANNEL_PLAYBACK);
#endif
m_pcmHandle = nullptr;
}
if (m_pushSource) {
delete m_source;
m_source = 0;
}
}
void QQnxAudioSink::changeState(QAudio::State state, QAudio::Error error)
{
if (m_state != state) {
m_state = state;
Q_EMIT stateChanged(state);
}
setError(error);
}
qint64 QQnxAudioSink::pushData(const char *data, qint64 len)
{
const QAudio::State s = state();
if (s == QAudio::StoppedState || s == QAudio::SuspendedState)
return 0;
if (s == QAudio::IdleState)
changeState(QAudio::ActiveState, QAudio::NoError);
qint64 totalWritten = 0;
int retry = 0;
constexpr int maxRetries = 10;
while (totalWritten < len) {
const int bytesWritten = write(data + totalWritten, len - totalWritten);
if (bytesWritten <= 0) {
++retry;
if (retry >= maxRetries) {
close();
changeState(QAudio::StoppedState, QAudio::FatalError);
return totalWritten;
} else {
continue;
}
}
retry = 0;
totalWritten += bytesWritten;
}
return totalWritten;
}
qint64 QQnxAudioSink::write(const char *data, qint64 len)
{
if (!m_pcmHandle)
return 0;
// Make sure we're writing (N * frame) worth of bytes
const int size = m_format.bytesForFrames(qBound(qint64(0), qint64(bytesFree()), len) / m_format.bytesPerFrame());
if (size == 0)
return 0;
int written = 0;
if (volume() < 1.0f) {
char out[size];
QAudioHelperInternal::qMultiplySamples(volume(), m_format, data, out, size);
written = snd_pcm_plugin_write(m_pcmHandle.get(), out, size);
} else {
written = snd_pcm_plugin_write(m_pcmHandle.get(), data, size);
}
if (written > 0) {
m_bytesWritten += written;
return written;
}
return 0;
}
void QQnxAudioSink::suspendInternal(QAudio::State suspendState)
{
if (!m_pushSource)
m_timer->stop();
m_suspendedInState = m_state;
changeState(suspendState, QAudio::NoError);
}
void QQnxAudioSink::resumeInternal()
{
changeState(m_suspendedInState, QAudio::NoError);
m_timer->start();
}
QAudio::State suspendState(const snd_pcm_event_t &event)
{
Q_ASSERT(event.type == SND_PCM_EVENT_AUDIOMGMT_STATUS);
Q_ASSERT(event.data.audiomgmt_status.new_status == SND_PCM_STATUS_SUSPENDED);
return QAudio::SuspendedState;
}
void QQnxAudioSink::addPcmEventFilter()
{
/* Enable PCM events */
snd_pcm_filter_t filter;
memset(&filter, 0, sizeof(filter));
filter.enable = (1<<SND_PCM_EVENT_AUDIOMGMT_STATUS) |
(1<<SND_PCM_EVENT_AUDIOMGMT_MUTE) |
(1<<SND_PCM_EVENT_OUTPUTCLASS) |
(1<<SND_PCM_EVENT_UNDERRUN);
snd_pcm_set_filter(m_pcmHandle.get(), SND_PCM_CHANNEL_PLAYBACK, &filter);
}
void QQnxAudioSink::createPcmNotifiers()
{
// QSocketNotifier::Read for poll based event dispatcher. Exception for
// select based event dispatcher.
m_pcmNotifier = new QSocketNotifier(snd_pcm_file_descriptor(m_pcmHandle.get(),
SND_PCM_CHANNEL_PLAYBACK),
QSocketNotifier::Read, this);
connect(m_pcmNotifier, &QSocketNotifier::activated,
this, &QQnxAudioSink::pcmNotifierActivated);
}
void QQnxAudioSink::destroyPcmNotifiers()
{
if (m_pcmNotifier) {
delete m_pcmNotifier;
m_pcmNotifier = 0;
}
}
void QQnxAudioSink::pcmNotifierActivated(int socket)
{
Q_UNUSED(socket);
snd_pcm_event_t pcm_event;
memset(&pcm_event, 0, sizeof(pcm_event));
while (snd_pcm_channel_read_event(m_pcmHandle.get(), SND_PCM_CHANNEL_PLAYBACK, &pcm_event) == 0) {
if (pcm_event.type == SND_PCM_EVENT_AUDIOMGMT_STATUS) {
if (pcm_event.data.audiomgmt_status.new_status == SND_PCM_STATUS_SUSPENDED)
suspendInternal(suspendState(pcm_event));
else if (pcm_event.data.audiomgmt_status.new_status == SND_PCM_STATUS_RUNNING)
resumeInternal();
else if (pcm_event.data.audiomgmt_status.new_status == SND_PCM_STATUS_PAUSED)
suspendInternal(QAudio::SuspendedState);
} else if (pcm_event.type == SND_PCM_EVENT_UNDERRUN) {
updateState();
}
}
}
QnxPushIODevice::QnxPushIODevice(QQnxAudioSink *output)
: QIODevice(output),
m_output(output)
{
}
QnxPushIODevice::~QnxPushIODevice()
{
}
qint64 QnxPushIODevice::readData(char *data, qint64 len)
{
Q_UNUSED(data);
Q_UNUSED(len);
return 0;
}
qint64 QnxPushIODevice::writeData(const char *data, qint64 len)
{
return m_output->pushData(data, len);
}
bool QnxPushIODevice::isSequential() const
{
return true;
}
QT_END_NAMESPACE