0.31.5

Author: atkAudioUser

buildspec.json

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

lib/atkaudio/CMakeLists.txt

@@ -22,8 +22,7 @@ FetchContent_Declare(
     juce
     EXCLUDE_FROM_ALL
     GIT_REPOSITORY https://github.com/juce-framework/JUCE.git
-    GIT_TAG
-        230340dbfc580628596243bb63b31aeb4d6b5a6d # develop 2025-11-27
+    GIT_TAG 8.0.11
     PATCH_COMMAND
         ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/patches/apply-juce-patches.cmake"
 )
@@ -100,41 +99,13 @@ if(NOT WIN32)
     )
 endif()
 
-# ASIO SDK (Windows only)
-if(WIN32)
-    set(ASIO_SDK_DIR "${CMAKE_SOURCE_DIR}/_deps/asiosdk")
-    if(NOT EXISTS "${ASIO_SDK_DIR}")
-        set(_asio_zip "${CMAKE_SOURCE_DIR}/_deps/asiosdk.zip")
-        set(_asio_temp "${CMAKE_SOURCE_DIR}/_deps/asiosdk_temp")
-        message(STATUS "Downloading ASIO SDK...")
-        file(DOWNLOAD "https://www.steinberg.net/asiosdk" "${_asio_zip}" STATUS _status SHOW_PROGRESS)
-        list(GET _status 0 _code)
-        if(_code EQUAL 0)
-            file(ARCHIVE_EXTRACT INPUT "${_asio_zip}" DESTINATION "${_asio_temp}")
-            file(GLOB _dirs "${_asio_temp}/*")
-            list(GET _dirs 0 _extracted)
-            file(RENAME "${_extracted}" "${ASIO_SDK_DIR}")
-            file(
-                REMOVE_RECURSE
-                "${_asio_temp}"
-                "${_asio_zip}"
-            )
-            message(STATUS "ASIO SDK installed to ${ASIO_SDK_DIR}")
-        endif()
-    endif()
-    target_include_directories(${PROJECT_NAME} PRIVATE "${ASIO_SDK_DIR}/common")
-endif()
-
 if(WIN32)
     file(TO_CMAKE_PATH "${CMAKE_INSTALL_PREFIX}" _sanitized_prefix)
     string(REGEX REPLACE "/$" "" _sanitized_prefix "${_sanitized_prefix}")
     set(CMAKE_INSTALL_PREFIX "${_sanitized_prefix}" CACHE PATH "Sanitized install prefix" FORCE)
 endif()
 
-if(BUILD_WITH_ASIO)
-    message(STATUS "Building with ASIO")
-    target_compile_definitions(${PROJECT_NAME} PRIVATE JUCE_ASIO=1)
-endif()
+target_compile_definitions(${PROJECT_NAME} PRIVATE JUCE_ASIO=1)
 
 target_compile_definitions(${PROJECT_NAME} PRIVATE JUCE_ASIO=1)
 

lib/atkaudio/src/atkaudio/AtomicSharedPtr.h

