0.31.12

Author: atkAudioUser

lib/atkaudio/cmake/cpack.cmake

@@ -215,16 +215,9 @@ elseif(APPLE)
             COMPONENT plugin
     )
 
-    # Install scanner inside the bundle (for proper code signing)
-    if(TARGET atkaudio-pluginforobs_scanner)
-        install(
-            TARGETS
-                atkaudio-pluginforobs_scanner
-            RUNTIME
-                DESTINATION "${TARGET_NAME}.plugin/Contents/MacOS"
-                COMPONENT plugin
-        )
-    endif()
+    # Note: Scanner is copied into bundle during build (POST_BUILD in scanner/CMakeLists.txt)
+    # This ensures it's included in the bundle before CPack packages it.
+    # Do NOT install scanner separately here - it would be redundant and already in the bundle.
 
     # macOS: data files are installed inside bundle Resources/ via MACOSX_PACKAGE_LOCATION
     # No separate data directory needed (unlike Windows/Linux)

lib/atkaudio/src/atkaudio/AtomicSharedPtr.h

@@ -2,67 +2,114 @@
 
 #include <atomic>
 #include <memory>
+#include <vector>
 
 namespace atk
 {
 
+// Atomic shared_ptr wrapper compatible with Apple libc++ (which lacks std::atomic<shared_ptr>).
+// Uses a spinlock for synchronization - safe for infrequent updates from UI thread
+// with frequent reads from audio thread.
+//
+// THREAD SAFETY:
+// - All operations are thread-safe
+// - Readers spin briefly if a write is in progress (nanoseconds)
+//
+// DESTRUCTION SAFETY:
+// - Old values are held by the writer until the next store()
+// - This ensures destruction happens on the writer thread, not reader
+//
+// USAGE CONTRACT:
+// - Writers should be infrequent (UI thread updates)
+// - Readers can be frequent (audio thread)
+//
+// NOTE: memory_order parameters are accepted for API compatibility but ignored.
 template <typename T>
 class AtomicSharedPtr
 {
 public:
     AtomicSharedPtr()
-        : ptr(nullptr)
+        : spinlock(new std::atomic<bool>(false))
     {
     }
 
     explicit AtomicSharedPtr(std::shared_ptr<T> p)
-        : ptr(nullptr)
+        : ptr(std::move(p))
+        , spinlock(new std::atomic<bool>(false))
     {
-        store(std::move(p), std::memory_order_relaxed);
     }
 
     ~AtomicSharedPtr()
     {
-        auto p = ptr.exchange(nullptr, std::memory_order_relaxed);
-        delete p;
+        delete spinlock;
     }
 
-    // Non-copyable and non-movable (like std::atomic)
+    // Non-copyable and non-movable
     AtomicSharedPtr(const AtomicSharedPtr&) = delete;
     AtomicSharedPtr& operator=(const AtomicSharedPtr&) = delete;
     AtomicSharedPtr(AtomicSharedPtr&&) = delete;
     AtomicSharedPtr& operator=(AtomicSharedPtr&&) = delete;
 
-    std::shared_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const
+    std::shared_ptr<T> load([[maybe_unused]] std::memory_order order = std::memory_order_acquire) const
     {
-        auto p = ptr.load(order);
-        if (p)
-            return *p;
-        return std::shared_ptr<T>();
+        lock();
+        auto result = ptr;
+        unlock();
+        return result;
+    }
+
+    void store(std::shared_ptr<T> desired, [[maybe_unused]] std::memory_order order = std::memory_order_release)
+    {
+        (void)exchange(std::move(desired));
     }
 
-    void store(std::shared_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst)
+    [[nodiscard]] std::shared_ptr<T>
+    exchange(std::shared_ptr<T> desired, [[maybe_unused]] std::memory_order order = std::memory_order_acq_rel)
     {
-        auto newPtr = new std::shared_ptr<T>(std::move(desired));
-        auto oldPtr = ptr.exchange(newPtr, order);
-        delete oldPtr;
+        lock();
+        auto old = std::move(ptr);
+        ptr = std::move(desired);
+        unlock();
+
+        // Keep old values alive to ensure destruction happens here (writer thread),
+        // not when reader's copy goes out of scope.
+        if (old)
+            retained.push_back(std::move(old));
+
+        // Remove entries where we're the sole owner (refcount == 1)
+        // Safe to delete - no readers have copies
+        auto it = retained.begin();
+        while (it != retained.end())
+            if (it->use_count() == 1)
+                it = retained.erase(it);
+            else
+                ++it;
+
+        return retained.empty() ? nullptr : retained.back();
     }
 
-    std::shared_ptr<T> exchange(std::shared_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst)
+private:
+    void lock() const
     {
-        auto newPtr = new std::shared_ptr<T>(std::move(desired));
-        auto oldPtr = ptr.exchange(newPtr, order);
-        std::shared_ptr<T> result;
-        if (oldPtr)
+        bool expected = false;
+        while (!spinlock->compare_exchange_weak(expected, true, std::memory_order_acquire))
         {
-            result = *oldPtr;
-            delete oldPtr;
+            expected = false;
+            while (spinlock->load(std::memory_order_relaxed))
+                ;
         }
-        return result;
     }
 
-private:
-    mutable std::atomic<std::shared_ptr<T>*> ptr;
+    void unlock() const
+    {
+        spinlock->store(false, std::memory_order_release);
+    }
+
+    std::shared_ptr<T> ptr;
+    std::atomic<bool>* spinlock;
+
+    // Prevent destruction on reader thread by keeping old values alive
+    std::vector<std::shared_ptr<T>> retained;
 };
 
 } // namespace atk

