qpulseaudio_contextmanager.cpp

++ // 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 "qpulseaudio_contextmanager_p.h"

++

++ #include <QtCore/qdebug.h>

++ #include <QtCore/qtimer.h>

++ #include <QtCore/private/qflatmap_p.h>

++ #include <QtGui/qguiapplication.h>

++ #include <QtGui/qicon.h>

++ #include <QtMultimedia/qaudiodevice.h>

++ #include <QtMultimedia/private/qaudiodevice_p.h>

++ #include <QtMultimedia/private/qpulsehelpers_p.h>

++ #include <QtMultimedia/private/qpulseaudiodevice_p.h>

++

++ #include <sys/types.h>

++ #include <unistd.h>

++ #include <mutex> // for lock_guard

++

++ QT_BEGIN_NAMESPACE

++

++ using PAOperationHandle = QPulseAudioInternal::PAOperationHandle;

++

++ static std::unique_ptr<QAudioDevicePrivate>

++ makeQAudioDevicePrivate(const char *device, const char *desc, bool isDef, QAudioDevice::Mode mode,

++                         const pa_channel_map &map, const pa_sample_spec &spec)

++ {

++     using namespace QPulseAudioInternal;

++

++     QAudioFormat::ChannelConfig channelConfig = channelConfigFromMap(map);

++

++     QAudioDevicePrivate::AudioDeviceFormat format;

++

++     format.minimumChannelCount = 1;

++     format.maximumChannelCount = PA_CHANNELS_MAX;

++     format.minimumSampleRate = 1;

++     format.maximumSampleRate = PA_RATE_MAX;

++

++     constexpr bool isBigEndian = QSysInfo::ByteOrder == QSysInfo::BigEndian;

++

++     constexpr struct

++     {

++         pa_sample_format pa_fmt;

++         QAudioFormat::SampleFormat qt_fmt;

++     } formatMap[] = {

++         { PA_SAMPLE_U8, QAudioFormat::UInt8 },

++         { isBigEndian ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE, QAudioFormat::Int16 },

++         { isBigEndian ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE, QAudioFormat::Int32 },

++         { isBigEndian ? PA_SAMPLE_FLOAT32BE : PA_SAMPLE_FLOAT32LE, QAudioFormat::Float },

++     };

++

++     for (const auto &f : formatMap) {

++         if (pa_sample_format_valid(f.pa_fmt) != 0)

++             format.supportedSampleFormats.append(f.qt_fmt);

++     }

++

++     QAudioFormat preferredFormat = sampleSpecToAudioFormat(spec);

++     if (!preferredFormat.isValid()) {

++         preferredFormat.setChannelCount(spec.channels ? spec.channels : 2);

++         preferredFormat.setSampleRate(spec.rate ? spec.rate : 48000);

++

++         Q_ASSERT(spec.format != PA_SAMPLE_INVALID);

++         if (!format.supportedSampleFormats.contains(preferredFormat.sampleFormat()))

++             preferredFormat.setSampleFormat(QAudioFormat::Float);

++     }

++

++     format.preferredFormat = preferredFormat;

++     format.preferredFormat.setChannelConfig(channelConfig);

++     format.channelConfiguration = channelConfig;

++     Q_ASSERT(format.preferredFormat.isValid());

++

++     return std::make_unique<QPulseAudioDevicePrivate>(QByteArray(device), mode, QString::fromUtf8(desc), isDef, format);

++ }

++

++ template<typename Info>

++ static bool updateDevicesMap(QReadWriteLock &lock, const QByteArray &defaultDeviceId,

++                              QMap<int, QAudioDevice> &devices, QAudioDevice::Mode mode,

++                              const Info &info)

++ {

++     QWriteLocker locker(&lock);

++

++     bool isDefault = defaultDeviceId == info.name;

++     auto newDeviceInfo = makeQAudioDevicePrivate(info.name, info.description, isDefault, mode,

++                                                  info.channel_map, info.sample_spec);

++

++     auto &device = devices[info.index];

++     QAudioDevicePrivateAllMembersEqual compare;

++     const QAudioDevicePrivate *handle = QAudioDevicePrivate::handle(device);

++     if (handle && compare(*newDeviceInfo, *handle))

++         return false;

++

++     device = QAudioDevicePrivate::createQAudioDevice(std::move(newDeviceInfo));

++     return true;

++ }

