0.13.0

Author: atkAudioUser

README.md

@@ -13,6 +13,8 @@
 - MIDI support (e.g. for using MIDI keyboard and a sampler plugin as soundboard)
 - etc
 
+Plugin Host2 can interface directly with audio and MIDI hardware, OBS audio sources, and output audio as new OBS sources, allowing for complex audio processing setups. E.g. use ASIO interface as audio device, take additional audio from OBS sources, route monitoring to ASIO outputs and/or different audio drivers/hardware, use plugins and create final mix, and output the processed audio as a new OBS source for recording and streaming. Or just create a simple soundboard with a sampler plugin and a MIDI keyboard.
+
 ## Device I/O
 - Send and receive audio directly into and from audio devices
 - "Anything from/to anywhere" device routing

buildspec.json

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

lib/atkaudio/cmake/cpack.cmake

@@ -34,6 +34,7 @@ file(TO_NATIVE_PATH "${ICON_PATH}" ICON_PATH)
 string(REPLACE "\\" "\\\\" ICON_PATH "${ICON_PATH}")
 set(CPACK_NSIS_MUI_ICON "${ICON_PATH}")
 set(CPACK_NSIS_MUI_UNIICON "${ICON_PATH}")
+set(CPACK_NSIS_INSTALLED_ICON_NAME "${CMAKE_SOURCE_DIR}/lib/atkaudio/assets/icon.ico")
 set(CPACK_PACKAGE_ICON "${ICON_PATH}")
 
 if(WIN32)
@@ -45,19 +46,20 @@ else()
   set(CPACK_PACKAGE_EXTENSION "pkg")
 endif()
 
-if(NOT DEFINED ENV{CI})
-  return()
-endif()
-if(NOT WIN32)
-  return()
-endif()
 
 set(CPACK_RELEASE_STAGING_DIRECTORY "${CMAKE_SOURCE_DIR}/release")
 set(BUILD_TYPE_FOR_CPACK "Release")
 
 set(CPACK_PACKAGE_DIRECTORY "${CMAKE_BINARY_DIR}")
 set(CPACK_PACKAGE_ABSOLUTE_PATH ${CPACK_PACKAGE_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}.${CPACK_PACKAGE_EXTENSION})
 
+if(NOT DEFINED ENV{CI})
+  set(BUILD_TYPE_FOR_CPACK "Debug")
+endif()
+if(NOT WIN32)
+  return()
+endif()
+
 include(CPack)
 
 if(NOT EXISTS ${CPACK_PACKAGE_ABSOLUTE_PATH})

lib/atkaudio/src/atkaudio/FifoBuffer2.h

@@ -30,7 +30,7 @@ class FifoBuffer2 : public juce::Timer
         fifo.reset();
         auto freeSpace = fifo.getFreeSpace();
 
-        if (freeSpace < minBufferSize)
+        if (freeSpace < (int)std::ceil(minBufferSize))
             freeSpace = 2 * freeSpace;
 
         if (buffer.getNumChannels() < minNumChannels)
