Merge pull request #277 from MohitBareja16/feature/n-input-mixer

feat: implement N-input dynamic mixer with per-channel gain routing

Author: MohitBareja16

src/audio/engine/audio_engine.h

@@ -258,6 +258,14 @@ class AudioEngine {
      */
     void push_param_change(int effect_index, int param_index, float value);
 
+    /**
+     * @brief Enqueue a mixer input gain change from the GUI thread.
+     * @param node_id      ID of the Mixer node.
+     * @param pin_index    Index of the input pin on the mixer.
+     * @param gain         New gain multiplier (0.0–2.0).
+     */
+    void push_mixer_gain_change(int node_id, int pin_index, float gain);
+
     /**
      * @brief Enqueue an effect enabled/disabled change from the GUI thread.
      * @param effect_index Index of the effect in the chain.

src/audio/engine/audio_engine_api.cpp

@@ -60,6 +60,15 @@ void AudioEngine::push_effect_mix(int effect_index, float mix) {
     command_queue_.try_push(cmd);
 }
 
+void AudioEngine::push_mixer_gain_change(int node_id, int pin_index, float gain) {
+    AudioCommand cmd{};
+    cmd.type = AudioCommand::SetMixerGain;
+    cmd.effect_index = node_id; // Overload effect_index to mean node_id
+    cmd.param_index = pin_index; // Overload param_index to mean pin_index
+    cmd.value = gain;
+    command_queue_.try_push(cmd);
+}
+
 int AudioEngine::get_suggested_buffer_size() const {
     float load = cpu_load_.load(std::memory_order_relaxed);
     int current = buffer_size_;

src/audio/engine/audio_engine_process.cpp

@@ -252,6 +252,11 @@ void AudioEngine::drain_gain_commands() {
         } else if (cmd.type == AudioCommand::SetOutputGain) {
             command_queue_.try_pop(cmd);
             output_gain_.store(cmd.value, std::memory_order_relaxed);
+        } else if (cmd.type == AudioCommand::SetMixerGain) {
+            command_queue_.try_pop(cmd);
+            if (audio_shadow_executor_) {
+                audio_shadow_executor_->update_mixer_gain(cmd.effect_index, cmd.param_index, cmd.value);
+            }
         } else {
             break;
         }
@@ -293,6 +298,9 @@ void AudioEngine::drain_commands() {
                 }
                 break;
             }
+            case AudioCommand::SetMixerGain:
+                // Skip SetMixerGain in the mutex-gated path, it is handled lock-free
+                break;
             case AudioCommand::SetInputGain:
                 input_gain_.store(cmd.value, std::memory_order_relaxed);
                 break;

src/audio/engine/audio_graph.cpp

@@ -15,10 +15,11 @@ int AudioGraph::add_node(const std::string &name, NodeRoutingType type,
 
   // Dynamically configure pin structures using the same unified ID pool
   if (type == NodeRoutingType::Mixer || type == NodeRoutingType::MergeSum) {
-    int inputs_to_create = (num_inputs > 0) ? num_inputs : 2;
+    int inputs_to_create = std::clamp((num_inputs > 0) ? num_inputs : 2, 2, 8);
     for (int i = 0; i < inputs_to_create; ++i) {
       node.input_pin_ids.push_back(next_id_++);
     }
+    node.input_gains.assign(inputs_to_create, 1.0f);
     node.output_pin_ids.push_back(next_id_++); // 1 Output Pin
   } else if (type == NodeRoutingType::Splitter) {
     node.input_pin_ids.push_back(next_id_++);  // 1 Input Pin
@@ -342,6 +343,151 @@ void AudioGraph::restore_link(const GraphLink& link) {
       rebuild_topology();
   }
 }
+bool AudioGraph::add_input_pin(int node_id) {
+  for (auto &node : nodes_) {
+    if (node.id == node_id && node.routing_type == NodeRoutingType::Mixer) {
+      if (node.input_pin_ids.size() < 8) {
+        node.input_pin_ids.push_back(next_id_++);
+        node.input_gains.push_back(1.0f);
+        // Do not necessarily need to rebuild topology if we just added an unconnected pin
+        return true;
+      }
+      return false;
+    }
+  }
+  return false;
+}
 
+bool AudioGraph::remove_input_pin(int node_id, int pin_id) {
+  for (auto &node : nodes_) {
+    if (node.id == node_id && (node.routing_type == NodeRoutingType::Mixer || node.routing_type == NodeRoutingType::MergeSum)) {
+      if (node.input_pin_ids.size() > 2) {
+        if (node.input_gains.size() < node.input_pin_ids.size()) {
+            node.input_gains.resize(node.input_pin_ids.size(), 1.0f);
+        }
+        int index_to_remove = -1;
+        if (pin_id == -1) {
+           index_to_remove = node.input_pin_ids.size() - 1;
+        } else {
+           for (size_t i = 0; i < node.input_pin_ids.size(); ++i) {
+               if (node.input_pin_ids[i] == pin_id) {
+                   index_to_remove = i;
+                   break;
+               }
+           }
+        }
+        if (index_to_remove != -1) {
+            int pin_to_remove = node.input_pin_ids[index_to_remove];
+            // Prevent removal if the pin is linked
+            for (const auto &link : links_) {
+              if (link.dest_pin_id == pin_to_remove) {
+                return false;
+              }
+            }
+            node.input_pin_ids.erase(node.input_pin_ids.begin() + index_to_remove);
+            node.input_gains.erase(node.input_gains.begin() + index_to_remove);
+            return true;
+        }
+      }
+      return false;
+    }
+  }
+  return false;
+}
+
+void AudioGraph::restore_input_pin(int node_id, int pin_id, int index, float gain) {
+  for (auto &node : nodes_) {
+    if (node.id == node_id) {
+        if (index >= 0) {
+            size_t idx = static_cast<size_t>(index);
+            if (idx <= node.input_pin_ids.size()) {
+                node.input_pin_ids.insert(node.input_pin_ids.begin() + idx, pin_id);
+                while (node.input_gains.size() < idx) {
+                    node.input_gains.push_back(1.0f);
+                }
+                node.input_gains.insert(node.input_gains.begin() + idx, gain);
+            } else {
+                node.input_pin_ids.push_back(pin_id);
+                node.input_gains.push_back(gain);
+            }
+        } else {
+            node.input_pin_ids.push_back(pin_id);
+            node.input_gains.push_back(gain);
+        }
+        if (pin_id >= next_id_) next_id_ = pin_id + 1;
+        break;
+    }
+  }
+}
+
+void AudioGraph::set_mixer_input_gain(int node_id, size_t pin_index, float gain) {
+  for (auto &node : nodes_) {
+    if (node.id == node_id && node.routing_type == NodeRoutingType::Mixer) {
+      if (pin_index < node.input_gains.size()) {
+        node.input_gains[pin_index] = std::clamp(gain, 0.0f, 2.0f);
+      }
+      break;
+    }
+  }
+}
+
+bool AudioGraph::add_output_pin(int node_id) {
+  for (auto &node : nodes_) {
+    if (node.id == node_id && node.routing_type == NodeRoutingType::Splitter) {
+      if (node.output_pin_ids.size() < 8) {
+        node.output_pin_ids.push_back(next_id_++);
+        return true;
+      }
+      return false;
+    }
+  }
+  return false;
+}
+
+bool AudioGraph::remove_output_pin(int node_id, int pin_id) {
+  for (auto &node : nodes_) {
+    if (node.id == node_id && node.routing_type == NodeRoutingType::Splitter) {
+      if (node.output_pin_ids.size() > 2) {
+        int index_to_remove = -1;
+        if (pin_id == -1) {
+           index_to_remove = node.output_pin_ids.size() - 1;
+        } else {
+           for (size_t i = 0; i < node.output_pin_ids.size(); ++i) {
+               if (node.output_pin_ids[i] == pin_id) {
+                   index_to_remove = i;
+                   break;
+               }
+           }
+        }
+        if (index_to_remove != -1) {
+            int pin_to_remove = node.output_pin_ids[index_to_remove];
+            for (const auto &link : links_) {
+              if (link.source_pin_id == pin_to_remove) {
+                return false;
+              }
+            }
+            node.output_pin_ids.erase(node.output_pin_ids.begin() + index_to_remove);
+            return true;
+        }
+      }
+      return false;
+    }
+  }
+  return false;
+}
+
+void AudioGraph::restore_output_pin(int node_id, int pin_id, int index) {
+  for (auto &node : nodes_) {
+    if (node.id == node_id && node.routing_type == NodeRoutingType::Splitter) {
+        if (index >= 0 && index <= node.output_pin_ids.size()) {
+            node.output_pin_ids.insert(node.output_pin_ids.begin() + index, pin_id);
+        } else {
+            node.output_pin_ids.push_back(pin_id);
+        }
+        if (pin_id >= next_id_) next_id_ = pin_id + 1;
+        break;
+    }
+  }
+}
 
 } // namespace Amplitron

src/audio/engine/audio_graph.h

@@ -31,6 +31,8 @@ struct DSPNode {
 
   float x = 0.0f;
   float y = 0.0f;
+
+  std::vector<float> input_gains; // Gain for each input pin (Mixer only)
 };
 
 struct GraphLink {
@@ -62,6 +64,17 @@ class AudioGraph {
   void restore_node(const DSPNode& node);
   void restore_link(const GraphLink& link);
 
+  // Dynamic Mixer API
+  bool add_input_pin(int node_id);
+  bool remove_input_pin(int node_id, int pin_id = -1);
+  void set_mixer_input_gain(int node_id, size_t pin_index, float gain);
+  void restore_input_pin(int node_id, int pin_id, int index, float gain);
+
+  // Dynamic Splitter API
+  bool add_output_pin(int node_id);
+  bool remove_output_pin(int node_id, int pin_id = -1);
+  void restore_output_pin(int node_id, int pin_id, int index);
+
   // Accessors
   const std::vector<int> &get_sorted_nodes() const { return sorted_node_ids_; }
   const std::vector<DSPNode> &get_nodes() const { return nodes_; }

src/audio/engine/audio_graph_executor.cpp

@@ -78,12 +78,17 @@ void AudioGraphExecutor::compile(const AudioGraph& graph) {
         }
 
         // Trace upstream connections to find which buffers to read from
-        for (int in_pin : it->input_pin_ids) {
+        for (size_t pin_idx = 0; pin_idx < it->input_pin_ids.size(); ++pin_idx) {
+            int in_pin = it->input_pin_ids[pin_idx];
+            float pin_gain = 1.0f;
+            if (pin_idx < it->input_gains.size()) {
+                pin_gain = it->input_gains[pin_idx];
+            }
             for (const auto& link : links) {
                 if (link.dest_pin_id == in_pin) {
                     int src_node_id = graph.get_node_from_pin(link.source_pin_id);
                     if (src_node_id != -1 && node_to_buffer.count(src_node_id)) {
-                        step.input_sources.push_back({ node_to_buffer[src_node_id] });
+                        step.input_sources.push_back({ node_to_buffer[src_node_id], pin_gain, static_cast<int>(pin_idx) });
                     }
                 }
             }
@@ -128,8 +133,14 @@ void AudioGraphExecutor::process(const float* input, float* output, int num_samp
             std::memset(node_input, 0, num_samples * sizeof(float));
             for (const auto& src : step.input_sources) {
                 const float* src_buf = buffer_pool_[src.buffer_index].data();
-                for (int i = 0; i < num_samples; ++i) {
-                    node_input[i] += src_buf[i];
+                if (src.gain == 1.0f) {
+                    for (int i = 0; i < num_samples; ++i) {
+                        node_input[i] += src_buf[i];
+                    }
+                } else {
+                    for (int i = 0; i < num_samples; ++i) {
+                        node_input[i] += src_buf[i] * src.gain;
+                    }
                 }
             }
         }
@@ -161,4 +172,18 @@ void AudioGraphExecutor::process(const float* input, float* output, int num_samp
     }
 }
 
+void AudioGraphExecutor::update_mixer_gain(int node_id, int pin_index, float gain) {
+    for (auto& step : execution_plan_) {
+        if (step.node_id == node_id && (step.type == NodeRoutingType::Mixer || step.type == NodeRoutingType::MergeSum)) {
+            for (auto& src : step.input_sources) {
+                if (src.pin_index == pin_index) {
+                    src.gain = std::clamp(gain, 0.0f, 2.0f);
+                    break;
+                }
+            }
+            break;
+        }
+    }
+}
+
 } // namespace Amplitron

src/audio/engine/audio_graph_executor.h

@@ -26,6 +26,7 @@ class AudioGraphExecutor {
     // Hot-path processing (Strictly allocation-free and lock-free)
     // Adjust the pedal->process signature if your pedals process strictly in-place
     void process(const float* input, float* output, int num_samples);
+    void update_mixer_gain(int node_id, int pin_index, float gain);
 
 private:
     int sample_rate_ = 48000;
@@ -34,6 +35,8 @@ class AudioGraphExecutor {
 
     struct InputSource {
         int buffer_index; // The pool index to read from
+        float gain = 1.0f;
+        int pin_index = 0;
     };
 
     struct NodeExecutionStep {

src/audio/utils/spsc_queue.h

@@ -89,6 +89,7 @@ struct AudioCommand {
         SetEffectParam,      // Change an effect parameter value
         SetEffectEnabled,    // Enable/disable an effect
         SetEffectMix,        // Change effect wet/dry mix
+        SetMixerGain,        // Change mixer input gain dynamically
         SetInputGain,        // Change master input gain
         SetOutputGain,       // Change master output gain
         AddEffect,           // Signal that effect list changed (swap pointer)