cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/dsp/wasm-dsp-imp.h

@@ -0,0 +1,188 @@
+/************************** BEGIN wasm-dsp-imp.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 wasm_dsp_imp_H
+#define wasm_dsp_imp_H
+
+#include <string>
+#include <vector>
+#include <assert.h>
+
+#include "faust/dsp/dsp.h"
+#include "faust/gui/meta.h"
+#include "faust/gui/JSONUIDecoder.h"
+#include "faust/export.h"
+
+// Generic wasm_dsp_factory class that keeps the JSON decoder.
+
+class LIFAUST_API wasm_dsp_factory_imp : public dsp_factory {
+    
+    public:
+    
+        wasm_dsp_factory_imp():fDecoder(nullptr) {}
+        virtual ~wasm_dsp_factory_imp()
+        {
+            delete fDecoder;
+        }
+    
+        JSONUIDecoderBase* fDecoder;
+    
+        std::string getName() { return fDecoder->getName(); }
+    
+        virtual std::string getSHAKey() { return ""; }
+    
+        virtual std::string getDSPCode() { return ""; }
+    
+        std::string getCompileOptions() { return fDecoder->getCompileOptions(); }
+    
+        std::vector<std::string> getLibraryList() { return fDecoder->getLibraryList(); }
+    
+        std::vector<std::string> getIncludePathnames() { return fDecoder->getIncludePathnames(); }
+    
+        virtual dsp* createDSPInstance() {}
+    
+        virtual void setMemoryManager(dsp_memory_manager* manager) {}
+    
+        virtual dsp_memory_manager* getMemoryManager() { return nullptr; }
+};
+
+// Generic wasm_dsp class that creates and use the JSON decoder, and manage DSP and audio memory.
+
+class LIFAUST_API wasm_dsp_imp : public dsp {
+    
+    protected:
+    
+        wasm_dsp_factory_imp* fFactory;
+    
+        char* fMemory;          // Wasm memory
+    
+        int fWasmInputs;        // Index in wasm memory
+        int fWasmOutputs;       // Index in wasm memory
+    
+        FAUSTFLOAT** fInputs;   // Wasm memory mapped to audio pointers
+        FAUSTFLOAT** fOutputs;  // Wasm memory mapped to audio pointers
+    
+        // Assuming fFactory and fMemory are set
+        void initDecoder()
+        {
+            assert(fFactory);
+            assert(fMemory);
+            
+            if (!fFactory->fDecoder) {
+                std::string json = std::string(fMemory);
+                std::cout << "JSON " << json <<  std::endl;
+                fFactory->fDecoder = createJSONUIDecoder(json);
+            }
+            
+            std::cout << "Libfaust version: " << fFactory->fDecoder->getLibVersion() << std::endl;
+            std::cout << "Compilation options: " << fFactory->fDecoder->getCompileOptions() << std::endl;
+            
+            int ptr_size = sizeof(FAUSTFLOAT*);
+            int sample_size = sizeof(FAUSTFLOAT);
+            int buffer_size = 4096; // Max
+            
+            fInputs = new FAUSTFLOAT*[fFactory->fDecoder->getNumInputs()];
+            fOutputs = new FAUSTFLOAT*[fFactory->fDecoder->getNumOutputs()];
+            
+            // DSP is placed first with index 0. Audio buffer start at the end of DSP
+            int audio_heap_ptr = fFactory->fDecoder->getDSPSize();
+            
+            // Setup pointers offset
+            int audio_heap_ptr_inputs = audio_heap_ptr;
+            int audio_heap_ptr_outputs = audio_heap_ptr_inputs + (fFactory->fDecoder->getNumInputs() * ptr_size);
+            
+            // Setup buffer offset
+            int audio_heap_inputs = audio_heap_ptr_outputs + (fFactory->fDecoder->getNumOutputs() * ptr_size);
+            int audio_heap_outputs = audio_heap_inputs + (fFactory->fDecoder->getNumInputs() * buffer_size * sample_size);
+            
+            if (fFactory->fDecoder->getNumInputs() > 0) {
+                
+                fWasmInputs = audio_heap_ptr_inputs;
+                int* HEAP32 = reinterpret_cast<int*>(fMemory + audio_heap_ptr_inputs);
+                FAUSTFLOAT* HEAPF32 = reinterpret_cast<FAUSTFLOAT*>(fMemory + audio_heap_inputs);
+                
+                for (int i = 0; i < fFactory->fDecoder->getNumInputs(); i++) {
+                    // Setup input buffer indexes for wasm side
+                    HEAP32[i] = audio_heap_inputs + (buffer_size * sample_size * i);
+                    // Setup input buffer pointers for runtime side
+                    fInputs[i] = HEAPF32 + (buffer_size * i);
+                }
+            }
+            
+            if (fFactory->fDecoder->getNumOutputs() > 0) {
+                
+                fWasmOutputs = audio_heap_ptr_outputs;
+                int* HEAP32 = reinterpret_cast<int*>(fMemory + audio_heap_ptr_outputs);
+                FAUSTFLOAT* HEAPF32 = reinterpret_cast<FAUSTFLOAT*>(fMemory + audio_heap_outputs);
+                
+                for (int i = 0; i < fFactory->fDecoder->getNumOutputs(); i++) {
+                    // Setup output buffer indexes for wasm side
+                    HEAP32[i] = audio_heap_outputs + (buffer_size * sample_size * i);
+                    // Setup output buffer pointers for runtime side
+                    fOutputs[i] = HEAPF32 + (buffer_size * i);
+                }
+            }
+        }
+  
+    public:
+    
+        wasm_dsp_imp(wasm_dsp_factory_imp* factory, char* memory = nullptr):
+        fFactory(factory),
+        fMemory(memory),
+        fInputs(nullptr),
+        fOutputs(nullptr),
+        fWasmInputs(0),
+        fWasmOutputs(0)
+        {}
+    
+        virtual ~wasm_dsp_imp()
+        {
+            delete [] fInputs;
+            delete [] fOutputs;
+        }
+    
+        virtual int getNumInputs() { return -1; }
+        virtual int getNumOutputs() { return -1; ; }
+        virtual void buildUserInterface(UI* ui_interface)
+        {
+            fFactory->fDecoder->buildUserInterface(ui_interface, fMemory);
+        }
+        virtual int getSampleRate() { return -1; }
+        virtual void init(int sample_rate) {}
+        virtual void instanceInit(int sample_rate) {}
+        virtual void instanceConstants(int sample_rate) {}
+        virtual void instanceResetUserInterface() {}
+        virtual void instanceClear() {}
+        virtual wasm_dsp_imp* clone() { return nullptr; }
+        virtual void metadata(Meta* m)
+        {
+            fFactory->fDecoder->metadata(m);
+        }
+        // Beware: subclasses usually have to overload the two 'compute' methods
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {}
+        virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {}
+};
+
+#endif
+/************************** END wasm-dsp-imp.h **************************/

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

