cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/dsp/dsp-combiner.h

@@ -0,0 +1,810 @@
+/************************** BEGIN dsp-combiner.h **************************
+FAUST Architecture File
+Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+---------------------------------------------------------------------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+EXCEPTION : As a special exception, you may create a larger work
+that contains this FAUST architecture section and distribute
+that work under terms of your choice, so long as this FAUST
+architecture section is not modified.
+************************************************************************/
+
+#ifndef __dsp_combiner__
+#define __dsp_combiner__
+
+#include <string.h>
+#include <string>
+#include <assert.h>
+#include <sstream>
+
+#include "faust/dsp/dsp.h"
+#include "faust/gui/UI.h"
+
+/**
+ * @file dsp-combiner.h
+ * @brief DSP Combiner Library
+ *
+ * This library provides classes for combining DSP modules.
+ * It includes classes for sequencing, parallelizing, splitting, merging, recursing, and crossfading DSP modules.
+ *
+ */
+
+enum Layout { kVerticalGroup, kHorizontalGroup, kTabGroup };
+
+/**
+ * @class dsp_binary_combiner
+ * @brief Base class and common code for binary combiners
+ *
+ * This class serves as the base class for various DSP combiners that work with two DSP modules.
+ * It provides common methods for building user interfaces, allocating and deleting channels, and more.
+ */
+class dsp_binary_combiner : public dsp {
+
+    protected:
+
+        dsp* fDSP1;
+        dsp* fDSP2;
+        int fBufferSize;
+        Layout fLayout;
+        std::string fLabel;
+
+        void buildUserInterfaceAux(UI* ui_interface)
+        {
+            switch (fLayout) {
+                case kHorizontalGroup:
+                    ui_interface->openHorizontalBox(fLabel.c_str());
+                    fDSP1->buildUserInterface(ui_interface);
+                    fDSP2->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                    break;
+                case kVerticalGroup:
+                    ui_interface->openVerticalBox(fLabel.c_str());
+                    fDSP1->buildUserInterface(ui_interface);
+                    fDSP2->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                    break;
+                case kTabGroup:
+                    ui_interface->openTabBox(fLabel.c_str());
+                    ui_interface->openVerticalBox("DSP1");
+                    fDSP1->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                    ui_interface->openVerticalBox("DSP2");
+                    fDSP2->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                    ui_interface->closeBox();
+                    break;
+            }
+        }
+
+        FAUSTFLOAT** allocateChannels(int num)
+        {
+            FAUSTFLOAT** channels = new FAUSTFLOAT*[num];
+            for (int chan = 0; chan < num; chan++) {
+                channels[chan] = new FAUSTFLOAT[fBufferSize];
+                memset(channels[chan], 0, sizeof(FAUSTFLOAT) * fBufferSize);
+            }
+            return channels;
+        }
+
+        void deleteChannels(FAUSTFLOAT** channels, int num)
+        {
+            for (int chan = 0; chan < num; chan++) {
+                delete [] channels[chan];
+            }
+            delete [] channels;
+        }
+
+     public:
+
+        dsp_binary_combiner(dsp* dsp1, dsp* dsp2, int buffer_size, Layout layout, const std::string& label)
+        :fDSP1(dsp1), fDSP2(dsp2), fBufferSize(buffer_size), fLayout(layout), fLabel(label)
+        {}
+
+        virtual ~dsp_binary_combiner()
+        {
+            delete fDSP1;
+            delete fDSP2;
+        }
+
+        virtual int getSampleRate()
+        {
+            return fDSP1->getSampleRate();
+        }
+        virtual void init(int sample_rate)
+        {
+            fDSP1->init(sample_rate);
+            fDSP2->init(sample_rate);
+        }
+        virtual void instanceInit(int sample_rate)
+        {
+            fDSP1->instanceInit(sample_rate);
+            fDSP2->instanceInit(sample_rate);
+        }
+        virtual void instanceConstants(int sample_rate)
+        {
+            fDSP1->instanceConstants(sample_rate);
+            fDSP2->instanceConstants(sample_rate);
+        }
+
+        virtual void instanceResetUserInterface()
+        {
+            fDSP1->instanceResetUserInterface();
+            fDSP2->instanceResetUserInterface();
+        }
+
+        virtual void instanceClear()
+        {
+            fDSP1->instanceClear();
+            fDSP2->instanceClear();
+        }
+
+        virtual void metadata(Meta* m)
+        {
+            fDSP1->metadata(m);
+            fDSP2->metadata(m);
+        }
+
+};
+
+/**
+ * @class dsp_sequencer
+ * @brief Combine two 'compatible' DSP modules in sequence
+ *
+ * This class allows you to combine two DSP modules in sequence.
+ * It computes the first DSP module's outputs and uses them as inputs for the second DSP module.
+ */
+class dsp_sequencer : public dsp_binary_combiner {
+
+    private:
+
+        FAUSTFLOAT** fDSP1Outputs;
+
+    public:
+
+        dsp_sequencer(dsp* dsp1, dsp* dsp2,
+                      int buffer_size = 4096,
+                      Layout layout = Layout::kTabGroup,
+                      const std::string& label = "Sequencer")
+        :dsp_binary_combiner(dsp1, dsp2, buffer_size, layout, label)
+        {
+            fDSP1Outputs = allocateChannels(fDSP1->getNumOutputs());
+        }
+
+        virtual ~dsp_sequencer()
+        {
+            deleteChannels(fDSP1Outputs, fDSP1->getNumOutputs());
+        }
+
+        virtual int getNumInputs() { return fDSP1->getNumInputs(); }
+        virtual int getNumOutputs() { return fDSP2->getNumOutputs(); }
+
+        virtual void buildUserInterface(UI* ui_interface)
+        {
+            buildUserInterfaceAux(ui_interface);
+        }
+
+        virtual dsp* clone()
+        {
+            return new dsp_sequencer(fDSP1->clone(), fDSP2->clone(), fBufferSize, fLayout, fLabel);
+        }
+
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            fDSP1->compute(count, inputs, fDSP1Outputs);
+            fDSP2->compute(count, fDSP1Outputs, outputs);
+        }
+
+        virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); }
+
+};
+
+/**
+ * @class dsp_parallelizer
+ * @brief Combine two DSP modules in parallel
+ *
+ * This class combines two DSP modules in parallel.
+ * It computes both DSP modules separately and combines their outputs.
+ */
+class dsp_parallelizer : public dsp_binary_combiner {
+
+    private:
+
+        FAUSTFLOAT** fDSP2Inputs;
+        FAUSTFLOAT** fDSP2Outputs;
+
+    public:
+
+        dsp_parallelizer(dsp* dsp1, dsp* dsp2,
+                     int buffer_size = 4096,
+                     Layout layout = Layout::kTabGroup,
+                     const std::string& label = "Parallelizer")
+        :dsp_binary_combiner(dsp1, dsp2, buffer_size, layout, label)
+        {
+            fDSP2Inputs = new FAUSTFLOAT*[fDSP2->getNumInputs()];
+            fDSP2Outputs = new FAUSTFLOAT*[fDSP2->getNumOutputs()];
+        }
+
+        virtual ~dsp_parallelizer()
+        {
+            delete [] fDSP2Inputs;
+            delete [] fDSP2Outputs;
+        }
+
+        virtual int getNumInputs() { return fDSP1->getNumInputs() + fDSP2->getNumInputs(); }
+        virtual int getNumOutputs() { return fDSP1->getNumOutputs() + fDSP2->getNumOutputs(); }
+
+        virtual void buildUserInterface(UI* ui_interface)
+        {
+            buildUserInterfaceAux(ui_interface);
+        }
+
+        virtual dsp* clone()
+        {
+            return new dsp_parallelizer(fDSP1->clone(), fDSP2->clone(), fBufferSize, fLayout, fLabel);
+        }
+
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            fDSP1->compute(count, inputs, outputs);
+
+            // Shift inputs/outputs channels for fDSP2
+            for (int chan = 0; chan < fDSP2->getNumInputs(); chan++) {
+                fDSP2Inputs[chan] = inputs[fDSP1->getNumInputs() + chan];
+            }
+            for (int chan = 0; chan < fDSP2->getNumOutputs(); chan++) {
+                fDSP2Outputs[chan] = outputs[fDSP1->getNumOutputs() + chan];
+            }
+
+            fDSP2->compute(count, fDSP2Inputs, fDSP2Outputs);
+        }
+
+        virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); }
+
+};
+
+/**
+ * @class dsp_splitter
+ * @brief Combine two 'compatible' DSP modules in a splitter
+ *
+ * This class combines two DSP modules in a splitter configuration.
+ * The outputs of the first DSP module are connected to the inputs of the second DSP module.
+ */
+class dsp_splitter : public dsp_binary_combiner {
+
+    private:
+
+        FAUSTFLOAT** fDSP1Outputs;
+        FAUSTFLOAT** fDSP2Inputs;
+
+    public:
+
+        dsp_splitter(dsp* dsp1, dsp* dsp2,
+                     int buffer_size = 4096,
+                     Layout layout = Layout::kTabGroup,
+                     const std::string& label = "Splitter")
+        :dsp_binary_combiner(dsp1, dsp2, buffer_size, layout, label)
+        {
+            fDSP1Outputs = allocateChannels(fDSP1->getNumOutputs());
+            fDSP2Inputs = new FAUSTFLOAT*[fDSP2->getNumInputs()];
+        }
+
+        virtual ~dsp_splitter()
+        {
+            deleteChannels(fDSP1Outputs, fDSP1->getNumOutputs());
+            delete [] fDSP2Inputs;
+        }
+
+        virtual int getNumInputs() { return fDSP1->getNumInputs(); }
+        virtual int getNumOutputs() { return fDSP2->getNumOutputs(); }
+
+        virtual void buildUserInterface(UI* ui_interface)
+        {
+            buildUserInterfaceAux(ui_interface);
+        }
+
+        virtual dsp* clone()
+        {
+            return new dsp_splitter(fDSP1->clone(), fDSP2->clone(), fBufferSize, fLayout, fLabel);
+        }
+
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            fDSP1->compute(count, inputs, fDSP1Outputs);
+
+            for (int chan = 0; chan < fDSP2->getNumInputs(); chan++) {
+                 fDSP2Inputs[chan] = fDSP1Outputs[chan % fDSP1->getNumOutputs()];
+            }
+
+            fDSP2->compute(count, fDSP2Inputs, outputs);
+        }
+};
+
+/**
+ * @class dsp_merger
+ * @brief Combine two 'compatible' DSP modules in a merger
+ *
+ * This class combines two DSP modules in a merger configuration.
+ * The outputs of the first DSP module are combined with the inputs of the second DSP module.
+ */
+class dsp_merger : public dsp_binary_combiner {
+
+    private:
+
+        FAUSTFLOAT** fDSP1Inputs;
+        FAUSTFLOAT** fDSP1Outputs;
+        FAUSTFLOAT** fDSP2Inputs;
+
+        void mix(int count, FAUSTFLOAT* dst, FAUSTFLOAT* src)
+        {
+            for (int frame = 0; frame < count; frame++) {
+                dst[frame] += src[frame];
+            }
+        }
+
+    public:
+
+        dsp_merger(dsp* dsp1, dsp* dsp2,
+                   int buffer_size = 4096,
+                   Layout layout = Layout::kTabGroup,
+                   const std::string& label = "Merger")
+        :dsp_binary_combiner(dsp1, dsp2, buffer_size, layout, label)
+        {
+            fDSP1Inputs = allocateChannels(fDSP1->getNumInputs());
+            fDSP1Outputs = allocateChannels(fDSP1->getNumOutputs());
+            fDSP2Inputs = new FAUSTFLOAT*[fDSP2->getNumInputs()];
+        }
+
+        virtual ~dsp_merger()
+        {
+            deleteChannels(fDSP1Inputs, fDSP1->getNumInputs());
+            deleteChannels(fDSP1Outputs, fDSP1->getNumOutputs());
+            delete [] fDSP2Inputs;
+        }
+
+        virtual int getNumInputs() { return fDSP1->getNumInputs(); }
+        virtual int getNumOutputs() { return fDSP2->getNumOutputs(); }
+
+        virtual void buildUserInterface(UI* ui_interface)
+        {
+            buildUserInterfaceAux(ui_interface);
+        }
+
+        virtual dsp* clone()
+        {
+            return new dsp_merger(fDSP1->clone(), fDSP2->clone(), fBufferSize, fLayout, fLabel);
+        }
+
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            fDSP1->compute(count, fDSP1Inputs, fDSP1Outputs);
+
+            memset(fDSP2Inputs, 0, sizeof(FAUSTFLOAT*) * fDSP2->getNumInputs());
+
+            for (int chan = 0; chan < fDSP1->getNumOutputs(); chan++) {
+                int mchan = chan % fDSP2->getNumInputs();
+                if (fDSP2Inputs[mchan]) {
+                    mix(count, fDSP2Inputs[mchan], fDSP1Outputs[chan]);
+                } else {
+                    fDSP2Inputs[mchan] = fDSP1Outputs[chan];
+                }
+            }
+
+            fDSP2->compute(count, fDSP2Inputs, outputs);
+        }
+};
+
+/**
+ * @class dsp_recursiver
+ * @brief Combine two 'compatible' DSP modules in a recursive way
+ *
+ * This class recursively combines two DSP modules.
+ * The outputs of each module are fed as inputs to the other module in a recursive manner.
+ */
+class dsp_recursiver : public dsp_binary_combiner {
+
+    private:
+
+        FAUSTFLOAT** fDSP1Inputs;
+        FAUSTFLOAT** fDSP1Outputs;
+
+        FAUSTFLOAT** fDSP2Inputs;
+        FAUSTFLOAT** fDSP2Outputs;
+
+    public:
+
+        dsp_recursiver(dsp* dsp1, dsp* dsp2,
+                       Layout layout = Layout::kTabGroup,
+                       const std::string& label = "Recursiver")
+        :dsp_binary_combiner(dsp1, dsp2, 1, layout, label)
+        {
+            fDSP1Inputs = allocateChannels(fDSP1->getNumInputs());
+            fDSP1Outputs = allocateChannels(fDSP1->getNumOutputs());
+            fDSP2Inputs = allocateChannels(fDSP2->getNumInputs());
+            fDSP2Outputs = allocateChannels(fDSP2->getNumOutputs());
+        }
+
+        virtual ~dsp_recursiver()
+        {
+            deleteChannels(fDSP1Inputs, fDSP1->getNumInputs());
+            deleteChannels(fDSP1Outputs, fDSP1->getNumOutputs());
+            deleteChannels(fDSP2Inputs, fDSP2->getNumInputs());
+            deleteChannels(fDSP2Outputs, fDSP2->getNumOutputs());
+        }
+
+        virtual int getNumInputs() { return fDSP1->getNumInputs() - fDSP2->getNumOutputs(); }
+        virtual int getNumOutputs() { return fDSP1->getNumOutputs(); }
+
+        virtual void buildUserInterface(UI* ui_interface)
+        {
+            buildUserInterfaceAux(ui_interface);
+        }
+
+        virtual dsp* clone()
+        {
+            return new dsp_recursiver(fDSP1->clone(), fDSP2->clone(), fLayout, fLabel);
+        }
+
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            for (int frame = 0; (frame < count); frame++) {
+
+                for (int chan = 0; chan < fDSP2->getNumOutputs(); chan++) {
+                    fDSP1Inputs[chan][0] = fDSP2Outputs[chan][0];
+                }
+
+                for (int chan = 0; chan < fDSP1->getNumInputs() - fDSP2->getNumOutputs(); chan++) {
+                    fDSP1Inputs[chan + fDSP2->getNumOutputs()][0] = inputs[chan][frame];
+                }
+
+                fDSP1->compute(1, fDSP1Inputs, fDSP1Outputs);
+
+                for (int chan = 0; chan < fDSP1->getNumOutputs(); chan++) {
+                    outputs[chan][frame] = fDSP1Outputs[chan][0];
+                }
+
+                for (int chan = 0; chan < fDSP2->getNumInputs(); chan++) {
+                    fDSP2Inputs[chan][0] = fDSP1Outputs[chan][0];
+                }
+
+                fDSP2->compute(1, fDSP2Inputs, fDSP2Outputs);
+            }
+        }
+
+        virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); }
+
+};
+
+/**
+ * @class dsp_crossfader
+ * @brief Crossfade between two DSP modules
+ *
+ * This class allows you to crossfade between two DSP modules.
+ * The crossfade parameter (as a slider) controls the mix between the two modules' outputs.
+ * When Crossfade = 1, the first DSP only is computed, when Crossfade = 0,
+ * the second DSP only is computed, otherwise both DSPs are computed and mixed.
+ */
+class dsp_crossfader: public dsp_binary_combiner {
+
+    private:
+    
+        FAUSTFLOAT fCrossfade;
+        FAUSTFLOAT** fDSPOutputs1;
+        FAUSTFLOAT** fDSPOutputs2;
+    
+    public:
+    
+        dsp_crossfader(dsp* dsp1, dsp* dsp2,
+                       Layout layout = Layout::kTabGroup,
+                       const std::string& label = "Crossfade")
+        :dsp_binary_combiner(dsp1, dsp2, 4096, layout, label),fCrossfade(FAUSTFLOAT(0.5))
+        {
+            fDSPOutputs1 = allocateChannels(fDSP1->getNumOutputs());
+            fDSPOutputs2 = allocateChannels(fDSP1->getNumOutputs());
+        }
+    
+        virtual ~dsp_crossfader()
+        {
+            deleteChannels(fDSPOutputs1, fDSP1->getNumInputs());
+            deleteChannels(fDSPOutputs2, fDSP1->getNumOutputs());
+        }
+    
+        virtual int getNumInputs() { return fDSP1->getNumInputs(); }
+        virtual int getNumOutputs() { return fDSP1->getNumOutputs(); }
+
+        void buildUserInterface(UI* ui_interface)
+        {
+            switch (fLayout) {
+                case kHorizontalGroup:
+                    ui_interface->openHorizontalBox(fLabel.c_str());
+                    ui_interface->addHorizontalSlider("Crossfade", &fCrossfade, FAUSTFLOAT(0.5), FAUSTFLOAT(0), FAUSTFLOAT(1), FAUSTFLOAT(0.01));
+                    fDSP1->buildUserInterface(ui_interface);
+                    fDSP2->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                    break;
+                case kVerticalGroup:
+                    ui_interface->openVerticalBox(fLabel.c_str());
+                    ui_interface->addHorizontalSlider("Crossfade", &fCrossfade, FAUSTFLOAT(0.5), FAUSTFLOAT(0), FAUSTFLOAT(1), FAUSTFLOAT(0.01));
+                    fDSP1->buildUserInterface(ui_interface);
+                    fDSP2->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                    break;
+                case kTabGroup:
+                    ui_interface->openTabBox(fLabel.c_str());
+                    ui_interface->openVerticalBox("Crossfade");
+                    ui_interface->addHorizontalSlider("Crossfade", &fCrossfade, FAUSTFLOAT(0.5), FAUSTFLOAT(0), FAUSTFLOAT(1), FAUSTFLOAT(0.01));
+                    ui_interface->closeBox();
+                    ui_interface->openVerticalBox("DSP1");
+                    fDSP1->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                    ui_interface->openVerticalBox("DSP2");
+                    fDSP2->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                    ui_interface->closeBox();
+                    break;
+            }
+        }
+    
+        virtual dsp* clone()
+        {
+            return new dsp_crossfader(fDSP1->clone(), fDSP2->clone(), fLayout, fLabel);
+        }
+    
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            if (fCrossfade == FAUSTFLOAT(1)) {
+                fDSP1->compute(count, inputs, outputs);
+            } else if (fCrossfade == FAUSTFLOAT(0)) {
+                fDSP2->compute(count, inputs, outputs);
+            } else {
+                // Compute each effect
+                fDSP1->compute(count, inputs, fDSPOutputs1);
+                fDSP2->compute(count, inputs, fDSPOutputs2);
+                // Mix between the two effects
+                FAUSTFLOAT gain1 = fCrossfade;
+                FAUSTFLOAT gain2 = FAUSTFLOAT(1) - gain1;
+                for (int frame = 0; (frame < count); frame++) {
+                    for (int chan = 0; chan < fDSP1->getNumOutputs(); chan++) {
+                        outputs[chan][frame] = fDSPOutputs1[chan][frame] * gain1 + fDSPOutputs2[chan][frame] * gain2;
+                    }
+                }
+            }
+        }
+    
+        virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); }
+};
+
+#ifndef __dsp_algebra_api__
+#define __dsp_algebra_api__
+
+/**
+ * DSP algebra API allowing to combine DSPs using the 5 operators Faust block algebra and an additional crossfader combiner.
+ * The two arguments GUI are composed in a group, either kVerticalGroup, kHorizontalGroup or kTabGroup with a label.
+ *
+ * Each operation takes two DSP and a optional layout and label parameters, returns the combined DSPs,
+ * or null if failure with an error message.
+ * 
+ * It includes methods to create sequencers, parallelizers, splitters, mergers, recursivers, and crossfaders.
+ */
+
+/**
+ * Create a DSP Sequencer
+ *
+ * This method creates a DSP Sequencer, which combines two DSP modules in a sequencer configuration.
+ * The outputs of the first DSP module are connected to the inputs of the second DSP module.
+ *
+ * @param dsp1 The first DSP module to combine
+ * @param dsp2 The second DSP module to combine
+ * @param error A reference to a string to store error messages (if any)
+ * @param layout The layout for the combined user interface (default: kTabGroup)
+ * @param label The label for the combiner (default: "Sequencer")
+ * @return A pointer to the created DSP Sequencer, or nullptr if an error occurs
+ */
+static dsp* createDSPSequencer(dsp* dsp1, dsp* dsp2,
+                               std::string& error,
+                               Layout layout = Layout::kTabGroup,
+                               const std::string& label = "Sequencer")
+{
+    if (dsp1->getNumOutputs() != dsp2->getNumInputs()) {
+        std::stringstream error_aux;
+        error_aux << "Connection error in dsp_sequencer : the number of outputs ("
+                  << dsp1->getNumOutputs() << ") of A "
+                  << "must be equal to the number of inputs (" << dsp2->getNumInputs() << ") of B" << std::endl;
+        error = error_aux.str();
+        return nullptr;
+    } else {
+        return new dsp_sequencer(dsp1, dsp2, 4096, layout, label);
+    }
+}
+
+/**
+ * Create a DSP Parallelizer
+ *
+ * This method creates a DSP Parallelizer, which combines two DSP modules in parallel.
+ * The resulting DSP module computes both input modules separately and combines their outputs.
+ *
+ * @param dsp1 The first DSP module to combine
+ * @param dsp2 The second DSP module to combine
+ * @param error A reference to a string to store error messages (if any)
+ * @param layout The layout for the combined user interface (default: kTabGroup)
+ * @param label The label for the combiner (default: "Parallelizer")
+ * @return A pointer to the created DSP Parallelizer, or nullptr if an error occurs
+ */
+static dsp* createDSPParallelizer(dsp* dsp1, dsp* dsp2,
+                                  std::string& error,
+                                  Layout layout = Layout::kTabGroup,
+                                  const std::string& label = "Parallelizer")
+{
+    return new dsp_parallelizer(dsp1, dsp2, 4096, layout, label);
+}
+
+/**
+ * Create a DSP Splitter
+ *
+ * This method creates a DSP Splitter, which combines two 'compatible' DSP modules in a splitter configuration.
+ * The outputs of the first DSP module are connected to the inputs of the second DSP module.
+ *
+ * @param dsp1 The first DSP module to combine
+ * @param dsp2 The second DSP module to combine
+ * @param error A reference to a string to store error messages (if any)
+ * @param layout The layout for the combined user interface (default: kTabGroup)
+ * @param label The label for the combiner (default: "Splitter")
+ * @return A pointer to the created DSP Splitter, or nullptr if an error occurs
+ */
+static dsp* createDSPSplitter(dsp* dsp1, dsp* dsp2, std::string& error, Layout layout = Layout::kTabGroup, const std::string& label = "Splitter")
+{
+    if (dsp1->getNumOutputs() == 0) {
+        error = "Connection error in dsp_splitter : the first expression has no outputs\n";
+        return nullptr;
+    } else if (dsp2->getNumInputs() == 0) {
+        error = "Connection error in dsp_splitter : the second expression has no inputs\n";
+        return nullptr;
+    } else if (dsp2->getNumInputs() % dsp1->getNumOutputs() != 0) {
+        std::stringstream error_aux;
+        error_aux << "Connection error in dsp_splitter : the number of outputs (" << dsp1->getNumOutputs()
+                  << ") of the first expression should be a divisor of the number of inputs ("
+                  << dsp2->getNumInputs()
+                  << ") of the second expression" << std::endl;
+        error = error_aux.str();
+        return nullptr;
+    } else if (dsp2->getNumInputs() == dsp1->getNumOutputs()) {
+        return new dsp_sequencer(dsp1, dsp2, 4096, layout, label);
+    } else {
+        return new dsp_splitter(dsp1, dsp2, 4096, layout, label);
+    }
+}
+
+/**
+ * Create a DSP Merger
+ *
+ * This method creates a DSP Merger, which combines two 'compatible' DSP modules in a merger configuration.
+ * The outputs of the first DSP module are combined with the inputs of the second DSP module.
+ *
+ * @param dsp1 The first DSP module to combine
+ * @param dsp2 The second DSP module to combine
+ * @param error A reference to a string to store error messages (if any)
+ * @param layout The layout for the combined user interface (default: kTabGroup)
+ * @param label The label for the combiner (default: "Merger")
+ * @return A pointer to the created DSP Merger, or nullptr if an error occurs
+ */
+static dsp* createDSPMerger(dsp* dsp1, dsp* dsp2,
+                            std::string& error,
+                            Layout layout = Layout::kTabGroup,
+                            const std::string& label = "Merger")
+{
+    if (dsp1->getNumOutputs() == 0) {
+        error = "Connection error in dsp_merger : the first expression has no outputs\n";
+        return nullptr;
+    } else if (dsp2->getNumInputs() == 0) {
+        error = "Connection error in dsp_merger : the second expression has no inputs\n";
+        return nullptr;
+    } else if (dsp1->getNumOutputs() % dsp2->getNumInputs() != 0) {
+        std::stringstream error_aux;
+        error_aux << "Connection error in dsp_merger : the number of outputs (" << dsp1->getNumOutputs()
+                  << ") of the first expression should be a multiple of the number of inputs ("
+                  << dsp2->getNumInputs()
+                  << ") of the second expression" << std::endl;
+        error = error_aux.str();
+        return nullptr;
+    } else if (dsp2->getNumInputs() == dsp1->getNumOutputs()) {
+        return new dsp_sequencer(dsp1, dsp2, 4096, layout, label);
+    } else {
+        return new dsp_merger(dsp1, dsp2, 4096, layout, label);
+    }
+}
+
+/**
+ * Create a DSP Recursiver
+ *
+ * This method creates a DSP Recursiver, which combines two 'compatible' DSP modules in a recursive way.
+ * The outputs of each module are fed as inputs to the other module in a recursive manner.
+ *
+ * @param dsp1 The first DSP module to combine
+ * @param dsp2 The second DSP module to combine
+ * @param error A reference to a string to store error messages (if any)
+ * @param layout The layout for the combined user interface (default: kTabGroup)
+ * @param label The label for the combiner (default: "Recursiver")
+ * @return A pointer to the created DSP Recursiver, or nullptr if an error occurs
+ */
+static dsp* createDSPRecursiver(dsp* dsp1, dsp* dsp2,
+                                std::string& error,
+                                Layout layout = Layout::kTabGroup,
+                                const std::string& label = "Recursiver")
+{
+    if ((dsp2->getNumInputs() > dsp1->getNumOutputs()) || (dsp2->getNumOutputs() > dsp1->getNumInputs())) {
+        std::stringstream error_aux;
+        error_aux << "Connection error in : dsp_recursiver" << std::endl;
+        if (dsp2->getNumInputs() > dsp1->getNumOutputs()) {
+            error_aux << "The number of outputs " << dsp1->getNumOutputs()
+                      << " of the first expression should be greater or equal to the number of inputs ("
+                      << dsp2->getNumInputs()
+                      << ") of the second expression" << std::endl;
+        }
+        if (dsp2->getNumOutputs() > dsp1->getNumInputs()) {
+            error_aux << "The number of inputs " << dsp1->getNumInputs()
+                      << " of the first expression should be greater or equal to the number of outputs ("
+                      << dsp2->getNumOutputs()
+                      << ") of the second expression" << std::endl;
+        }
+        error = error_aux.str();
+        return nullptr;
+    } else {
+        return new dsp_recursiver(dsp1, dsp2, layout, label);
+    }
+}
+
+/**
+ * Create a DSP Crossfader
+ *
+ * This method creates a DSP Crossfader, which allows you to crossfade between two DSP modules.
+ * The crossfade parameter (as a slider) controls the mix between the two modules' outputs.
+ * When Crossfade = 1, the first DSP only is computed, when Crossfade = 0,
+ * the second DSP only is computed, otherwise both DSPs are computed and mixed.
+ *
+ * @param dsp1 The first DSP module to combine
+ * @param dsp2 The second DSP module to combine
+ * @param error A reference to a string to store error messages (if any)
+ * @param layout The layout for the combined user interface (default: kTabGroup)
+ * @param label The label for the crossfade slider (default: "Crossfade")
+ * @return A pointer to the created DSP Crossfader, or nullptr if an error occurs
+ */
+static dsp* createDSPCrossfader(dsp* dsp1, dsp* dsp2,
+                                std::string& error,
+                                Layout layout = Layout::kTabGroup,
+                                const std::string& label = "Crossfade")
+{
+    if (dsp1->getNumInputs() != dsp2->getNumInputs()) {
+        std::stringstream error_aux;
+        error_aux << "Error in dsp_crossfader : the number of inputs ("
+        << dsp1->getNumInputs() << ") of A "
+        << "must be equal to the number of inputs (" << dsp2->getNumInputs() << ") of B" << std::endl;
+        error = error_aux.str();
+        return nullptr;
+    } else if (dsp1->getNumOutputs() != dsp2->getNumOutputs()) {
+        std::stringstream error_aux;
+        error_aux << "Error in dsp_crossfader : the number of outputs ("
+        << dsp1->getNumOutputs() << ") of A "
+        << "must be equal to the number of outputs (" << dsp2->getNumOutputs() << ") of B" << std::endl;
+        error = error_aux.str();
+        return nullptr;
+    } else {
+        return new dsp_crossfader(dsp1, dsp2, layout, label);
+    }
+}
+
+#endif
+
+#endif
+/************************** END dsp-combiner.h **************************/