++

++ static bool updateDevicesMap(QReadWriteLock &lock, const QByteArray &defaultDeviceId,

++                              QMap<int, QAudioDevice> &devices)

++ {

++     QWriteLocker locker(&lock);

++

++     bool result = false;

++

++     for (QAudioDevice &device : devices) {

++         auto deviceInfo = QAudioDevicePrivate::handle<QPulseAudioDevicePrivate>(device);

++         const auto isDefault = deviceInfo->id == defaultDeviceId;

++         if (deviceInfo->isDefault != isDefault) {

++             auto newDeviceInfo = std::make_unique<QPulseAudioDevicePrivate>(*deviceInfo);

++             newDeviceInfo->isDefault = isDefault;

++             device = QAudioDevicePrivate::createQAudioDevice(std::move(newDeviceInfo));

++             result = true;

++         }

++     }

++

++     return result;

++ };

++

++ void QPulseAudioContextManager::serverInfoCallback(pa_context *context, const pa_server_info *info,

++                                                    void *userdata)

++ {

++     using namespace Qt::Literals;

++     using namespace QPulseAudioInternal;

++

++     if (!info) {

++         qWarning() << "Failed to get server information:" << currentError(context);

++         return;

++     }

++

++     if (Q_UNLIKELY(qLcPulseAudioEngine().isEnabled(QtDebugMsg))) {

++         char ss[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];

++

++         pa_sample_spec_snprint(ss, sizeof(ss), &info->sample_spec);

++         pa_channel_map_snprint(cm, sizeof(cm), &info->channel_map);

++

++         qCDebug(qLcPulseAudioEngine)

++                 << QStringLiteral("User name: %1\n"

++                                   "Host Name: %2\n"

++                                   "Server Name: %3\n"

++                                   "Server Version: %4\n"

++                                   "Default Sample Specification: %5\n"

++                                   "Default Channel Map: %6\n"

++                                   "Default Sink: %7\n"

++                                   "Default Source: %8\n")

++                            .arg(QString::fromUtf8(info->user_name),

++                                 QString::fromUtf8(info->host_name),

++                                 QString::fromUtf8(info->server_name),

++                                 QLatin1StringView(info->server_version), QLatin1StringView(ss),

++                                 QLatin1StringView(cm), QString::fromUtf8(info->default_sink_name),

++                                 QString::fromUtf8(info->default_source_name));

++     }

++

++     QPulseAudioContextManager *pulseEngine = static_cast<QPulseAudioContextManager *>(userdata);

++

++     bool defaultSinkChanged = false;

++     bool defaultSourceChanged = false;

++

++     {

++         QWriteLocker locker(&pulseEngine->m_serverLock);

++         pulseEngine->m_serverName = QString::fromUtf8(info->server_name);

++

++         if (pulseEngine->m_defaultSink != info->default_sink_name) {

++             pulseEngine->m_defaultSink = info->default_sink_name;

++             defaultSinkChanged = true;

++         }

++

++         if (pulseEngine->m_defaultSource != info->default_source_name) {

++             pulseEngine->m_defaultSource = info->default_source_name;

++             defaultSourceChanged = true;

++         }

++     }

++

++     if (defaultSinkChanged

++         && updateDevicesMap(pulseEngine->m_sinkLock, pulseEngine->m_defaultSink,

++                             pulseEngine->m_sinks))

++         Q_EMIT pulseEngine->audioOutputsChanged();

++

++     if (defaultSourceChanged

++         && updateDevicesMap(pulseEngine->m_sourceLock, pulseEngine->m_defaultSource,

++                             pulseEngine->m_sources))

++         Q_EMIT pulseEngine->audioInputsChanged();

++

++     pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);