@@ -0,0 +1,309 @@
+/************************** BEGIN wasm-dsp.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 wasm_dsp_H
+#define wasm_dsp_H
+
+#include <string>
+#include <vector>
+
+#include "faust/dsp/dsp.h"
+#include "faust/dsp/libfaust-signal.h"
+#include "faust/gui/meta.h"
+
+/*!
+ \addtogroup wasmcpp C++ interface for compiling Faust code. Note that the API is not thread safe.
+ @{
+ */
+
+/**
+ * Get the library version.
+ *
+ * @return the library version as a static string.
+ */
+extern "C" LIFAUST_API const char* getCLibFaustVersion();
+
+/**
+ * DSP instance class with methods.
+ */
+class LIFAUST_API wasm_dsp : public dsp {
+    
+    private:
+    
+        // wasm_dsp objects are allocated using wasm_dsp_factory::createDSPInstance();
+        wasm_dsp() {}
+
+    public:
+
+        int getNumInputs();
+
+        int getNumOutputs();
+
+        void buildUserInterface(UI* ui_interface);
+
+        int getSampleRate();
+
+        void init(int sample_rate);
+
+        void instanceInit(int sample_rate);
+
+        void instanceConstants(int sample_rate);
+
+        void instanceResetUserInterface();
+
+        void instanceClear();
+
+        wasm_dsp* clone();
+
+        void metadata(Meta* m);
+
+        void compute(int count, FAUSTFLOAT** input, FAUSTFLOAT** output);
+    
+};
+
+/**
+ * Wasm DSP factory class.
+ */
+class LIFAUST_API wasm_dsp_factory : public dsp_factory {
+    
+    public:
+    
+        virtual ~wasm_dsp_factory();
+
+        /**
+         *  Return factory name:
+         *  either the name declared in DSP with [declare name "foo"] syntax
+         *  or 'filename' (if createWasmDSPFactoryFromFile is used)
+         *  or 'name_app' (if createWasmDSPFactoryFromString is used)
+         */
+        std::string getName();
+
+        /* Return factory SHA key */
+        std::string getSHAKey();
+
+        /* Return factory expanded DSP code */
+        std::string getDSPCode();
+
+        /* Return factory compile options */
+        std::string getCompileOptions();
+
+        /* Get the Faust DSP factory list of library dependancies */
+        std::vector<std::string> getLibraryList();
+
+        /* Get the list of all used includes */
+        std::vector<std::string> getIncludePathnames();
+    
+        /* Get warning messages list for a given compilation */
+        std::vector<std::string> getWarningMessages();
+   
+        /* Create a new DSP instance, to be deleted with C++ 'delete' */
+        wasm_dsp* createDSPInstance();
+
+        /* Set a custom memory manager to be used when creating instances */
+        void setMemoryManager(dsp_memory_manager* manager);
+
+        /* Return the currently set custom memory manager */
+        dsp_memory_manager* getMemoryManager();
+};
+
+/**
+ * Get the Faust DSP factory associated with a given SHA key (created from the 'expanded' DSP source),
+ * if already allocated in the factories cache and increment it's reference counter. You will have to explicitly
+ * use deleteWasmDSPFactory to properly decrement reference counter when the factory is no more needed.
+ *
+ * @param sha_key - the SHA key for an already created factory, kept in the factory cache
+ *
+ * @return a valid DSP factory if one is associated with the SHA key, otherwise a null pointer.
+ */
+LIFAUST_API wasm_dsp_factory* getWasmDSPFactoryFromSHAKey(const std::string& sha_key);
+
+/**
+ * Create a Faust DSP factory from a DSP source code as a file. Note that the library keeps an internal cache of all
+ * allocated factories so that the compilation of same DSP code (that is same source code and
+ * same set of 'normalized' compilations options) will return the same (reference counted) factory pointer. You will
+ * have to explicitly use deleteWasmDSPFactory to properly decrement reference counter when the factory is no
+ * more needed.
+ *
+ * @param filename - the DSP filename
+ * @param argc - the number of parameters in argv array
+ * @param argv - the array of parameters
+ * @param error_msg - the error string to be filled
+ * @param internal_memory - whether to use an internally allocated memory block for wasm module
+ *
+ * @return a DSP factory on success, otherwise a null pointer.
+ */
+LIFAUST_API wasm_dsp_factory* createWasmDSPFactoryFromFile(const std::string& filename, int argc, const char* argv[],
+                                                           std::string& error_msg, bool internal_memory);
+
+/**
+ * Create a Faust DSP factory from a DSP source code as a string. Note that the library keeps an internal cache of all
+ * allocated factories so that the compilation of same DSP code (that is same source code and
+ * same set of 'normalized' compilations options) will return the same (reference counted) factory pointer. You will
+ * have to explicitly use deleteDSPFactory to properly decrement reference counter when the factory is no more needed.
+ *
+ * @param name_app - the name of the Faust program
+ * @param dsp_content - the Faust program as a string
+ * @param argc - the number of parameters in argv array
+ * @param argv - the array of parameters
+ * @param error_msg - the error string to be filled
+ * @param internal_memory - whether to use an internally allocated memory block for wasm module
+ *
+ * @return a DSP factory on success, otherwise a null pointer.
+ */
+LIFAUST_API wasm_dsp_factory* createWasmDSPFactoryFromString(const std::string& name_app, const std::string& dsp_content, int argc,
+                                                             const char* argv[], std::string& error_msg, bool internal_memory);
+
+/**
+ * Create a Faust DSP factory from a vector of output signals.
+ * It has to be used with the signal API defined in libfaust-signal.h.
+ *
+ * @param name_app - the name of the Faust program
+ * @param signals - the vector of output signals
+ * @param argc - the number of parameters in argv array
+ * @param argv - the array of parameters
+ * @param error_msg - the error string to be filled
+ * @param internal_memory - whether to use an internally allocated memory block for wasm module
+ *
+ * @return a DSP factory on success, otherwise a null pointer.
+ */
+LIFAUST_API wasm_dsp_factory* createWasmDSPFactoryFromSignals(const std::string& name_app, tvec signals,
+                                                              int argc, const char* argv[], std::string& error_msg,
+                                                              bool internal_memory);
+
+/**
+ * Delete a Faust DSP factory, that is decrements it's reference counter, possible really deleting the internal pointer.
+ * Possibly also delete DSP pointers associated with this factory, if they were not explicitly deleted.
+ * Beware: all kept factories and DSP pointers (in local variables...) thus become invalid.
+ *
+ * @param factory - the DSP factory
+ *
+ * @return true if the factory internal pointer was really deleted, and false if only 'decremented'.
+ */
+LIFAUST_API bool deleteWasmDSPFactory(wasm_dsp_factory* factory);
+
+/**
+ * Delete all Faust DSP factories kept in the library cache. Beware: all kept factory and DSP pointers (in local
+ * variables...) thus become invalid.
+ *
+ */
+LIFAUST_API void deleteAllWasmDSPFactories();
+
+/**
+ * Return Faust DSP factories of the library cache as a vector of their SHA keys.
+ *
+ * @return the Faust DSP factories.
+ */
+LIFAUST_API std::vector<std::string> getAllWasmDSPFactories();
+
+/**
+ * Create a Faust DSP factory from a machine code string. Note that the library keeps an internal cache of all
+ * allocated factories so that the compilation of the same DSP code (that is the same machine code string) will return
+ * the same (reference counted) factory pointer. You will have to explicitly use deleteWasmDSPFactory to properly
+ * decrement reference counter when the factory is no more needed.
+ *
+ * @param machine_code - the machine code string
+ * @param error_msg - the error string to be filled
+ *
+ * @return the DSP factory on success, otherwise a null pointer.
+ */
+LIFAUST_API wasm_dsp_factory* readWasmDSPFactoryFromMachine(const std::string& machine_code, std::string& error_msg);
+
+/**
+ * Write a Faust DSP factory into a machine code string.
+ *
+ * @param factory - the DSP factory
+ *
+ * @return the machine code as a string.
+ */
+LIFAUST_API std::string writeWasmDSPFactoryToMachine(wasm_dsp_factory* factory);
+
+/**
+ * Create a Faust DSP factory from a machine code file. Note that the library keeps an internal cache of all
+ * allocated factories so that the compilation of the same DSP code (that is the same machine code file) will return
+ * the same (reference counted) factory pointer. You will have to explicitly use deleteWasmDSPFactory to properly
+ * decrement reference counter when the factory is no more needed.
+ *
+ * @param machine_code_path - the machine code file pathname
+ * @param error_msg - the error string to be filled
+ *
+ * @return the DSP factory on success, otherwise a null pointer.
+ */
+LIFAUST_API wasm_dsp_factory* readWasmDSPFactoryFromMachineFile(const std::string& machine_code_path, std::string& error_msg);
+
+/**
+ * Write a Faust DSP factory into a machine code file.
+ *
+ * @param factory - the DSP factory
+ * @param machine_code_path - the machine code file pathname
+ *
+ */
+LIFAUST_API void writeWasmDSPFactoryToMachineFile(wasm_dsp_factory* factory, const std::string& machine_code_path);
+
+/*!
+ @}
+ */
+
+#ifdef EMCC
+#include <emscripten.h>
+#include <emscripten/bind.h>
+using namespace emscripten;
+
+EMSCRIPTEN_BINDINGS(CLASS_wasm_dsp_factory)
+{
+    class_<wasm_dsp_factory>("wasm_dsp_factory")
+    .constructor()
+    .function("createDSPInstance", &wasm_dsp_factory::createDSPInstance, allow_raw_pointers())
+    .function("deleteDSPInstance", &wasm_dsp_factory::deleteDSPInstance, allow_raw_pointers())
+    .class_function("readWasmDSPFactoryFromMachineFile2", &wasm_dsp_factory::readWasmDSPFactoryFromMachineFile2,
+                    allow_raw_pointers())
+    .class_function("readWasmDSPFactoryFromMachine2", &wasm_dsp_factory::readWasmDSPFactoryFromMachine2,
+                    allow_raw_pointers())
+    .class_function("createWasmDSPFactory", &wasm_dsp_factory::createWasmDSPFactory, allow_raw_pointers())
+    .class_function("deleteWasmDSPFactory", &wasm_dsp_factory::deleteWasmDSPFactory2, allow_raw_pointers())
+    .class_function("getErrorMessage", &wasm_dsp_factory::getErrorMessage)
+    .class_function("extractJSON", &wasm_dsp_factory::extractJSON, allow_raw_pointers());
+}
+
+EMSCRIPTEN_BINDINGS(CLASS_wasm_dsp)
+{
+    class_<wasm_dsp>("wasm_dsp")
+    .constructor()
+    .function("getNumInputs", &wasm_dsp::getNumInputs, allow_raw_pointers())
+    .function("getNumOutputs", &wasm_dsp::getNumOutputs, allow_raw_pointers())
+    .function("getSampleRate", &wasm_dsp::getSampleRate, allow_raw_pointers())
+    .function("init", &wasm_dsp::init, allow_raw_pointers())
+    .function("instanceInit", &wasm_dsp::instanceInit, allow_raw_pointers())
+    .function("instanceConstants", &wasm_dsp::instanceConstants, allow_raw_pointers())
+    .function("instanceResetUserInterface", &wasm_dsp::instanceResetUserInterface, allow_raw_pointers())
+    .function("instanceClear", &wasm_dsp::instanceClear, allow_raw_pointers())
+    .function("clone", &wasm_dsp::clone, allow_raw_pointers())
+    .function("compute", &wasm_dsp::computeJS, allow_raw_pointers())
+    .function("setParamValue", &wasm_dsp::setParamValue, allow_raw_pointers())
+    .function("getParamValue", &wasm_dsp::getParamValue, allow_raw_pointers());
+}
+
+#endif
+
+#endif
+/************************** END wasm-dsp.h **************************/

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