@@ -6,18 +6,6 @@
 namespace atk
 {
 
-/**
- * @brief Generic atomic wrapper for shared_ptr to work around std::atomic<std::shared_ptr<T>>
- *        not being supported in Apple's libc++ implementation (as of macOS 15 / Xcode 17).
- *
- * This wrapper provides the same interface as std::atomic<std::shared_ptr<T>> would,
- * but uses std::atomic<std::shared_ptr<T>*> internally, which is universally supported.
- *
- * @tparam T The type pointed to by the shared_ptr
- *
- * @note Once Apple's libc++ supports std::atomic<std::shared_ptr<T>> (check with
- *       __cpp_lib_atomic_shared_ptr feature macro), this wrapper can be replaced.
- */
 template <typename T>
 class AtomicSharedPtr
 {
@@ -45,12 +33,6 @@ class AtomicSharedPtr
     AtomicSharedPtr(AtomicSharedPtr&&) = delete;
     AtomicSharedPtr& operator=(AtomicSharedPtr&&) = delete;
 
-    /**
-     * @brief Atomically loads and returns the shared_ptr
-     * @param order Memory ordering constraint
-     * @return A copy of the stored shared_ptr
-     * @note When the returned shared_ptr goes out of scope, it may trigger delete
-     */
     std::shared_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const
     {
         auto p = ptr.load(order);
@@ -59,24 +41,13 @@ class AtomicSharedPtr
         return std::shared_ptr<T>();
     }
 
-    /**
-     * @brief Atomically stores a new shared_ptr, replacing the old one
-     * @param desired The new shared_ptr to store
-     * @param order Memory ordering constraint
-     */
     void store(std::shared_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst)
     {
         auto newPtr = new std::shared_ptr<T>(std::move(desired));
         auto oldPtr = ptr.exchange(newPtr, order);
         delete oldPtr;
     }
 
-    /**
-     * @brief Atomically replaces the stored shared_ptr and returns the old value
-     * @param desired The new shared_ptr to store
-     * @param order Memory ordering constraint
-     * @return The previously stored shared_ptr
-     */
     std::shared_ptr<T> exchange(std::shared_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst)
     {
         auto newPtr = new std::shared_ptr<T>(std::move(desired));

lib/atkaudio/src/atkaudio/AudioProcessorGraphMT/AdaptiveSpinLock.h

@@ -32,12 +32,8 @@ namespace atk
 {
 
 /**
- * Adaptive Exponential Backoff Spin Lock
- *
- * Three modes:
- * - Fixed1024: Legacy fixed 1024 pause cycles
- * - BenchmarkedAdaptive: Benchmarked exponential backoff based on buffer size/sample rate
- * - Fixed8192Backoff (default): Fixed exponential backoff 8→16384, then yield forever
+ * Adaptive Exponential Backoff Spin Lock for realtime audio.
+ * Modes: Fixed1024, BenchmarkedAdaptive, Fixed8192Backoff (default).
  */
 class AdaptiveSpinLock
 {

lib/atkaudio/src/atkaudio/AudioProcessorGraphMT/AudioThreadPool.h

@@ -174,33 +174,8 @@ class RealtimeJobQueue
 
 //==============================================================================
 /**
-    Global audio thread pool singleton - REALTIME SAFE AUDIO PATH.
-
-    This thread pool is designed for realtime audio processing with the following features:
-    - Singleton instance shared across all audio graph processors
-    - Persistent worker threads to avoid creation/destruction overhead
-    - Lock-free job queue for realtime-safe job distribution (atomic fetch_add)
-    - Barrier synchronization using mutex + condition_variable
-    - High-priority threads with platform-specific realtime scheduling
-
-    Thread safety:
-    - getInstance()/deleteInstance(): Call only during program load/unload (single-threaded)
-    - initialize()/shutdown(): Thread-safe via mutex
-    - prepareJobs(): Call only from main audio thread (before kickWorkers)
-    - addJob(): Call only from main audio thread (between prepareJobs and kickWorkers)
-    - kickWorkers(): Call only from main audio thread
-    - tryStealAndExecuteJob(): Safe to call from any thread
-
-    Job queue safety:
-    - Queue is reset via prepareJobs() before each batch
-    - Maximum 1024 jobs per batch (queue size)
-    - Jobs are processed before next prepareJobs() call
-
-    Usage pattern:
-       prepareJobs(barrier);          // Main thread: setup barrier, reset queue
-       addJob(...);                   // Main thread: add jobs (max 1024)
-       kickWorkers();                 // Main thread: wake workers
-       barrier->arrive_and_wait();    // Wait for completion
+    Global audio thread pool singleton for realtime parallel processing.
+    Lock-free job queue, barrier synchronization, high-priority worker threads.
 */
 class AudioThreadPool
 {

lib/atkaudio/src/atkaudio/AudioProcessorGraphMT/DagPartitioner.h

@@ -15,9 +15,7 @@ namespace atk
 {
 
 /**
- * @brief Simplified DAG partitioner using node-centric model with vector-based storage.
- *
- * Optimized for performance using only vectors to avoid allocations.
+ * DAG partitioner for extracting parallelizable subgraphs.
  *
  * Rules:
  * 1) Node exists only once in the graph
@@ -27,27 +25,19 @@ namespace atk
  * 5) Every node with NO output connections is an endpoint
  * 6) If no other node outputs to this node, it's an input
  * 7) If node outputs to >1 nodes, it's a split point (subgraph endpoint)
- *    => Subgraph ends when: numOutputs != 1
  * 8) If node receives input from >1 nodes, it's a join point (new subgraph starts)
- *    => New subgraph starts when: numInputs != 1
- *
- * In other words: A subgraph is a linear chain where every node has exactly 1 input and 1 output,
- * except at the boundaries.
  *
- * Template parameter NodeIDType should be copyable and comparable.
+ * A subgraph is a linear chain where each node has exactly 1 input and 1 output (except boundaries).
  */
 template <typename NodeIDType>
 class DagPartitioner
 {
 public:
-    /**
-     * @brief Simple node - tracks what it connects to using vectors.
-     */
     struct Node
     {
         NodeIDType id;
-        std::vector<NodeIDType> outputsTo;  // Nodes this one outputs to
-        std::vector<NodeIDType> inputsFrom; // Nodes that output to this one
+        std::vector<NodeIDType> outputsTo;
+        std::vector<NodeIDType> inputsFrom;
 
         explicit Node(NodeIDType nodeId = NodeIDType())
             : id(nodeId)
@@ -61,15 +51,12 @@ class DagPartitioner
         }
     };
 
-    /**
-     * @brief Partitioned subgraph result.
-     */
     struct Subgraph
     {
-        std::vector<NodeIDType> nodeIDs; // Nodes in this subgraph
-        std::vector<size_t> dependsOn;   // Subgraph indices this depends on
-        std::vector<size_t> dependents;  // Subgraph indices that depend on this
-        int topologicalLevel = 0;        // Topological level for scheduling
+        std::vector<NodeIDType> nodeIDs;
+        std::vector<size_t> dependsOn;
+        std::vector<size_t> dependents;
+        int topologicalLevel = 0;
 
         void clear()
         {
@@ -80,9 +67,6 @@ class DagPartitioner
         }
     };
 
-    /**
-     * @brief Simple thread pool for parallel endpoint tracing.
-     */
     class ThreadPool
     {
     public:
@@ -179,31 +163,11 @@ class DagPartitioner
     {
     }
 
-    /**
-     * @brief Set parallelization threshold.
-     * @param threshold Minimum number of nodes to enable parallel processing (0 = always parallel)
-     */
     void setParallelThreshold(size_t threshold)
     {
         parallelThreshold = threshold;
     }
 
-    /**
-     * @brief Extract subgraphs from a node graph.
-     *
-     * Uses rules to determine boundaries automatically:
-     * - Rule 5: Node with 0 outputs = output boundary (endpoint)
-     * - Rule 6: Node with 0 inputs = input boundary
-     * - Rule 7: Node with >1 outputs = split point (subgraph endpoint)
-     * - Rule 8: Node with >1 inputs = join point (new subgraph starts)
-     *
-     * Traces from endpoints backwards, creating subgraphs as linear chains.
-     * Each endpoint is traced in parallel as a separate task.
-     *
-     * @param nodes Map of node ID to Node (with connectivity)
-     * @param excludeNodeIDs Optional vector of node IDs to exclude from subgraphs (e.g., I/O nodes)
-     * @return Vector of extracted subgraphs
-     */
     std::vector<Subgraph>
     extractSubgraphs(const std::map<NodeIDType, Node>& nodes, const std::vector<NodeIDType>& excludeNodeIDs = {})
     {
@@ -278,19 +242,6 @@ class DagPartitioner
         return subgraphs;
     }
 
-    /**
-     * @brief Build subgraph dependencies and assign topological levels using ASAP scheduling
-     * with worker-aware load balancing.
-     *
-     * Uses As-Soon-As-Possible (ASAP) scheduling with load balancing:
-     * - Each subgraph is assigned to the earliest possible level (after all dependencies)
-     * - If a level exceeds numWorkers capacity, excess subgraphs with slack are pushed to later levels
-     * - A subgraph has "slack" if its earliest dependent is more than 1 level away
-     *
-     * @param subgraphs Vector of subgraphs (modified in-place)
-     * @param nodes Original node graph
-     * @param numWorkers Number of worker threads (0 or negative = no load balancing)
-     */
     void buildSubgraphDependencies(
         std::vector<Subgraph>& subgraphs,
         const std::map<NodeIDType, Node>& nodes,

lib/atkaudio/src/atkaudio/AudioProcessorGraphMT/SubgraphExtractor.h

@@ -9,13 +9,7 @@ namespace atk
 {
 
 /**
- * @brief Extracts subgraphs from a JUCE AudioProcessorGraphMT for parallel processing.
- *
- * This class bridges between JUCE's audio graph types and the general-purpose
- * DagPartitioner. It handles audio-specific concerns like:
- * - Converting JUCE Node/Connection types to generic DAG nodes/links
- * - Identifying audio and MIDI I/O nodes
- * - Preserving connection information in subgraphs
+ * Extracts subgraphs from AudioProcessorGraphMT for parallel processing.
  */
 class SubgraphExtractor
 {
@@ -24,49 +18,24 @@ class SubgraphExtractor
     using Node = AudioProcessorGraphMT::Node;
     using Connection = AudioProcessorGraphMT::Connection;
 
-    /**
-     * @brief Represents a subgraph of audio processors.
-     *
-     * Contains JUCE-specific information about nodes and connections
-     * in addition to the partitioning information from DagPartitioner.
-     */
     struct Subgraph
     {
-        std::vector<NodeID> nodeIDs;         // Audio processor nodes in this subgraph
-        std::vector<NodeID> inputNodeIDs;    // Input I/O nodes feeding this subgraph
-        std::vector<NodeID> outputNodeIDs;   // Output I/O nodes this subgraph feeds to
-        std::vector<Connection> connections; // JUCE connections within this subgraph
-        std::vector<size_t> dependsOn;       // Indices of subgraphs this one depends on
-        std::vector<size_t> dependents;      // Indices of subgraphs that depend on this one
-        int topologicalLevel = 0;            // Level in dependency hierarchy
+        std::vector<NodeID> nodeIDs;
+        std::vector<NodeID> inputNodeIDs;
+        std::vector<NodeID> outputNodeIDs;
+        std::vector<Connection> connections;
+        std::vector<size_t> dependsOn;
+        std::vector<size_t> dependents;
+        int topologicalLevel = 0;
     };
 
     SubgraphExtractor() = default;
 
-    /**
-     * @brief Set parallelization threshold for DagPartitioner.
-     * @param threshold Minimum number of nodes to enable parallel processing (0 = always parallel, default = 20)
-     */
     void setParallelThreshold(size_t threshold)
     {
         partitioner.setParallelThreshold(threshold);
     }
 
-    /**
-     * @brief Extract subgraphs from an AudioProcessorGraphMT for parallel processing.
-     *
-     * This method:
-     * 1. Identifies all audio/MIDI I/O nodes
-     * 2. Converts the audio graph to generic DAG representation
-     * 3. Uses DagPartitioner to extract parallelizable subgraphs
-     * 4. Converts results back to audio-specific subgraph representation
-     *
-     * Both audio AND MIDI connections create dependencies - a node must wait for all inputs.
-     * I/O nodes (audio and MIDI) are excluded from subgraphs as they're handled externally.
-     *
-     * @param graph The AudioProcessorGraphMT to extract subgraphs from
-     * @return Vector of extracted subgraphs with audio-specific information
-     */
     std::vector<Subgraph> extractUniversalParallelization(atk::AudioProcessorGraphMT& graph)
     {
         subgraphs.clear();
@@ -172,17 +141,6 @@ class SubgraphExtractor
         return subgraphs;
     }
 
-    /**
-     * @brief Build dependency relationships between subgraphs and assign topological levels.
-     *
-     * This method analyzes connections between subgraphs to determine which can run in parallel.
-     * Handles both audio AND MIDI connections when determining dependencies.
-     * Uses ASAP scheduling with worker-aware load balancing when numWorkers > 0.
-     *
-     * @param subgraphs Vector of subgraphs (will be modified in-place)
-     * @param connections Vector of all JUCE connections in the graph
-     * @param numWorkers Number of worker threads for load balancing (SIZE_MAX = no load balancing)
-     */
     void buildSubgraphDependencies(
         std::vector<Subgraph>& subgraphs,
         const std::vector<Connection>& connections,