++ }

++

++ void QPulseAudioContextManager::sinkInfoCallback(pa_context *context, const pa_sink_info *info,

++                                                  int isLast, void *userdata)

++ {

++     using namespace Qt::Literals;

++     using namespace QPulseAudioInternal;

++

++     QPulseAudioContextManager *pulseEngine = static_cast<QPulseAudioContextManager *>(userdata);

++

++     if (isLast < 0) {

++         qWarning() << "Failed to get sink information:" << currentError(context);

++         return;

++     }

++

++     if (isLast) {

++         pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);

++         return;

++     }

++

++     Q_ASSERT(info);

++

++     if (Q_UNLIKELY(qLcPulseAudioEngine().isEnabled(QtDebugMsg))) {

++         static const QFlatMap<pa_sink_state, QStringView> stateMap{

++             { PA_SINK_INVALID_STATE, u"n/a" }, { PA_SINK_RUNNING, u"RUNNING" },

++             { PA_SINK_IDLE, u"IDLE" },         { PA_SINK_SUSPENDED, u"SUSPENDED" },

++             { PA_SINK_UNLINKED, u"UNLINKED" },

++         };

++

++         qCDebug(qLcPulseAudioEngine)

++                 << QStringLiteral("Sink #%1\n"

++                                   "\tState: %2\n"

++                                   "\tName: %3\n"

++                                   "\tDescription: %4\n")

++                            .arg(QString::number(info->index), stateMap.value(info->state),

++                                 QString::fromUtf8(info->name),

++                                 QString::fromUtf8(info->description));

++     }

++

++     if (updateDevicesMap(pulseEngine->m_sinkLock, pulseEngine->m_defaultSink, pulseEngine->m_sinks,

++                          QAudioDevice::Output, *info))

++         Q_EMIT pulseEngine->audioOutputsChanged();

++ }

++

++ void QPulseAudioContextManager::sourceInfoCallback(pa_context *context, const pa_source_info *info,

++                                                    int isLast, void *userdata)

++ {

++     using namespace Qt::Literals;

++

++     Q_UNUSED(context);

++     QPulseAudioContextManager *pulseEngine = static_cast<QPulseAudioContextManager *>(userdata);

++

++     if (isLast) {

++         pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);

++         return;

++     }

++

++     Q_ASSERT(info);

++

++     if (Q_UNLIKELY(qLcPulseAudioEngine().isEnabled(QtDebugMsg))) {

++         static const QFlatMap<pa_source_state, QStringView> stateMap{

++             { PA_SOURCE_INVALID_STATE, u"n/a" }, { PA_SOURCE_RUNNING, u"RUNNING" },

++             { PA_SOURCE_IDLE, u"IDLE" },         { PA_SOURCE_SUSPENDED, u"SUSPENDED" },

++             { PA_SOURCE_UNLINKED, u"UNLINKED" },

++         };

++

++         qCDebug(qLcPulseAudioEngine)

++                 << QStringLiteral("Source #%1\n"

++                                   "\tState: %2\n"

++                                   "\tName: %3\n"

++                                   "\tDescription: %4\n")

++                            .arg(QString::number(info->index), stateMap.value(info->state),

++                                 QString::fromUtf8(info->name),

++                                 QString::fromUtf8(info->description));

++     }

++

++     // skip monitor channels

++     if (info->monitor_of_sink != PA_INVALID_INDEX)

++         return;

++

++     if (updateDevicesMap(pulseEngine->m_sourceLock, pulseEngine->m_defaultSource,

++                          pulseEngine->m_sources, QAudioDevice::Input, *info))

++         Q_EMIT pulseEngine->audioInputsChanged();

++ }

++

++ void QPulseAudioContextManager::eventCallback(pa_context *context, pa_subscription_event_type_t t,

++                                               uint32_t index, void *userdata)

