0.27.1

Author: atkAudioUser

buildspec.json

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

lib/atkaudio/CMakeLists.txt

@@ -44,6 +44,7 @@ target_compile_definitions(
     JUCE_USE_CURL=1
     JUCE_WEB_BROWSER=0
     JUCE_MODAL_LOOPS_PERMITTED=1 # we use QT event loop, so this is needed
+    $<$<CONFIG:RelWithDebInfo>:JUCE_DEBUG=1>  # Enable DBG() in RelWithDebInfo builds
 )
 
 set_target_properties(${PROJECT_NAME} PROPERTIES

lib/atkaudio/src/atkaudio/AudioModule.h

@@ -22,16 +22,7 @@ class atkAudioModule
 {
 public:
     atkAudioModule() = default;
-
-    virtual ~atkAudioModule()
-    {
-        // Clean up parent component on message thread
-        if (parentComponent)
-        {
-            auto* parent = parentComponent.release();
-            juce::MessageManager::callAsync([parent] { delete parent; });
-        }
-    }
+    virtual ~atkAudioModule() = default;
 
     // Disable copy
     atkAudioModule(const atkAudioModule&) = delete;
@@ -68,16 +59,28 @@ class atkAudioModule
             if (!window)
                 return;
 
-            // Lazy initialization - add to desktop on first show
-            if (visible && !window->isOnDesktop())
+            // If window is already on desktop, just toggle visibility
+            if (window->isOnDesktop())
             {
-                ensureParentComponent();
+                window->setVisible(visible);
+                if (visible)
+                    window->toFront(true);
+                return;
+            }
 
-                void* parentHandle = getParentNativeHandle();
-                if (parentHandle)
-                    window->addToDesktop(0, parentHandle);
+            // Lazy initialization - add to desktop on first show
+            if (visible)
+            {
+                // DocumentWindow (TopLevelWindow) requires calling through TopLevelWindow interface
+                if (auto* topLevel = dynamic_cast<juce::TopLevelWindow*>(window))
+                {
+                    topLevel->addToDesktop(); // TopLevelWindow has no-args version
+                }
                 else
-                    window->addToDesktop(0);
+                {
+                    // Regular components can use flags
+                    window->addToDesktop(juce::ComponentPeer::windowAppearsOnTaskbar);
+                }
 
                 // Center the window on screen
                 if (auto* docWindow = dynamic_cast<juce::DocumentWindow*>(window))
@@ -114,43 +117,6 @@ class atkAudioModule
      * The window is created by derived class (can be lazy or in constructor)
      */
     virtual juce::Component* getWindowComponent() = 0;
-
-    /**
-     * Get the native parent handle for this module instance
-     * Can be used by derived classes for auxiliary windows (e.g., ChannelClient's matrix/settings windows)
-     * Returns the peer handle of the parent component if available
-     */
-    void* getParentNativeHandle()
-    {
-        ensureParentComponent();
-        if (parentComponent && parentComponent->getPeer())
-            return parentComponent->getPeer()->getNativeHandle();
-        return nullptr;
-    }
-
-private:
-    /**
-     * Ensure parent component exists for this module instance
-     */
-    void ensureParentComponent()
-    {
-        if (!parentComponent)
-        {
-            parentComponent = std::make_unique<juce::Component>();
-            parentComponent->setVisible(false);
-
-            // Get native window handle from OBS/Qt
-            void* nativeHandle = atk::getQtMainWindowHandle();
-            if (nativeHandle)
-                parentComponent->addToDesktop(0, nativeHandle);
-            else
-                parentComponent->addToDesktop(0);
-        }
-    }
-
-    // Per-instance parent component for window ownership
-    // Each module has its own parent to avoid shared state and X11 errors
-    std::unique_ptr<juce::Component> parentComponent;
 };
 
 } // namespace atk

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

@@ -3,6 +3,7 @@
 #include "DeviceIoApp.h"
 
 #include <juce_audio_utils/juce_audio_utils.h>
+#include <juce_dsp/juce_dsp.h>
 
 #define MAX_CHANNELS 256
 
@@ -35,11 +36,87 @@ struct atk::DeviceIo::Impl : public juce::Timer
     // processBlock
     void process(float** buffer, int numChannels, int numSamples, double sampleRate)
     {
-        auto& fromObsBuffer = deviceIoApp->getFromObsBuffer();
-        fromObsBuffer.write(buffer, numChannels, numSamples, sampleRate);
+        // Ensure temp buffer is large enough
+        if (tempBuffer.getNumChannels() < numChannels || tempBuffer.getNumSamples() < numSamples)
+            tempBuffer.setSize(numChannels, numSamples, false, false, true);
 
+        // Read hardware input into temp buffer
         auto& toObsBuffer = deviceIoApp->getToObsBuffer();
-        toObsBuffer.read(buffer, numChannels, numSamples, sampleRate, this->mixInput);
+        bool hasHardwareInput =
+            toObsBuffer.read(tempBuffer.getArrayOfWritePointers(), numChannels, numSamples, sampleRate, false);
+
+        // Prepare output buffer for hardware (with delay applied)
+        juce::AudioBuffer<float> hardwareOutputBuffer;
+
+        // Send to hardware output based on mode
+        auto& fromObsBuffer = deviceIoApp->getFromObsBuffer();
+        if (hasHardwareInput)
+        {
+            if (this->mixInput)
+            {
+                // When both HW input and output are selected with mix ON:
+                // Send OBS input + hardware input to hardware output
+                hardwareOutputBuffer.setSize(numChannels, numSamples, false, false, true);
+                for (int ch = 0; ch < numChannels; ++ch)
+                {
+                    auto* mixDest = hardwareOutputBuffer.getWritePointer(ch);
+                    const auto* obsInput = buffer[ch];
+                    const auto* hwInput = tempBuffer.getReadPointer(ch);
+                    for (int i = 0; i < numSamples; ++i)
+                        mixDest[i] = obsInput[i] + hwInput[i];
+                }
+                // Apply output delay before sending to hardware
+                applyOutputDelay(hardwareOutputBuffer, numChannels, numSamples, sampleRate);
+                fromObsBuffer
+                    .write(hardwareOutputBuffer.getArrayOfWritePointers(), numChannels, numSamples, sampleRate);
+            }
+            else
+            {
+                // When both HW input and output are selected with mix OFF:
+                // Send only hardware input to hardware output
+                hardwareOutputBuffer.setSize(numChannels, numSamples, false, false, true);
+                for (int ch = 0; ch < numChannels; ++ch)
+                    hardwareOutputBuffer.copyFrom(ch, 0, tempBuffer, ch, 0, numSamples);
+                // Apply output delay before sending to hardware
+                applyOutputDelay(hardwareOutputBuffer, numChannels, numSamples, sampleRate);
+                fromObsBuffer
+                    .write(hardwareOutputBuffer.getArrayOfWritePointers(), numChannels, numSamples, sampleRate);
+            }
+        }
+        else
+        {
+            // No hardware input: send OBS input to hardware output
+            hardwareOutputBuffer.setSize(numChannels, numSamples, false, false, true);
+            for (int ch = 0; ch < numChannels; ++ch)
+                std::memcpy(hardwareOutputBuffer.getWritePointer(ch), buffer[ch], numSamples * sizeof(float));
+            // Apply output delay before sending to hardware
+            applyOutputDelay(hardwareOutputBuffer, numChannels, numSamples, sampleRate);
+            fromObsBuffer.write(hardwareOutputBuffer.getArrayOfWritePointers(), numChannels, numSamples, sampleRate);
+        }
+
+        // Send to OBS output based on mode
+        if (hasHardwareInput)
+        {
+            // Handle mixing or replacing based on mixInput flag
+            if (this->mixInput)
+            {
+                // Mix: OBS input + HW input -> OBS output
+                for (int ch = 0; ch < numChannels; ++ch)
+                {
+                    auto* dest = buffer[ch];
+                    const auto* hwInput = tempBuffer.getReadPointer(ch);
+                    for (int i = 0; i < numSamples; ++i)
+                        dest[i] += hwInput[i];
+                }
+            }
+            else
+            {
+                // Replace: HW input -> OBS output
+                for (int ch = 0; ch < numChannels; ++ch)
+                    std::memcpy(buffer[ch], tempBuffer.getReadPointer(ch), numSamples * sizeof(float));
+            }
+        }
+        // else: No hardware input - pass through OBS audio unchanged
     }
 
     juce::Component* getWindowComponent()
@@ -57,6 +134,9 @@ struct atk::DeviceIo::Impl : public juce::Timer
             return;
         }
 