@@ -265,53 +265,70 @@ class SyncBuffer : public juce::Timer
     void prepareReader(double sampleRate, int newNumChannels, int bufferSize)
     {
         readerSampleRate.store(sampleRate, std::memory_order_release);
-        readerBufferSize.store(bufferSize, std::memory_order_release);
-        readerNumChannels.store(newNumChannels, std::memory_order_release);
     }
 
     void prepareWriter(double sampleRate, int newNumChannels, int bufferSize)
     {
         writerSampleRate.store(sampleRate, std::memory_order_release);
-        writerBufferSize.store(bufferSize, std::memory_order_release);
-        writerNumChannels.store(newNumChannels, std::memory_order_release);
     }
 
     int write(const float* const* src, int numChannels, int numSamples)
     {
+        juce::ScopedLock lock(writeLock);
+
+        auto newMinBufferSize = numSamples;
+        if (writerNumChannels.load(std::memory_order_acquire) < numChannels ||
+            writerBufferSize.load(std::memory_order_acquire) < newMinBufferSize)
+        {
+            isPrepared.store(false, std::memory_order_release);
+
+            writerNumChannels.store(numChannels, std::memory_order_release);
+            writerBufferSize.store(newMinBufferSize, std::memory_order_release);
+        }
+
         if (!isPrepared.load(std::memory_order_acquire))
             return 0;
 
-        juce::ScopedLock lock(writeLock);
-
         fifoBuffer.write(src, numChannels, numSamples);
 
         return numSamples;
     }
 
     int read(float* const* dest, int numChannels, int numSamples, bool addToBuffer = false)
     {
-        if (!isPrepared.load(std::memory_order_acquire))
-            return 0;
-
         juce::ScopedLock lock(readLock);
+        auto readerMinBufferSizeOverhead = (int)std::ceil(
+            (ATK_RATE_FACTOR * readerSampleRate.load(std::memory_order_acquire) -
+             readerSampleRate.load(std::memory_order_acquire)) /
+            2 * ATK_SMOOTHING_SPEED
+        );
+
+        auto readerMinBufferSize = readerMinBufferSizeOverhead + numSamples;
 
         auto ratio =
             writerSampleRate.load(std::memory_order_acquire) / readerSampleRate.load(std::memory_order_acquire);
 
+        readerMinBufferSize = (int)std::ceil(readerMinBufferSize * ratio);
+
+        if (readerNumChannels.load(std::memory_order_acquire) < numChannels ||
+            readerBufferSize.load(std::memory_order_acquire) < readerMinBufferSize)
+        {
+            isPrepared.store(false, std::memory_order_release);
+
+            readerNumChannels.store(numChannels, std::memory_order_release);
+            readerBufferSize.store(readerMinBufferSize, std::memory_order_release);
+        }
+
+        if (!isPrepared.load(std::memory_order_acquire))
+            return 0;
+
         int maxAvailable = fifoBuffer.getNumReady();
 
         auto factor = 1.0f;
-        if (maxAvailable < std::ceil(ATK_RATE_FACTOR * numSamples))
-        {
+        if (maxAvailable < readerMinBufferSize)
             factor = factor / ATK_RATE_FACTOR;
-        }
-        else if (maxAvailable > 2 * std::max(
-                                        std::ceil(ATK_RATE_FACTOR * readerBufferSize.load(std::memory_order_acquire)),
-                                        (float)writerBufferSize.load(std::memory_order_acquire)
-                                    ))
-        {
+        else if (maxAvailable > 2 * std::max(readerMinBufferSize, writerBufferSize.load(std::memory_order_acquire)))
             factor = factor * ATK_RATE_FACTOR;
-        }
 
         rateSmoothing.setTargetValue(factor);
         factor = rateSmoothing.getNextValue();
@@ -394,8 +411,8 @@ class SyncBuffer : public juce::Timer
 
     juce::AudioBuffer<float> tempBuffer;
 
-    std::atomic<int> readerBufferSize;
-    std::atomic<int> writerBufferSize;
+    std::atomic<int> readerBufferSize{0};
+    std::atomic<int> writerBufferSize{0};
     std::atomic<int> readerNumChannels{0};
     std::atomic<int> writerNumChannels{0};
 

lib/atkaudio/src/atkaudio/PluginHost/JuceHostPlugin.h

@@ -35,7 +35,7 @@ class HostAudioProcessorImpl
                 opt.applicationName = getName();
                 opt.commonToAllUsers = false;
                 opt.doNotSave = false;
-                opt.filenameSuffix = ".props";
+                opt.filenameSuffix = "settings";
                 opt.ignoreCaseOfKeyNames = false;
                 opt.storageFormat = PropertiesFile::StorageFormat::storeAsXML;
                 opt.osxLibrarySubFolder = "Application Support";
@@ -158,7 +158,7 @@ class HostAudioProcessorImpl
 
     const String getName() const final
     {
-        return "atkAudioObsAudioPluginHost";
+        return "atkAudio Plugin Host";
     }
 
     bool acceptsMidi() const final

lib/atkaudio/src/atkaudio/PluginHost2/ObsOutput.h

@@ -26,11 +26,13 @@ class ObsOutputAudioProcessor : public juce::AudioProcessor
         if (!privateSource)
         {
             privateSource = obs_source_create(id.c_str(), name.c_str(), nullptr, nullptr);
-            obs_source_set_audio_active(privateSource, true);
 
             auto* sceneSource = obs_frontend_get_current_scene();
             auto* scene = obs_scene_from_source(sceneSource);
             obs_scene_add(scene, privateSource);
+
+            obs_source_set_audio_active(privateSource, true);
+            obs_source_set_enabled(privateSource, true);
         }
     }
 

lib/atkaudio/src/atkaudio/PluginHost2/ObsSource.h

@@ -46,6 +46,9 @@ static juce::StringArray GetObsAudioSources(obs_source_t* parentSource = nullptr
             if ((caps & OBS_SOURCE_AUDIO) == 0)
                 return true;
 
+            if (name && juce::String(name).containsIgnoreCase("ph2out"))
+                return true;
+
             if (name)
                 names->add(juce::String(name));
             return true;
@@ -179,6 +182,7 @@ class ObsSourceAudioProcessor : public juce::AudioProcessor
         if (source)
         {
             obs_source_add_audio_capture_callback(source, obs_capture_callback, this);
+            obs_source_set_muted(source, true);
             currentObsSource = source;
         }
     }

lib/atkaudio/src/atkaudio/PluginHost2/PluginHost2.cpp

@@ -22,52 +22,6 @@ struct atk::PluginHost2::Impl : public juce::Timer
     {
     }
 