++ {

++     QPulseAudioContextManager *pulseEngine = static_cast<QPulseAudioContextManager *>(userdata);

++

++     int type = t & PA_SUBSCRIPTION_EVENT_TYPE_MASK;

++     int facility = t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK;

++

++     switch (type) {

++     case PA_SUBSCRIPTION_EVENT_NEW:

++     case PA_SUBSCRIPTION_EVENT_CHANGE:

++         switch (facility) {

++         case PA_SUBSCRIPTION_EVENT_SERVER: {

++             PAOperationHandle op{

++                 pa_context_get_server_info(context, serverInfoCallback, userdata),

++                 PAOperationHandle::HasRef,

++             };

++             if (!op)

++                 qWarning() << "PulseAudioService: failed to get server info";

++             break;

++         }

++         case PA_SUBSCRIPTION_EVENT_SINK: {

++             PAOperationHandle op{

++                 pa_context_get_sink_info_by_index(context, index, sinkInfoCallback, userdata),

++                 PAOperationHandle::HasRef,

++             };

++

++             if (!op)

++                 qWarning() << "PulseAudioService: failed to get sink info";

++             break;

++         }

++         case PA_SUBSCRIPTION_EVENT_SOURCE: {

++             PAOperationHandle op{

++                 pa_context_get_source_info_by_index(context, index, sourceInfoCallback, userdata),

++                 PAOperationHandle::HasRef,

++             };

++

++             if (!op)

++                 qWarning() << "PulseAudioService: failed to get source info";

++             break;

++         }

++         default:

++             break;

++         }

++         break;

++     case PA_SUBSCRIPTION_EVENT_REMOVE:

++         switch (facility) {

++         case PA_SUBSCRIPTION_EVENT_SINK: {

++             QWriteLocker locker(&pulseEngine->m_sinkLock);

++             pulseEngine->m_sinks.remove(index);

++             break;

++         }

++         case PA_SUBSCRIPTION_EVENT_SOURCE: {

++             QWriteLocker locker(&pulseEngine->m_sourceLock);

++             pulseEngine->m_sources.remove(index);

++             break;

++         }

++         default:

++             break;

++         }

++         break;

++     default:

++         break;

++     }

++ }

++

++ void QPulseAudioContextManager::contextStateCallbackInit(pa_context *context, void *userdata)

++ {

++     Q_UNUSED(context);

++

++     if (Q_UNLIKELY(qLcPulseAudioEngine().isEnabled(QtDebugMsg)))

++         qCDebug(qLcPulseAudioEngine) << pa_context_get_state(context);

++

++     QPulseAudioContextManager *pulseEngine =

++             reinterpret_cast<QPulseAudioContextManager *>(userdata);

++     pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);

++ }

++

++ void QPulseAudioContextManager::contextStateCallback(pa_context *c, void *userdata)

++ {

++     QPulseAudioContextManager *self = reinterpret_cast<QPulseAudioContextManager *>(userdata);

++     pa_context_state_t state = pa_context_get_state(c);

++

++     if (Q_UNLIKELY(qLcPulseAudioEngine().isEnabled(QtDebugMsg)))

++         qCDebug(qLcPulseAudioEngine) << state;

++

++     if (state == PA_CONTEXT_FAILED)

++         QMetaObject::invokeMethod(self, &QPulseAudioContextManager::onContextFailed,

++                                   Qt::QueuedConnection);

++ }

++

++ Q_GLOBAL_STATIC(QPulseAudioContextManager, pulseEngine);

++

++ QPulseAudioContextManager::QPulseAudioContextManager(QObject *parent) : QObject(parent)

++ {

++     prepare();

++ }

++

++ QPulseAudioContextManager::~QPulseAudioContextManager()

++ {

++     release();

++ }

++

++ void QPulseAudioContextManager::prepare()