+        // Add output delay to state
+        state->setAttribute("outputDelayMs", outputDelayMs.load(std::memory_order_acquire));
+
         auto stateString = state->toString().toStdString();
 
         s = stateString;
@@ -71,6 +151,13 @@ struct atk::DeviceIo::Impl : public juce::Timer
         if (!element)
             return;
 
+        // Restore output delay
+        if (element->hasAttribute("outputDelayMs"))
+        {
+            float delayMs = static_cast<float>(element->getDoubleAttribute("outputDelayMs"));
+            outputDelayMs.store(delayMs, std::memory_order_release);
+        }
+
         deviceManager->initialise(0, 0, element.get(), false);
     }
 
@@ -79,12 +166,78 @@ struct atk::DeviceIo::Impl : public juce::Timer
         this->mixInput = val;
     }
 
+    void setOutputDelay(float delayMs)
+    {
+        outputDelayMs.store(delayMs, std::memory_order_release);
+    }
+
+    float getOutputDelay() const
+    {
+        return outputDelayMs.load(std::memory_order_acquire);
+    }
+
+    void applyOutputDelay(juce::AudioBuffer<float>& buffer, int numChannels, int numSamples, double sampleRate)
+    {
+        // Prepare delay lines if not ready or parameters changed
+        if (!delayPrepared || outputDelayLines.size() != numChannels)
+            prepareOutputDelay(numChannels, numSamples, sampleRate);
+
+        // Get current delay setting
+        float delayMs = outputDelayMs.load(std::memory_order_acquire);
+        float delaySamples = (delayMs / 1000.0f) * static_cast<float>(sampleRate);
+
+        // Apply delay to each channel
+        for (int ch = 0; ch < numChannels; ++ch)
+        {
+            if (ch < outputDelayLines.size())
+            {
+                // Set target delay value
+                outputDelaySmooth[ch].setTargetValue(delaySamples);
+
+                auto* channelData = buffer.getWritePointer(ch);
+                for (int i = 0; i < numSamples; ++i)
+                {
+                    outputDelayLines[ch].pushSample(0, channelData[i]);
+                    channelData[i] = outputDelayLines[ch].popSample(0, outputDelaySmooth[ch].getNextValue());
+                }
+            }
+        }
+    }
+
+    void prepareOutputDelay(int numChannels, int numSamples, double sampleRate)
+    {
+        outputDelayLines.clear();
+        outputDelayLines.resize(numChannels);
+
+        for (auto& delayLine : outputDelayLines)
+        {
+            delayLine.prepare(juce::dsp::ProcessSpec{sampleRate, static_cast<uint32_t>(numSamples), 1});
+            delayLine.reset();
+            delayLine.setMaximumDelayInSamples(10 * static_cast<int>(sampleRate)); // 10 seconds max
+            delayLine.setDelay(0.0f);
+        }
+
+        outputDelaySmooth.clear();
+        outputDelaySmooth.resize(numChannels);
+        for (auto& smooth : outputDelaySmooth)
+            smooth.reset(sampleRate, 0.4f); // 400ms smoothing time
+
+        delayPrepared = true;
+    }
+
 private:
     juce::AudioDeviceManager* deviceManager = nullptr;
     DeviceIoApp* deviceIoApp = nullptr;
     AudioAppMainWindow* mainWindow = nullptr;
 
     std::vector<juce::Interpolators::Lagrange> interpolators;