@@ -0,0 +1,188 @@
+/************************** BEGIN ysfx-dsp.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 ysfx_dsp_H
+#define ysfx_dsp_H
+
+#include <string>
+#include <vector>
+
+#include "faust/dsp/dsp.h"
+#include "faust/gui/meta.h"
+#include "ysfx.h"
+
+/**
+ * DSP instance class with methods.
+ */
+template <class REAL>
+class ysfx_dsp : public dsp {
+    
+    private:
+    
+        struct ControlValue {
+            FAUSTFLOAT fValue;
+            ControlValue(FAUSTFLOAT value):fValue(value)
+            {}
+        };
+    
+        ysfx_config_t* fConfig;
+        ysfx_t* fDSP;
+        const char* fFileName;
+        std::vector<ControlValue*> fInputsValue;
+        std::vector<ControlValue*> fOutputsValue;
+    
+        void updateInputsControl()
+        {
+            for (int i = 0; i < fInputsValue.size(); i++) {
+                ysfx_slider_set_value(fDSP, i, fInputsValue[i]->fValue);
+            }
+        }
+        
+        void updateOutputsControl()
+        {
+            for (int i = 0; i < fOutputsValue.size(); i++) {
+                fOutputsValue[i]->fValue = ysfx_slider_get_value(fDSP, i);
+            }
+        }
+    
+    public:
+
+        ysfx_dsp(const char* filename)
+        {
+            fConfig = ysfx_config_new();
+            fDSP = ysfx_new(fConfig);
+            if (!ysfx_load_file(fDSP, filename, 0)) {
+                std::cerr << "File not found:" << filename << endl;
+                throw std::bad_alloc();
+            }
+            if (!ysfx_compile(fDSP, 0)) {
+                cout << "Cannot compile:" << filename << endl;
+                throw std::bad_alloc();
+            }
+            fFileName = filename;
+        }
+
+        virtual ~ysfx_dsp()
+        {
+            ysfx_config_free(fConfig);
+            ysfx_free(fDSP);
+            for (int i = 0; i < fInputsValue.size(); i++) {
+                delete fInputsValue[i];
+            }
+            for (int i = 0; i < fOutputsValue.size(); i++) {
+                delete fOutputsValue[i];
+            }
+        }
+ 
+        int getNumInputs()
+        {
+            return ysfx_get_num_inputs(fDSP);
+        }
+
+        int getNumOutputs()
+        {
+            return ysfx_get_num_outputs(fDSP);
+        }
+
+        void buildUserInterface(UI* ui_interface)
+        {
+            int i = 0;
+            ui_interface->openVerticalBox("JSFX");
+            while (ysfx_slider_exists(fDSP, i)) {
+                ysfx_slider_range_t ra;
+                ysfx_slider_get_range(fDSP, i, &ra);
+                fInputsValue.push_back(new ControlValue(ra.def));
+                string name = ysfx_slider_get_name(fDSP, i);
+                if (startWith(name, "button")) {
+                    ui_interface->addButton(ysfx_slider_get_name(fDSP, i), &fInputsValue[i]->fValue);
+                } else if (startWith(name, "checkbox")) {
+                    ui_interface->addCheckbox(ysfx_slider_get_name(fDSP, i), &fInputsValue[i]->fValue);
+                } else if (startWith(name, "hslider")) {
+                    ui_interface->addHorizontalSlider(ysfx_slider_get_name(fDSP, i),
+                                                      &fInputsValue[i]->fValue,
+                                                      ra.def,
+                                                      ra.min,
+                                                      ra.max,
+                                                      ra.inc);
+                } else if (startWith(name, "vslider")) {
+                    ui_interface->addVorizontalSlider(ysfx_slider_get_name(fDSP, i),
+                                                      &fInputsValue[i]->fValue,
+                                                      ra.def,
+                                                      ra.min,
+                                                      ra.max,
+                                                      ra.inc);
+                } else if (startWith(name, "nentry")) {
+                    ui_interface->addNumEntry(ysfx_slider_get_name(fDSP, i),
+                                              &fInputsValue[i]->fValue,
+                                              ra.def,
+                                              ra.min,
+                                              ra.max,
+                                              ra.inc);
+                }
+                i++;
+            }
+            ui_interface->closeBox();
+        }
+
+        int getSampleRate()
+        {
+            return ysfx_get_sample_rate(fDSP);
+        }
+
+        void init(int sample_rate)
+        {
+            ysfx_set_sample_rate(fDSP, sample_rate);
+            ysfx_init(fDSP);
+        }
+
+        void instanceInit(int sample_rate) {}
+
+        void instanceConstants(int sample_rate) {}
+
+        void instanceResetUserInterface() {}
+
+        void instanceClear() {}
+
+        ysfx_dsp* clone()
+        {
+            return new ysfx_dsp(fFileName);
+        }
+
+        void metadata(Meta* m) {}
+
+        void compute(int count, FAUSTFLOAT** input, FAUSTFLOAT** output)
+        {
+            updateInputsControl();
+            if (sizeof(REAL) == sizeof(float)) {
+                ysfx_process_float(fDSP, (const float **)input, (float **)output, getNumInputs(), getNumOutputs(), count);
+            } else {
+                ysfx_process_double(fDSP, (const double **)input, (double **)output, getNumInputs(), getNumOutputs(), count);
+            }
+            updateOutputsControl();
+        }
+    
+};
+
+#endif
+/************************** END ysfx-dsp.h **************************/