-    void initialise(int numInputChannels, int numOutputChannels, double sampleRate, void* obs_parent_source)
-    {
-        auto& dm = mainHostWindow->getDeviceManager();
-        dm.initialiseWithDefaultDevices(numInputChannels, numOutputChannels);
-        dm.addAudioDeviceType(std::make_unique<VirtualAudioIODeviceType>());
-        dm.setCurrentAudioDeviceType(IO_TYPE, true);
-        juce::AudioDeviceManager::AudioDeviceSetup setup = dm.getAudioDeviceSetup();
-        setup.inputDeviceName = IO_NAME;
-        setup.outputDeviceName = IO_NAME;
-        dm.setAudioDeviceSetup(setup, true);
-    }
-
-    juce::AudioBuffer<float> outputData{MAX_AUDIO_CHANNELS, AUDIO_OUTPUT_FRAMES};
-
-    void process(float** buffer, int newNumChannels, int newNumSamples, double newSampleRate)
-    {
-        (void)newSampleRate;
-        outputData.setSize(newNumChannels, newNumSamples, false, false, true);
-
-        auto& dm = mainHostWindow->getDeviceManager();
-
-        auto* currentDevice = dm.getCurrentAudioDevice();
-        if (!currentDevice || currentDevice->getTypeName() != IO_TYPE)
-        {
-            for (int ch = 0; ch < newNumChannels; ++ch)
-                std::fill(buffer[ch], buffer[ch] + newNumSamples, 0.0f);
-
-            return;
-        }
-
-        juce::ScopedLock lock(dm.getAudioCallbackLock());
-        currentDevice = dm.getCurrentAudioDevice();
-        auto* vdev = static_cast<VirtualAudioIODevice*>(currentDevice);
-        if (vdev && currentDevice && currentDevice->getTypeName() == IO_TYPE)
-        {
-            vdev->process(
-                const_cast<const float**>(buffer),
-                outputData.getArrayOfWritePointers(),
-                newNumChannels,
-                newNumSamples
-            );
-            for (int ch = 0; ch < newNumChannels; ++ch)
-                std::memcpy(buffer[ch], outputData.getReadPointer(ch), newNumSamples * sizeof(float));
-        }
-    }
-
     void setVisible(bool visible)
     {
         if (!mainHostWindow->isOnDesktop() && visible)
@@ -118,9 +72,50 @@ struct atk::PluginHost2::Impl : public juce::Timer
         );
     }
 
+    void process(float** buffer, int newNumChannels, int newNumSamples, double newSampleRate)
+    {
+        (void)newSampleRate;
+        outputData.setSize(newNumChannels, newNumSamples, false, false, true);
+
+        auto& dm = mainHostWindow->getDeviceManager();
+
+        auto* currentDevice = dm.getCurrentAudioDevice();
+        if (!currentDevice || currentDevice->getTypeName() != IO_TYPE)
+        {
+            for (int ch = 0; ch < newNumChannels; ++ch)
+                std::fill(buffer[ch], buffer[ch] + newNumSamples, 0.0f);
+
+            return;
+        }
+
+        juce::ScopedLock lock(dm.getAudioCallbackLock());
+        hostTimeNs = juce::Time::getHighResolutionTicks();
+
+        currentDevice = dm.getCurrentAudioDevice();
+        auto* vdev = static_cast<VirtualAudioIODevice*>(currentDevice);
+        auto* cb = vdev->getAudioDeviceCallback();
+        if (cb && vdev && currentDevice && currentDevice->getTypeName() == IO_TYPE)
+        {
+            cb->audioDeviceIOCallbackWithContext(
+                const_cast<const float**>(buffer),
+                newNumChannels,
+                outputData.getArrayOfWritePointers(),
+                newNumChannels,
+                newNumSamples,
+                context
+            );
+            for (int ch = 0; ch < newNumChannels; ++ch)
+                std::memcpy(buffer[ch], outputData.getReadPointer(ch), newNumSamples * sizeof(float));
+        }
+    }
+
 private:
     std::unique_ptr<MainHostWindow> mainHostWindow;
     std::unique_ptr<juce::AudioDeviceManager> deviceManager;
+
+    juce::AudioBuffer<float> outputData{MAX_AUDIO_CHANNELS, AUDIO_OUTPUT_FRAMES};
+    uint64_t hostTimeNs;
+    juce::AudioIODeviceCallbackContext context{.hostTimeNs = &hostTimeNs};
 };
 
 void atk::PluginHost2::process(float** buffer, int numChannels, int numSamples, double sampleRate)
@@ -143,16 +138,6 @@ void atk::PluginHost2::setState(std::string& s)
     pImpl->setState(s);
 }
 
-void atk::PluginHost2::initialise(
-    int numInputChannels,
-    int numOutputChannels,
-    double sampleRate,
-    void* obs_parent_source
-)
-{
-    pImpl->initialise(numInputChannels, numOutputChannels, sampleRate, obs_parent_source);
-}
-
 atk::PluginHost2::PluginHost2()
     : pImpl(new Impl())
 {

lib/atkaudio/src/atkaudio/PluginHost2/PluginHost2.h

@@ -19,8 +19,6 @@ class PluginHost2
     void getState(std::string& s);
     void setState(std::string& s);
 
-    void initialise(int numInputChannels, int numOutputChannels, double sampleRate, void* obs_parent_source = nullptr);
-
 private:
     struct Impl;
     Impl* pImpl;