Fix: Remove realtime safety violations from audio callback

Removed all heap allocations (std::vector::resize) and blocking I/O (console logging) from the real-time audio thread to prevent audio glitches and priority inversion.

Author: sarv-tech

src/audio/engine/audio_command_dispatcher.cpp

@@ -101,13 +101,10 @@ void AudioCommandDispatcher::drain_commands(std::atomic<float>& input_gain,
             if (node_id >= 0 && node_id < static_cast<int>(dummy_effects.size())) {
                 // Comments on node_id semantics: node_id is used as a 0-based linear index fallback
                 // for the GUI and tests
-                std::cerr << "[AudioCommandDispatcher] Node ID " << node_id
-                          << " not found in executor or graph; falling back to dummy_effects index."
-                          << std::endl;
+                error_flag_.store(true, std::memory_order_release);
                 return dummy_effects[node_id];
             }
-            std::cerr << "[AudioCommandDispatcher] Node ID " << node_id
-                      << " lookup failed completely." << std::endl;
+            error_flag_.store(true, std::memory_order_release);
             return nullptr;
         };
 

src/audio/engine/audio_command_dispatcher.h

@@ -36,8 +36,13 @@ class AudioCommandDispatcher {
                         std::shared_ptr<AudioGraphExecutor>& executor, AudioGraph& main_graph,
                         std::vector<std::shared_ptr<Effect>>& dummy_effects);
 
+    bool check_and_clear_error() {
+        return error_flag_.exchange(false, std::memory_order_acq_rel);
+    }
+
    private:
     SPSCQueue<AudioCommand, 256> command_queue_;
+    std::atomic<bool> error_flag_{false};
 };
 
 }  // namespace Amplitron

src/audio/engine/audio_engine_process.cpp

@@ -13,8 +13,10 @@ void AudioEngine::process_audio(const float* input, float* output, int frame_cou
     auto t_start = std::chrono::steady_clock::now();
 
     if (frame_count > static_cast<int>(process_buffer_.size())) {
-        process_buffer_.resize(frame_count, 0.0f);
-        process_buffer_right_.resize(frame_count, 0.0f);
+        if (output) {
+            std::memset(output, 0, static_cast<size_t>(frame_count) * 2 * sizeof(float));
+        }
+        return;
     }
 
     const bool analyzer_on = analyzer_capture_->is_analyzer_enabled();

tests/integration/test_audio_engine.cpp

@@ -531,15 +531,19 @@ TEST_F(AudioEngineTest, TunerTapSampleRateAndReset) {
     engine.clear_tuner_tap();
 }
 
-TEST_F(AudioEngineTest, ProcessAudioResizesInternalBuffersWhenFrameCountExceedsCapacity) {
+TEST_F(AudioEngineTest, ProcessAudioZerosOutputWhenFrameCountExceedsCapacity) {
     // Default internal buffer capacity is 16384. Request a size larger than this.
     const int large_frame_count = 17000;
     std::vector<float> in(large_frame_count, 0.5f);
-    std::vector<float> out(large_frame_count * 2, 0.0f);
+    std::vector<float> out(large_frame_count * 2, 1.0f); // Pre-fill with 1.0f
 
     engine.process_audio(in.data(), out.data(), large_frame_count);
 
-    // Check that the internal buffers resized accordingly
-    ASSERT_GE(engine.test_process_buffer().size(), static_cast<size_t>(large_frame_count));
-    ASSERT_GE(engine.test_process_buffer_right().size(), static_cast<size_t>(large_frame_count));
+    // Check that the internal buffers did NOT resize (they stay at 16384)
+    ASSERT_LT(engine.test_process_buffer().size(), static_cast<size_t>(large_frame_count));
+    
+    // Check that the output was safely zeroed out
+    for (float sample : out) {
+        ASSERT_NEAR(sample, 0.0f, 1e-6f);
+    }
 }

tests/unit/test_audio_command_dispatcher.cpp

@@ -90,4 +90,7 @@ TEST(AudioCommandDispatcher_DrainCommands) {
     ASSERT_NEAR(fx1->get_mix(), 0.7f, 0.01f);
     ASSERT_NEAR(input_gain.load(), 0.2f, 0.01f);
     ASSERT_NEAR(output_gain.load(), 0.3f, 0.01f);
+    
+    // Verify that the invalid node lookup safely set the atomic error flag instead of throwing/printing
+    ASSERT_TRUE(dispatcher.check_and_clear_error());
 }