+    juce::AudioBuffer<float> tempBuffer;
+
+    // Output delay (applied before sending to hardware)
+    std::vector<juce::dsp::DelayLine<float, juce::dsp::DelayLineInterpolationTypes::Linear>> outputDelayLines;
+    std::vector<juce::LinearSmoothedValue<float>> outputDelaySmooth;
+    std::atomic<float> outputDelayMs{0.0f};
+    bool delayPrepared = false;
 
     bool mixInput = false;
 };
@@ -99,6 +252,16 @@ void atk::DeviceIo::setMixInput(bool mixInput)
     pImpl->setMixInput(mixInput);
 }
 
+void atk::DeviceIo::setOutputDelay(float delayMs)
+{
+    pImpl->setOutputDelay(delayMs);
+}
+
+float atk::DeviceIo::getOutputDelay() const
+{
+    return pImpl->getOutputDelay();
+}
+
 void atk::DeviceIo::getState(std::string& s)
 {
     pImpl->getState(s);

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

@@ -12,10 +12,21 @@ class DeviceIo : public atkAudioModule
     DeviceIo();
     ~DeviceIo();
 
-    void process(float** buffer, int numChannels, int numSamples, double sampleRate);
+    void process(float** buffer, int numChannels, int numSamples, double sampleRate) override;
 
     void setMixInput(bool mixInput);
 
+    /**
+     * Set output delay in milliseconds (applied before sending to hardware).
+     * Range: 0-10000 ms
+     */
+    void setOutputDelay(float delayMs);
+
+    /**
+     * Get current output delay in milliseconds
+     */
+    float getOutputDelay() const;
+
     void getState(std::string& s) override;
     void setState(std::string& s) override;
 

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

@@ -113,17 +113,19 @@ class AudioAppMainWindow final : public DocumentWindow
 {
 public:
     AudioAppMainWindow(DeviceIoApp& demo)
-        : DocumentWindow("", Colours::lightgrey, DocumentWindow::minimiseButton | DocumentWindow::closeButton, false)
+        : DocumentWindow(
+              "Audio Device Settings",
+              Colours::lightgrey,
+              DocumentWindow::minimiseButton | DocumentWindow::closeButton,
+              false
+          )
         , audioApp(demo)
     {
-        setContentOwned(&demo, true);
+        setUsingNativeTitleBar(true);
+        setContentOwned(&audioApp, false); // Don't take ownership - Impl owns it
         setResizable(true, false);
 
-        // Position title bar buttons on the right (Windows-style), like Plugin Host
-        setTitleBarButtonsRequired(DocumentWindow::minimiseButton | DocumentWindow::closeButton, false);
-
-        centreWithSize(demo.getWidth(), demo.getHeight());
-        setVisible(false);
+        // Don't add to desktop yet - AudioModule will handle this on first setVisible(true)
     }
 
     ~AudioAppMainWindow() override