++ {

++     using namespace QPulseAudioInternal;

++     bool keepGoing = true;

++     bool ok = true;

++

++     m_mainLoop.reset(pa_threaded_mainloop_new());

++     if (m_mainLoop == nullptr) {

++         qCritical() << "PulseAudioService: unable to create pulseaudio mainloop";

++         return;

++     }

++

++     pa_threaded_mainloop_set_name(

++             m_mainLoop.get(), "QPulseAudioEngi"); // thread names are limited to 15 chars on linux

++

++     if (pa_threaded_mainloop_start(m_mainLoop.get()) != 0) {

++         qCritical() << "PulseAudioService: unable to start pulseaudio mainloop";

++         m_mainLoop = {};

++         return;

++     }

++

++     m_mainLoopApi = pa_threaded_mainloop_get_api(m_mainLoop.get());

++

++     std::unique_lock guard{ *this };

++

++     PAProplistHandle proplist{

++         pa_proplist_new(),

++     };

++     if (!QGuiApplication::applicationDisplayName().isEmpty())

++         pa_proplist_sets(proplist.get(), PA_PROP_APPLICATION_NAME,

++                          qUtf8Printable(QGuiApplication::applicationDisplayName()));

++     if (!QGuiApplication::desktopFileName().isEmpty())

++         pa_proplist_sets(proplist.get(), PA_PROP_APPLICATION_ID,

++                          qUtf8Printable(QGuiApplication::desktopFileName()));

++     if (const QString windowIconName = QGuiApplication::windowIcon().name();

++         !windowIconName.isEmpty())

++         pa_proplist_sets(proplist.get(), PA_PROP_WINDOW_ICON_NAME, qUtf8Printable(windowIconName));

++

++     m_context = PAContextHandle{

++         pa_context_new_with_proplist(m_mainLoopApi, nullptr, proplist.get()),

++         PAContextHandle::HasRef,

++     };

++

++     if (!m_context) {

++         qCritical() << "PulseAudioService: Unable to create new pulseaudio context";

++         guard.unlock();

++         m_mainLoop = {};

++         onContextFailed();

++         return;

++     }

++

++     pa_context_set_state_callback(m_context.get(), contextStateCallbackInit, this);

++

++     if (pa_context_connect(m_context.get(), nullptr, static_cast<pa_context_flags_t>(0), nullptr)

++         < 0) {

++         qWarning() << "PulseAudioService: pa_context_connect() failed";

++         m_context = {};

++         guard.unlock();

++         m_mainLoop = {};

++         return;

++     }

++

++     pa_threaded_mainloop_wait(m_mainLoop.get());

++

++     while (keepGoing) {

++         switch (pa_context_get_state(m_context.get())) {

++         case PA_CONTEXT_CONNECTING:

++         case PA_CONTEXT_AUTHORIZING:

++         case PA_CONTEXT_SETTING_NAME:

++             break;

++

++         case PA_CONTEXT_READY:

++             qCDebug(qLcPulseAudioEngine) << "Connection established.";

++             keepGoing = false;

++             break;

++

++         case PA_CONTEXT_TERMINATED:

++             qCritical("PulseAudioService: Context terminated.");

++             keepGoing = false;

++             ok = false;

++             break;

++

++         case PA_CONTEXT_FAILED:

++         default:

++             qCritical() << "PulseAudioService: Connection failure:"

++                         << currentError(m_context.get());

++             keepGoing = false;

++             ok = false;

++         }

++

++         if (keepGoing)

++             pa_threaded_mainloop_wait(m_mainLoop.get());

++     }

++

++     if (ok) {

++         pa_context_set_state_callback(m_context.get(), contextStateCallback, this);

++

++         pa_context_set_subscribe_callback(m_context.get(), eventCallback, this);

++         PAOperationHandle op{

++             pa_context_subscribe(m_context.get(),

++                                  pa_subscription_mask_t(PA_SUBSCRIPTION_MASK_SINK

++                                                         | PA_SUBSCRIPTION_MASK_SOURCE

++                                                         | PA_SUBSCRIPTION_MASK_SERVER),

++                                  nullptr, nullptr),

++             PAOperationHandle::HasRef,

++         };

++

++         if (!op)

++             qWarning() << "PulseAudioService: failed to subscribe to context notifications";

++     } else {

++         m_context = {};

++     }

++

++     guard.unlock();

++

++     if (ok) {

++         updateDevices();

++     } else {

++         m_mainLoop = {};

++         onContextFailed();

++     }

++ }

