Safeguard port creation when PipeWire server not connected

Author: pri-yan-shu

src/soundio/pipewireenumerator.cpp

@@ -83,6 +83,7 @@ PipewireEnumerator::~PipewireEnumerator() {
     pw_thread_loop_stop(m_pPwThreadLoop);
 
     if (m_pPwFilter) {
+        spa_hook_remove(&m_pwFilterListener);
         pw_filter_destroy(m_pPwFilter);
     }
 
@@ -110,7 +111,6 @@ PipewireEnumerator::~PipewireEnumerator() {
 
 void PipewireEnumerator::initialize() {
     if (m_initialized) {
-        qWarning() << "PipewireEnumerator::initialize already initialized";
         return;
     }
 
@@ -158,6 +158,16 @@ void PipewireEnumerator::initialize() {
 
     pw_filter_add_listener(m_pPwFilter, &m_pwFilterListener, &filter_events, this);
 
+    const auto registeredOutputs = m_pSoundManager->registeredOutputs();
+    for (const auto& output : registeredOutputs) {
+        createOutputPorts(output);
+    }
+
+    const auto registeredInputs = m_pSoundManager->registeredInputs();
+    for (const auto& input : registeredInputs) {
+        createInputPorts(input);
+    }
+
     int res = pw_filter_connect(m_pPwFilter,
             PW_FILTER_FLAG_RT_PROCESS,
             nullptr,
@@ -491,10 +501,11 @@ void PipewireEnumerator::callback(const spa_io_position* pos) {
     const uint64_t framesPerBuffer = pos->clock.duration;
 
     if (sampleRate != m_sampleRate || framesPerBuffer != m_framesPerBuffer) {
-        qWarning() << "PipewireEnumerator::callback rate requested"
-                   << m_sampleRate << "provided" << sampleRate
-                   << "buffer size requested" << m_framesPerBuffer << "provided"
-                   << framesPerBuffer;
+        qWarning() << "PipewireEnumerator::callback"
+                      "requested"
+                   << m_framesPerBuffer << "samples at" << m_sampleRate << "hz,"
+                                                                           "provided"
+                   << framesPerBuffer << "samples at" << sampleRate << "hz";
         setLatency(sampleRate, framesPerBuffer);
     }
 
@@ -504,7 +515,7 @@ void PipewireEnumerator::callback(const spa_io_position* pos) {
     for (uint32_t deviceId : m_openedDevices) {
         QSharedPointer<SoundDevicePipewire> device = m_soundDevices.at(deviceId);
         QList<AudioInputBuffer> deviceInputs = device->inputs();
-        for (AudioInputBuffer input : deviceInputs) {
+        for (const AudioInputBuffer& input : deviceInputs) {
             ChannelGroup channelGroup = input.getChannelGroup();
             const int iChannelCount = channelGroup.getChannelCount();
             const int iChannelBase = channelGroup.getChannelBase();
@@ -543,7 +554,7 @@ void PipewireEnumerator::callback(const spa_io_position* pos) {
 
     for (uint32_t deviceId : m_openedDevices) {
         QSharedPointer<SoundDevicePipewire> device = m_soundDevices.at(deviceId);
-        for (AudioOutputBuffer output : device->outputs()) {
+        for (const AudioOutputBuffer& output : device->outputs()) {
             ChannelGroup chanGroup = output.getChannelGroup();
             const int iChannelCount = chanGroup.getChannelCount();
             const int iChannelBase = chanGroup.getChannelBase();
@@ -637,72 +648,71 @@ void PipewireEnumerator::registerInput(const AudioInput& input, AudioDestination
         return;
     }
 
-    pw_thread_loop_lock(m_pPwThreadLoop);
-    pw_properties* props = pw_properties_new(
-            // see pipewire/keys.h header
-            PW_KEY_FORMAT_DSP,
-            "32 bit float mono audio",
-            nullptr);
-    pw_properties_setf(props, PW_KEY_PORT_NAME, "%s:FL", input.getString().toStdString().c_str());
-    void* portFL = pw_filter_add_port(m_pPwFilter,
-            SPA_DIRECTION_INPUT,
-            PW_FILTER_PORT_FLAG_MAP_BUFFERS,
-            sizeof(uint32_t),
-            props,
-            nullptr,
-            0);
-
-    props = pw_properties_new(
-            // see pipewire/keys.h header
-            PW_KEY_FORMAT_DSP,
-            "32 bit float mono audio",
-            nullptr);
-    pw_properties_setf(props, PW_KEY_PORT_NAME, "%s:FR", input.getString().toStdString().c_str());
-    void* portFR = pw_filter_add_port(m_pPwFilter,
-            SPA_DIRECTION_INPUT,
-            PW_FILTER_PORT_FLAG_MAP_BUFFERS,
-            sizeof(uint32_t),
-            props,
-            nullptr,
-            0);
-    pw_thread_loop_unlock(m_pPwThreadLoop);
-    m_inputs.insert(input,
-            std::pair{static_cast<uint32_t*>(portFL),
-                    static_cast<uint32_t*>(portFR)});
+    if (m_initialized) {
+        pw_thread_loop_lock(m_pPwThreadLoop);
+        createInputPorts(input);
+        pw_thread_loop_unlock(m_pPwThreadLoop);
+    }
 }
 
 void PipewireEnumerator::registerOutput(const AudioOutput& output, AudioSource*) {
-    pw_thread_loop_lock(m_pPwThreadLoop);
+    if (m_initialized) {
+        pw_thread_loop_lock(m_pPwThreadLoop);
+        createOutputPorts(output);
+        pw_thread_loop_unlock(m_pPwThreadLoop);
+    }
+}
+
+// need to pw_thread_loop_lock before calling this
+uint32_t* PipewireEnumerator::createPorts(const AudioPath& path, bool channel) {
+    spa_direction direction;
+    switch (path.getType()) {
+    case AudioPathType::Main:
+    case AudioPathType::Headphones:
+    case AudioPathType::Booth:
+    case AudioPathType::Bus:
+    case AudioPathType::Deck:
+        direction = SPA_DIRECTION_OUTPUT;
+        break;
+    case AudioPathType::VinylControl:
+    case AudioPathType::Microphone:
+    case AudioPathType::Auxiliary:
+    case AudioPathType::RecordBroadcast:
+        direction = SPA_DIRECTION_INPUT;
+        break;
+    default:
+        qWarning() << "PipewireEnumerator::createPorts path type AudioPathType::Invalid";
+        return nullptr;
+    }
+
     pw_properties* props = pw_properties_new(
             // see pipewire/keys.h header
             PW_KEY_FORMAT_DSP,
             "32 bit float mono audio",
             nullptr);
-    pw_properties_setf(props, PW_KEY_PORT_NAME, "%s:FL", output.getString().toStdString().c_str());
-    void* portFL = pw_filter_add_port(m_pPwFilter,
-            SPA_DIRECTION_OUTPUT,
+    pw_properties_setf(props,
+            PW_KEY_PORT_NAME,
+            channel ? "%s:FR" : "%s:FL",
+            path.getString().toStdString().c_str());
+    return static_cast<uint32_t*>(pw_filter_add_port(m_pPwFilter,
+            direction,
             PW_FILTER_PORT_FLAG_MAP_BUFFERS,
             sizeof(uint32_t),
             props,
             nullptr,
-            0);
-    props = pw_properties_new(
-            // see pipewire/keys.h header
-            PW_KEY_FORMAT_DSP,
-            "32 bit float mono audio",
-            nullptr);
-    pw_properties_setf(props, PW_KEY_PORT_NAME, "%s:FR", output.getString().toStdString().c_str());
-    void* portFR = pw_filter_add_port(m_pPwFilter,
-            SPA_DIRECTION_OUTPUT,
-            PW_FILTER_PORT_FLAG_MAP_BUFFERS,
-            sizeof(uint32_t),
-            props,
-            nullptr,
-            0);
-    pw_thread_loop_unlock(m_pPwThreadLoop);
-    m_outputs.insert(output,
-            std::pair{static_cast<uint32_t*>(portFL),
-                    static_cast<uint32_t*>(portFR)});
+            0));
+}
+
+// need to pw_thread_loop_lock before calling this
+void PipewireEnumerator::createInputPorts(const AudioInput& input) {
+    auto ports = std::pair{createPorts(input, false), createPorts(input, true)};
+    m_inputs.insert(input, ports);
+}
+
+// need to pw_thread_loop_lock before calling this
+void PipewireEnumerator::createOutputPorts(const AudioOutput& output) {
+    auto ports = std::pair{createPorts(output, false), createPorts(output, true)};
+    m_outputs.insert(output, ports);
 }
 
 void PipewireEnumerator::setLatency(unsigned int sampleRate, unsigned int framesPerBuffer) {

src/soundio/pipewireenumerator.h

@@ -115,6 +115,9 @@ class PipewireEnumerator : public SoundDeviceEnumerator {
 
     void updateAudioLatencyUsage(const SINT framesPerBuffer);
     void setLatency(unsigned int sampleRate, unsigned int framesPerBuffer);
+    void createInputPorts(const AudioInput& path);
+    void createOutputPorts(const AudioOutput& path);
+    uint32_t* createPorts(const AudioPath& path, bool channel);
 
     struct Link {
         uint32_t input;