0.31.9

Author: atkAudioUser

buildspec.json

@@ -47,6 +47,6 @@
   "uuids": {
     "windowsApp": "ad885c58-5ca9-44de-8f4f-1c12676626a9"
   },
-  "version": "0.31.8",
+  "version": "0.31.9",
   "website": "https://www.atkaudio.com"
 }

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

@@ -29,6 +29,21 @@ struct atk::DeviceIo::Impl
 
     void process(float** buffer, int numChannels, int numSamples, double sampleRate)
     {
+        bool currentBypass = bypass.load(std::memory_order_acquire);
+        bool wasJustBypassed = wasBypassed.exchange(currentBypass, std::memory_order_acq_rel);
+
+        if (currentBypass)
+            return;
+
+        // Clear stale data from buffers when transitioning from bypassed to active
+        if (wasJustBypassed)
+        {
+            auto& toObsBuffer = deviceIoApp->getToObsBuffer();
+            auto& fromObsBuffer = deviceIoApp->getFromObsBuffer();
+            toObsBuffer.reset();
+            fromObsBuffer.reset();
+        }
+
         if (tempBuffer.getNumChannels() < numChannels || tempBuffer.getNumSamples() < numSamples)
             tempBuffer.setSize(numChannels, numSamples, false, false, true);
 
@@ -207,13 +222,37 @@ struct atk::DeviceIo::Impl
     bool delayPrepared = false;
 
     bool mixInput = false;
+    std::atomic<bool> bypass{false};
+    std::atomic<bool> wasBypassed{false};
+
+public:
+    void setBypass(bool v)
+    {
+        bypass.store(v, std::memory_order_release);
+    }
+
+    bool isBypassed() const
+    {
+        return bypass.load(std::memory_order_acquire);
+    }
 };
 
 void atk::DeviceIo::process(float** buffer, int numChannels, int numSamples, double sampleRate)
 {
     pImpl->process(buffer, numChannels, numSamples, sampleRate);
 }
 