++

++ void QPulseAudioContextManager::release()

++ {

++     if (m_context) {

++         std::lock_guard lock{ *this };

++         pa_context_disconnect(m_context.get());

++         m_context = {};

++     }

++

++     if (m_mainLoop) {

++         pa_threaded_mainloop_stop(m_mainLoop.get());

++         m_mainLoop = {};

++     }

++ }

++

++ void QPulseAudioContextManager::updateDevices()

++ {

++     std::lock_guard lock(*this);

++

++     // Get default input and output devices

++     bool success = waitForAsyncOperation(

++             pa_context_get_server_info(m_context.get(), serverInfoCallback, this));

++

++     if (!success)

++         qWarning() << "PulseAudioService: failed to get server info";

++

++     // Get output devices

++     success = waitForAsyncOperation(

++             pa_context_get_sink_info_list(m_context.get(), sinkInfoCallback, this));

++

++     if (!success)

++         qWarning() << "PulseAudioService: failed to get sink info";

++

++     // Get input devices

++     success = waitForAsyncOperation(

++             pa_context_get_source_info_list(m_context.get(), sourceInfoCallback, this));

++

++     if (!success)

++         qWarning() << "PulseAudioService: failed to get source info";

++ }

++

++ void QPulseAudioContextManager::onContextFailed()

++ {

++     release();

++

++     // Try to reconnect later

++     QTimer::singleShot(3000, this, &QPulseAudioContextManager::prepare);

++ }

++

++ QPulseAudioContextManager *QPulseAudioContextManager::instance()

++ {

++     return pulseEngine();

++ }

++

++ void QPulseAudioContextManager::wait(const PAOperationHandle &op)

++ {

++     pa_operation_set_state_callback(op.get(), [](pa_operation *, void *userdata) {

++         auto *self = reinterpret_cast<QPulseAudioContextManager *>(userdata);

++         pa_threaded_mainloop_signal(self->mainloop(), 0);

++     }, this);

++

++     while (m_mainLoop && pa_operation_get_state(op.get()) == PA_OPERATION_RUNNING)

++         pa_threaded_mainloop_wait(m_mainLoop.get());

++

++     pa_operation_set_state_callback(op.get(), nullptr, nullptr);

++ }

++

++ bool QPulseAudioContextManager::waitForAsyncOperation(pa_operation *op)

++ {

++     PAOperationHandle operation{

++         op,

++         PAOperationHandle::HasRef,

++     };

++

++     return waitForAsyncOperation(operation);

++ }

++

++ bool QPulseAudioContextManager::waitForAsyncOperation(const PAOperationHandle &op)

++ {

++     if (!op)

++         return false;

++

++     wait(op);

++     return true;

++ }

++

++ QList<QAudioDevice> QPulseAudioContextManager::availableDevices(QAudioDevice::Mode mode) const

++ {

++     if (mode == QAudioDevice::Output) {

++         QReadLocker locker(&m_sinkLock);

++         return m_sinks.values();

++     }

++

++     if (mode == QAudioDevice::Input) {

++         QReadLocker locker(&m_sourceLock);

++         return m_sources.values();

++     }

++

++     return {};

++ }

++

++ QByteArray QPulseAudioContextManager::defaultDevice(QAudioDevice::Mode mode) const

++ {

++     return (mode == QAudioDevice::Output) ? m_defaultSink : m_defaultSource;

++ }

++

++ pa_context_state_t QPulseAudioContextManager::getContextState()

++ {

++     auto lock = std::lock_guard{ *this };

++     return pa_context_get_state(m_context.get());

++ }

++

++ bool QPulseAudioContextManager::contextIsGood()

++ {

++     return PA_CONTEXT_IS_GOOD(getContextState());

++ }

++

++ QString QPulseAudioContextManager::serverName()

++ {

++     QReadLocker locker(&pulseEngine->m_serverLock);

++     return m_serverName;

++ }

++

++ QT_END_NAMESPACE

Revision control