File indexing completed on 2024-12-01 05:05:12

 /*
     SPDX-FileCopyrightText: 2016 David Rosca <nowrep@gmail.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "streamrestore.h"
 #include "context.h"
 #include "debug.h"
 
 namespace QPulseAudio
 {
 StreamRestore::StreamRestore(quint32 index, const QVariantMap &properties, QObject *parent)
     : PulseObject(parent)
 {
     memset(&m_volume, 0, sizeof(m_volume));
     memset(&m_channelMap, 0, sizeof(m_channelMap));
 
     m_index = index;
     m_properties = properties;
 }
 
 void StreamRestore::update(const pa_ext_stream_restore_info *info)
 {
     m_cache.valid = false;
     const QString infoName = QString::fromUtf8(info->name);
     if (m_name != infoName) {
         m_name = infoName;
         Q_EMIT nameChanged();
     }
     const QString infoDevice = QString::fromUtf8(info->device);
     if (m_device != infoDevice) {
         m_device = infoDevice;
         Q_EMIT deviceChanged();
     }
     if (m_muted != info->mute) {
         m_muted = info->mute;
         Q_EMIT mutedChanged();
     }
     if (!pa_cvolume_equal(&m_volume, &info->volume)) {
         m_volume = info->volume;
         Q_EMIT volumeChanged();
         Q_EMIT channelVolumesChanged();
     }
     if (!pa_channel_map_equal(&m_channelMap, &info->channel_map)) {
         m_channels.clear();
         m_channels.reserve(info->channel_map.channels);
         for (int i = 0; i < info->channel_map.channels; ++i) {
             m_channels << QString::fromUtf8(pa_channel_position_to_pretty_string(info->channel_map.map[i]));
         }
         m_channelMap = info->channel_map;
         Q_EMIT channelsChanged();
     }
 }
 
 QString StreamRestore::name() const
 {
     return m_name;
 }
 
 QString StreamRestore::device() const
 {
     return m_device;
 }
 
 void StreamRestore::setDevice(const QString &device)
 {
     if (m_cache.valid) {
         if (m_cache.device != device) {
             writeChanges(m_cache.volume, m_cache.muted, device);
         }
     } else {
         if (m_device != device) {
             writeChanges(m_volume, m_muted, device);
         }
     }
 }
 
 qint64 StreamRestore::volume() const
 {
     // FIXME: workaround for pipewire not supporting stream restore subscription
     // revert when fix is released
     // https://gitlab.freedesktop.org/pipewire/pipewire/-/issues/3805
     if (m_cache.valid) {
         return m_cache.volume.values[0];
     } else {
         return m_volume.values[0];
     }
 }
 
 void StreamRestore::setVolume(qint64 volume)
 {
     pa_cvolume vol = m_cache.valid ? m_cache.volume : m_volume;
 
     // If no channel exists force one. We need one to be able to control the volume
     // See https://bugs.kde.org/show_bug.cgi?id=407397
     if (vol.channels == 0) {
         vol.channels = 1;
     }
 
     for (int i = 0; i < vol.channels; ++i) {
         vol.values[i] = volume;
     }
 
     if (m_cache.valid) {
         writeChanges(vol, m_cache.muted, m_cache.device);
     } else {
         writeChanges(vol, m_muted, m_device);
     }
 }
 
 bool StreamRestore::isMuted() const
 {
     // FIXME: workaround for pipewire not supporting stream restore subscription
     // revert when fix is released
     // https://gitlab.freedesktop.org/pipewire/pipewire/-/issues/3805
     if (m_cache.valid) {
         return m_cache.muted;
     } else {
         return m_muted;
     }
 }
 
 void StreamRestore::setMuted(bool muted)
 {
     if (m_cache.valid) {
         if (m_cache.muted != muted) {
             writeChanges(m_cache.volume, muted, m_cache.device);
         }
     } else {
         if (m_muted != muted) {
             writeChanges(m_volume, muted, m_device);
         }
     }
 }
 
 bool StreamRestore::hasVolume() const
 {
     return true;
 }
 
 bool StreamRestore::isVolumeWritable() const
 {
     return true;
 }
 
 QStringList StreamRestore::channels() const
 {
     return m_channels;
 }
 
 QList<qreal> StreamRestore::channelVolumes() const
 {
     QList<qreal> ret;
     ret.reserve(m_volume.channels);
     for (int i = 0; i < m_volume.channels; ++i) {
         ret << m_volume.values[i];
     }
     return ret;
 }
 
 void StreamRestore::setChannelVolume(int channel, qint64 volume)
 {
     Q_ASSERT(channel >= 0 && channel < m_volume.channels);
     pa_cvolume vol = m_cache.valid ? m_cache.volume : m_volume;
     vol.values[channel] = volume;
 
     if (m_cache.valid) {
         writeChanges(vol, m_cache.muted, m_cache.device);
     } else {
         writeChanges(vol, m_muted, m_device);
     }
 }
 
 quint32 StreamRestore::deviceIndex() const
 {
     return PA_INVALID_INDEX;
 }
 
 void StreamRestore::setDeviceIndex(quint32 deviceIndex)
 {
     Q_UNUSED(deviceIndex);
     qCWarning(PLASMAPA) << "Not implemented";
 }
 
 void StreamRestore::writeChanges(const pa_cvolume &volume, bool muted, const QString &device)
 {
     const QByteArray nameData = m_name.toUtf8();
     const QByteArray deviceData = device.toUtf8();
 
     pa_ext_stream_restore_info info;
     info.name = nameData.constData();
     info.channel_map = m_channelMap;
     info.volume = volume;
     info.device = deviceData.isEmpty() ? nullptr : deviceData.constData();
     info.mute = muted;
 
     // If no channel exists force one. We need one to be able to control the volume
     // See https://bugs.kde.org/show_bug.cgi?id=407397
     if (info.channel_map.channels == 0) {
         info.channel_map.channels = 1;
         info.channel_map.map[0] = PA_CHANNEL_POSITION_MONO;
     }
 
     m_cache.valid = true;
     m_cache.volume = volume;
     m_cache.muted = muted;
     m_cache.device = device;
 
     context()->streamRestoreWrite(&info);
 }
 
 } // QPulseAudio