+void atk::DeviceIo::setBypass(bool shouldBypass)
+{
+    if (pImpl)
+        pImpl->setBypass(shouldBypass);
+}
+
+bool atk::DeviceIo::isBypassed() const
+{
+    return pImpl ? pImpl->isBypassed() : false;
+}
+
 void atk::DeviceIo::setMixInput(bool mixInput)
 {
     pImpl->setMixInput(mixInput);

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

@@ -14,6 +14,10 @@ class DeviceIo : public atkAudioModule
 
     void process(float** buffer, int numChannels, int numSamples, double sampleRate) override;
 
+    // Bypass processing when filter should be inactive (e.g., not in scene)
+    void setBypass(bool shouldBypass);
+    bool isBypassed() const;
+
     void setMixInput(bool mixInput);
     void setOutputDelay(float delayMs);
     float getOutputDelay() const;

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

@@ -31,6 +31,8 @@ struct atk::DeviceIo2::Impl : public juce::AsyncUpdater
     std::vector<juce::dsp::DelayLine<float, juce::dsp::DelayLineInterpolationTypes::Linear>> outputDelayLines;
     std::vector<juce::SmoothedValue<float, juce::ValueSmoothingTypes::Linear>> outputDelaySmooth;
     bool delayPrepared = false;
+    std::atomic<bool> bypass{false};
+    std::atomic<bool> wasBypassed{false};
 
     enum class UpdateType
     {
@@ -194,6 +196,16 @@ struct atk::DeviceIo2::Impl : public juce::AsyncUpdater
 
     void process(float** buffer, int numChannels, int numSamples, double sampleRate)
     {
+        bool currentBypass = bypass.load(std::memory_order_acquire);
+        bool wasJustBypassed = wasBypassed.exchange(currentBypass, std::memory_order_acq_rel);
+
+        // When bypassed, leave buffer as-is and skip IO routing
+        if (currentBypass)
+            return;
+
+        // Clear stale data from AudioClient buffers when transitioning from bypassed to active
+        if (wasJustBypassed)
+            audioClient.clearBuffers();
         bool needsReconfiguration =
             preparedNumChannels != numChannels || preparedNumSamples < numSamples || preparedSampleRate != sampleRate;
 
@@ -543,6 +555,17 @@ void atk::DeviceIo2::process(float** buffer, int numChannels, int numSamples, do
         pImpl->process(buffer, numChannels, numSamples, sampleRate);
 }
 
+void atk::DeviceIo2::setBypass(bool shouldBypass)
+{
+    if (pImpl)
+        pImpl->bypass.store(shouldBypass, std::memory_order_release);
+}
+
+bool atk::DeviceIo2::isBypassed() const
+{
+    return pImpl ? pImpl->bypass.load(std::memory_order_acquire) : false;
+}
+
 void atk::DeviceIo2::setOutputDelay(float delayMs)
 {
     if (pImpl)

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

@@ -15,6 +15,10 @@ class DeviceIo2 : public atkAudioModule
 
     void process(float** buffer, int numChannels, int numSamples, double sampleRate) override;
 
+    // When bypassed, DeviceIo2 does no processing and leaves the buffer untouched
+    void setBypass(bool shouldBypass);
+    bool isBypassed() const;
+
     void setOutputDelay(float delayMs);
     float getOutputDelay() const;
 

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

@@ -419,6 +419,23 @@ void AudioClient::pushSubscribedOutputs(const juce::AudioBuffer<float>& deviceBu
     }
 }
 
+void AudioClient::clearBuffers()
+{
+    auto snapshot = bufferSnapshot.load(std::memory_order_acquire);
+    if (!snapshot)
+        return;
+
+    // Clear all input buffers
+    for (const auto& bufRef : snapshot->inputBuffers)
+        if (bufRef.buffer)
+            bufRef.buffer->reset();
+
+    // Clear all output buffers
+    for (const auto& bufRef : snapshot->outputBuffers)
+        if (bufRef.buffer)
+            bufRef.buffer->reset();
+}
+
 void AudioClient::setSubscriptions(const AudioClientState& state)
 {
     if (auto* server = AudioServer::getInstanceWithoutCreating())

lib/atkaudio/src/atkaudio/ModuleInfrastructure/AudioServer/AudioServer.h

@@ -146,6 +146,7 @@ class AudioClient
 
     void pullSubscribedInputs(juce::AudioBuffer<float>& deviceBuffer, int numSamples, double sampleRate);
     void pushSubscribedOutputs(const juce::AudioBuffer<float>& deviceBuffer, int numSamples, double sampleRate);
+    void clearBuffers();
     void setSubscriptions(const AudioClientState& state);
     AudioClientState getSubscriptions() const;
 

lib/atkaudio/src/atkaudio/PluginHost2/Core/DeviceIo2Plugin.h

@@ -82,6 +82,9 @@ class DeviceIo2Plugin final : public juce::AudioProcessor
         if (!deviceIo2)
             return;
 
+        if (deviceIo2->isBypassed())
+            return;
+
         // Convert JUCE buffer to raw pointer format expected by DeviceIo2
         const int numChannels = buffer.getNumChannels();
         const int numSamples = buffer.getNumSamples();

src/device_io.cpp

@@ -194,6 +194,9 @@ static struct obs_audio_data* devio_filter(void* data, struct obs_audio_data* au
         for (size_t j = 0; j < frames; j++)
             adata[i][j] *= outputGain;
 
+    if (obs_source_t* parent = obs_filter_get_parent(adio->context))
+        adio->deviceIo.setBypass(!obs_source_active(parent));
+
     adio->deviceIo.setMixInput(adio->mixInput.load(std::memory_order_acquire));
     adio->deviceIo.process(adata, channels, frames, adio->sampleRate);
 

src/device_io2.cpp

@@ -187,6 +187,9 @@ static struct obs_audio_data* deviceio2_filter(void* data, struct obs_audio_data
         for (size_t j = 0; j < frames; j++)
             adata[i][j] *= outputGain;
 
+    if (obs_source_t* parent = obs_filter_get_parent(adio->context))
+        adio->deviceIo2.setBypass(!obs_source_active(parent));
+
     adio->deviceIo2.process(adata, channels, frames, adio->sampleRate);
 
     auto inputGain = adio->inputGain.load(std::memory_order_acquire);