File indexing completed on 2024-04-21 16:20:30

 /*
     SPDX-FileCopyrightText: 2014-2015 Harald Sitter <sitter@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #ifndef CONTEXT_H
 #define CONTEXT_H
 
 #include <QMutex>
 #include <QObject>
 #include <QSet>
 
 #include <pulse/ext-stream-restore.h>
 #include <pulse/glib-mainloop.h>
 #include <pulse/mainloop.h>
 #include <pulse/pulseaudio.h>
 
 #include "maps.h"
 #include "operation.h"
 
 namespace QPulseAudio
 {
 class Server;
 
 class Context : public QObject
 {
     Q_OBJECT
 public:
     explicit Context(QObject *parent = nullptr);
     ~Context() override;
 
     static Context *instance();
 
     static const qint64 NormalVolume;
     static const qint64 MinimalVolume;
     static const qint64 MaximalVolume;
 
     void ref();
     void unref();
 
     bool isValid()
     {
         return m_context && m_mainloop;
     }
 
     pa_context *context() const
     {
         return m_context;
     }
 
     const SinkMap &sinks() const
     {
         return m_sinks;
     }
     const SinkInputMap &sinkInputs() const
     {
         return m_sinkInputs;
     }
     const SourceMap &sources() const
     {
         return m_sources;
     }
     const SourceOutputMap &sourceOutputs() const
     {
         return m_sourceOutputs;
     }
     const ClientMap &clients() const
     {
         return m_clients;
     }
     const CardMap &cards() const
     {
         return m_cards;
     }
     const ModuleMap &modules() const
     {
         return m_modules;
     }
     const StreamRestoreMap &streamRestores() const
     {
         return m_streamRestores;
     }
     Server *server() const
     {
         return m_server;
     }
     QString newDefaultSink() const
     {
         return m_newDefaultSink;
     }
     QString newDefaultSource() const
     {
         return m_newDefaultSource;
     }
 
     void subscribeCallback(pa_context *context, pa_subscription_event_type_t type, uint32_t index);
     void contextStateCallback(pa_context *context);
 
     void sinkCallback(const pa_sink_info *info);
     void sinkInputCallback(const pa_sink_input_info *info);
     void sourceCallback(const pa_source_info *info);
     void sourceOutputCallback(const pa_source_output_info *info);
     void clientCallback(const pa_client_info *info);
     void cardCallback(const pa_card_info *info);
     void moduleCallback(const pa_module_info *info);
     void streamRestoreCallback(const pa_ext_stream_restore_info *info);
     void serverCallback(const pa_server_info *info);
 
     void setCardProfile(quint32 index, const QString &profile);
     void setDefaultSink(const QString &name);
     void setDefaultSource(const QString &name);
     void streamRestoreWrite(const pa_ext_stream_restore_info *info);
 
     static void setApplicationId(const QString &applicationId);
 
     template<typename PAFunction>
     void setGenericVolume(quint32 index, int channel, qint64 newVolume, pa_cvolume cVolume, PAFunction pa_set_volume)
     {
         if (!m_context) {
             return;
         }
         newVolume = qBound<qint64>(0, newVolume, PA_VOLUME_MAX);
         pa_cvolume newCVolume = cVolume;
         if (channel == -1) { // -1 all channels
             const qint64 orig = pa_cvolume_max(&cVolume);
             const qint64 diff = newVolume - orig;
             for (int i = 0; i < newCVolume.channels; ++i) {
                 const qint64 channel = newCVolume.values[i];
                 const qint64 channelDiff = orig == 0 ? diff : diff * channel / orig;
                 newCVolume.values[i] = qBound<qint64>(0, newCVolume.values[i] + channelDiff, PA_VOLUME_MAX);
             }
         } else {
             Q_ASSERT(newCVolume.channels > channel);
             newCVolume.values[channel] = newVolume;
         }
         if (!PAOperation(pa_set_volume(m_context, index, &newCVolume, nullptr, nullptr))) {
             qCWarning(PLASMAPA) << "pa_set_volume failed";
             return;
         }
     }
 
     template<typename PAFunction>
     void setGenericVolumes(quint32 index, QVector<qint64> channelVolumes, pa_cvolume cVolume, PAFunction pa_set_volume)
     {
         if (!m_context) {
             return;
         }
         Q_ASSERT(channelVolumes.count() == cVolume.channels);
 
         pa_cvolume newCVolume = cVolume;
         for (int i = 0; i < channelVolumes.count(); ++i) {
             newCVolume.values[i] = qBound<qint64>(0, channelVolumes.at(i), PA_VOLUME_MAX);
         }
 
         if (!PAOperation(pa_set_volume(m_context, index, &newCVolume, nullptr, nullptr))) {
             qCWarning(PLASMAPA) << "pa_set_volume failed";
             return;
         }
     }
 
     template<typename PAFunction>
     void setGenericMute(quint32 index, bool mute, PAFunction pa_set_mute)
     {
         if (!m_context) {
             return;
         }
         if (!PAOperation(pa_set_mute(m_context, index, mute, nullptr, nullptr))) {
             qCWarning(PLASMAPA) << "pa_set_mute failed";
             return;
         }
     }
 
     template<typename PAFunction>
     void setGenericPort(quint32 index, const QString &portName, PAFunction pa_set_port)
     {
         if (!m_context) {
             return;
         }
         if (!PAOperation(pa_set_port(m_context, index, portName.toUtf8().constData(), nullptr, nullptr))) {
             qCWarning(PLASMAPA) << "pa_set_port failed";
             return;
         }
     }
 
     template<typename PAFunction>
     void setGenericDeviceForStream(quint32 streamIndex, quint32 deviceIndex, PAFunction pa_move_stream_to_device)
     {
         if (!m_context) {
             return;
         }
         if (!PAOperation(pa_move_stream_to_device(m_context, streamIndex, deviceIndex, nullptr, nullptr))) {
             qCWarning(PLASMAPA) << "pa_move_stream_to_device failed";
             return;
         }
     }
 
 private:
     void connectToDaemon();
     void reset();
 
     // Don't forget to add things to reset().
     SinkMap m_sinks;
     SinkInputMap m_sinkInputs;
     SourceMap m_sources;
     SourceOutputMap m_sourceOutputs;
     ClientMap m_clients;
     CardMap m_cards;
     ModuleMap m_modules;
     StreamRestoreMap m_streamRestores;
     Server *m_server;
 
     pa_context *m_context;
     pa_glib_mainloop *m_mainloop;
 
     QString m_newDefaultSink;
     QString m_newDefaultSource;
 
     int m_references;
     static Context *s_context;
     static QString s_applicationId;
 };
 
 } // QPulseAudio
 
 #endif // CONTEXT_H