cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

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

@@ -0,0 +1,836 @@
+/************************** BEGIN dsp-adapter.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_adapter__
+#define __dsp_adapter__
+
+#ifndef _WIN32
+#include <alloca.h>
+#endif
+#include <string.h>
+#include <cmath>
+#include <assert.h>
+#include <stdio.h>
+
+#include "faust/dsp/dsp.h"
+
+// Adapts a DSP for a different number of inputs/outputs
+class dsp_adapter : public decorator_dsp {
+    
+    private:
+    
+        FAUSTFLOAT** fAdaptedInputs;
+        FAUSTFLOAT** fAdaptedOutputs;
+        int fHWInputs;
+        int fHWOutputs;
+        int fBufferSize;
+    
+        void adaptBuffers(FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            for (int i = 0; i < fHWInputs; i++) {
+                fAdaptedInputs[i] = inputs[i];
+            }
+            for (int i = 0; i < fHWOutputs; i++) {
+                fAdaptedOutputs[i] = outputs[i];
+            }
+        }
+    
+    public:
+    
+        dsp_adapter(dsp* dsp, int hw_inputs, int hw_outputs, int buffer_size):decorator_dsp(dsp)
+        {
+            fHWInputs = hw_inputs;
+            fHWOutputs = hw_outputs;
+            fBufferSize = buffer_size;
+            
+            fAdaptedInputs = new FAUSTFLOAT*[dsp->getNumInputs()];
+            for (int i = 0; i < dsp->getNumInputs() - fHWInputs; i++) {
+                fAdaptedInputs[i + fHWInputs] = new FAUSTFLOAT[buffer_size];
+                memset(fAdaptedInputs[i + fHWInputs], 0, sizeof(FAUSTFLOAT) * buffer_size);
+            }
+            
+            fAdaptedOutputs = new FAUSTFLOAT*[dsp->getNumOutputs()];
+            for (int i = 0; i < dsp->getNumOutputs() - fHWOutputs; i++) {
+                fAdaptedOutputs[i + fHWOutputs] = new FAUSTFLOAT[buffer_size];
+                memset(fAdaptedOutputs[i + fHWOutputs], 0, sizeof(FAUSTFLOAT) * buffer_size);
+            }
+        }
+    
+        virtual ~dsp_adapter()
+        {
+            for (int i = 0; i < fDSP->getNumInputs() - fHWInputs; i++) {
+                delete [] fAdaptedInputs[i + fHWInputs];
+            }
+            delete [] fAdaptedInputs;
+            
+            for (int i = 0; i < fDSP->getNumOutputs() - fHWOutputs; i++) {
+                delete [] fAdaptedOutputs[i + fHWOutputs];
+            }
+            delete [] fAdaptedOutputs;
+        }
+    
+        virtual int getNumInputs() { return fHWInputs; }
+        virtual int getNumOutputs() { return fHWOutputs; }
+    
+        virtual dsp_adapter* clone() { return new dsp_adapter(fDSP->clone(), fHWInputs, fHWOutputs, fBufferSize); }
+    
+        virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            adaptBuffers(inputs, outputs);
+            fDSP->compute(date_usec, count, fAdaptedInputs, fAdaptedOutputs);
+        }
+    
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            adaptBuffers(inputs, outputs);
+            fDSP->compute(count, fAdaptedInputs, fAdaptedOutputs);
+        }
+};
+
+// Adapts a DSP for a different sample size
+template <typename REAL_INT, typename REAL_EXT>
+class dsp_sample_adapter : public decorator_dsp {
+    
+    private:
+    
+        REAL_INT** fAdaptedInputs;
+        REAL_INT** fAdaptedOutputs;
+    
+        void adaptInputBuffers(int count, FAUSTFLOAT** inputs)
+        {
+            for (int chan = 0; chan < fDSP->getNumInputs(); chan++) {
+                for (int frame = 0; frame < count; frame++) {
+                    fAdaptedInputs[chan][frame] = REAL_INT(reinterpret_cast<REAL_EXT**>(inputs)[chan][frame]);
+                }
+            }
+        }
+    
+        void adaptOutputsBuffers(int count, FAUSTFLOAT** outputs)
+        {
+            for (int chan = 0; chan < fDSP->getNumOutputs(); chan++) {
+                for (int frame = 0; frame < count; frame++) {
+                    reinterpret_cast<REAL_EXT**>(outputs)[chan][frame] = REAL_EXT(fAdaptedOutputs[chan][frame]);
+                }
+            }
+        }
+    
+    public:
+    
+        dsp_sample_adapter(dsp* dsp):decorator_dsp(dsp)
+        {
+            fAdaptedInputs = new REAL_INT*[dsp->getNumInputs()];
+            for (int i = 0; i < dsp->getNumInputs(); i++) {
+                fAdaptedInputs[i] = new REAL_INT[4096];
+            }
+            
+            fAdaptedOutputs = new REAL_INT*[dsp->getNumOutputs()];
+            for (int i = 0; i < dsp->getNumOutputs(); i++) {
+                fAdaptedOutputs[i] = new REAL_INT[4096];
+            }
+        }
+    
+        virtual ~dsp_sample_adapter()
+        {
+            for (int i = 0; i < fDSP->getNumInputs(); i++) {
+                delete [] fAdaptedInputs[i];
+            }
+            delete [] fAdaptedInputs;
+            
+            for (int i = 0; i < fDSP->getNumOutputs(); i++) {
+                delete [] fAdaptedOutputs[i];
+            }
+            delete [] fAdaptedOutputs;
+        }
+    
+        virtual dsp_sample_adapter* clone() { return new dsp_sample_adapter(fDSP->clone()); }
+    
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            assert(count <= 4096);
+            adaptInputBuffers(count, inputs);
+            // DSP base class uses FAUSTFLOAT** type, so reinterpret_cast has to be used even if the real DSP uses REAL_INT
+            fDSP->compute(count, reinterpret_cast<FAUSTFLOAT**>(fAdaptedInputs), reinterpret_cast<FAUSTFLOAT**>(fAdaptedOutputs));
+            adaptOutputsBuffers(count, outputs);
+        }
+    
+        virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            assert(count <= 4096);
+            adaptInputBuffers(count, inputs);
+            // DSP base class uses FAUSTFLOAT** type, so reinterpret_cast has to be used even if the real DSP uses REAL_INT
+            fDSP->compute(date_usec, count, reinterpret_cast<FAUSTFLOAT**>(fAdaptedInputs), reinterpret_cast<FAUSTFLOAT**>(fAdaptedOutputs));
+            adaptOutputsBuffers(count, outputs);
+        }
+};
+
+// Template used to specialize double parameters expressed as NUM/DENOM
+template <int NUM, int DENOM>
+struct Double {
+    static constexpr double value() { return double(NUM)/double(DENOM); }
+};
+
+// Base class for filters
+template <class fVslider0, int fVslider1>
+struct Filter {
+    inline int getFactor() { return fVslider1; }
+};
+
+// Identity filter: copy input to output
+template <class fVslider0, int fVslider1>
+struct Identity : public Filter<fVslider0, fVslider1> {
+    inline int getFactor() { return fVslider1; }
+    
+    inline void compute(int count, FAUSTFLOAT* input0, FAUSTFLOAT* output0)
+    {
+        memcpy(output0, input0, count * sizeof(FAUSTFLOAT));
+    }
+};
+
+// Generated with process = fi.lowpass(3, ma.SR*hslider("FCFactor", 0.4, 0.4, 0.5, 0.01)/hslider("Factor", 2, 2, 8, 1));
+template <class fVslider0, int fVslider1, typename REAL>
+struct LowPass3 : public Filter<fVslider0, fVslider1> {
+    
+    REAL fVec0[2];
+    REAL fRec1[2];
+    REAL fRec0[3];
+    
+    inline REAL LowPass3_faustpower2_f(REAL value)
+    {
+        return (value * value);
+    }
+    
+    LowPass3()
+    {
+        for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
+            fVec0[l0] = 0.0;
+        }
+        for (int l1 = 0; (l1 < 2); l1 = (l1 + 1)) {
+            fRec1[l1] = 0.0;
+        }
+        for (int l2 = 0; (l2 < 3); l2 = (l2 + 1)) {
+            fRec0[l2] = 0.0;
+        }
+    }
+    
+    inline void compute(int count, FAUSTFLOAT* input0, FAUSTFLOAT* output0)
+    {
+        // Computed at template specialization time
+        REAL fSlow0 = std::tan((3.1415926535897931 * (REAL(fVslider0::value()) / REAL(fVslider1))));
+        REAL fSlow1 = (1.0 / fSlow0);
+        REAL fSlow2 = (1.0 / (((fSlow1 + 1.0000000000000002) / fSlow0) + 1.0));
+        REAL fSlow3 = (1.0 / (fSlow1 + 1.0));
+        REAL fSlow4 = (1.0 - fSlow1);
+        REAL fSlow5 = (((fSlow1 + -1.0000000000000002) / fSlow0) + 1.0);
+        REAL fSlow6 = (2.0 * (1.0 - (1.0 / LowPass3_faustpower2_f(fSlow0))));
+        // Computed at runtime
+        for (int i = 0; (i < count); i = (i + 1)) {
+            REAL fTemp0 = REAL(input0[i]);
+            fVec0[0] = fTemp0;
+            fRec1[0] = (0.0 - (fSlow3 * ((fSlow4 * fRec1[1]) - (fTemp0 + fVec0[1]))));
+            fRec0[0] = (fRec1[0] - (fSlow2 * ((fSlow5 * fRec0[2]) + (fSlow6 * fRec0[1]))));
+            output0[i] = FAUSTFLOAT((fSlow2 * (fRec0[2] + (fRec0[0] + (2.0 * fRec0[1])))));
+            fVec0[1] = fVec0[0];
+            fRec1[1] = fRec1[0];
+            fRec0[2] = fRec0[1];
+            fRec0[1] = fRec0[0];
+        }
+    }
+};
+
+// Generated with process = fi.lowpass(4, ma.SR*hslider("FCFactor", 0.4, 0.4, 0.5, 0.01)/hslider("Factor", 2, 2, 8, 1));
+template <class fVslider0, int fVslider1, typename REAL>
+struct LowPass4 : public Filter<fVslider0, fVslider1> {
+    
+    REAL fRec1[3];
+    REAL fRec0[3];
+    
+    inline REAL LowPass4_faustpower2_f(REAL value)
+    {
+        return (value * value);
+    }
+    
+    LowPass4()
+    {
+        for (int l0 = 0; (l0 < 3); l0 = (l0 + 1)) {
+            fRec1[l0] = 0.0f;
+        }
+        for (int l1 = 0; (l1 < 3); l1 = (l1 + 1)) {
+            fRec0[l1] = 0.0f;
+        }
+    }
+    
+    inline void compute(int count, FAUSTFLOAT* input0, FAUSTFLOAT* output0)
+    {
+        // Computed at template specialization time
+        REAL fSlow0 = std::tan((3.1415926535897931 * (REAL(fVslider0::value()) / REAL(fVslider1))));
+        REAL fSlow1 = (1.0 / fSlow0);
+        REAL fSlow2 = (1.0 / (((fSlow1 + 0.76536686473017945) / fSlow0) + 1.0));
+        REAL fSlow3 = (1.0 / (((fSlow1 + 1.8477590650225735) / fSlow0) + 1.0));
+        REAL fSlow4 = (((fSlow1 + -1.8477590650225735) / fSlow0) + 1.0);
+        REAL fSlow5 = (2.0 * (1.0 - (1.0 / LowPass4_faustpower2_f(fSlow0))));
+        REAL fSlow6 = (((fSlow1 + -0.76536686473017945) / fSlow0) + 1.0);
+        // Computed at runtime
+        for (int i = 0; (i < count); i = (i + 1)) {
+            fRec1[0] = (REAL(input0[i]) - (fSlow3 * ((fSlow4 * fRec1[2]) + (fSlow5 * fRec1[1]))));
+            fRec0[0] = ((fSlow3 * (fRec1[2] + (fRec1[0] + (2.0 * fRec1[1])))) - (fSlow2 * ((fSlow6 * fRec0[2]) + (fSlow5 * fRec0[1]))));
+            output0[i] = FAUSTFLOAT((fSlow2 * (fRec0[2] + (fRec0[0] + (2.0 * fRec0[1])))));
+            fRec1[2] = fRec1[1];
+            fRec1[1] = fRec1[0];
+            fRec0[2] = fRec0[1];
+            fRec0[1] = fRec0[0];
+        }
+    }
+};
+
+// Generated with process = fi.lowpass3e(ma.SR*hslider("FCFactor", 0.4, 0.4, 0.5, 0.01)/hslider("Factor", 2, 2, 8, 1));
+template <class fVslider0, int fVslider1, typename REAL>
+struct LowPass3e : public Filter<fVslider0, fVslider1> {
+    
+    REAL fRec1[3];
+    REAL fVec0[2];
+    REAL fRec0[2];
+    
+    inline REAL LowPass3e_faustpower2_f(REAL value)
+    {
+        return (value * value);
+    }
+    
+    LowPass3e()
+    {
+        for (int l0 = 0; (l0 < 3); l0 = (l0 + 1)) {
+            fRec1[l0] = 0.0;
+        }
+        for (int l1 = 0; (l1 < 2); l1 = (l1 + 1)) {
+            fVec0[l1] = 0.0;
+        }
+        for (int l2 = 0; (l2 < 2); l2 = (l2 + 1)) {
+            fRec0[l2] = 0.0;
+        }
+    }
+    
+    inline void compute(int count, FAUSTFLOAT* input0, FAUSTFLOAT* output0)
+    {
+        // Computed at template specialization time
+        REAL fSlow0 = std::tan((3.1415926535897931 * (REAL(fVslider0::value()) / REAL(fVslider1))));
+        REAL fSlow1 = (1.0 / fSlow0);
+        REAL fSlow2 = (1.0 / (fSlow1 + 0.82244590899881598));
+        REAL fSlow3 = (0.82244590899881598 - fSlow1);
+        REAL fSlow4 = (1.0 / (((fSlow1 + 0.80263676416103003) / fSlow0) + 1.4122708937742039));
+        REAL fSlow5 = LowPass3e_faustpower2_f(fSlow0);
+        REAL fSlow6 = (0.019809144837788999 / fSlow5);
+        REAL fSlow7 = (fSlow6 + 1.1615164189826961);
+        REAL fSlow8 = (((fSlow1 + -0.80263676416103003) / fSlow0) + 1.4122708937742039);
+        REAL fSlow9 = (2.0 * (1.4122708937742039 - (1.0 / fSlow5)));
+        REAL fSlow10 = (2.0 * (1.1615164189826961 - fSlow6));
+        // Computed at runtime
+        for (int i = 0; (i < count); i = (i + 1)) {
+            fRec1[0] = (REAL(input0[i]) - (fSlow4 * ((fSlow8 * fRec1[2]) + (fSlow9 * fRec1[1]))));
+            REAL fTemp0 = (fSlow4 * (((fSlow7 * fRec1[0]) + (fSlow10 * fRec1[1])) + (fSlow7 * fRec1[2])));
+            fVec0[0] = fTemp0;
+            fRec0[0] = (0.0 - (fSlow2 * ((fSlow3 * fRec0[1]) - (fTemp0 + fVec0[1]))));
+            output0[i] = FAUSTFLOAT(fRec0[0]);
+            fRec1[2] = fRec1[1];
+            fRec1[1] = fRec1[0];
+            fVec0[1] = fVec0[0];
+            fRec0[1] = fRec0[0];
+        }
+    }
+};
+
+// Generated with process = fi.lowpass6e(ma.SR*hslider("FCFactor", 0.4, 0.4, 0.5, 0.01)/hslider("Factor", 2, 2, 8, 1));
+template <class fVslider0, int fVslider1, typename REAL>
+struct LowPass6e : public Filter<fVslider0, fVslider1> {
+    
+    REAL fRec2[3];
+    REAL fRec1[3];
+    REAL fRec0[3];
+    
+    inline REAL LowPass6e_faustpower2_f(REAL value)
+    {
+        return (value * value);
+    }
+    
+    LowPass6e()
+    {
+        for (int l0 = 0; (l0 < 3); l0 = (l0 + 1)) {
+            fRec2[l0] = 0.0;
+        }
+        for (int l1 = 0; (l1 < 3); l1 = (l1 + 1)) {
+            fRec1[l1] = 0.0;
+        }
+        for (int l2 = 0; (l2 < 3); l2 = (l2 + 1)) {
+            fRec0[l2] = 0.0;
+        }
+    }
+    
+    inline void compute(int count, FAUSTFLOAT* input0, FAUSTFLOAT* output0)
+    {
+        // Computed at template specialization time
+        REAL fSlow0 = std::tan((3.1415926535897931 * (REAL(fVslider0::value()) / REAL(fVslider1))));
+        REAL fSlow1 = (1.0 / fSlow0);
+        REAL fSlow2 = (1.0 / (((fSlow1 + 0.16840487111358901) / fSlow0) + 1.0693584077073119));
+        REAL fSlow3 = LowPass6e_faustpower2_f(fSlow0);
+        REAL fSlow4 = (1.0 / fSlow3);
+        REAL fSlow5 = (fSlow4 + 53.536152954556727);
+        REAL fSlow6 = (1.0 / (((fSlow1 + 0.51247864188914105) / fSlow0) + 0.68962136448467504));
+        REAL fSlow7 = (fSlow4 + 7.6217312988706034);
+        REAL fSlow8 = (1.0 / (((fSlow1 + 0.78241304682164503) / fSlow0) + 0.24529150870616001));
+        REAL fSlow9 = (9.9999997054999994e-05 / fSlow3);
+        REAL fSlow10 = (fSlow9 + 0.00043322720055500002);
+        REAL fSlow11 = (((fSlow1 + -0.78241304682164503) / fSlow0) + 0.24529150870616001);
+        REAL fSlow12 = (2.0 * (0.24529150870616001 - fSlow4));
+        REAL fSlow13 = (2.0 * (0.00043322720055500002 - fSlow9));
+        REAL fSlow14 = (((fSlow1 + -0.51247864188914105) / fSlow0) + 0.68962136448467504);
+        REAL fSlow15 = (2.0 * (0.68962136448467504 - fSlow4));
+        REAL fSlow16 = (2.0 * (7.6217312988706034 - fSlow4));
+        REAL fSlow17 = (((fSlow1 + -0.16840487111358901) / fSlow0) + 1.0693584077073119);
+        REAL fSlow18 = (2.0 * (1.0693584077073119 - fSlow4));
+        REAL fSlow19 = (2.0 * (53.536152954556727 - fSlow4));
+        // Computed at runtime
+        for (int i = 0; (i < count); i = (i + 1)) {
+            fRec2[0] = (REAL(input0[i]) - (fSlow8 * ((fSlow11 * fRec2[2]) + (fSlow12 * fRec2[1]))));
+            fRec1[0] = ((fSlow8 * (((fSlow10 * fRec2[0]) + (fSlow13 * fRec2[1])) + (fSlow10 * fRec2[2]))) - (fSlow6 * ((fSlow14 * fRec1[2]) + (fSlow15 * fRec1[1]))));
+            fRec0[0] = ((fSlow6 * (((fSlow7 * fRec1[0]) + (fSlow16 * fRec1[1])) + (fSlow7 * fRec1[2]))) - (fSlow2 * ((fSlow17 * fRec0[2]) + (fSlow18 * fRec0[1]))));
+            output0[i] = FAUSTFLOAT((fSlow2 * (((fSlow5 * fRec0[0]) + (fSlow19 * fRec0[1])) + (fSlow5 * fRec0[2]))));
+            fRec2[2] = fRec2[1];
+            fRec2[1] = fRec2[0];
+            fRec1[2] = fRec1[1];
+            fRec1[1] = fRec1[0];
+            fRec0[2] = fRec0[1];
+            fRec0[1] = fRec0[0];
+        }
+    }
+};
+
+// A "si.bus(N)" like hard-coded class
+struct dsp_bus : public dsp {
+    
+    int fChannels;
+    int fSampleRate;
+    
+    dsp_bus(int channels):fChannels(channels), fSampleRate(-1)
+    {}
+    
+    virtual int getNumInputs() { return fChannels; }
+    virtual int getNumOutputs() { return fChannels; }
+    
+    virtual int getSampleRate() { return fSampleRate; }
+    
+    virtual void buildUserInterface(UI* ui_interface) {}
+    virtual void init(int sample_rate)
+    {
+        //classInit(sample_rate);
+        instanceInit(sample_rate);
+    }
+    
+    virtual void instanceInit(int sample_rate)
+    {
+        fSampleRate = sample_rate;
+        instanceConstants(sample_rate);
+        instanceResetUserInterface();
+        instanceClear();
+    }
+    
+    virtual void instanceConstants(int sample_rate) {}
+    virtual void instanceResetUserInterface() {}
+    virtual void instanceClear() {}
+    
+    virtual dsp* clone() { return new dsp_bus(fChannels); }
+    
+    virtual void metadata(Meta* m) {}
+    
+    virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+    {
+        for (int chan = 0; chan < fChannels; chan++) {
+            memcpy(outputs[chan], inputs[chan], sizeof(FAUSTFLOAT) * count);
+        }
+    }
+    
+    virtual void compute(double /*date_usec*/, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+    {
+        compute(count, inputs, outputs);
+    }
+    
+};
+
+// Base class for sample-rate adapter
+template <typename FILTER>
+class sr_sampler : public decorator_dsp {
+    
+    protected:
+    
+        std::vector<FILTER> fInputLowPass;
+        std::vector<FILTER> fOutputLowPass;
+    
+        inline int getFactor() { return this->fOutputLowPass[0].getFactor(); }
+    
+    public:
+    
+        sr_sampler(dsp* dsp):decorator_dsp(dsp)
+        {
+            for (int chan = 0; chan < fDSP->getNumInputs(); chan++) {
+                fInputLowPass.push_back(FILTER());
+            }
+            for (int chan = 0; chan < fDSP->getNumOutputs(); chan++) {
+                fOutputLowPass.push_back(FILTER());
+            }
+        }
+};
+
+// Down sample-rate adapter
+template <typename FILTER>
+class dsp_down_sampler : public sr_sampler<FILTER> {
+    
+    public:
+    
+        dsp_down_sampler(dsp* dsp):sr_sampler<FILTER>(dsp)
+        {}
+    
+        virtual void init(int sample_rate)
+        {
+            this->fDSP->init(sample_rate / this->getFactor());
+        }
+    
+        virtual void instanceInit(int sample_rate)
+        {
+            this->fDSP->instanceInit(sample_rate / this->getFactor());
+        }
+    
+        virtual void instanceConstants(int sample_rate)
+        {
+            this->fDSP->instanceConstants(sample_rate / this->getFactor());
+        }
+    
+        virtual dsp_down_sampler* clone() { return new dsp_down_sampler(decorator_dsp::clone()); }
+    
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            int real_count = count / this->getFactor();
+            
+            // Adapt inputs
+            FAUSTFLOAT** fInputs = (FAUSTFLOAT**)alloca(this->fDSP->getNumInputs() * sizeof(FAUSTFLOAT*));
+            for (int chan = 0; chan < this->fDSP->getNumInputs(); chan++) {
+                // Lowpass filtering in place on 'inputs'
+                this->fInputLowPass[chan].compute(count, inputs[chan], inputs[chan]);
+                // Allocate fInputs with 'real_count' frames
+                fInputs[chan] = (FAUSTFLOAT*)alloca(sizeof(FAUSTFLOAT) * real_count);
+                // Decimate
+                for (int frame = 0; frame < real_count; frame++) {
+                    fInputs[chan][frame] = inputs[chan][frame * this->getFactor()];
+                }
+            }
+            
+            // Allocate fOutputs with 'real_count' frames
+            FAUSTFLOAT** fOutputs = (FAUSTFLOAT**)alloca(this->fDSP->getNumOutputs() * sizeof(FAUSTFLOAT*));
+            for (int chan = 0; chan < this->fDSP->getNumOutputs(); chan++) {
+                fOutputs[chan] = (FAUSTFLOAT*)alloca(sizeof(FAUSTFLOAT) * real_count);
+            }
+            
+            // Compute at lower rate
+            this->fDSP->compute(real_count, fInputs, fOutputs);
+            
+            // Adapt outputs
+            for (int chan = 0; chan < this->fDSP->getNumOutputs(); chan++) {
+                // Puts zeros
+                memset(outputs[chan], 0, sizeof(FAUSTFLOAT) * count);
+                for (int frame = 0; frame < real_count; frame++) {
+                    // Copy one sample every 'DownFactor'
+                    // Apply volume
+                    //outputs[chan][frame * this->getFactor()] = fOutputs[chan][frame] * this->getFactor();
+                    outputs[chan][frame * this->getFactor()] = fOutputs[chan][frame];
+                }
+                // Lowpass filtering in place on 'outputs'
+                this->fOutputLowPass[chan].compute(count, outputs[chan], outputs[chan]);
+            }
+        }
+    
+        virtual void compute(double /*date_usec*/, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); }
+};
+
+// Up sample-rate adapter
+template <typename FILTER>
+class dsp_up_sampler : public sr_sampler<FILTER> {
+    
+    public:
+    
+        dsp_up_sampler(dsp* dsp):sr_sampler<FILTER>(dsp)
+        {}
+    
+        virtual void init(int sample_rate)
+        {
+            this->fDSP->init(sample_rate * this->getFactor());
+        }
+    
+        virtual void instanceInit(int sample_rate)
+        {
+            this->fDSP->instanceInit(sample_rate * this->getFactor());
+        }
+    
+        virtual void instanceConstants(int sample_rate)
+        {
+            this->fDSP->instanceConstants(sample_rate * this->getFactor());
+        }
+    
+        virtual dsp_up_sampler* clone() { return new dsp_up_sampler(decorator_dsp::clone()); }
+    
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            int real_count = count * this->getFactor();
+            
+            // Adapt inputs
+            FAUSTFLOAT** fInputs = (FAUSTFLOAT**)alloca(this->fDSP->getNumInputs() * sizeof(FAUSTFLOAT*));
+            
+            for (int chan = 0; chan < this->fDSP->getNumInputs(); chan++) {
+                // Allocate fInputs with 'real_count' frames
+                fInputs[chan] = (FAUSTFLOAT*)alloca(sizeof(FAUSTFLOAT) * real_count);
+                // Puts zeros
+                memset(fInputs[chan], 0, sizeof(FAUSTFLOAT) * real_count);
+                for (int frame = 0; frame < count; frame++) {
+                    // Copy one sample every 'UpFactor'
+                    fInputs[chan][frame * this->getFactor()] = inputs[chan][frame];
+                }
+                // Lowpass filtering in place on 'fInputs'
+                this->fInputLowPass[chan].compute(real_count, fInputs[chan], fInputs[chan]);
+            }
+            
+            // Allocate fOutputs with 'real_count' frames
+            FAUSTFLOAT** fOutputs = (FAUSTFLOAT**)alloca(this->fDSP->getNumOutputs() * sizeof(FAUSTFLOAT*));
+            
+            for (int chan = 0; chan < this->fDSP->getNumOutputs(); chan++) {
+                fOutputs[chan] = (FAUSTFLOAT*)alloca(sizeof(FAUSTFLOAT) * real_count);
+            }
+            
+            // Compute at upper rate
+            this->fDSP->compute(real_count, fInputs, fOutputs);
+            
+            // Adapt outputs
+            for (int chan = 0; chan < this->fDSP->getNumOutputs(); chan++) {
+                // Lowpass filtering in place on 'fOutputs'
+                this->fOutputLowPass[chan].compute(real_count, fOutputs[chan], fOutputs[chan]);
+                // Decimate
+                for (int frame = 0; frame < count; frame++) {
+                    // Apply volume
+                    //outputs[chan][frame] = fOutputs[chan][frame * this->getFactor()] * this->getFactor();
+                    outputs[chan][frame] = fOutputs[chan][frame * this->getFactor()];
+                }
+            }
+        }
+    
+        virtual void compute(double /*date_usec*/, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); }
+};
+
+// Create a UP/DS + Filter adapted DSP
+template <typename REAL>
+dsp* createSRAdapter(dsp* DSP, std::string& error, int ds = 0, int us = 0, int filter = 0)
+{
+    if (ds >= 2) {
+        switch (filter) {
+            case 0:
+                if (ds == 2) {
+                    return new dsp_down_sampler<Identity<Double<1,1>, 2>>(DSP);
+                } else if (ds == 3) {
+                    return new dsp_down_sampler<Identity<Double<1,1>, 3>>(DSP);
+                } else if (ds == 4) {
+                    return new dsp_down_sampler<Identity<Double<1,1>, 4>>(DSP);
+                } else if (ds == 8) {
+                    return new dsp_down_sampler<Identity<Double<1,1>, 8>>(DSP);
+                } else if (ds == 16) {
+                    return new dsp_down_sampler<Identity<Double<1,1>, 16>>(DSP);
+                } else if (ds == 32) {
+                    return new dsp_down_sampler<Identity<Double<1,1>, 32>>(DSP);
+                } else {
+                    error = "ERROR : ds factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            case 1:
+                if (ds == 2) {
+                    return new dsp_down_sampler<LowPass3<Double<45,100>, 2, REAL>>(DSP);
+                } else if (ds == 3) {
+                    return new dsp_down_sampler<LowPass3<Double<45,100>, 3, REAL>>(DSP);
+                } else if (ds == 4) {
+                    return new dsp_down_sampler<LowPass3<Double<45,100>, 4, REAL>>(DSP);
+                } else if (ds == 8) {
+                    return new dsp_down_sampler<LowPass3<Double<45,100>, 8, REAL>>(DSP);
+                } else if (ds == 16) {
+                    return new dsp_down_sampler<LowPass3<Double<45,100>, 16, REAL>>(DSP);
+                } else if (ds == 32) {
+                    return new dsp_down_sampler<LowPass3<Double<45,100>, 32, REAL>>(DSP);
+                } else {
+                    error = "ERROR : ds factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            case 2:
+                if (ds == 2) {
+                    return new dsp_down_sampler<LowPass4<Double<45,100>, 2, REAL>>(DSP);
+                } else if (ds == 3) {
+                    return new dsp_down_sampler<LowPass4<Double<45,100>, 3, REAL>>(DSP);
+                } else if (ds == 4) {
+                    return new dsp_down_sampler<LowPass4<Double<45,100>, 4, REAL>>(DSP);
+                } else if (ds == 8) {
+                    return new dsp_down_sampler<LowPass4<Double<45,100>, 8, REAL>>(DSP);
+                } else if (ds == 16) {
+                    return new dsp_down_sampler<LowPass4<Double<45,100>, 16, REAL>>(DSP);
+                } else if (ds == 32) {
+                    return new dsp_down_sampler<LowPass4<Double<45,100>, 32, REAL>>(DSP);
+                } else {
+                    error = "ERROR : ds factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            case 3:
+                if (ds == 2) {
+                    return new dsp_down_sampler<LowPass3e<Double<45,100>, 2, REAL>>(DSP);
+                } else if (ds == 3) {
+                    return new dsp_down_sampler<LowPass3e<Double<45,100>, 3, REAL>>(DSP);
+                } else if (ds == 4) {
+                    return new dsp_down_sampler<LowPass3e<Double<45,100>, 4, REAL>>(DSP);
+                } else if (ds == 8) {
+                    return new dsp_down_sampler<LowPass3e<Double<45,100>, 8, REAL>>(DSP);
+                } else if (ds == 16) {
+                    return new dsp_down_sampler<LowPass3e<Double<45,100>, 16, REAL>>(DSP);
+                } else if (ds == 32) {
+                    return new dsp_down_sampler<LowPass3e<Double<45,100>, 32, REAL>>(DSP);
+                } else {
+                    error = "ERROR : ds factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            case 4:
+                if (ds == 2) {
+                    return new dsp_down_sampler<LowPass6e<Double<45,100>, 2, REAL>>(DSP);
+                } else if (ds == 3) {
+                    return new dsp_down_sampler<LowPass6e<Double<45,100>, 3, REAL>>(DSP);
+                } else if (ds == 4) {
+                    return new dsp_down_sampler<LowPass6e<Double<45,100>, 4, REAL>>(DSP);
+                } else if (ds == 8) {
+                    return new dsp_down_sampler<LowPass6e<Double<45,100>, 8, REAL>>(DSP);
+                } else if (ds == 16) {
+                    return new dsp_down_sampler<LowPass6e<Double<45,100>, 16, REAL>>(DSP);
+                } else if (ds == 32) {
+                    return new dsp_down_sampler<LowPass6e<Double<45,100>, 32, REAL>>(DSP);
+                } else {
+                    error = "ERROR : ds factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            default:
+                error = "ERROR : filter type must be in [0..4] range\n";
+                return nullptr;
+        }
+    } else if (us >= 2) {
+        
+        switch (filter) {
+            case 0:
+                if (us == 2) {
+                    return new dsp_up_sampler<Identity<Double<1,1>, 2>>(DSP);
+                } else if (us == 3) {
+                    return new dsp_up_sampler<Identity<Double<1,1>, 3>>(DSP);
+                } else if (us == 4) {
+                    return new dsp_up_sampler<Identity<Double<1,1>, 4>>(DSP);
+                } else if (us == 8) {
+                    return new dsp_up_sampler<Identity<Double<1,1>, 8>>(DSP);
+                } else if (us == 16) {
+                    return new dsp_up_sampler<Identity<Double<1,1>, 16>>(DSP);
+                } else if (us == 32) {
+                    return new dsp_up_sampler<Identity<Double<1,1>, 32>>(DSP);
+                } else {
+                    error = "ERROR : us factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            case 1:
+                if (us == 2) {
+                    return new dsp_up_sampler<LowPass3<Double<45,100>, 2, REAL>>(DSP);
+                } else if (us == 3) {
+                    return new dsp_up_sampler<LowPass3<Double<45,100>, 3, REAL>>(DSP);
+                } else if (us == 4) {
+                    return new dsp_up_sampler<LowPass3<Double<45,100>, 4, REAL>>(DSP);
+                } else if (us == 8) {
+                    return new dsp_up_sampler<LowPass3<Double<45,100>, 8, REAL>>(DSP);
+                } else if (us == 16) {
+                    return new dsp_up_sampler<LowPass3<Double<45,100>, 16, REAL>>(DSP);
+                } else if (us == 32) {
+                    return new dsp_up_sampler<LowPass3<Double<45,100>, 32, REAL>>(DSP);
+                } else {
+                    error = "ERROR : us factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            case 2:
+                if (us == 2) {
+                    return new dsp_up_sampler<LowPass4<Double<45,100>, 2, REAL>>(DSP);
+                } else if (us == 3) {
+                    return new dsp_up_sampler<LowPass4<Double<45,100>, 3, REAL>>(DSP);
+                } else if (us == 4) {
+                    return new dsp_up_sampler<LowPass4<Double<45,100>, 4, REAL>>(DSP);
+                } else if (us == 8) {
+                    return new dsp_up_sampler<LowPass4<Double<45,100>, 8, REAL>>(DSP);
+                } else if (us == 16) {
+                    return new dsp_up_sampler<LowPass4<Double<45,100>, 16, REAL>>(DSP);
+                } else if (us == 32) {
+                    return new dsp_up_sampler<LowPass4<Double<45,100>, 32, REAL>>(DSP);
+                } else {
+                    error = "ERROR : us factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            case 3:
+                if (us == 2) {
+                    return new dsp_up_sampler<LowPass3e<Double<45,100>, 2, REAL>>(DSP);
+                } else if (us == 3) {
+                    return new dsp_up_sampler<LowPass3e<Double<45,100>, 3, REAL>>(DSP);
+                } else if (us == 4) {
+                    return new dsp_up_sampler<LowPass3e<Double<45,100>, 4, REAL>>(DSP);
+                } else if (us == 8) {
+                    return new dsp_up_sampler<LowPass3e<Double<45,100>, 8, REAL>>(DSP);
+                } else if (us == 16) {
+                    return new dsp_up_sampler<LowPass3e<Double<45,100>, 16, REAL>>(DSP);
+                } else if (us == 32) {
+                    return new dsp_up_sampler<LowPass3e<Double<45,100>, 32, REAL>>(DSP);
+                } else {
+                    error = "ERROR : us factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            case 4:
+                if (us == 2) {
+                    return new dsp_up_sampler<LowPass6e<Double<45,100>, 2, REAL>>(DSP);
+                } else if (us == 3) {
+                    return new dsp_up_sampler<LowPass6e<Double<45,100>, 3, REAL>>(DSP);
+                } else if (us == 4) {
+                    return new dsp_up_sampler<LowPass6e<Double<45,100>, 4, REAL>>(DSP);
+                } else if (us == 8) {
+                    return new dsp_up_sampler<LowPass6e<Double<45,100>, 8, REAL>>(DSP);
+                } else if (us == 16) {
+                    return new dsp_up_sampler<LowPass6e<Double<45,100>, 16, REAL>>(DSP);
+                } else if (us == 32) {
+                    return new dsp_up_sampler<LowPass6e<Double<45,100>, 32, REAL>>(DSP);
+                } else {
+                    error = "ERROR : us factor type must be in [2..32] range\n";
+                    return nullptr;
+                }
+            default:
+                error = "ERROR : filter type must be in [0..4] range\n";
+                return nullptr;
+        }
+    } else {
+        return DSP;
+    }
+}
+    
+#endif
+/************************** END dsp-adapter.h **************************/