lib/atkaudio/src/atkaudio/DeviceIo/DeviceIo.cpp

@@ -35,7 +35,7 @@ struct atk::DeviceIo::Impl
         // Update smoother if sample rate or target changed
         if (fadeGain.getTargetValue() != targetGain)
         {
-            fadeGain.reset(sampleRate, fadeDurationSeconds);
+            fadeGain.reset(sampleRate, fadeDurationSeconds.load(std::memory_order_acquire));
 
             // Clear buffers when transitioning from bypass to active
             if (!currentBypass)
@@ -138,9 +138,20 @@ struct atk::DeviceIo::Impl
         juce::XmlElement state("DEVICEIO_STATE");
         state.setAttribute("outputDelayMs", outputDelayMs.load(std::memory_order_acquire));
 
-        auto deviceState = deviceIoApp->getDeviceManager().createStateXml();
-        if (deviceState)
-            state.addChildElement(new juce::XmlElement(*deviceState));
+        // Use getAudioDeviceSetup() instead of createStateXml() to ensure
+        // channel configuration is always captured correctly
+        auto& dm = deviceIoApp->getDeviceManager();
+        auto setup = dm.getAudioDeviceSetup();
+
+        auto* deviceSetup = new juce::XmlElement("DEVICESETUP");
+        deviceSetup->setAttribute("deviceType", dm.getCurrentAudioDeviceType());
+        deviceSetup->setAttribute("audioOutputDeviceName", setup.outputDeviceName);
+        deviceSetup->setAttribute("audioInputDeviceName", setup.inputDeviceName);
+        deviceSetup->setAttribute("audioDeviceRate", setup.sampleRate);
+        deviceSetup->setAttribute("audioDeviceBufferSize", setup.bufferSize);
+        deviceSetup->setAttribute("audioDeviceInChans", setup.inputChannels.toString(2));
+        deviceSetup->setAttribute("audioDeviceOutChans", setup.outputChannels.toString(2));
+        state.addChildElement(deviceSetup);
 
         s = state.toString().toStdString();
     }
@@ -243,7 +254,7 @@ struct atk::DeviceIo::Impl
     bool mixInput = false;
     std::atomic<bool> bypass{false};
     juce::SmoothedValue<float, juce::ValueSmoothingTypes::Linear> fadeGain{1.0f};
-    static constexpr double fadeDurationSeconds = 0.5;
+    std::atomic<double> fadeDurationSeconds{0.5};
 
 public:
     void setBypass(bool v)
@@ -255,6 +266,11 @@ struct atk::DeviceIo::Impl
     {
         return bypass.load(std::memory_order_acquire);
     }
+
+    void setFadeTime(double seconds)
+    {
+        fadeDurationSeconds.store(seconds, std::memory_order_release);
+    }
 };
 
 void atk::DeviceIo::process(float** buffer, int numChannels, int numSamples, double sampleRate)
@@ -273,6 +289,12 @@ bool atk::DeviceIo::isBypassed() const
     return pImpl ? pImpl->isBypassed() : false;
 }
 
+void atk::DeviceIo::setFadeTime(double seconds)
+{
+    if (pImpl)
+        pImpl->setFadeTime(seconds);
+}
+
 void atk::DeviceIo::setMixInput(bool mixInput)
 {
     pImpl->setMixInput(mixInput);

lib/atkaudio/src/atkaudio/DeviceIo/DeviceIo.h

@@ -18,6 +18,9 @@ class DeviceIo : public atkAudioModule
     void setBypass(bool shouldBypass);
     bool isBypassed() const;
 
+    // Set the fade time for bypass transitions (in seconds)
+    void setFadeTime(double seconds);
+
     void setMixInput(bool mixInput);
     void setOutputDelay(float delayMs);
     float getOutputDelay() const;

lib/atkaudio/src/atkaudio/DeviceIo2/DeviceIo2.cpp

@@ -33,7 +33,7 @@ struct atk::DeviceIo2::Impl : public juce::AsyncUpdater
     bool delayPrepared = false;
     std::atomic<bool> bypass{false};
     juce::SmoothedValue<float, juce::ValueSmoothingTypes::Linear> fadeGain{1.0f};
-    static constexpr double fadeDurationSeconds = 0.5;
+    std::atomic<double> fadeDurationSeconds{0.5};
 
     enum class UpdateType
     {
@@ -203,7 +203,7 @@ struct atk::DeviceIo2::Impl : public juce::AsyncUpdater
         // Update smoother if target changed
         if (fadeGain.getTargetValue() != targetGain)
         {
-            fadeGain.reset(sampleRate, fadeDurationSeconds);
+            fadeGain.reset(sampleRate, fadeDurationSeconds.load(std::memory_order_acquire));
 
             // Clear buffers when transitioning from bypass to active
             if (!currentBypass)
@@ -586,6 +586,12 @@ bool atk::DeviceIo2::isBypassed() const
     return pImpl ? pImpl->bypass.load(std::memory_order_acquire) : false;
 }
 
+void atk::DeviceIo2::setFadeTime(double seconds)
+{
+    if (pImpl)
+        pImpl->fadeDurationSeconds.store(seconds, std::memory_order_release);
+}
+
 void atk::DeviceIo2::setOutputDelay(float delayMs)
 {
     if (pImpl)

lib/atkaudio/src/atkaudio/DeviceIo2/DeviceIo2.h

@@ -19,6 +19,9 @@ class DeviceIo2 : public atkAudioModule
     void setBypass(bool shouldBypass);
     bool isBypassed() const;
 
+    // Set the fade time for bypass transitions (in seconds)
+    void setFadeTime(double seconds);
+
     void setOutputDelay(float delayMs);
     float getOutputDelay() const;
 

lib/atkaudio/src/atkaudio/ModuleInfrastructure/AudioServer/AudioServer.cpp

@@ -1539,29 +1539,43 @@ void AudioServer::updateClientSubscriptions(void* clientId, const AudioClientSta
         std::vector<ChannelSubscription> newOutput =
             (newOutputIt != newOutputSubs.end()) ? newOutputIt->second : std::vector<ChannelSubscription>{};
 
-        // ATOMIC: Remove old + Add new in single locked operation
+        // ATOMIC: Update subscriptions in single locked operation
+        // IMPORTANT: Preserve existing SyncBuffers to avoid audio discontinuity
         {
             std::unique_lock<std::mutex> handlerLock(handler->clientBuffersMutex);
             bool snapshotDirty = false;
 
             auto bufferIt = handler->clientBuffers.find(clientId);
             if (bufferIt != handler->clientBuffers.end())
             {
-                // Clear old subscriptions
-                bufferIt->second.inputBuffer.reset();
-                bufferIt->second.outputBuffer.reset();
-                bufferIt->second.inputMappings.clear();
-                bufferIt->second.outputMappings.clear();
-
-                snapshotDirty = true;
-
                 // If no new subscriptions for this device, remove client entry entirely
                 if (newInput.empty() && newOutput.empty())
                 {
+                    bufferIt->second.inputBuffer.reset();
+                    bufferIt->second.outputBuffer.reset();
+                    bufferIt->second.inputMappings.clear();
+                    bufferIt->second.outputMappings.clear();
                     handler->clientBuffers.erase(bufferIt);
                     handler->rebuildSnapshotLocked();
                     continue;
                 }
+
+                // Preserve existing SyncBuffers - only clear mappings
+                // This prevents audio discontinuity when adding/removing channels
+                bufferIt->second.inputMappings.clear();
+                bufferIt->second.outputMappings.clear();
+
+                // Only reset buffers if subscription type is being removed entirely
+                if (newInput.empty() && bufferIt->second.inputBuffer)
+                {
+                    bufferIt->second.inputBuffer.reset();
+                    snapshotDirty = true;
+                }
+                if (newOutput.empty() && bufferIt->second.outputBuffer)
+                {
+                    bufferIt->second.outputBuffer.reset();
+                    snapshotDirty = true;
+                }
             }
             else if (newInput.empty() && newOutput.empty())
             {